@mkbabb/glass-ui 4.0.1 → 4.1.0

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

@@ -27,9 +27,9 @@ export interface ConcentricHandle {
     dispose: () => void;
 }
 /**
- * Mount the concentric renderer on `canvasRef`. The WebGPU primary + the WebGL2 fallback
- * are BOTH pure fullscreen fragment passes evaluating the SAME radial-Fourier field (the
- * ONE math source `ringField.ts`), so the picker is the only seam. Returns the uniform
- * lifecycle handle.
+ * 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

@@ -6,6 +6,10 @@ export declare const MAX_RINGS = 8;
 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.
@@ -13,12 +17,22 @@ export declare const MAX_RING_STOPS = 4;
 export interface ConcentricConfig {
     /** The ring origins (1..MAX_CENTERS) — a multi-center sum produces ring interference. */
     centers: RingCenter[];
-    /** The radial sum-of-sines table (1..MAX_RINGS). */
+    /** The clean radial sum-of-sines table (1..2 frequencies — NOT a turbulence ladder). */
     ringComponents: RingComponent[];
-    /** The ellipsoidal-norm axis ratio (a, b) — the 3D-tilt depth implication. */
+    /** 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). */
@@ -31,13 +45,23 @@ export interface ConcentricConfig {
 /**
  * The warm-cream identity palette (the library default — NOT a themed hue). A three-stop
  * warm ramp over the warm-cream foreground family, resolved via the ColorResolver: a soft
- * cream trough, a warm amber mid, a deeper ember crest — so the ring field reads as warm
+ * 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[];
-/** The default 5-octave Phillips radial ring ladder. */
+/**
+ * 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 — the default interference (a moiré beat). */
+/**
+ * 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. */
+/** 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 +1,5 @@
 export { default as Concentric } from "./Concentric.vue";
 export { useConcentric, type ConcentricHandle, type UseConcentricOptions, } from "./composables/useConcentric";
-export { type ConcentricConfig, DEFAULT_CONCENTRIC_CONFIG, DEFAULT_RING_COMPONENTS, DEFAULT_CENTERS, WARM_IDENTITY_PALETTE, MAX_RINGS, MAX_CENTERS, MAX_RING_STOPS, } from "./constants";
-export { type RingComponent, type RingCenter, type Vec2, sampleRingField, ellipsoidalRadius, buildRingLadder, RING_GRAVITY, } from "./composables/ringField";
+export { type ConcentricConfig, 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 +1,4 @@
 /** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
 export declare const CONCENTRIC_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]\u00B2 domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
-/** The concentric fragment source — the aurora-class radial-Fourier field. */
-export declare const CONCENTRIC_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define RING_GRAVITY 9.81\n#define MAX_RINGS 8\n#define MAX_CENTERS 4\n#define MAX_RING_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uSpeed;\nuniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio\nuniform float uFieldNorm;     // field \u2192 [0,1] amplitude scale\nuniform float uAspect;\nuniform int   uCenterCount;\nuniform int   uRingCount;\nuniform int   uStopCount;\nuniform float uHasBackground;\nuniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)\nuniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)\nuniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2) \u2014 transcribes ringField.ts ellipsoidalRadius.\nfloat ellipsoidalRadius(vec2 p, vec2 center, float axisA, float axisB) {\n  float dx = (p.x - center.x) / max(axisA, 1e-4);\n  float dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// f(p,t) \u2014 the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).\nfloat sampleRingField(vec2 p, float t) {\n  float acc = 0.0;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec3 cj = uCenters[j];\n    float radius = ellipsoidalRadius(p, cj.xy, uAxis.x, uAxis.y);\n    float centerSum = 0.0;\n    for (int i = 0; i < MAX_RINGS; i++) {\n      if (i >= uRingCount) break;\n      vec3 r = uRings[i];\n      float k = TAU / max(r.y, 1e-4);\n      float omega = sqrt(RING_GRAVITY * k) * uSpeed;\n      float theta = k * radius - omega * t + r.z;\n      centerSum += r.x * sin(theta);\n    }\n    acc += centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  // cube-root LMS (the GLSL chunk inlines cbrt as sign(x)\u00B7pow(|x|,1/3) \u2014 no cbrt3 fn).\n  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];\n  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];\n  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n  float raw = sampleRingField(p, uTime);\n  float v = clamp(0.5 + raw * uFieldNorm, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(v);\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  if (uHasBackground > 0.5) {\n    fragColor = vec4(rgb, 1.0);\n    return;\n  }\n  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  fragColor = vec4(rgb * alpha, alpha);\n}";
+/** The concentric fragment source — the 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 +1 @@
-export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst RING_GRAVITY: f32 = 9.81;\nconst MAX_RINGS: i32 = 8;\nconst MAX_CENTERS: i32 = 4;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uAxisA, uAxisB)\n  u0: vec4<f32>,\n  // ints: (uCenterCount, uRingCount, uStopCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, _pad, _pad) \u2014 field \u2192 [0,1] scale\n  norm: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, _pad)\n  centers: array<vec4<f32>, 4>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  // aspect-correct so the rings stay circular under the ellipsoidal norm (NOT squashed\n  // by the canvas aspect): widen the domain x by the aspect ratio.\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2). The single radial\n// metric (transcribes ringField.ts ellipsoidalRadius).\nfn ellipsoidalRadius(p: vec2<f32>, center: vec2<f32>, axisA: f32, axisB: f32) -> f32 {\n  let dx = (p.x - center.x) / max(axisA, 1e-4);\n  let dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).\nfn sampleRingField(p: vec2<f32>, t: f32) -> f32 {\n  var acc = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadius(p, cj.xy, axisA, axisB);\n    var centerSum = 0.0;\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      // \u03C9 = \u221A(g\u00B7k); speed scales the travel (the shared dispersion law).\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let theta = k * radius - omega * t + r.z;\n      centerSum = centerSum + r.x * sin(theta);\n    }\n    acc = acc + centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n\n  let raw = sampleRingField(p, t);\n  // Normalize the field \u2192 [0,1] for the palette ramp (uFieldNorm is the amplitude scale).\n  let v = clamp(0.5 + raw * u.norm.x, 0.0, 1.0);\n\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // Premultiplied-alpha output over the (transparent / themed) ground.\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: the field paints fully opaque.\n    return vec4<f32>(rgb, 1.0);\n  }\n  // transparent ground: the field's alpha rides its own brightness so the page reads\n  // through the troughs (the ring crests carry the ink; the calm field is faint).\n  let alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";
+export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst 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";

package/dist/components/custom/confirm-dialog/ConfirmDialog.vue.d.ts

@@ -9,11 +9,11 @@ type __VLS_ModelProps = {
     "open"?: boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_13: {}, __VLS_36: {};
+declare var __VLS_35: {}, __VLS_64: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_13) => any;
+    default?: (props: typeof __VLS_35) => any;
 } & {
-    action?: (props: typeof __VLS_36) => any;
+    action?: (props: typeof __VLS_64) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/components/custom/constellation/Constellation.vue.d.ts

@@ -4,8 +4,13 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
     speed: number;
     count: number;
     opacityCeiling: number;
+    parallax: number;
     pointerReactive: boolean;
     warpOnClick: boolean;
+    wander: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
     gravityWell: boolean | {
         holdMs?: number;
         gain?: number;
@@ -14,10 +19,6 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
         maxSpeed?: number;
         soften?: number;
     };
-    wander: boolean | {
-        minIdle?: number;
-        jitter?: number;
-    };
     pinned: boolean | number;
     accentEdges: boolean;
     pinnedDrift: boolean | {

package/dist/components/custom/constellation/composables/constellationGLSetup.d.ts

@@ -0,0 +1,10 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { ConstellationRenderState } from "./constellationWGPUSetup";
+export interface ConstellationGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    onResize?: (w: number, h: number) => void;
+    shouldContinue: () => boolean;
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createConstellationGLSetup(deps: ConstellationGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/constellation/composables/constellationWGPUSetup.d.ts

@@ -0,0 +1,19 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import { type ConstellationUniformValues, type PackedNode, type PackedEdge } from "./uniformBridgeWGPU";
+/** The per-frame render state the renderer resolves (the stepped field → packed rows). */
+export interface ConstellationRenderState {
+    nodes: PackedNode[];
+    edges: PackedEdge[];
+    uniforms: ConstellationUniformValues;
+}
+export interface ConstellationWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    /** Advance the field + the shared pointer field one renderer frame, return the packed render state. */
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    /** Size the canvas backing store (returns the resolved backing-store [w,h] in device px). */
+    onResize?: (w: number, h: number) => void;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+}
+/** Build the constellation `setupWGPU(device, context, format)` callback. */
+export declare function createConstellationWGPUSetup(deps: ConstellationWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

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

@@ -0,0 +1,66 @@
+/** Floats per node row (one vec4). */
+export declare const NODE_FLOATS = 4;
+/** Bytes per node row. */
+export declare const NODE_BYTES: number;
+/** The pre-sized node storage buffer byte length. */
+export declare const NODES_BUFFER_BYTES: number;
+/** Floats per edge row (2 vec4s). */
+export declare const EDGE_FLOATS = 8;
+/** Bytes per edge row. */
+export declare const EDGE_BYTES: number;
+/** The pre-sized edge storage buffer byte length. */
+export declare const EDGES_BUFFER_BYTES: number;
+export declare const CONSTELLATION_UNIFORM_BYTES = 112;
+export interface ConstellationUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+}
+export declare function createConstellationScratch(): ConstellationUniformScratch;
+/** The per-frame uniform values the render reads (resolved JS-side). */
+export interface ConstellationUniformValues {
+    resolutionX: number;
+    resolutionY: number;
+    dpr: number;
+    kVis: number;
+    time: number;
+    lineWidth: number;
+    opacityCeiling: number;
+    /** The field-yields-to-type `--constellation-alpha` global dimmer. */
+    alpha: number;
+    edgeAlpha: number;
+    edgeFocusAlpha: number;
+    edgeAccentAlpha: number;
+    edgeFloor: number;
+    /** Premultiplied-ready RGBA (`[0,1]`) — `node`/`nodeDim`/`line`/`accent`. */
+    node: [number, number, number, number];
+    nodeDim: [number, number, number, number];
+    line: [number, number, number, number];
+    accent: [number, number, number, number];
+}
+/** Pack the constellation uniforms in place. */
+export declare function packConstellationUniforms(scratch: ConstellationUniformScratch, v: ConstellationUniformValues): ConstellationUniformScratch;
+/** A pre-sized node scratch (`MAX_NODES` rows × NODE_FLOATS). */
+export declare function createNodeScratch(): Float32Array;
+/** A pre-sized edge scratch (`E_MAX` rows × EDGE_FLOATS). */
+export declare function createEdgeScratch(): Float32Array;
+/** A packed node row in screen-px: `(x, y, radius, dim)`. */
+export interface PackedNode {
+    x: number;
+    y: number;
+    r: number;
+    dim: number;
+}
+/** Pack `count` node rows into the scratch (clamped to MAX_NODES). Returns the count packed. */
+export declare function packNodes(scratch: Float32Array, nodes: readonly PackedNode[]): number;
+/** A packed edge row: `(ax, ay, bx, by, alpha, accent, focus)`. */
+export interface PackedEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    alpha: number;
+    accent: number;
+    focus: number;
+}
+/** Pack `count` edge rows into the scratch (clamped to E_MAX). Returns the count packed. */
+export declare function packEdges(scratch: Float32Array, edges: readonly PackedEdge[]): number;

