@mkbabb/glass-ui 4.1.0 → 5.0.0

package/dist/components/custom/dot-flow-field/constants.d.ts

@@ -1,69 +0,0 @@
-import type { WaveComponent } from "./composables/flowField";
-import type { OklchStop } from "../../../composables/color";
-/** Compile-time lattice cap — mirrors the WGSL storage-buffer array bound. */
-export declare const MAX_PARTICLES = 16384;
-/** Compile-time wave-component cap — mirrors the WGSL `MAX_WAVE_COMPONENTS` #define. */
-export declare const MAX_WAVE_COMPONENTS = 8;
-/** Compile-time palette cap — mirrors the WGSL `MAX_FLOW_STOPS` #define. */
-export declare const MAX_FLOW_STOPS = 4;
-/**
- * The full author schema — the studio's `useConfiguratorState` model. Every field is a
- * tunable the demo configurator drives; the SFC resolves it into the uniform table.
- *
- * RETOPOLOGY: the lattice density is derived from `gridPitch` (a clean break from the free
- * `particleCount` — README MIGRATION row `particleCount → gridPitch`). The brightness/scale
- * shape rides `contrast`/`waveBandCenter`/`waveBandWidth`; the sub-cell drift rides
- * `displaceAmp`/`springK`; `coherence` maps the octave count + persistence.
- */
-export interface FlowFieldConfig {
-    /** The Gerstner sum-of-sines table (1..MAX_WAVE_COMPONENTS) — the LARGE-wave ladder. */
-    waveComponents: WaveComponent[];
-    /** The dispersion-driven sweep speed (scales ω). LOW = slow sweep (default 0.3). */
-    windSpeed: number;
-    /** The fbm curl-noise braiding-break weight (0..0.4 — keep low; default 0.12). */
-    curlStrength: number;
-    /** The lattice spacing in CSS-px (drives N = view/pitch²). ~26px ≈ the reference. */
-    gridPitch: number;
-    /** The dot billboard base radius in px @ 1×. */
-    dotSize: number;
-    /** How far a dot drifts from its anchor, in pitch fractions (capped < 0.5 pitch). */
-    displaceAmp: number;
-    /** The restoring-spring rate (the pull-to-anchor stiffness; higher = stiffer). */
-    springK: number;
-    /** The sweeping-band center over the normalized height (the iso-band the wave rides). */
-    waveBandCenter: number;
-    /** The sweeping bright-stripe thickness (`waveBand` width over the normalized height). */
-    waveBandWidth: number;
-    /** The brightness modulation depth (subtle ↔ bold; 0..1). */
-    contrast: number;
-    /** The Coherence axis (0..1; high = few coarse octaves coherent, low = many fine). */
-    coherence: number;
-    /** The soft-disc globe mask (the reference's two-sphere composition); off by default. */
-    globeMask: boolean;
-    /** The dot-color ramp (the demo themes it mono-white); resolved via the ColorResolver. */
-    palette: OklchStop[];
-    /** The ground color (the demo sets near-black; default transparent). */
-    background: OklchStop | "transparent";
-    /** Pointer-warp the lattice (a local displacement ripple 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 teal). A two-stop warm-amber
- * ramp over the warm-cream foreground family, resolved via the ColorResolver. A consumer
- * (the demo) themes it mono-white-on-near-black through a PRESET, never a token edit.
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/**
- * The default LARGE-wave ladder about a 35° diagonal wind — 3 coherent octaves, λ₀ at
- * 2.5× the domain extent (ONE dominant sweeping wave). The §1 regime inversion.
- */
-export declare const DEFAULT_WAVE_COMPONENTS: WaveComponent[];
-/**
- * The shipped warm-identity default config — the SUBTLE + LARGE regime (the §1/§2
- * topology+regime targets): a calm warm-cream lattice (~26px pitch) a slow LARGE wave
- * sweeps through, the dots only breathing a hair off their anchors. globeMask OFF (the
- * neutral register — the reference's soft-disc is a DEMO preset).
- */
-export declare const DEFAULT_FLOW_CONFIG: FlowFieldConfig;

package/dist/components/custom/dot-flow-field/index.d.ts

@@ -1,5 +0,0 @@
-export { default as DotFlowField } from "./DotFlowField.vue";
-export { useDotFlowField, type DotFlowFieldHandle, type UseDotFlowFieldOptions, } from "./composables/useDotFlowField";
-export { type FlowFieldConfig, DEFAULT_FLOW_CONFIG, DEFAULT_WAVE_COMPONENTS, WARM_IDENTITY_PALETTE, MAX_PARTICLES, MAX_WAVE_COMPONENTS, MAX_FLOW_STOPS, } from "./constants";
-export { type WaveComponent, type Vec2, sampleVelocity, gerstnerVelocity, curlFBM, buildWaveLadder, gridOrigin, sampleHeight, sampleDisplacement, waveBand, FLOW_GRAVITY, FLOW_DOMAIN_HALF, } from "./composables/flowField";
-export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/dot-flow-field/shaders/flow-field.compute.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const FLOW_FIELD_COMPUTE_WGSL = "\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst CURL_EPS: f32 = 0.012;\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nstruct Particle {\n  // (pos.x, pos.y, height, |disp|) \u2014 the anchored-lattice live state\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct FlowUniforms {\n  // p0: (uTime, uDt, uWindSpeed, uCurlStrength)\n  p0: vec4<f32>,\n  // p1: (uGridPitch, uDisplaceAmp, uSpringK, uGridCols)  \u2014 the lattice geometry\n  p1: vec4<f32>,\n  // ints: (uWaveCount, uParticleCount, uGridColsI, _pad)\n  ints: vec4<i32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n};\n\n@group(0) @binding(0) var<uniform> u: FlowUniforms;\n@group(0) @binding(1) var<storage, read_write> particles: array<Particle>;\n\n// \u2500\u2500 The deterministic lattice origin (transcribes flowField.ts gridOrigin) \u2500\u2500\nfn gridOrigin(index: u32, cols: i32, pitch: f32) -> vec2<f32> {\n  let c = max(cols, 1);\n  let col = i32(index) % c;\n  let row = i32(index) / c;\n  let half = f32(c - 1) * pitch * 0.5;\n  return vec2<f32>(f32(col) * pitch - half, f32(row) * pitch - half);\n}\n\n// \u2500\u2500 The Gerstner-sum analytic \u2207\u22A5h velocity (transcribes flowField.ts gerstnerVelocity) \u2500\u2500\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let amplitude = w.x;\n    let wavelength = max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let phase = w.w;\n    let k = TAU / wavelength;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + phase;\n    let akc = amplitude * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  // v = \u2207\u22A5h = (\u2202h/\u2202y, \u2212\u2202h/\u2202x).\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// \u2500\u2500 The scalar Gerstner HEIGHT (transcribes flowField.ts sampleHeight \u2014 the brightness\n//    driver, normalized to \u2248[-1,1] by the total amplitude so the band thresholds are\n//    wave-table-independent). \u2500\u2500\nfn sampleHeight(o: vec2<f32>, t: f32) -> f32 {\n  var h = 0.0;\n  var ampSum = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let k = TAU / max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * o.x + d.y * o.y) - omega * t + w.w;\n    h = h + w.x * sin(theta);\n    ampSum = ampSum + abs(w.x);\n  }\n  return h / max(ampSum, 1e-4);\n}\n\n// \u2500\u2500 Shared curl-noise basis (the WGSL twin of flow.glsl.ts curlFBM) \u2500\u2500\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let a = hash21(i + vec2<f32>(0.0, 0.0));\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\n\nfn potentialFBM(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\nfn curlFBM(p: vec2<f32>) -> vec2<f32> {\n  let dx = potentialFBM(p + vec2<f32>(CURL_EPS, 0.0)) - potentialFBM(p - vec2<f32>(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2<f32>(0.0, CURL_EPS)) - potentialFBM(p - vec2<f32>(0.0, CURL_EPS));\n  let g = vec2<f32>(dx, dy) / (2.0 * CURL_EPS);\n  return vec2<f32>(g.y, -g.x);\n}\n\n// The composite flow velocity (transcribes flowField.ts sampleVelocity EXACTLY \u2014 the\n// coarse \u00D70.55 curl domain-scale, the \u00A73.2 inversion).\nfn sampleVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let curlStrength = u.p0.w;\n  var v = gerstnerVelocity(p, t);\n  if (curlStrength > 0.0) {\n    let c = curlFBM(vec2<f32>(p.x * 0.55 + t * 0.15, p.y * 0.55));\n    v = v + c * curlStrength;\n  }\n  return v;\n}\n\n// The sub-cell DISPLACEMENT (transcribes flowField.ts sampleDisplacement \u2014 \u2207\u22A5h + the\n// coarse curl break, soft-clamped through tanh so the magnitude rides into [0,1)).\nfn sampleDisplacement(o: vec2<f32>, t: f32) -> vec2<f32> {\n  let v = sampleVelocity(o, t);\n  let mag = length(v);\n  if (mag < 1e-5) { return vec2<f32>(0.0, 0.0); }\n  let bounded = tanh(mag);\n  return v * (bounded / mag);\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  let count = u32(u.ints.y);\n  if (idx >= count) { return; } // bounds-guard the dispatch tail\n\n  let t = u.p0.x;\n  let dt = u.p0.y;\n  let pitch = u.p1.x;\n  let displaceAmp = u.p1.y;\n  let springK = u.p1.z;\n  let cols = u.ints.z;\n\n  // The PERMANENT anchor \u2014 no wrap, no re-seed (the coherence fix).\n  let o = gridOrigin(idx, cols, pitch);\n  let disp = sampleDisplacement(o, t);\n  let anchorTarget = o + disp * (displaceAmp * pitch);\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  // Framerate-independent critically-damped pull-to-anchor:\n  //   p \u2190 mix(p, anchorTarget, 1 - exp(-springK\u00B7dt))  (the GPGPU influence-pull pattern).\n  let k = 1.0 - exp(-springK * dt);\n  pos = mix(pos, anchorTarget, k);\n\n  let h = sampleHeight(o, t);\n  particles[idx] = Particle(vec4<f32>(pos, h, length(disp)));\n}\n";

package/dist/components/custom/dot-flow-field/shaders/flow-field.glsl.d.ts

@@ -1,4 +0,0 @@
-/** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
-export declare const FLOW_FIELD_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 dot-lattice + sweeping-brightness fragment source (the anchored-grid model). */
-export declare const FLOW_FIELD_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define FLOW_GRAVITY 9.81\n#define CURL_EPS 0.012\n#define MAX_WAVE_COMPONENTS 8\n#define MAX_FLOW_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uWindSpeed;\nuniform float uCurlStrength;\nuniform float uDomainHalf;\nuniform float uAspect;\nuniform float uGridPitchDomain;  // lattice pitch in DOMAIN units\nuniform float uDotRadiusDomain;  // dot radius in DOMAIN units\nuniform float uDisplaceAmp;      // sub-cell drift in pitch fractions\nuniform float uContrast;\nuniform float uBaseBright;\nuniform float uWaveBandCenter;\nuniform float uWaveBandWidth;\nuniform float uGlobeMask;\nuniform int   uWaveCount;\nuniform int   uStopCount;\nuniform float uHasBackground;\nuniform vec3  uBg;\nuniform vec4  uWaves[MAX_WAVE_COMPONENTS];   // (amplitude, wavelength, directionDeg, phase)\nuniform vec3  uPalette[MAX_FLOW_STOPS];      // linear-sRGB stops\n\nconst mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);\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// \u2500\u2500 The Gerstner-sum analytic \u2207\u22A5h velocity (transcribes flowField.ts gerstnerVelocity) \u2500\u2500\nvec2 gerstnerVelocity(vec2 p, float t) {\n  float dhdx = 0.0;\n  float dhdy = 0.0;\n  for (int i = 0; i < MAX_WAVE_COMPONENTS; i++) {\n    if (i >= uWaveCount) break;\n    vec4 w = uWaves[i];\n    float k = TAU / max(w.y, 1e-4);\n    float dirRad = w.z * PI / 180.0;\n    vec2 d = vec2(cos(dirRad), sin(dirRad));\n    float omega = sqrt(FLOW_GRAVITY * k) * uWindSpeed;\n    float theta = k * (d.x * p.x + d.y * p.y) - omega * t + w.w;\n    float akc = w.x * k * cos(theta);\n    dhdx += akc * d.x;\n    dhdy += akc * d.y;\n  }\n  return vec2(dhdy, -dhdx);\n}\n\n// \u2500\u2500 The scalar Gerstner HEIGHT (transcribes flowField.ts sampleHeight) \u2500\u2500\nfloat sampleHeight(vec2 o, float t) {\n  float h = 0.0;\n  float ampSum = 0.0;\n  for (int i = 0; i < MAX_WAVE_COMPONENTS; i++) {\n    if (i >= uWaveCount) break;\n    vec4 w = uWaves[i];\n    float k = TAU / max(w.y, 1e-4);\n    float dirRad = w.z * PI / 180.0;\n    vec2 d = vec2(cos(dirRad), sin(dirRad));\n    float omega = sqrt(FLOW_GRAVITY * k) * uWindSpeed;\n    float theta = k * (d.x * o.x + d.y * o.y) - omega * t + w.w;\n    h += w.x * sin(theta);\n    ampSum += abs(w.x);\n  }\n  return h / max(ampSum, 1e-4);\n}\n\n// \u2500\u2500 Shared curl-noise basis (the GLSL twin of flow.glsl.ts curlFBM) \u2500\u2500\nfloat hash21(vec2 p) {\n  vec3 p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);\n  p3 += dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  float a = hash21(i + vec2(0.0, 0.0));\n  float b = hash21(i + vec2(1.0, 0.0));\n  float c = hash21(i + vec2(0.0, 1.0));\n  float d = hash21(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\nfloat potentialFBM(vec2 p0) {\n  float v = 0.0;\n  float amp = 0.5;\n  float freq = 1.0;\n  vec2 p = p0;\n  for (int i = 0; i < 3; i++) {\n    v += amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\nvec2 sampleVelocity(vec2 p, float t) {\n  vec2 v = gerstnerVelocity(p, t);\n  if (uCurlStrength > 0.0) {\n    vec2 c = curlFBM(vec2(p.x * 0.55 + t * 0.15, p.y * 0.55));\n    v += c * uCurlStrength;\n  }\n  return v;\n}\n// sub-cell displacement (transcribes flowField.ts sampleDisplacement \u2014 tanh soft-clamp).\nvec2 sampleDisplacement(vec2 o, float t) {\n  vec2 v = sampleVelocity(o, t);\n  float mag = length(v);\n  if (mag < 1e-5) return vec2(0.0);\n  return v * (tanh(mag) / mag);\n}\n\n// The sweeping bright-stripe band (transcribes flowField.ts waveBand).\nfloat waveBand(float h, float center, float width) {\n  float w = max(width, 1e-3);\n  float d = abs(h - center);\n  return 1.0 - smoothstep(0.0, w, d);\n}\n\n// The optional soft-disc globe mask (the reference's two-sphere composition).\nfloat globeMask(vec2 o, float t, float on) {\n  if (on <= 0.5) return 1.0;\n  float cx = 0.35 * sin(t * 0.13);\n  float cy = 0.28 * cos(t * 0.11);\n  float d = length(o - vec2(cx, cy));\n  return 1.0 - smoothstep(0.45, 0.75, d);\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  // Domain-space pixel (aspect-corrected x so the lattice stays square).\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n  float pitch = max(uGridPitchDomain, 1e-3);\n\n  // The nearest lattice cell ORIGIN (the anchored grid \u2014 the deterministic gridOrigin\n  // mapping, evaluated per-pixel: round p/pitch to the nearest cell center).\n  vec2 cell = floor(p / pitch + 0.5);\n  vec2 o = cell * pitch;\n\n  // The dot DRIFTS toward o + disp\u00B7displaceAmp\u00B7pitch (the same sub-cell offset the\n  // compute kernel writes \u2014 here evaluated analytically per pixel).\n  vec2 disp = sampleDisplacement(o, uTime);\n  vec2 dotCenter = o + disp * (uDisplaceAmp * pitch);\n\n  // The soft circle around the (drifted) dot center.\n  float dist = length(p - dotCenter);\n  float radius = max(uDotRadiusDomain, 1e-4);\n  float mask = 1.0 - smoothstep(radius * 0.6, radius, dist);\n  if (mask < 0.002) {\n    if (uHasBackground > 0.5) {\n      fragColor = vec4(clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0)), 1.0);\n    } else {\n      fragColor = vec4(0.0);\n    }\n    return;\n  }\n\n  // The brightness lights the dot \u2014 the SWEEPING band over the height at the anchor.\n  float h = sampleHeight(o, uTime);\n  float band = waveBand(h, uWaveBandCenter, uWaveBandWidth);\n  float bright = (uBaseBright + band * uContrast) * globeMask(o, uTime, uGlobeMask);\n  bright = clamp(bright, 0.0, 1.6);\n\n  float tone = clamp(bright, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(tone) * bright;\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  float alpha = mask * clamp(bright * 0.8 + 0.12, 0.0, 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, alpha), 1.0);\n    return;\n  }\n  fragColor = vec4(rgb * alpha, alpha);\n}";

package/dist/components/custom/dot-flow-field/shaders/flow-field.render.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const FLOW_FIELD_RENDER_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_FLOW_STOPS: i32 = 4;\n\nstruct Particle {\n  // (pos.x, pos.y, height, |disp|)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct RenderUniforms {\n  // r0: (uTime, uContrast, uBaseBright, uDomainHalf)\n  r0: vec4<f32>,\n  // r1: (uDotSize, uSizePulse, uAspect, uGridPitch)\n  r1: vec4<f32>,\n  // r2: (uWaveBandCenter, uWaveBandWidth, uGlobeMask, _pad)\n  r2: vec4<f32>,\n  // ints: (uStopCount, uParticleCount, _pad, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb, hasBackground)\n  bg: vec4<f32>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n@group(0) @binding(1) var<storage, read> particles: array<Particle>;\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// The sweeping bright-stripe band (transcribes flowField.ts waveBand): a soft two-sided\n// ridge over the normalized height \u2014 1 at the band center, falling to 0 at \u00B1width.\nfn waveBand(h: f32, center: f32, width: f32) -> f32 {\n  let w = max(width, 1e-3);\n  let d = abs(h - center);\n  return 1.0 - smoothstep(0.0, w, d);\n}\n\n// The optional soft-disc globe mask \u2014 a slow Lissajous-drifting radial field (the\n// reference's two-sphere composition). OFF when uGlobeMask <= 0.5 (returns 1).\nfn globeMask(o: vec2<f32>, t: f32, on: f32) -> f32 {\n  if (on <= 0.5) { return 1.0; }\n  // a slow Lissajous center drift within the domain\n  let cx = 0.35 * sin(t * 0.13);\n  let cy = 0.28 * cos(t * 0.11);\n  let d = length(o - vec2<f32>(cx, cy));\n  // a soft disc of radius ~0.6 with a feathered edge\n  return 1.0 - smoothstep(0.45, 0.75, d);\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.x;\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\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the soft circle\n  @location(1) bright: f32,        // band-driven brightness [0, ~1.6]\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vi: u32,\n  @builtin(instance_index) ii: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space.\n  var corners = 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 local = corners[vi];\n\n  let pr = particles[ii].data;\n  let p = pr.xy;\n  let h = pr.z;\n  let dispMag = pr.w;\n  let half = u.r0.w;\n\n  // Brightness = base + band\u00B7contrast, masked by the optional globe (read at the live\n  // position \u2014 close enough to the anchor at the sub-cell cap). The band SWEEPS as h\n  // translates across the lattice.\n  let band = waveBand(h, u.r2.x, u.r2.y);\n  var bright = u.r0.z + band * u.r0.y;\n  bright = bright * globeMask(p, u.r0.x, u.r2.z);\n\n  // A subtle drift-driven size pulse (never a re-seed \u2014 the dot only breathes).\n  let sizePulse = u.r1.y;\n  let sizeWorld = u.r1.x * (1.0 + dispMag * sizePulse);\n\n  // Position the quad at the dot in clip space. Domain [-half,half] \u2192 NDC [-1,1];\n  // the quad half-extent rides sizeWorld (in domain units, aspect-corrected x).\n  let aspect = u.r1.z;\n  let ndc = p / half;\n  let off = local * sizeWorld / half;\n  let offX = off.x / max(aspect, 1e-4);\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc.x + offX, ndc.y + off.y, 0.0, 1.0);\n  out.local = local;\n  out.bright = bright;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Soft circle \u2014 radial smoothstep over the billboard-local radius.\n  let r = length(in.local);\n  let feather = 0.4;\n  let mask = 1.0 - smoothstep(1.0 - feather, 1.0, r);\n  if (mask < 0.002) { return vec4<f32>(0.0); }\n\n  // The brightness lights the dot core; the palette tints it (the warm-cream identity).\n  let bright = clamp(in.bright, 0.0, 1.6);\n  let tone = clamp(bright, 0.0, 1.0);\n  let lin = samplePaletteLin(tone) * bright;\n  // A floor alpha so even an off-band dot stays a faint lattice point (the calm grid).\n  let alpha = mask * clamp(bright * 0.8 + 0.12, 0.0, 1.0);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n  // Premultiplied-alpha output.\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/dot-matrix/DotMatrix.vue.d.ts

@@ -1,43 +0,0 @@
-import type { DotMatrixConfig } from "./constants";
-/**
- * DotMatrix — a globe of fine warm-cream dots on a sphere SURFACE (BC.W-VIZ-DOTMATRIX —
- * the Claude co-work "fine-dot spheres on dark" reference).
- *
- * The dots are laid via the Fibonacci phyllotaxis spiral (even-by-area, no pole-pinching)
- * and depth-shaded so the globe reads as a translucent dot-SHELL — the near hemisphere
- * brighter + larger, the rim/far side fading toward near-invisible (the shape is painted
- * by BRIGHTNESS + DEPTH, not motion; stop the spin and it STILL reads as a sphere). It
- * spins slowly on a gently tilted axis. WebGPU-FIRST: the render pass draws instanced
- * billboard quads + the crisp `fwidth` SDF fragment; a WebGL2 instanced-billboard fallback
- * draws the SAME dots where WebGPU is absent (born-GPU — no Canvas2D). It composes
- * `useDotMatrix` → the `createGpuSubstrate` picker over the ONE canvas lifecycle leaf
- * (offscreen-pause, live-PRM freeze, the shared pointer field) — it never bootstraps its
- * own context.
- *
- * The DEFAULT palette is the warm-cream library identity over a transparent ground (the
- * glass card shows through); the mono-warm-white-on-near-black reference + the two-globe
- * composition are DEMO presets (presets-in-consumers — never a library token). The
- * teal-on-navy is GONE entirely.
- */
-type __VLS_Props = {
-    /** The full author schema (the studio's `useConfiguratorState` model). */
-    config?: DotMatrixConfig;
-    /**
-     * 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/dot-matrix/composables/dotMatrixField.d.ts

@@ -1,89 +0,0 @@
-/** A 3-vector. */
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-/** A row-major 3×3 matrix (the spin matrix the WGSL transcribes column-for-column). */
-export type Mat3 = readonly [
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number
-];
-/** The depth-fade result — the per-dot opacity + size multipliers. */
-export interface FacingFade {
-    /** The camera-facing opacity multiplier ∈ [facingLo, facingLo+facingHi]. */
-    opacity: number;
-    /** The depth-of-field size taper ∈ [0.6, 1.0]. */
-    size: number;
-    /** The raw facing term ∈ [0,1] (1 = dead-front, 0 = dead-back). */
-    facing: number;
-}
-/** The golden ratio φ = (1+√5)/2 ≈ 1.6180339887. */
-export declare const GOLDEN_RATIO: number;
-/** The golden angle = 2π/φ = π·(3−√5) ≈ 2.39996 rad ≈ 137.508° (the irrational azimuth). */
-export declare const GOLDEN_ANGLE: number;
-/**
- * The Fibonacci-phyllotaxis position for dot `i` of `N` on the UNIT sphere — the
- * area-centered half-offset variant (admits ANY `N`, the cheaper no-`acos` `y = cos(polar)`
- * form). The WGSL `instance_index → unit position` mapping transcribes this EXACTLY (the
- * F3 round-trip anchor):
- *
- *   y     = 1 − 2·(i + 0.5) / N      // y ∈ (−1,1), the cos(polar) — even by AREA
- *   r     = sqrt(1 − y²)             // ring radius at that latitude
- *   theta = i · goldenAngle          // the golden-angle azimuth spiral
- *   pos   = (cos(theta)·r, y, sin(theta)·r)
- *
- * This beats lat-long (`theta = 2πi/cols, phi = πj/rows`, which clusters at the poles →
- * banded rings) because the irrational golden ratio gives near-equal AREA with no
- * resonance gaps (extremelearning.com.au; arXiv 0912.4540).
- */
-export declare function fibonacciDot(i: number, n: number): Vec3;
-/** The opacity floor (a dead-back dot stays a faint shell point, never fully gone). */
-export declare const FACING_LO = 0.15;
-/** The opacity facing-gain (dead-front lifts to facingLo + facingHi). */
-export declare const FACING_HI = 0.85;
-/** The size depth-of-field taper base (a dead-back dot is 0.6× the dead-front size). */
-export declare const SIZE_TAPER_BASE = 0.6;
-/** The size depth-of-field taper gain. */
-export declare const SIZE_TAPER_GAIN = 0.4;
-/**
- * The §T2 depth-fade — the part that makes the dot field READ as a sphere. After the spin,
- * modulate per-dot opacity + size by the rotated-normal's camera-facing-ness (a SOFT
- * falloff, NOT a binary back-face cull — the soft fade is what reads as a translucent
- * shell vs a flat disc). For a sphere centered at origin the surface normal IS the
- * normalized dot position, so the facing term is the rotated-normal's z:
- *
- *   facing  = clamp(n.z · 0.5 + 0.5, 0, 1)            // 1 = dead-front, 0 = dead-back
- *   opacity = facingLo + facingHi · facing            // 0.15 + 0.85·facing
- *   size    = 0.6 + 0.4 · facing                      // the DOF dot-size taper
- *
- * `depthFade` ∈ [0,1] scales the facing GAIN (depthFade=1 → the full 0.85 shell read;
- * depthFade=0 → flat uniform opacity, the no-shell degenerate the gate's clause-6 flat-
- * uniform bite catches).
- */
-export declare function facingFade(normal: Vec3, depthFade?: number): FacingFade;
-/**
- * The spin matrix at time `t` — a slow Y-rotation about a gently TILTED axis (a tilted
- * globe reads more alive than a dead-vertical spin). The axis is the Y-axis tilted by
- * `axisTilt` (radians) toward +x; the rotation angle is `rate · t`. Returns a row-major
- * mat3 the WGSL transcribes column-for-column (mat3x3 is column-major → the transpose is
- * written as the SAME columns). A fixed `renderAt(t)` drives it deterministically for the
- * π capture (the spin reads at the same `t` on every host).
- */
-export declare function spinMatrix(t: number, axisTilt: number, rate: number): Mat3;
-/** Apply a row-major mat3 to a Vec3 (the rotated surface normal `n = spin · unitPos`). */
-export declare function applyMat3(m: Mat3, v: Vec3): Vec3;
-/**
- * The breathing radius scalar at time `t` — a gentle `R·(1 + breathDepth·sin(t·breathRate))`
- * pulse, the calmest non-dead register (`breathDepth ≈ 0.02`, far below the dot-flow sweep).
- * Returns the multiplier on the base radius (1 at rest when `depth=0`). The WGSL transcribes
- * the SAME `1 + depth·sin(t·rate)` form.
- */
-export declare function breathRadius(t: number, depth: number, rate: number): number;

package/dist/components/custom/dot-matrix/composables/uniformBridgeWGPU.d.ts

@@ -1,52 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import { type DotMatrixConfig } from "../constants";
-/** The byte size of one dot in the instance buffer (vec4<f32> = unitPos.xyz + sphereIdx). */
-export declare const DOT_BYTES = 16;
-/** The per-sphere offset of the SECOND globe (the reference two-globe composition). */
-export declare const SPHERE2_OFFSET: {
-    readonly x: 0.62;
-    readonly y: 0.32;
-};
-/** The per-sphere scale of the SECOND globe (a smaller satellite). */
-export declare const SPHERE2_SCALE = 0.46;
-/** The transient pointer state the interactive arm writes (closed over, never the config). */
-export interface DotPointerState {
-    /** Normalized-host pointer (0..1) → NDC offset; (0.5,0.5) is screen center. */
-    x: number;
-    y: number;
-    /** 1 while the pointer is over the host, 0 at rest (decays the parallax/dimple). */
-    active: number;
-    /** The repel/attract sign × strength (the dimple direction · velocity scale). */
-    push: number;
-    /** The accel-burst brightness/scale bloom 0..1 (the flick term). */
-    bloom: number;
-}
-/** A fresh resting pointer state. */
-export declare function restingPointer(): DotPointerState;
-export declare const DOT_RENDER_UNIFORM_BYTES: number;
-export interface DotUniformScratch {
-    buffer: ArrayBuffer;
-    f32: Float32Array;
-    i32: Int32Array;
-}
-export declare function createDotRenderScratch(): DotUniformScratch;
-/**
- * Build the STATIC Fibonacci-phyllotaxis instance buffer — `dotCount` dots per sphere,
- * each `(unitPos.xyz, sphereIdx)`. The second sphere's dots are CONCATENATED with
- * `sphereIdx = 1` so the shader resolves the per-sphere offset/scale. Built ONCE (the
- * layout is time-invariant; the spin + depth-fade are per-frame). The WGSL
- * `instance_index → unit position` mapping reads this buffer (it does NOT re-derive the
- * phyllotaxis on the GPU — the JS+GPU agree by construction).
- */
-export declare function buildDotsBuffer(config: DotMatrixConfig): Float32Array;
-/** The total dot instance count for a config (per-sphere × spheres). */
-export declare function dotInstanceCount(config: DotMatrixConfig): number;
-/**
- * Pack the per-frame render uniforms in place. `timeSec` drives the spin matrix + the
- * breathing; `pointer` carries the interactive parallax/dimple/bloom; `palette` is the
- * live ColorResolver stops (re-read each frame so a studio edit reaches the buffer).
- */
-export declare function packDotRenderUniforms(scratch: DotUniformScratch, config: DotMatrixConfig, timeSec: number, resolutionPx: {
-    w: number;
-    h: number;
-}, dpr: number, pointer: DotPointerState, breathRadius: number, palette: OklchStop[]): DotUniformScratch;

package/dist/components/custom/dot-matrix/composables/useDotMatrix.d.ts

@@ -1,34 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import type { OklchStop } from "../../../../composables/color";
-import type { DotMatrixConfig } from "../constants";
-export interface UseDotMatrixOptions {
-    config: DotMatrixConfig;
-    /** Resolve the dot-color 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 DotMatrixHandle {
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 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 (a pointer/setter that re-introduced motion). */
-    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 dot-matrix renderer on `canvasRef`. The WebGPU primary runs the instanced-
- * billboard render pass over the static phyllotaxis dots buffer; the WebGL2 fallback draws
- * the SAME instanced billboards (the ONE math source). Returns the uniform lifecycle handle.
- */
-export declare function useDotMatrix(canvasRef: Ref<HTMLCanvasElement | null>, options: UseDotMatrixOptions): DotMatrixHandle;

package/dist/components/custom/dot-matrix/composables/useDotSphere.d.ts

@@ -1,27 +0,0 @@
-import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
-import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
-import type { OklchStop } from "../../../../composables/color";
-import { type DotMatrixConfig } from "../constants";
-import { restingPointer, type DotPointerState } from "./uniformBridgeWGPU";
-export interface DotSetupDeps {
-    canvas: HTMLCanvasElement;
-    config: DotMatrixConfig;
-    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame. */
-    getPalette: () => OklchStop[];
-    /** The live transient pointer state (the interactive parallax/dimple/bloom). */
-    pointer: DotPointerState;
-    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
-    shouldContinue: () => boolean;
-    /** The per-frame pointer hook — advances the shared field (the no-own-rAF discipline). */
-    onFrame?: (timeSec: number) => void;
-}
-/** Build the dot-matrix `setupWGPU(device, context, format)` callback. */
-export declare function createDotWGPUSetup(deps: DotSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;
-/**
- * Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes — the SAME
- * instanced billboards via `gl.drawArraysInstanced`. It seeds the SAME JS phyllotaxis dot
- * buffer the WGSL primary uses + splices the SHARED GLSL color chunk (the ONE color source
- * → no drift between backends). No Canvas2D anywhere (§E).
- */
-export declare function createDotGLSetup(deps: DotSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;
-export { restingPointer };

package/dist/components/custom/dot-matrix/constants.d.ts

@@ -1,58 +0,0 @@
-import type { OklchStop } from "../../../composables/color";
-/** Compile-time dot cap — mirrors the WGSL/GLSL instance-buffer array bound. */
-export declare const MAX_DOTS = 4000;
-/** Compile-time palette cap — mirrors the WGSL `MAX_DOT_STOPS` #define. */
-export declare const MAX_DOT_STOPS = 4;
-/** Pointer interaction mode — a repel pushes dots off the surface, attract pulls them in. */
-export type DotPointerMode = "repel" | "attract";
-/**
- * The full author schema — the studio's `useConfiguratorState` model. Every field is a
- * tunable the demo configurator drives; the composable resolves it into the uniform table.
- * A NEW schema (no prior `dot-matrix`, no MIGRATION row).
- */
-export interface DotMatrixConfig {
-    /** Dot count on the sphere surface (500–MAX_DOTS; the reference's fine field). */
-    dotCount: number;
-    /** Sphere radius as a fraction of the view min-dimension (0.2–0.9). */
-    radius: number;
-    /** Base dot billboard radius in px @ 1× (DPR-aware → crisp). */
-    dotSize: number;
-    /** The subtle resting opacity (0–1). */
-    baseOpacity: number;
-    /** Depth-fade strength (0–1; high = strong translucent-shell read). */
-    depthFade: number;
-    /** The slow dignified Y-spin in rad/s (0–0.3). */
-    rotationSpeed: number;
-    /** The rotation-axis tilt in degrees (a tilted globe reads more alive; ~23°). */
-    axisTilt: number;
-    /** The globe count (1 default; the reference two-globe composition is 2). */
-    spheres: 1 | 2;
-    /** The sub-perceptual breathing radius-pulse depth (0 default; demo 0.02). */
-    breathing: number;
-    /** The dot-color ramp (the demo themes it mono-white); resolved via the ColorResolver. */
-    palette: OklchStop[];
-    /** The ground color (the demo sets near-black; default transparent). */
-    background: OklchStop | "transparent";
-    /** Pointer parallax + repel + accel-burst (the §T7 interaction). */
-    interactive: boolean;
-    /** repel ↔ attract (the dimple direction). */
-    pointerMode: DotPointerMode;
-    /** The pointer-parallax depth (0–0.3; the screen-center tracks the cursor). */
-    parallax: number;
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
-    respectReducedMotion: boolean;
-}
-/**
- * The warm-cream identity palette (the library default — NOT teal). A two-stop warm-amber
- * ramp over the warm-cream foreground family, mirroring the dot-flow `WARM_IDENTITY_PALETTE`.
- * A consumer (the demo) themes it mono-warm-white-on-near-black through a PRESET, never a
- * token edit.
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/**
- * The shipped warm-identity default config — the §T5 SUBTLE + CALM register: ONE calm
- * warm-cream globe of fine dots on a transparent ground (the glass card shows through),
- * slowly rotating on a tilted axis. The depth-fade carries the sphere read; the second
- * sphere + the breathing + the near-black ground are DEMO presets (presets-in-consumers).
- */
-export declare const DEFAULT_DOT_MATRIX_CONFIG: DotMatrixConfig;

package/dist/components/custom/dot-matrix/index.d.ts

@@ -1,5 +0,0 @@
-export { default as DotMatrix } from "./DotMatrix.vue";
-export { useDotMatrix, type DotMatrixHandle, type UseDotMatrixOptions, } from "./composables/useDotMatrix";
-export { type DotMatrixConfig, type DotPointerMode, DEFAULT_DOT_MATRIX_CONFIG, WARM_IDENTITY_PALETTE, MAX_DOTS, MAX_DOT_STOPS, } from "./constants";
-export { type Vec3, type Mat3, type FacingFade, fibonacciDot, facingFade, spinMatrix, applyMat3, breathRadius, GOLDEN_RATIO, GOLDEN_ANGLE, FACING_LO, FACING_HI, SIZE_TAPER_BASE, SIZE_TAPER_GAIN, } from "./composables/dotMatrixField";
-export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/dot-matrix/shaders/dot-matrix.glsl.d.ts

@@ -1,4 +0,0 @@
-/** The instanced-billboard VERTEX shader (gl_VertexID quad + instanced dot attribute). */
-export declare const DOT_MATRIX_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_DOT_STOPS 4\n#define GOLDEN_ANGLE 2.399963229728653\n\n// The static quad corner (6 verts: two triangles) + the instanced per-dot data.\nin vec2 aCorner;          // billboard-local [-1,1]\nin vec4 aDot;             // (unitPos.xyz, sphereIdx) \u2014 instanced (divisor 1)\n\nuniform vec4 uU0;         // (resX, resY, dpr, time)\nuniform vec4 uU1;         // (radius, dotSize, baseOpacity, aspect)\nuniform vec4 uU2;         // (facingLo, facingHi, sizeLo, sizeHi)\nuniform vec4 uU3;         // (parallax, pointerPush, pointerBloom, pointerActive)\nuniform vec4 uU4;         // (pointerX, pointerY, sphere2Scale, breathRadius)\nuniform vec4 uU5;         // (sphere2OffsetX, sphere2OffsetY, hasBackground, _pad)\nuniform mat3 uSpin;       // the slow tilted Y-rotation\n\nout vec2 vLocal;          // [-1,1] billboard-local for the SDF circle\nout float vBright;        // facing-driven brightness\nout float vAlpha;         // facing-driven opacity\nout float vTone;          // palette tone (0 = bright cream near-front, 1 = amber rim)\n\nfloat facingTerm(vec3 n) {\n  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front\n}\n\nvoid main() {\n  vec3 unitPos = aDot.xyz;\n  float sphereIdx = aDot.w;\n\n  float breath = uU4.w;\n  float sphereScale = uU1.x;\n  vec2 sphereOffset = vec2(0.0);\n  if (sphereIdx > 0.5) {\n    sphereScale = uU1.x * uU4.z;\n    sphereOffset = vec2(uU5.x, uU5.y);\n  }\n\n  // The rotated surface normal = spin \u00B7 unitPos (the \u00A7T2 facing source).\n  vec3 n = uSpin * unitPos;\n  float facing = facingTerm(n);\n\n  // Pointer-repel/attract dimple (the \u00A7T7 local perturbation).\n  float pAct = uU3.w;\n  vec2 pointerNdc = vec2(uU4.x * 2.0 - 1.0, 1.0 - uU4.y * 2.0);\n  vec2 screenN = n.xy * sphereScale + sphereOffset;\n  vec2 toPointer = screenN - pointerNdc;\n  float pd = length(toPointer);\n  float dimple = exp(-pd * pd * 18.0) * uU3.y * pAct;\n  vec2 lift = n.xy * dimple;\n\n  vec2 parallaxOff = pointerNdc * uU3.x * pAct;\n  vec2 center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;\n\n  // The depth-of-field size taper + the accel-burst bloom scale.\n  float sizeTaper = uU2.z + uU2.w * facing;\n  float burstScale = 1.0 + uU3.z * exp(-pd * pd * 12.0);\n  float dotR = uU1.y * sizeTaper * burstScale;\n\n  float offX = aCorner.x * dotR;\n  float offY = aCorner.y * dotR;\n\n  float facingOpacity = uU2.x + uU2.y * facing;\n  float burstBright = 1.0 + uU3.z * 0.8 * exp(-pd * pd * 12.0);\n\n  vLocal = aCorner;\n  vBright = facingOpacity * burstBright;\n  vAlpha = clamp(uU1.z * facingOpacity * burstBright, 0.0, 1.0);\n  // The palette tone reads the DEPTH (near-front bright cream \u2192 rim amber) so the depth-shell\n  // reads tonally on BOTH a dark AND a light ground.\n  vTone = clamp(1.0 - facing, 0.0, 1.0);\n\n  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the\n  // final clip-space x divides by aspect so a wide canvas does not squash it into an ellipse.\n  float aspect = max(uU1.w, 1e-4);\n  gl_Position = vec4((center2d.x + offX) / aspect, center2d.y + offY, 0.0, 1.0);\n}";
-/** The crisp fwidth-SDF dot fragment (the ONE AA canon; splices the shared color chunk). */
-export declare const DOT_MATRIX_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_DOT_STOPS 4\n\nin vec2 vLocal;\nin float vBright;\nin float vAlpha;\nin float vTone;\nout vec4 fragColor;\n\nuniform vec4 uBg;                       // (background.rgb, hasBackground)\nuniform int  uStopCount;\nuniform vec3 uPalette[MAX_DOT_STOPS];   // linear-sRGB stops\n\nconst mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);\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\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  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon; ~1px band at any DPR).\n  float d = length(vLocal) - 1.0;\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage < 0.002) discard;\n\n  vec3 lin = samplePaletteLin(vTone) * clamp(vBright, 0.0, 1.6);\n  float alpha = vAlpha * coverage;\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  fragColor = vec4(rgb * alpha, alpha);\n}";

package/dist/components/custom/dot-matrix/shaders/dot-matrix.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const DOT_MATRIX_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_DOT_STOPS: i32 = 4;\n// The golden-angle constant (transcribes dotMatrixField.ts GOLDEN_ANGLE = PI*(3-sqrt5)).\nconst GOLDEN_ANGLE: f32 = 2.399963229728653;\n\nstruct Dot {\n  // (unitPos.xyz, sphereIdx)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct Uniforms {\n  // u0: (uResolutionX, uResolutionY, uDpr, uTime)\n  u0: vec4<f32>,\n  // u1: (uRadius, uDotSize, uBaseOpacity, uAspect)\n  u1: vec4<f32>,\n  // u2: (uFacingLo, uFacingHi, uSizeLo, uSizeHi)\n  u2: vec4<f32>,\n  // u3: (uParallax, uPointerPush, uPointerBloom, uPointerActive)\n  u3: vec4<f32>,\n  // u4: (uPointerX, uPointerY, uSphere2Scale, uBreathRadius)\n  u4: vec4<f32>,\n  // u5: (uSphere2OffsetX, uSphere2OffsetY, uHasBackground, _pad)\n  u5: vec4<f32>,\n  spin: mat3x3<f32>,\n  // ints: (uStopCount, uDotCount, uSpheres, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb, _pad)\n  bg: vec4<f32>,\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n@group(0) @binding(1) var<storage, read> dots: array<Dot>;\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// The \u00A7T2 depth-fade (transcribes dotMatrixField.ts facingFade): the rotated-normal's z\n// \u2192 a SOFT facing term \u2192 opacity + size ramps. NOT a binary back-face cull.\nfn facingTerm(n: vec3<f32>) -> f32 {\n  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front, 0 = dead-back\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.x;\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\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the SDF circle\n  @location(1) bright: f32,        // facing-driven brightness [0, ~1.6]\n  @location(2) alpha: f32,         // facing-driven opacity\n  @location(3) tone: f32,          // palette tone (0 = bright cream near-front, 1 = amber rim)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vi: u32,\n  @builtin(instance_index) ii: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space (camera-facing by construction).\n  var corners = 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 local = corners[vi];\n\n  let dot = dots[ii].data;\n  var unitPos = dot.xyz;          // the STATIC phyllotaxis position (JS-computed)\n  let sphereIdx = dot.w;\n\n  // The breathing radius pulse (transcribes breathRadius \u2014 1 at rest).\n  let breath = u.u4.w;\n  // Per-sphere offset/scale (the reference two-globe composition).\n  var sphereScale = u.u1.x;       // uRadius\n  var sphereOffset = vec2<f32>(0.0, 0.0);\n  if (sphereIdx > 0.5) {\n    sphereScale = u.u1.x * u.u4.z;             // uRadius * uSphere2Scale\n    sphereOffset = vec2<f32>(u.u5.x, u.u5.y);  // uSphere2Offset\n  }\n\n  // The rotated surface NORMAL = spin \u00B7 unitPos (the \u00A7T2 facing source). The spin matrix\n  // is the slow tilted Y-rotation (dotMatrixField.ts spinMatrix).\n  let n = u.spin * unitPos;\n  let facing = facingTerm(n);\n\n  // Pointer-repel/attract \u2014 a soft Gaussian dimple lifts the dot radially off the surface\n  // near the cursor (the \u00A7T7 local perturbation). The pointer is in NDC (-1..1); a repel\n  // (push>0) pushes the dot OUT, an attract (push<0) pulls IN. Velocity scales the push.\n  let pAct = u.u3.w;\n  let pointerNdc = vec2<f32>(u.u4.x * 2.0 - 1.0, 1.0 - u.u4.y * 2.0);\n  let screenN = n.xy * sphereScale + sphereOffset;\n  let toPointer = screenN - pointerNdc;\n  let pd = length(toPointer);\n  let dimple = exp(-pd * pd * 18.0) * u.u3.y * pAct;   // soft Gaussian falloff \u00D7 push\n  // Lift along the rotated normal's screen projection (radially through the shell).\n  let lift = n.xy * dimple;\n\n  // Project the rotated normal to the screen (orthographic \u2014 the \u00A7T5 flat hero look),\n  // scaled by the sphere radius + the breathing, plus the per-sphere offset + the dimple\n  // lift + the pointer-parallax screen-center track.\n  let parallaxOff = (pointerNdc) * u.u3.x * pAct;       // uParallax \u00B7 pointer \u00B7 active\n  let center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;\n\n  // The depth-of-field dot-size taper (transcribes facingFade size): 0.6 + 0.4\u00B7facing,\n  // plus the accel-burst bloom scale near the cursor.\n  let sizeTaper = u.u2.z + u.u2.w * facing;\n  let burstScale = 1.0 + u.u3.z * exp(-pd * pd * 12.0);\n  let dotR = u.u1.y * sizeTaper * burstScale;            // uDotSize \u00B7 taper \u00B7 burst\n\n  let offX = local.x * dotR;\n  let offY = local.y * dotR;\n\n  // The opacity ramp (transcribes facingFade opacity): facingLo + facingHi\u00B7facing, scaled\n  // by the base opacity + a faint burst brightness lift near the cursor.\n  let facingOpacity = u.u2.x + u.u2.y * facing;          // facingLo + facingHi\u00B7facing\n  let burstBright = 1.0 + u.u3.z * 0.8 * exp(-pd * pd * 12.0);\n\n  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the\n  // final clip-space x divides by aspect so a wide canvas does not squash it into an\n  // ellipse (aspect \u2265 1 \u2192 x shrinks; aspect < 1 \u2192 x grows). This keeps the dot quads round\n  // AND the sphere circular in PIXELS regardless of the canvas aspect.\n  let aspect = max(u.u1.w, 1e-4);\n  let clipX = (center2d.x + offX) / aspect;\n  let clipY = center2d.y + offY;\n\n  var out: VSOut;\n  out.pos = vec4<f32>(clipX, clipY, 0.0, 1.0);\n  out.local = local;\n  out.bright = facingOpacity * burstBright;\n  out.alpha = clamp(u.u1.z * facingOpacity * burstBright, 0.0, 1.0);\n  // The palette tone reads the DEPTH (not the opacity): the near-front samples the bright\n  // cream stop[0] (tone 0), the rim/far the darker amber stop (tone \u2192 1), so the depth-shell\n  // reads TONALLY on BOTH a dark AND a light ground (a light-ground globe can't lean on the\n  // opacity fade alone \u2014 over a light card a faded dot reads brighter, inverting the shell).\n  out.tone = clamp(1.0 - facing, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon \u2014 the band is ~1px wide at\n  // any DPR/zoom, so fine sub-2px dots stay crisp). d = |uv| - 1; aa = fwidth(d).\n  let d = length(in.local) - 1.0;\n  let aa = max(fwidth(d), 1e-4);\n  let coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage < 0.002) { discard; }\n\n  // The palette tints the dot by DEPTH (near-front cream \u2192 rim amber); the brightness lights\n  // the core. The near hemisphere reads as the bright warm-cream stop, the rim/far fading to\n  // the darker amber \u2014 the translucent dot-shell on both grounds.\n  let lin = samplePaletteLin(in.tone) * clamp(in.bright, 0.0, 1.6);\n  let alpha = in.alpha * coverage;\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n  // Premultiplied-alpha output (the translucent dot-shell additive over the clear).\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -1,71 +0,0 @@
-import { type Surface } from "../../ui/_shared/useSurfaceAxis";
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
-    buttonPosition?: "left" | "right";
-    /** Accessible name for the expand (fullscreen) button. */
-    expandLabel?: string;
-    /** Accessible name for the collapse (exit fullscreen) button. */
-    collapseLabel?: string;
-    /** Surface decoration register for the fullscreen overlay
-     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
-     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
-    surface?: Surface;
-} & {
-    /**
-     * Two-way `open` model so consumers can drive fullscreen externally
-     * (programmatic toggles, route-driven launches, etc.) while the corner
-     * buttons continue to operate without parent wiring.
-     */
-    open?: boolean;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:open": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<{
-    buttonPosition?: "left" | "right";
-    /** Accessible name for the expand (fullscreen) button. */
-    expandLabel?: string;
-    /** Accessible name for the collapse (exit fullscreen) button. */
-    collapseLabel?: string;
-    /** Surface decoration register for the fullscreen overlay
-     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
-     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
-    surface?: Surface;
-} & {
-    /**
-     * Two-way `open` model so consumers can drive fullscreen externally
-     * (programmatic toggles, route-driven launches, etc.) while the corner
-     * buttons continue to operate without parent wiring.
-     */
-    open?: boolean;
-}> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
-}>, {
-    surface: Surface;
-    buttonPosition: "left" | "right";
-    expandLabel: string;
-    collapseLabel: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    'expand-trigger'?: (props: {
-        expand: () => void;
-        label: string;
-    }) => any;
-} & {
-    default?: (props: {
-        fullscreen: boolean;
-    }) => any;
-} & {
-    'fullscreen-chrome'?: (props: {
-        collapse: () => void;
-        label: string;
-        fullscreen: boolean;
-    }) => any;
-} & {
-    default?: (props: {
-        fullscreen: boolean;
-    }) => any;
-}>;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};