package/dist/components/custom/constellation/composables/useConstellation.d.ts

@@ -1,9 +1,12 @@
 import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
 import { type ConstellationField, type ConstellationProps } from "../constellationField";
 /** The imperative seam the SFC re-exposes via `defineExpose`. */
 export interface ConstellationExpose {
     field: ConstellationField;
     isFrozen: Ref<boolean>;
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 instanced twin). */
+    backend: () => GpuBackend;
     warpTo(a: {
         x: number;
         y: number;
@@ -13,14 +16,4 @@ export interface ConstellationExpose {
     warpSettled(): boolean;
     pinNode(idx: number): void;
 }
-/**
- * Drive a `<Constellation>` instance. `props` is the REACTIVE (defaulted) prop
- * surface — the per-frame live-read props (`pointerReactive`/`opacityCeiling`/
- * `accentEdges`/`drawOverlay`) are read off `props.x` INSIDE the render loop so a
- * bound `:opacity-ceiling` updates without a remount (the Vue 3.5 reactive-prop
- * read; the SFC `defineProps` destructure transform does not reach a composable
- * argument, so the live reads stay on `props`). `hostRef`/`canvasRef` are the SFC
- * template refs. Returns the imperative expose object the SFC spreads into
- * `defineExpose`.
- */
 export declare function useConstellation(props: ConstellationProps, hostRef: Ref<HTMLElement | null>, canvasRef: Ref<HTMLCanvasElement | null>): ConstellationExpose;

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

@@ -59,3 +59,36 @@ export declare const DEFAULT_PINNED_DRIFT_JITTER = 8000;
  *  ≥ ~0.72·BASE_WIDTH ≈ 922px (incl. the 1280 export frame — byte-identical
  *  there by construction); below it the marks stop crushing sub-pixel. */
 export declare const DEFAULT_K_FLOOR = 0.72;
+/**
+ * The maximum node count the points/edges buffers pre-size for (the slider cap — a count
+ * above this is clamped at upload). ≫ this BOOKS the compute neighbor-bin path.
+ */
+export declare const MAX_NODES = 256;
+/**
+ * The per-node max degree budget — the edge buffer is pre-sized at `MAX_NODES · MAX_DEGREE`
+ * so the CPU all-pairs scan never overflows it (a denser-than-degree neighborhood drops the
+ * weakest edges, never re-allocates). 12 is a generous incident-edge ceiling for a
+ * distance-threshold ε-proximity graph at the default link/count.
+ */
+export declare const MAX_DEGREE = 12;
+/** The pre-sized edge instance budget (`MAX_NODES · MAX_DEGREE`). */
+export declare const E_MAX: number;
+/**
+ * The pointer-parallax depth default (§6). Each node carries a seeded depth `z ∈ [0,1]`;
+ * the pointer offsets node screen positions by `parallax · z · (pointer − center)` — a
+ * cheap pointer-parallax giving the flat lattice apparent depth (the Awwwards "living
+ * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not a
+ * behavior break). 0 = the flat lattice (no parallax).
+ */
+export declare const DEFAULT_PARALLAX = 0.08;
+/**
+ * The base node radius band (CSS px) the DPR-aware SDF circle sizes within (the §1 "Node
+ * size" config axis). `seedField` rolls each node's radius in `[NODE_R_MIN, NODE_R_MIN +
+ * NODE_R_SPREAD)` (the prior `1.6 + rng()*1.6` band, named); the WGSL/GLSL fragment SDF
+ * sizes `half = radius · uKVis · uDpr / uResolution` so the disc samples at full device
+ * resolution and is AA'd by the pixel-footprint derivative — crisp at ANY DPR.
+ */
+export declare const NODE_R_MIN = 1.6;
+export declare const NODE_R_SPREAD = 1.6;
+/** The hairline edge half-width (CSS px) the instanced segment-quad fragment AAs. */
+export declare const DEFAULT_LINE_WIDTH = 1;

package/dist/components/custom/constellation/constellationField.d.ts

@@ -39,4 +39,34 @@ export declare function refitField(field: ConstellationField, prevW: number, pre
  * `setWarpTarget` to a random node when it elapses AND the spring has settled
  * (a click-warp in flight pre-empts the cadence — `warpSettled` reports false).
  */
-export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number): void;
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number, pointerVel?: ConstellationPointer | null): void;
+import type { ConstellationEdge } from "./constellationTypes";
+/**
+ * Scan the proximity graph and return its edge SET (the `1 − d²/reach²` distance-falloff
+ * weight per pair within `reach = link·k`). `accentIndex ≥ 0` marks the edges incident on
+ * that node (the flagged-node tether). Pure + node-testable; the render loop calls it each
+ * frame and uploads the result to the instanced-lines storage buffer.
+ *
+ * `eMax` caps the result (the pre-sized buffer budget). When the scan would exceed it, the
+ * WEAKEST overflow edges are dropped (a denser-than-budget neighborhood keeps its strongest
+ * links — never re-allocates the GPU buffer mid-frame).
+ */
+export declare function buildEdges(field: ConstellationField, link: number, accentIndex?: number, eMax?: number): ConstellationEdge[];
+/**
+ * Append the POINTER-WEB tether edges to an existing edge set (the `drawPointerWeb` math
+ * relocated): the cursor is a "virtual node" whose incident edges (to every node within
+ * `reach`) carry `focus = 1` (the render strokes them at the focus alpha). No-op when the
+ * pointer is inactive (`x < 0`). The `eMax` budget is shared with the ambient set.
+ */
+export declare function appendPointerWeb(edges: ConstellationEdge[], field: ConstellationField, link: number, pointer: ConstellationPointer | null, eMax?: number): void;
+/**
+ * The parallax-offset SCREEN position for a node (§6). Offsets the node by
+ * `parallax · z · (pointer − center)` — a cheap pointer-parallax giving the flat lattice
+ * apparent depth (deeper nodes — higher `z` — shift more, the Awwwards "living network"
+ * register). When the pointer is inactive the offset is 0 (the flat lattice). Pure; the
+ * render loop maps each node's `(x,y)` through this before writing the GPU position buffer.
+ */
+export declare function parallaxNodePos(node: ConstellationNode, pointer: ConstellationPointer | null, w: number, h: number, parallax: number): {
+    x: number;
+    y: number;
+};

package/dist/components/custom/constellation/constellationInteraction.d.ts

@@ -19,20 +19,7 @@ export declare function readInteractionConfig(canvas: HTMLCanvasElement): {
         jitter: number;
     };
 };
-/**
- * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
- * composed inside `stepField` (NO new rAF): ease `well.strength` toward
- * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
- * inverse-square pull toward the held point onto each node within `cfg.reach`
- * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
- * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
- * invariant — so a released well re-settles). No-ops (entirely skipped) when
- * `field.well` is undefined → the default render is byte-identical to HEAD.
- *
- * `dt` is clamped to {@link WARP_DT_CLAMP} (the same park-resume guard the warp
- * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
- */
-export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;
+export { stepWell } from "./constellationWell";
 /**
  * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
  * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
@@ -130,3 +117,25 @@ export declare function makePinnedDrift(override?: {
  * rests at the leg's end, the next leg arming after `minIdle + rng()*jitter`.
  */
 export declare function stepPinnedDrift(field: ConstellationField, now: number, rng: () => number): void;
+/** The flick-burst threshold (the shared usePointerVelocityField `burst` 0..1) above which
+ *  a fast flick fires the focal warp + a transient ripple (a slow drag never fires). */
+export declare const BURST_FIRE_THRESHOLD = 0.45;
+/**
+ * Fire a focal BURST off a flick (the §E "reads velocity AND acceleration" mandate). A high
+ * `burst` (from the shared `usePointerVelocityField`, the eased flick impulse) warps the
+ * focal node toward the cursor (the warp spring snaps it) AND drops an expanding ripple at
+ * the focal — the lattice "snaps the focal toward the cursor and drops an expanding ring"
+ * (the WGSL ripple instance / the accent-ring overlay). A slow drag (`burst` below the
+ * threshold) never fires (a steady hover is the gentle gather, not a snap). Returns true
+ * when a burst fired. Composes the EXISTING `warpTo` + the ripple list — no new mechanic,
+ * no second rAF (the warp rides the substrate's ONE clock); PRM is enforced by the CALLER
+ * (the shared field's `tick(0)` zeroes `burst` under reduce, so this never fires).
+ */
+export declare function fireBurst(field: ConstellationField, pointer: {
+    x: number;
+    y: number;
+}, burst: number, ripples: {
+    x: number;
+    y: number;
+    start: number;
+}[]): boolean;

package/dist/components/custom/constellation/constellationRender.d.ts

@@ -0,0 +1,25 @@
+import type { ConstellationField, ConstellationPalette } from "./constellationField";
+import { DEFAULT_PALETTE } from "./constants";
+/** R5-8 — the visual-SIZE draw scale: `max(k, kFloor)`. The instanced disc/segment
+ *  geometry sizes on this; positions/reach stay on TRUE `field.k`. Exported so a
+ *  consumer skin floors its own marks on the same axis. */
+export declare function kVisOf(field: ConstellationField): number;
+export { DEFAULT_PALETTE };
+/**
+ * Resolve the FULL neutral palette + legibility weights off a canvas's resolved custom
+ * properties (the `--constellation-*` set). The colors AND the alpha multipliers route
+ * through the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
+ * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read. SSR-safe
+ * (returns the warm-cream defaults with no `window`).
+ */
+export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
+/**
+ * Parse a CSS color string (the `--constellation-*` hsl/hex literals the palette carries)
+ * into a linear-ish premultiplied-ready RGBA in `[0,1]` for the GPU uniform write. A small
+ * sRGB parser: it reads `#rgb`/`#rrggbb`/`#rrggbbaa`, `rgb()/rgba()`, and `hsl()/hsla()` —
+ * the forms the `--constellation-*` token authoring uses (PLAIN-hsl per arm). The shader
+ * outputs premultiplied alpha over the transparent clear, so the render loop multiplies the
+ * `a` into the uniform color at upload (kept here so there is ONE color parse seam). Falls
+ * back to opaque warm-ink on an unparseable value (never a NaN garbage write).
+ */
+export declare function parseColorRGBA(input: string): [number, number, number, number];

package/dist/components/custom/constellation/constellationTypes.d.ts

@@ -5,6 +5,35 @@ export interface ConstellationNode {
     vy: number;
     r: number;
     dim: boolean;
+    /**
+     * BC.W-VIZ-CONSTELLATION — the seeded parallax DEPTH (`z ∈ [0,1]`, §6). The pointer
+     * offsets the node's SCREEN position by `parallax · z · (pointer − center)` so the flat
+     * lattice reads as having depth (the Awwwards "living network" register). Seeded in
+     * `seedField`; perturbs the GPU node-position write only (never a layout property). A
+     * field literal that omits it is treated as `z = 0.5` (the mid-plane, no parallax bias).
+     */
+    z?: number;
+}
+/**
+ * BC.W-VIZ-CONSTELLATION — ONE edge of the proximity graph, the row the CPU all-pairs scan
+ * (`buildEdges`) writes each frame into the instanced-lines storage buffer. `a`/`b` are the
+ * two endpoint positions in canvas-local CSS px; `alpha` is the distance-falloff weight
+ * (`1 − d²/reach²`, the `drawEdges` math) the segment-quad fragment multiplies; `accent`
+ * (0/1) flags the accented-node tether (the flagged-node edge tint); `focus` (0/1) flags
+ * the pointer-web tether (the cursor's incident edges). The WGSL/GLSL render transcribes
+ * the SHAPE, never re-derives the scan (the ONE math source stays JS).
+ */
+export interface ConstellationEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    /** The distance-falloff weight `1 − d²/reach²` (the drawEdges math). */
+    alpha: number;
+    /** 1 when the edge is incident on the accented node (the tether tint), else 0. */
+    accent: number;
+    /** 1 when the edge is a pointer-web tether (the cursor's incident edge), else 0. */
+    focus: number;
 }
 export interface ConstellationRipple {
     x: number;
@@ -274,6 +303,15 @@ export interface ConstellationProps {
     link?: number;
     /** Drift speed. Default 0.16. */
     speed?: number;
+    /**
+     * BC.W-VIZ-CONSTELLATION (§6) — the pointer-PARALLAX depth. Each node carries a seeded
+     * depth `z ∈ [0,1]`; the pointer offsets node screen positions by `parallax · z ·
+     * (pointer − center)` so the flat lattice reads as having depth (the Awwwards "living
+     * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not
+     * a behavior break); 0 = the flat lattice. GPU-only (perturbs the node-position write,
+     * never a layout property). Frozen under reduced-motion / `freeze`.
+     */
+    parallax?: number;
     /**
      * AY.W-COHERE E3 — the per-instance outer-envelope RECESSION knob (the aurora
      * `opacityCeiling` / fourier `intensity` sibling — ONE recession vocabulary

package/dist/components/custom/constellation/constellationWell.d.ts

@@ -0,0 +1,15 @@
+import type { ConstellationField } from "./constellationField";
+/**
+ * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
+ * composed inside `stepField` (NO new rAF): ease `well.strength` toward
+ * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
+ * inverse-square pull toward the held point onto each node within `cfg.reach`
+ * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
+ * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
+ * invariant — so a released well re-settles). No-ops (entirely skipped) when
+ * `field.well` is undefined → the default render is byte-identical to HEAD.
+ *
+ * `dt` is clamped to {@link WELL_DT_CLAMP} (the same park-resume guard the warp
+ * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
+ */
+export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;

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

@@ -1,6 +1,6 @@
 export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, refitField, BASE_WIDTH, } from "./constellationField";
-export { DEFAULT_K_FLOOR } from "./constants";
-export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationInteraction";
-export { kVisOf, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, DEFAULT_PALETTE, } from "./constellationDraw";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";
+export { seedField, stepField, refitField, buildEdges, appendPointerWeb, parallaxNodePos, BASE_WIDTH, } from "./constellationField";
+export { DEFAULT_K_FLOOR, DEFAULT_PARALLAX, MAX_NODES, MAX_DEGREE, E_MAX, } from "./constants";
+export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, fireBurst, BURST_FIRE_THRESHOLD, } from "./constellationInteraction";
+export { kVisOf, readPalette, parseColorRGBA, DEFAULT_PALETTE, } from "./constellationRender";
+export type { ConstellationNode, ConstellationEdge, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

package/dist/components/custom/constellation/shaders/constellation-lines.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_LINES_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance edge rows \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aAB;  // (a.x, a.y, b.x, b.y)\nlayout(location = 1) in vec4 aW;   // (alpha, accent, focus, _pad)\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\nuniform float uLineWidth;\n\nout float vLineCoord;\nout float vAlpha;\nout float vAccent;\nout float vFocus;\n\nvoid main() {\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 alongQuad = quad[gl_VertexID];\n\n  vec2 a = aAB.xy;\n  vec2 b = aAB.zw;\n  vec2 dir = normalize(b - a + vec2(1e-6, 0.0));\n  vec2 ortho = vec2(-dir.y, dir.x);\n  // accent tether reads a touch heavier (1.1\u00D7).\n  float halfWPx = uLineWidth * uKVis * uDpr * 0.5 * mix(1.0, 1.1, aW.y);\n  vec2 p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * alongQuad.y * halfWPx;\n\n  vec2 ndc = vec2(\n    p.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(ndc, 0.0, 1.0);\n  vLineCoord = alongQuad.y;\n  vAlpha = aW.x;\n  vAccent = aW.y;\n  vFocus = aW.z;\n}\n";
+export declare const CONSTELLATION_LINES_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uLine;     // premultiplied-ready rgba\nuniform vec4 uAccent;\nuniform float uAlphaGlobal;       // --constellation-alpha\nuniform float uOpacityCeiling;\nuniform float uEdgeAlpha;\nuniform float uEdgeFocusAlpha;\nuniform float uEdgeAccentAlpha;\nuniform float uEdgeFloor;\n\nin float vLineCoord;\nin float vAlpha;\nin float vAccent;\nin float vFocus;\nout vec4 fragColor;\n\nvoid main() {\n  float aaBand = 0.6;\n  float cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(vLineCoord));\n  if (cross <= 0.0) { discard; }\n\n  float dim = uAlphaGlobal * uOpacityCeiling;\n  vec4 col = uLine;\n  float weight = (uEdgeAlpha * vAlpha + uEdgeFloor) * dim;\n  if (vAccent > 0.5) {\n    col = uAccent;\n    weight = uEdgeAccentAlpha * vAlpha * dim;\n  } else if (vFocus > 0.5) {\n    col = uLine;\n    weight = uEdgeFocusAlpha * uAlphaGlobal * uOpacityCeiling * vAlpha;\n  }\n\n  float a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  fragColor = vec4(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-lines.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONSTELLATION_LINES_WGSL = "\nstruct Edge {\n  // vec4 0: (a.x, a.y, b.x, b.y)\n  ab: vec4<f32>,\n  // vec4 1: (alpha, accent, focus, _pad)\n  w: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> edges: array<Edge>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) lineCoord: f32,  // [-1,1] cross-line \u2192 fragment AA\n  @location(1) alpha: f32,      // distance-falloff weight\n  @location(2) accent: f32,     // accent flag (the flagged-node tether tint)\n  @location(3) focus: f32,      // focus flag (the pointer-web tether)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  var QUAD = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0,  1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0,  1.0),\n  );\n  let alongQuad = QUAD[vIdx];\n\n  let e = edges[iIdx];\n  let a = e.ab.xy;\n  let b = e.ab.zw;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n  let lineW = u.u1.y;\n\n  // Screen-space segment direction + orthogonal (the half-width offset axis).\n  let dir = normalize(b - a + vec2<f32>(1e-6, 0.0));\n  let ortho = vec2<f32>(-dir.y, dir.x);\n  // Lerp along the segment (alongQuad.x \u2208 [-1,1] \u2192 [0,1]); offset by ortho \u00D7 half-width.\n  // The accent tether reads a touch heavier (1.1\u00D7 the neutral width).\n  let halfWPx = lineW * kVis * dpr * 0.5 * mix(1.0, 1.1, e.w.y);\n  let p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * (alongQuad.y) * halfWPx;\n\n  // px (y-down) \u2192 clip (y-up).\n  let ndc = vec2<f32>(\n    p.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(res.y, 1.0) * 2.0,\n  );\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc, 0.0, 1.0);\n  out.lineCoord = alongQuad.y;\n  out.alpha = e.w.x;\n  out.accent = e.w.y;\n  out.focus = e.w.z;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Cross-line AA \u2014 a smoothstep on |lineCoord| so the hairline edge is crisp.\n  let aaBand = 0.6;\n  let cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(in.lineCoord));\n  if (cross <= 0.0) { discard; }\n\n  let dim = u.u1.w * u.u1.z; // alpha \u00B7 opacityCeiling\n  // Resolve the edge class: accent tether \u00B7 focus pointer-web \u00B7 neutral ambient.\n  var col = u.uLine;\n  var weight = (u.uEdge.x * in.alpha + u.uEdge.w) * dim; // edgeAlpha\u00B7falloff + edgeFloor\n  if (in.accent > 0.5) {\n    col = u.uAccent;\n    weight = u.uEdge.z * in.alpha * dim; // edgeAccentAlpha\n  } else if (in.focus > 0.5) {\n    col = u.uLine;\n    weight = u.uEdge.y * u.u1.w * u.u1.z * in.alpha; // edgeFocusAlpha \u00B7 alpha \u00B7 ceiling\n  }\n\n  let a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_POINTS_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance node row (x, y, radius, dim) \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aNode;\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\n\nout vec2 vUv;   // [-1,1] billboard-local \u2192 fragment SDF coord\nout float vDim;\n\nvoid main() {\n  // Two-triangle quad corners (the SAME order as the WGSL QUAD).\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 corner = quad[gl_VertexID];\n\n  vec2 centerPx = aNode.xy;\n  // px (y-down) \u2192 clip (y-up).\n  vec2 centerNdc = vec2(\n    centerPx.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(uResolution.y, 1.0) * 2.0\n  );\n  // half-extent: radius\u00B7kVis CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (half is a GLSL reserved word \u2014 name it halfExt.)\n  float radPx = aNode.z * uKVis * uDpr;\n  vec2 halfExt = vec2(\n    radPx / max(uResolution.x, 1.0) * 2.0,\n    radPx / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(centerNdc + corner * halfExt, 0.0, 1.0);\n  vUv = corner;\n  vDim = aNode.w;\n}\n";
+export declare const CONSTELLATION_POINTS_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uNode;      // premultiplied-ready rgba\nuniform vec4 uNodeDim;\nuniform float uOpacityCeiling;\n\nin vec2 vUv;\nin float vDim;\nout vec4 fragColor;\n\nvoid main() {\n  // SDF: distance to the unit-circle edge (0 at the rim, neg inside).\n  float d = length(vUv) - 1.0;\n  // fwidth(d) \u2014 the pixel footprint, the resolution-independent AA width.\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  vec4 col = mix(uNode, uNodeDim, vDim);\n  float a = col.a * coverage * uOpacityCeiling;\n  fragColor = vec4(col.rgb * a, a); // premultiplied\n}\n";