@mkbabb/glass-ui 7.0.0 → 9.0.0

package/dist/components/fourier-field/shaders/fourier-field.glsl.d.ts

@@ -1,4 +0,0 @@
-/** The instanced ribbon VERTEX — expands the unit quad to each instance's covered bbox. */
-export declare const FOURIER_FIELD_VERT_GLSL = "#version 300 es\n// Must equal the WGSL twin and FOURIER_TANGENT_EPS in constants.ts.\n#define RIBBON_UNDERGLOW_SCALE 2.2\n\nin vec2 aCorner;   // the unit quad corner \u2208 [0,1]\u00B2\nin vec4 aSeg;      // (ax, ay, bx, by) \u2014 segment endpoints in MODEL space\nin vec4 aData;     // (age, strokeHalf, arg2, _pad) \u2014 strokeHalf/age/arg2 per layer\n\nuniform vec4 uFit;         // (centerX, centerY, scale, aspect) \u2014 model\u2192clip fit\nuniform int  uLayer;       // 0 trail \u00B7 1 epicycle \u00B7 2 head \u00B7 3 cel-rope \u00B7 4 cel-arm\nuniform float uEdgeMargin; // AA-feather slop in MODEL units (a few CSS px), padding the bbox\n\nout vec2 vP;       // the MODEL-space fragment coordinate (the fs runs the SDF on it)\nout vec2 vA;\nout vec2 vB;\nout float vAge;\nout float vHalf;\nout float vArg2;\n\nvoid main() {\n  vec2 a = aSeg.xy;\n  vec2 b = aSeg.zw;\n  float strokeHalf = aData.y;\n  vA = a; vB = b; vAge = aData.x; vHalf = strokeHalf; vArg2 = aData.z;\n\n  vec2 pos;\n  if (uLayer == 1 || uLayer == 2) {\n    // AABB around a \u2014 the epicycle orbit RING (radius = |b-a|) or the head HALO.\n    float ext = (uLayer == 1) ? (length(b - a) + strokeHalf * 0.7) : (strokeHalf * 4.5);\n    ext += uEdgeMargin;\n    pos = a + (aCorner * 2.0 - 1.0) * ext;\n  } else {\n    // Capsule along a\u2192b padded by the covered extent (trail under-glow, cel stroke).\n    float ext = (uLayer == 0) ? (strokeHalf * RIBBON_UNDERGLOW_SCALE) : strokeHalf;\n    ext += uEdgeMargin;\n    vec2 d = b - a;\n    float len = length(d);\n    vec2 dir = len > 1e-6 ? d / len : vec2(1.0, 0.0);\n    vec2 perp = vec2(-dir.y, dir.x);\n    vec2 along = mix(a - dir * ext, b + dir * ext, aCorner.x);\n    pos = along + perp * (aCorner.y * 2.0 - 1.0) * ext;\n  }\n\n  vP = pos;\n  vec2 center = uFit.xy;\n  float scale = max(uFit.z, 1e-6);\n  float aspect = max(uFit.w, 1e-4);\n  // model \u2192 clip (the inverse of the fs's p = center + vClip\u00B7aspect, scale).\n  float clipX = (pos.x - center.x) * scale / aspect;\n  float clipY = (pos.y - center.y) * scale;\n  gl_Position = vec4(clipX, clipY, 0.0, 1.0);\n}\n";
-/** The instanced ribbon FRAGMENT — the exact per-layer SDF over-composite, loop-free. */
-export declare const FOURIER_FIELD_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_FOURIER_STOPS 4\n// Must equal the WGSL twin and FOURIER_TANGENT_EPS in constants.ts.\n#define TANGENT_EPS 1e-4\n#define SPEED_REF_HALFWIDTHS 6.0\n// The thick luminous ribbon mirrors RIBBON_TAIL_FRAC verbatim\n// from constants.ts because the GLSL twin cannot import a TS const; parity coverage verifies the\n// two copies are equal so the mid-body floor (RIBBON_HEAD_FLOOR_PX) can never drift off it.\n#define RIBBON_TAIL_FRAC 0.4\n#define RIBBON_UNDERGLOW_SCALE 2.2\n#define RIBBON_UNDERGLOW_ALPHA 0.16\n\nin vec2 vP;\nin vec2 vA;\nin vec2 vB;\nin float vAge;\nin float vHalf;\nin float vArg2;\nout vec4 fragColor;\n\nuniform vec4 uTrail;      // (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\nuniform vec4 uEnv;        // (trailFloor, intensity, showEpicycles, rainbowChain)\nuniform vec4 uLoom;       // (squashGain, celGain, _pad, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b\nuniform int  uLayer;      // 0 trail \u00B7 1 epicycle \u00B7 2 head \u00B7 3 cel-rope \u00B7 4 cel-arm\nuniform int  uStopCount;\nuniform vec3 uPalette[MAX_FOURIER_STOPS]; // linear-sRGB stops\n\nconst float PI = 3.141592653589793;\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// Negative-safe cube root (the WGSL chunk's cbrt3 twin; the GLSL chunk inlines it).\nvec3 cbrt3(vec3 v) { return sign(v) * pow(abs(v), vec3(1.0 / 3.0)); }\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 labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i0]);\n  vec3 labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i1]);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvec3 chainColorLin(float seg, bool rainbow) {\n  vec3 baseLin = uPalette[0];\n  if (!rainbow) return baseLin;\n  vec3 lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  vec3 lch = oklabToOklch(lab);\n  float hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0));\n  vec3 lifted = vec3(0.66, max(lch.y, 0.14), lch.z + hueShift);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\nfloat segDist(vec2 p, vec2 a, vec2 b) {\n  vec2 pa = p - a;\n  vec2 ba = b - a;\n  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// The head travel frame (T, \u015D), the GLSL twin of the WGSL headFrame.\nstruct HeadFrame { vec2 T; float sHat; };\nHeadFrame headFrame(vec2 head, vec2 headBack, float halfW) {\n  vec2 d = head - headBack;\n  float s = length(d);\n  HeadFrame fr;\n  if (s <= TANGENT_EPS) { fr.T = vec2(1.0, 0.0); fr.sHat = 0.0; return fr; }\n  fr.T = d / s;\n  float refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  fr.sHat = clamp(s / refScale, 0.0, 1.0);\n  return fr;\n}\n\n// The volume-preserving anisotropic head distance (the WGSL headAniso twin).\nfloat headAniso(vec2 p, vec2 head, HeadFrame fr, float k) {\n  float g = 1.0 + k * fr.sHat;\n  vec2 n = vec2(-fr.T.y, fr.T.x);\n  vec2 rel = p - head;\n  float along = dot(rel, fr.T) / g;\n  float across = dot(rel, n) * g;\n  return length(vec2(along, across));\n}\n\nvoid main() {\n  vec2 p = vP;\n  float aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n  float peak = uTrail.y * uEnv.y;\n  float headGlow = uTrail.z * uEnv.y;\n  float fadeExp = uTrail.w;\n  float trailFloor = uEnv.x;\n  bool rainbow = uEnv.w > 0.5;\n  float squashGain = uLoom.x;\n  float celGain = uLoom.y;\n  float halfW = vHalf;\n\n  if (uLayer == 0) {\n    // \u2500\u2500 TRAIL \u2014 the tapered luminous ribbon over its own soft under-glow \u2500\u2500\n    float age = vAge;\n    float d = segDist(p, vA, vB);\n    // Head\u2192tail taper: the ribbon half-width scales with age (thick head, thin tail).\n    float ribbonHalf = halfW * (RIBBON_TAIL_FRAC + (1.0 - RIBBON_TAIL_FRAC) * age);\n    vec3 lin = samplePaletteLin(1.0 - age * 0.4);\n    vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n    // Soft under-glow: a wider, low-alpha copy under the crisp ribbon (one color event).\n    float glowHalf = ribbonHalf * RIBBON_UNDERGLOW_SCALE;\n    float glowCover = 1.0 - smoothstep(glowHalf, glowHalf + aa * 3.0, d);\n    float ga = peak * RIBBON_UNDERGLOW_ALPHA * pow(age, fadeExp) * glowCover;\n    // The crisp tapered ribbon core.\n    float cover = 1.0 - smoothstep(ribbonHalf, ribbonHalf + aa, d);\n    float ca = max(peak * pow(age, fadeExp), peak * trailFloor) * cover;\n    // core OVER glow OVER transparent (both premultiplied on the SAME rgb \u2192 out = rgb\u00B7outA).\n    float outA = ca + ga * (1.0 - ca);\n    fragColor = vec4(rgb * outA, outA);\n  } else if (uLayer == 1) {\n    // \u2500\u2500 EPICYCLE \u2014 orbit RING + ARM + joint DOT union (MAX-blended, no join seam) \u2500\u2500\n    float seg = vArg2;\n    vec3 lin = chainColorLin(seg, rainbow);\n    vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n    float radius = length(vB - vA);\n    float dRing = abs(length(p - vA) - radius);\n    float ringW = max(halfW * 0.45, aa);\n    float ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n    float dArm = segDist(p, vA, vB);\n    float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n    float dotR = max(halfW * 0.7, aa * 2.0);\n    float dDot = length(p - vA);\n    float dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n    float m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n    fragColor = vec4(rgb * m, m);\n  } else if (uLayer == 2) {\n    // \u2500\u2500 HEAD \u2014 squash-and-stretch (\u00A72b): halo + saturated core + white specular \u2500\u2500\n    vec2 head = vA;\n    vec2 headBack = vB;\n    HeadFrame fr = headFrame(head, headBack, halfW);\n    float dHead = headAniso(p, head, fr, squashGain);\n    float coreR = halfW * 1.5;\n    float haloR = coreR * 3.0;\n    vec3 headRgb = clamp(linearToSrgb(samplePaletteLin(0.0)), vec3(0.0), vec3(1.0));\n    float halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    vec4 accum = vec4(headRgb * halo, halo);\n    float core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4(headRgb * core, core) + accum * (1.0 - core);\n    float spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4(vec3(1.0) * spec, spec) + accum * (1.0 - spec);\n    fragColor = accum;\n  } else {\n    // \u2500\u2500 CEL \u2014 the technicolor ink shadow (rope uLayer==3, arm uLayer==4) \u2500\u2500\n    float celA = clamp(celGain, 0.0, 1.0);\n    float d = segDist(p, vA, vB);\n    float cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    float m = cover * celA * peak * vArg2; // vArg2 = celStrength (1.0 rope / 0.7 arm)\n    fragColor = vec4(0.0, 0.0, 0.0, m);\n  }\n}\n";

package/dist/components/fourier-field/shaders/fourier-field.render.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const FOURIER_FIELD_RENDER_WGSL = "\n// The instanced-ribbon LAYER selector (a pipeline-overridable constant \u2014 5 pipelines share the\n// ONE module, each specializing this): 0 trail \u00B7 1 epicycle \u00B7 2 head \u00B7 3 cel-rope \u00B7 4 cel-arm.\noverride LAYER: i32 = 0;\n\nconst PI: f32 = 3.141592653589793;\n// The degenerate-tangent guard must equal FOURIER_TANGENT_EPS in\n// constants.ts and the GL CPU bead path so a cusp resolves identically across both engines.\nconst TANGENT_EPS: f32 = 1e-4;\nconst SPEED_REF_HALFWIDTHS: f32 = 6.0;\n// The thick luminous ribbon mirrors RIBBON_TAIL_FRAC verbatim\n// from constants.ts because the WGSL twin cannot import a TS const; parity coverage verifies the\n// two copies are equal so the mid-body floor (RIBBON_HEAD_FLOOR_PX) can never drift off it.\nconst RIBBON_TAIL_FRAC: f32 = 0.4;\nconst RIBBON_UNDERGLOW_SCALE: f32 = 2.2;\nconst RIBBON_UNDERGLOW_ALPHA: f32 = 0.16;\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct RenderUniforms {\n  // r0: (centerX, centerY, scale, aspect)  \u2014 model\u2192clip fit transform\n  r0: vec4<f32>,\n  // r1: (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\n  r1: vec4<f32>,\n  // r2: (trailFloor, intensity, showEpicycles, rainbowChain)\n  r2: vec4<f32>,\n  // r3: (squashGain, celGain, edgeMargin, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b + the ribbon bbox slop\n  r3: vec4<f32>,\n  // ints: (sampleCount, armCount, stopCount, _pad)\n  ints: vec4<i32>,\n  // palette stops: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n// curveSamples[i] = (x, y, age, _pad) in MODEL space \u2014 the render VERTEX-PULLS these.\n@group(0) @binding(1) var<storage, read> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) in MODEL space.\n@group(0) @binding(2) var<storage, read> chainTips: array<vec4<f32>>;\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\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\nfn chainColorLin(seg: f32, rainbow: bool) -> vec3<f32> {\n  let baseLin = u.palette[0].rgb;\n  if (!rainbow) { return baseLin; }\n  let lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  let lch = oklabToOklch(lab);\n  let hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0));\n  let h = lch.z + hueShift;\n  let lifted = vec3<f32>(0.66, max(lch.y, 0.14), h);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\nfn segDist(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {\n  let pa = p - a;\n  let ba = b - a;\n  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// The head travel frame + the volume-preserving anisotropic distance.\nstruct HeadFrame { T: vec2<f32>, sHat: f32, };\nfn headFrame(head: vec2<f32>, headBack: vec2<f32>, halfW: f32) -> HeadFrame {\n  let d = head - headBack;\n  let s = length(d);\n  var out: HeadFrame;\n  if (s <= TANGENT_EPS) {\n    out.T = vec2<f32>(1.0, 0.0);\n    out.sHat = 0.0;\n    return out;\n  }\n  out.T = d / s;\n  let refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  out.sHat = clamp(s / refScale, 0.0, 1.0);\n  return out;\n}\n\nfn headAniso(p: vec2<f32>, head: vec2<f32>, fr: HeadFrame, k: f32) -> f32 {\n  let g = 1.0 + k * fr.sHat;\n  let n = vec2<f32>(-fr.T.y, fr.T.x);\n  let rel = p - head;\n  let along = dot(rel, fr.T) / g;\n  let across = dot(rel, n) * g;\n  return length(vec2<f32>(along, across));\n}\n\n// The cel ink lags behind the travel \u2014 the SAME \u2212T\u00B7halfW\u00B71.4 offset both engines apply (the\n// head frame is read straight off the compute-filled curveSamples[0]/[1], parity by construction).\nfn celOffset(halfW: f32) -> vec2<f32> {\n  let fr = headFrame(curveSamples[0].xy, curveSamples[1].xy, halfW);\n  return -fr.T * halfW * 1.4;\n}\n\n// The unit quad as two triangles (6 verts) in [0,1]\u00B2 \u2014 the instanced vertex expands it.\nfn quadCorner(vi: u32) -> vec2<f32> {\n  var c = array<vec2<f32>, 6>(\n    vec2<f32>(0.0, 0.0), vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0),\n    vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 0.0), vec2<f32>(1.0, 1.0),\n  );\n  return c[vi];\n}\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) p: vec2<f32>,      // model-space fragment coordinate\n  @location(1) a: vec2<f32>,\n  @location(2) b: vec2<f32>,\n  @location(3) segData: vec3<f32>,   // (age, strokeHalf, arg2)\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32, @builtin(instance_index) inst: u32) -> VSOut {\n  let corner = quadCorner(vi);\n  let center = u.r0.xy;\n  let scale = max(u.r0.z, 1e-6);\n  let aspect = max(u.r0.w, 1e-4);\n  let halfW = u.r1.x * 0.5;\n  let margin = u.r3.z;\n\n  var a: vec2<f32> = vec2<f32>(0.0);\n  var b: vec2<f32> = vec2<f32>(0.0);\n  var strokeHalf: f32 = halfW;\n  var age: f32 = 0.0;\n  var arg2: f32 = 0.0;\n  var isCapsule: bool = true;\n  var ext: f32 = halfW;\n\n  if (LAYER == 0) {\n    // TRAIL \u2014 the curve capsule; the covered extent is the head-width under-glow.\n    a = curveSamples[inst].xy;\n    b = curveSamples[inst + 1u].xy;\n    age = max(curveSamples[inst].z, curveSamples[inst + 1u].z);\n    ext = halfW * RIBBON_UNDERGLOW_SCALE;\n    isCapsule = true;\n  } else if (LAYER == 1) {\n    // EPICYCLE \u2014 the chain AABB around a (radius = |b\u2212a|).\n    a = chainTips[inst].xy;\n    b = chainTips[inst + 1u].xy;\n    arg2 = f32(inst) / max(f32(u.ints.y - 1), 1.0);\n    ext = length(b - a) + halfW * 0.7;\n    isCapsule = false;\n  } else if (LAYER == 2) {\n    // HEAD \u2014 the comet head at curveSamples[0], AABB by the halo radius.\n    a = curveSamples[0].xy;\n    b = curveSamples[1].xy;\n    ext = halfW * 4.5;\n    isCapsule = false;\n  } else if (LAYER == 3) {\n    // CEL-ROPE \u2014 the curve capsule, offset opposite travel; full-width ink.\n    let off = celOffset(halfW);\n    a = curveSamples[inst].xy + off;\n    b = curveSamples[inst + 1u].xy + off;\n    arg2 = 1.0;\n    ext = halfW;\n    isCapsule = true;\n  } else {\n    // CEL-ARM (LAYER == 4) \u2014 the chain capsule, offset; the narrower arm ink (0.55\u00B7halfW).\n    let off = celOffset(halfW);\n    a = chainTips[inst].xy + off;\n    b = chainTips[inst + 1u].xy + off;\n    strokeHalf = halfW * 0.55;\n    arg2 = 0.7;\n    ext = halfW * 0.55;\n    isCapsule = true;\n  }\n  ext = ext + margin;\n\n  var pos: vec2<f32>;\n  if (isCapsule) {\n    let d = b - a;\n    let len = length(d);\n    var dir = vec2<f32>(1.0, 0.0);\n    if (len > 1e-6) { dir = d / len; }\n    let perp = vec2<f32>(-dir.y, dir.x);\n    let along = mix(a - dir * ext, b + dir * ext, corner.x);\n    pos = along + perp * (corner.y * 2.0 - 1.0) * ext;\n  } else {\n    pos = a + (corner * 2.0 - vec2<f32>(1.0)) * ext;\n  }\n\n  let clipX = (pos.x - center.x) * scale / aspect;\n  let clipY = (pos.y - center.y) * scale;\n  var out: VSOut;\n  out.pos = vec4<f32>(clipX, clipY, 0.0, 1.0);\n  out.p = pos;\n  out.a = a;\n  out.b = b;\n  out.segData = vec3<f32>(age, strokeHalf, arg2);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let p = in.p;\n  let aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n  let peak = u.r1.y * u.r2.y;\n  let headGlow = u.r1.z * u.r2.y;\n  let fadeExp = u.r1.w;\n  let trailFloor = u.r2.x;\n  let rainbow = u.r2.w > 0.5;\n  let squashGain = u.r3.x;\n  let celGain = u.r3.y;\n  let halfW = in.segData.y;\n  let age = in.segData.x;\n  let arg2 = in.segData.z;\n  let a = in.a;\n  let b = in.b;\n\n  if (LAYER == 0) {\n    // \u2500\u2500 TRAIL \u2014 the tapered luminous ribbon over its own soft under-glow \u2500\u2500\n    let d = segDist(p, a, b);\n    let ribbonHalf = halfW * (RIBBON_TAIL_FRAC + (1.0 - RIBBON_TAIL_FRAC) * age);\n    let lin = samplePaletteLin(1.0 - age * 0.4);\n    let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n    let glowHalf = ribbonHalf * RIBBON_UNDERGLOW_SCALE;\n    let glowCover = 1.0 - smoothstep(glowHalf, glowHalf + aa * 3.0, d);\n    let ga = peak * RIBBON_UNDERGLOW_ALPHA * pow(age, fadeExp) * glowCover;\n    let cover = 1.0 - smoothstep(ribbonHalf, ribbonHalf + aa, d);\n    let ca = max(peak * pow(age, fadeExp), peak * trailFloor) * cover;\n    let outA = ca + ga * (1.0 - ca);\n    return vec4<f32>(rgb * outA, outA);\n  } else if (LAYER == 1) {\n    // \u2500\u2500 EPICYCLE \u2014 orbit RING + ARM + joint DOT union (MAX-blended, no join seam) \u2500\u2500\n    let lin = chainColorLin(arg2, rainbow);\n    let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n    let radius = length(b - a);\n    let dRing = abs(length(p - a) - radius);\n    let ringW = max(halfW * 0.45, aa);\n    let ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n    let dArm = segDist(p, a, b);\n    let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n    let dotR = max(halfW * 0.7, aa * 2.0);\n    let dDot = length(p - a);\n    let dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n    let m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n    return vec4<f32>(rgb * m, m);\n  } else if (LAYER == 2) {\n    // \u2500\u2500 HEAD \u2014 squash-and-stretch (\u00A72b): halo + saturated core + white specular \u2500\u2500\n    let head = a;\n    let headBack = b;\n    let fr = headFrame(head, headBack, halfW);\n    let dHead = headAniso(p, head, fr, squashGain);\n    let coreR = halfW * 1.5;\n    let haloR = coreR * 3.0;\n    let headRgb = clamp(linearToSrgb(samplePaletteLin(0.0)), vec3<f32>(0.0), vec3<f32>(1.0));\n    let halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    var accum = vec4<f32>(headRgb * halo, halo);\n    let core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4<f32>(headRgb * core, core) + accum * (1.0 - core);\n    let spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4<f32>(vec3<f32>(1.0) * spec, spec) + accum * (1.0 - spec);\n    return accum;\n  } else {\n    // \u2500\u2500 CEL \u2014 the technicolor ink shadow (rope LAYER==3, arm LAYER==4) \u2500\u2500\n    let celA = clamp(celGain, 0.0, 1.0);\n    let d = segDist(p, a, b);\n    let cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    let m = cover * celA * peak * arg2; // arg2 = celStrength (1.0 rope / 0.7 arm)\n    return vec4<f32>(0.0, 0.0, 0.0, m);\n  }\n}\n";

package/dist/components/fourier-field/shaders/fourier-field.ribbon.d.ts

@@ -1,51 +0,0 @@
-/**
- * The ordered ribbon LAYER kinds — the fullscreen loop's draw order, one instanced draw each:
- *   cel-rope → cel-arm  (the technicolor ink shadow, painted FIRST, UNDER the lit chain)
- *   epicycle            (the orbit rings + arms + joint dots — the scaffold under the curve)
- *   trail               (the tapered luminous ribbon over its own under-glow)
- *   head                (the squash-and-stretch comet head — halo + core + specular)
- */
-export type RibbonLayerKind = "cel-rope" | "cel-arm" | "epicycle" | "trail" | "head";
-/**
- * The blend mode a layer draws with. `over` is the premultiplied source-over
- * (`ONE, ONE_MINUS_SRC_ALPHA`) every layer but the epicycle uses. `max` (per-channel
- * `blendEquation MAX`) is the FB5 fix for the epicycle-join over-composite SEAM: adjacent
- * arms' rings/dots overlap, and over-compositing them separately double-darkened the joins
- * (the named 9× residual); MAX makes the epicycle group a per-channel UNION so overlapping
- * arms take the brighter contribution instead of stacking.
- */
-export type RibbonBlend = "over" | "max";
-/** The shader LAYER selector (WGSL override `LAYER` / GLSL `uLayer`) per kind. */
-export declare const RIBBON_LAYER_ID: Readonly<Record<RibbonLayerKind, number>>;
-export interface RibbonLayer {
-    readonly kind: RibbonLayerKind;
-    /** The instance count for this layer's single `drawInstanced` (0 layers are omitted). */
-    readonly instanceCount: number;
-    readonly blend: RibbonBlend;
-}
-export interface RibbonPlanInput {
-    /** The comet-curve sample count — the trail draws `sampleCount − 1` capsule instances. */
-    readonly sampleCount: number;
-    /** The epicycle arm count (0 / `showEpicycles: false` → no epicycle + no cel-arm layer). */
-    readonly armCount: number;
-    readonly showEpicycles: boolean;
-    /** The cel-shadow gain — `0` omits the cel-rope + cel-arm layers (byte-frozen). */
-    readonly celGain: number;
-}
-/**
- * The per-frame ribbon DRAW PLAN both backends iterate — the ordered list of instanced draws
- * that reproduces the fullscreen loop's paint (cel first/under, head last/over). An empty
- * layer (no arms, no cel) is omitted, never a zero-instance draw.
- */
-export declare function planRibbonLayers(input: RibbonPlanInput): RibbonLayer[];
-/**
- * The unit quad as a 4-vertex TRIANGLE_STRIP for the WebGL2 instanced draw — corners
- * (0,0)(1,0)(0,1)(1,1) in `[0,1]²`; the instanced vertex expands each corner to the
- * per-instance capsule (a→b padded) or AABB (ring / head halo) bbox. The WGPU render pass
- * builds the SAME quad from `vertex_index` in-shader (a 6-vertex two-triangle list), so it
- * consumes only {@link planRibbonLayers}, never this buffer.
- */
-export declare const RIBBON_QUAD_STRIP: Float32Array<ArrayBuffer>;
-export declare const RIBBON_QUAD_STRIP_VERTS = 4;
-/** Floats per ribbon instance in the WebGL2 attribute buffer: `aSeg`(vec4) + `aData`(vec4). */
-export declare const RIBBON_INSTANCE_FLOATS = 8;

package/dist/components/handmark/brush.d.ts

@@ -1,269 +0,0 @@
-/**
- * brush.ts — the flat Brush DATA model (the keystone; SPEC §2). Pure data, 0 deps.
- * ─────────────────────────────────────────────────────────────────────────────
- * A `Brush` is a plain JSON-serialisable record — twelve scalars, four enums, and
- * one optional `stamp` function. Every built-in medium is a frozen literal: a
- * POINT in one continuous parameter space, NOT a class in a taxonomy. The renderer
- * (`ink.ts`) reads fields — it NEVER branches on instrument name (SPEC §12 acc-1).
- * Adding a medium = adding one row here; an in-between medium = a spread/lerp.
- *
- * Field-count discipline (SPEC §2): resist a 13th scalar per new instrument —
- * `blend` earned its place only because highlighter genuinely needed `multiply`.
- *
- * The shipped register: PEN is the default (clean ink, grain:0 ⇒ no filter, the one
- * `ribbon:'stroke'` clean voice). The variable-width VOICES — boil (the pressured
- * pen-line), crayon (the waxy swell), marker (the juicy core), highlighter (the wide
- * slab) — all ENGAGE `ribbon:'hull'`, the vendored perfect-freehand body, sharing the
- * one curvature-coupled pressure profile (ink.ts `addPressure`). pen/pencil/ring stay
- * `ribbon:'stroke'` by intent (pen clean, pencil's dry tooth-grain is its character,
- * ring a thin whisper). The pf body ships whenever any hull brush does.
- */
-export type BlendMode = "source-over" | "multiply" | "darken" | "screen";
-export interface TaperSpec {
-    /** px the width ramps 0→full at the start (lift-on). */
-    start: number;
-    /** px the width ramps full→0 at the end (lift-off / dry run-out). */
-    end: number;
-    /** out-cubic = the lazy pencil run-out. */
-    ease: "linear" | "out-cubic";
-}
-export interface Brush {
-    /** base stroke diameter, in viewBox units. */
-    weight: number;
-    /** 0..1.4 seeded ±width variance along arc-length. */
-    weightJitter: number;
-    /** -1..1 pressure→width gain (pf `thinning`). */
-    thinning: number;
-    /** lift-on / lift-off ramp. */
-    taper: TaperSpec;
-    /** L2 body strategy: plain stroked <path> | pf filled hull. DEFAULT 'stroke'. */
-    ribbon: "stroke" | "hull";
-    /** 0..1 base alpha. */
-    opacity: number;
-    /** 'source-over' ink | 'multiply' highlighter-behind-text. */
-    blend: BlendMode;
-    /** overdraw count (pen 1 · crayon 2-3). */
-    passes: number;
-    /** 0..1 per-pass alpha falloff (heavy core, light fringe). */
-    passOpacity: number;
-    /** 0..1 paper-through depth — THE master pen↔crayon knob. 0 ⇒ NO filter. */
-    grain: number;
-    /** feTurbulence baseFrequency (high=pencil tooth · low=crayon wax). */
-    grainFreq: number;
-    /** feDisplacementMap edge-fray scale, px. */
-    grainScale: number;
-    /** feTurbulence numOctaves (grain richness). */
-    octaves: number;
-    /** macro tremor → wobbleLinePoints({ roughness }). */
-    roughness: number;
-    /** micro displacement scale (boil amplitude + warp filter). */
-    wobble: number;
-    /** wobble centerline resolution. */
-    segments: number;
-    cap: "round" | "square" | "butt";
-    /** when present, OVERRIDES the built-in ink stage only. */
-    stamp?: StampFn;
-}
-/** SPEC §5 — the arbitrary-brush escape hatch (one optional field, not a framework). */
-export type StampFn = (ctx: {
-    centerline: [number, number][];
-    brush: Brush;
-    rng: () => number;
-    seed: number;
-    length: number;
-    color: string;
-}) => {
-    paths: InkPath[];
-    filterId?: string | null;
-    defs?: string[];
-};
-/** One ink path the renderer emits (shared with ink.ts; declared here to avoid a cycle). */
-export interface InkPath {
-    d: string;
-    fill?: string;
-    stroke?: string;
-    opacity: number;
-    blend: BlendMode;
-    /** geometry finish — bound to the SVG `stroke-linecap` on the path (d). */
-    cap?: "round" | "square" | "butt";
-}
-/**
- * The named points in the continuum. `pen` is the DEFAULT (clean ink, grain:0,
- * `ribbon:'stroke'`). `boil`/`crayon`/`marker`/`highlighter` engage `ribbon:'hull'`
- * (the curvature-coupled variable-width body); `pencil`/`ring` stay clean stroke.
- */
-export declare const BRUSHES: {
-    readonly pen: {
-        readonly weight: 6;
-        readonly weightJitter: 0.1;
-        readonly thinning: 0.15;
-        readonly taper: {
-            readonly start: 14;
-            readonly end: 14;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "stroke";
-        readonly opacity: 1;
-        readonly blend: "source-over";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0;
-        readonly grainFreq: 0.1;
-        readonly grainScale: 0;
-        readonly octaves: 2;
-        readonly roughness: 0.7;
-        readonly wobble: 1.2;
-        readonly segments: 9;
-        readonly cap: "round";
-    };
-    readonly boil: {
-        readonly weight: 7;
-        readonly weightJitter: 0.12;
-        readonly thinning: 0.55;
-        readonly taper: {
-            readonly start: 14;
-            readonly end: 18;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "hull";
-        readonly opacity: 1;
-        readonly blend: "source-over";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0;
-        readonly grainFreq: 0.1;
-        readonly grainScale: 0;
-        readonly octaves: 2;
-        readonly roughness: 0.9;
-        readonly wobble: 1.4;
-        readonly segments: 14;
-        readonly cap: "round";
-    };
-    readonly pencil: {
-        readonly weight: 3;
-        readonly weightJitter: 0.3;
-        readonly thinning: 0.4;
-        readonly taper: {
-            readonly start: 8;
-            readonly end: 18;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "stroke";
-        readonly opacity: 0.6;
-        readonly blend: "source-over";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0.5;
-        readonly grainFreq: 0.42;
-        readonly grainScale: 1.5;
-        readonly octaves: 3;
-        readonly roughness: 1;
-        readonly wobble: 1.6;
-        readonly segments: 11;
-        readonly cap: "round";
-    };
-    readonly crayon: {
-        readonly weight: 16;
-        readonly weightJitter: 1;
-        readonly thinning: 0.25;
-        readonly taper: {
-            readonly start: 6;
-            readonly end: 6;
-            readonly ease: "linear";
-        };
-        readonly ribbon: "hull";
-        readonly opacity: 0.8;
-        readonly blend: "source-over";
-        readonly passes: 2;
-        readonly passOpacity: 0.18;
-        readonly grain: 0.85;
-        readonly grainFreq: 0.16;
-        readonly grainScale: 2.6;
-        readonly octaves: 4;
-        readonly roughness: 1.5;
-        readonly wobble: 3;
-        readonly segments: 13;
-        readonly cap: "round";
-    };
-    readonly ring: {
-        readonly weight: 5;
-        readonly weightJitter: 0.6;
-        readonly thinning: 0.3;
-        readonly taper: {
-            readonly start: 8;
-            readonly end: 12;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "stroke";
-        readonly opacity: 0.55;
-        readonly blend: "source-over";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0.7;
-        readonly grainFreq: 0.18;
-        readonly grainScale: 1.8;
-        readonly octaves: 4;
-        readonly roughness: 1.4;
-        readonly wobble: 2.6;
-        readonly segments: 13;
-        readonly cap: "round";
-    };
-    readonly marker: {
-        readonly weight: 12;
-        readonly weightJitter: 0.2;
-        readonly thinning: 0.1;
-        readonly taper: {
-            readonly start: 4;
-            readonly end: 10;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "hull";
-        readonly opacity: 0.92;
-        readonly blend: "source-over";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0.22;
-        readonly grainFreq: 0.09;
-        readonly grainScale: 1;
-        readonly octaves: 3;
-        readonly roughness: 1;
-        readonly wobble: 2.2;
-        readonly segments: 9;
-        readonly cap: "square";
-    };
-    readonly highlighter: {
-        readonly weight: 26;
-        readonly weightJitter: 0.05;
-        readonly thinning: 0;
-        readonly taper: {
-            readonly start: 6;
-            readonly end: 10;
-            readonly ease: "out-cubic";
-        };
-        readonly ribbon: "hull";
-        readonly opacity: 0.38;
-        readonly blend: "multiply";
-        readonly passes: 1;
-        readonly passOpacity: 0;
-        readonly grain: 0.12;
-        readonly grainFreq: 0.2;
-        readonly grainScale: 1.5;
-        readonly octaves: 2;
-        readonly roughness: 0.5;
-        readonly wobble: 1.4;
-        readonly segments: 9;
-        readonly cap: "square";
-    };
-};
-export type BrushName = keyof typeof BRUSHES;
-/**
- * Resolution order (KISS, deterministic): preset → object overrides → extra `o`.
- * A string selects a preset; an object spreads over `pen`. Later wins.
- */
-export declare const resolveBrush: (b: BrushName | Partial<Brush>, o?: Partial<Brush>) => Brush;
-/**
- * lerpBrush — the continuum proof (SPEC §12 acc-2). Linearly interpolate the
- * scalar fields of two brushes; enums/taper/ribbon snap from `a` below 0.5, `b`
- * at/above. Yields a sensible in-between ("inky crayon"), no NaN.
- */
-export declare const lerpBrush: (a: Brush, b: Brush, t: number) => Brush;

package/dist/components/handmark/composables/useHandMark.d.ts

@@ -1,99 +0,0 @@
-/**
- * useHandMark.ts — the headless reactive core (L2/L3/L4; SPEC §9).
- * ─────────────────────────────────────────────────────────────────────────────
- * Sits between the props and the SFC template so a future React/web-component skin
- * reuses L1–L4. It orchestrates: resolve brush → shapeGeom → ink → animation. It
- * owns NO DOM (the SFC anchors/measures/mounts the filter); it owns the reactive
- * pipeline + the draw-on, boil state machine.
- *
- * Two draw-on mechanisms, picked by a FIELD (never an instrument `if`):
- *   - clean ink (no grain): `stroke-dashoffset` on `pathLength="1"` — the slides
- *     recipe, geometry-agnostic, compositor-cheap, no filter to re-raster.
- *   - grained ink (crayon): a `clip-path: inset()` WIPE — the filter rasters ONCE
- *     and the reveal mutates only the clip (`ds-crayon-handmark §5.1`). NEVER
- *     dashoffset under a filter (it would re-raster the graph per frame — the Δ4
- *     gate).
- *
- * PRM: every draw-on collapses to instant (finished static state); boil no-ops
- * (`useLineBoil.start()` early-returns under reduced motion).
- */
-import { type Ref } from "vue";
-import { type Brush, type BrushName } from "../brush";
-/**
- * The boil clock surface the SFC binds — the `useLineBoil` return shape, declared
- * structurally over glass-ui's OWN `Ref` (pencil-boil ships a nested `@vue`, so its
- * `Ref` symbol differs; the no-op stub is built with this `ref`, hence the surface
- * is named here rather than `ReturnType<typeof useLineBoil>`).
- */
-export interface BoilClock {
-    currentFrame: Ref<number>;
-    start: () => void;
-    stop: () => void;
-}
-import { type ShapeGeom } from "../geometry";
-import { type SVGFragment } from "../ink";
-import type { HandAnimation, HandMarkProps, HandShape, MarkBox } from "../types";
-export interface UseHandMarkInput {
-    brush: BrushName | Partial<Brush>;
-    shape: HandShape;
-    color: string;
-    seed: number;
-    overrides?: Partial<Brush>;
-    animation: HandAnimation;
-    boilFps: number;
-    boilFrames: number;
-    roughness: number | null;
-    segments: number | null;
-    jagged: boolean;
-    /** NATURAL underline morphology (C-2) — procedural off the house-seeded engine. */
-    natural: boolean;
-    /** NATURAL-underline excursion knob ( (c)); `null` ⇒ derive from brush wobble. */
-    amplitude: number | null;
-    box: MarkBox | null;
-    path: string | null;
-    filterId: string;
-    /**
-     * The MEASURED text baseline as a fraction of the `.hm` box height (text-mode
-     * underline anchor). `null` until the SFC measures it (ResizeObserver +
-     * `document.fonts.ready`) — geometry falls back to the legacy constant for that
-     * one pre-measure frame. Ignored in positioned (`box`) mode.
-     */
-    baselineFrac: number | null;
-    /**
-     * The aspect-correct marking-space height: `VB_W * boxAspect`, using the
-     * SFC-measured `.hm` box aspect so `preserveAspectRatio="none"`
-     * scales the text-mode wobble SHAPE uniformly (the humps stop crushing flat on a short
-     * word). Defaults to `VB_H`; used ONLY for the measured text-mode marks (the positioned/
-     * box path keeps `VB_H` byte-for-byte).
-     */
-    vbH: number;
-}
-/**
- * Normalise raw HandMarkProps (with their defaults applied) into the core input.
- * `baselineFrac` is the SFC's MEASURED text baseline (text-mode underline anchor) —
- * passed in (not a prop) because it is a runtime measurement, `null` until measured.
- */
-export declare function normalizeProps(props: HandMarkProps, filterId: string, baselineFrac?: number | null, vbH?: number): UseHandMarkInput;
-export interface HandMarkCore {
-    /** the resolved effective brush vector. */
-    brush: Ref<Brush>;
-    /** the static base geometry (boil re-perturbs THIS). */
-    baseGeom: Ref<ShapeGeom>;
-    /** the live SVG fragment (paths + filter defs). */
-    fragment: Ref<SVGFragment>;
-    /** the live `d` (escape-hatch path > boiled geometry > static base). */
-    pathD: Ref<string>;
-    /** does the brush emit a grain filter? (drives the draw-on mechanism). */
-    grained: Ref<boolean>;
-    /** the draw-on mechanism for this mark: dashoffset (pen) | clip (crayon). */
-    drawKind: Ref<"dashoffset" | "clip">;
-    /** does this animation draw on at all? */
-    draws: Ref<boolean>;
-    /** does this animation boil? */
-    boils: Ref<boolean>;
-    /** the boil clock (a real `useLineBoil` only when the mark boils; else a no-op stub). */
-    boil: BoilClock;
-    /** arm/disarm boil (draw-then-boil holds it until the draw finishes). */
-    boilArmed: Ref<boolean>;
-}
-export declare function useHandMark(input: Ref<UseHandMarkInput>): HandMarkCore;

package/dist/components/handmark/constants.d.ts

@@ -1,69 +0,0 @@
-/**
- * constants.ts — the marking-space geometry constants (the colocation home).
- * ─────────────────────────────────────────────────────────────────────────────
- * The hand-mark family's named geometry constants live here (the
- * convention's `constants.ts` home). geometry.ts + the SFC re-read them by name.
- */
-/** Marking-space width (the 0..100 × 0..40 viewBox; `preserveAspectRatio="none"`). */
-export declare const VB_W = 100;
-/** Marking-space height. */
-export declare const VB_H = 40;
-/**
- * The hairline gap, as a fraction of the `.hm` box, between the MEASURED text
- * baseline and the underline centerline. The underline rides just under the real
- * glyph bottoms — a hand mark sits a few % of cap-height below the baseline, never
- * through it (the E1 occlusion root: a constant `y=32` strikethroughs tight-leading
- * display type because 80% of a `line-height:1.02` box IS the baseline).
- */
-export declare const UNDERLINE_GAP = 0.06;
-/**
- * The highlighter LOW-SEAT band ( C-1(a)). A real highlighter rides
- * the low two-thirds of the line — the ink sits on the baseline and rises to
- * ~x-height — NOT the box vertical center the fork shipped. The band centerline
- * seats at `baselineFrac − HIGHLIGHT_RISE` (raised off the baseline by ~half a
- * lowercase x-height) so the wide slab (weight 26) covers x-height down to the
- * baseline. Expressed as a fraction of the `.hm` box, parallel to UNDERLINE_GAP.
- */
-export declare const HIGHLIGHT_RISE = 0.22;
-/** Pre-measure fallback for the highlight band's low seat (null baselineFrac). */
-export declare const HIGHLIGHT_FALLBACK_FRAC = 0.66;
-/**
- * The boil voice — φ-incommensurate fractal value-noise (the masthead morphology).
- * ─────────────────────────────────────────────────────────────────────────────
- * The boil centerline is a 1-D fractal value-noise displacement off the HOUSE
- * `mulberry32`, NOT a seeded sinusoid. A sinusoid self-correlates
- * into a near-period — it reads as a spell-check squiggle and a clean sine fails any
- * honest non-periodicity discriminator (a sine's extrema are near-uniformly spaced).
- * The value-noise sums octaves at φ-stepped frequencies (mutually irrational → the
- * sum NEVER closes into a period); each octave's amplitude decays by 1/φ. The result
- * is a hump-to-hump-IRREGULAR hand line whose inter-extremum spacing-CV is the honest
- * teeth (measured: ~0.41 at the paint's segment count, ~0.71 resampled at RES=64,
- * over 400 seeds — vs a sinusoid's ~0.14; a clean separation either side of a
- * 0.30 floor). The amplitude is SCALE-RELATIVE (a fraction of the rendered span), so
- * a long word and a short word wobble in proportion. FILTER-FREE — the wander lives
- * in the control points + the hull width, never a feTurbulence.
- *
- * Constants pinned against a 400-seed spacing-CV spike (NOT a seed-overfit autocorr
- * peak — autocorr cannot separate smooth low-frequency value-
- * noise from a sinusoid at any resolution).
- */
-/** φ — the per-octave frequency step (mutually irrational → never periodic). */
-export declare const NOISE_PHI = 1.618033988749895;
-/** octave count of the fractal value-noise sum. */
-export declare const NOISE_OCTAVES = 4;
-/** base octave frequency (humps across the unit span); octave k rides F0·φ^k. */
-export declare const NOISE_F0 = 2.5;
-/** displacement amplitude as a fraction of the rendered span (scale-relative). */
-export declare const NOISE_AMP_FRAC = 0.05;
-/** endpoint-only cosine taper width (the ends settle to baseline; the BODY stays irregular). */
-export declare const NOISE_EDGE = 0.12;
-/**
- * The AMPLITUDE-KNOB reference wobble ( (c)). The natural-underline
- * excursion is `span × NOISE_AMP_FRAC × f(wobble)` where `f(wobble) = wobble, NOISE_WOBBLE_REF`
- * repurposing the existing Brush `wobble` scalar to drive the centerline amplitude,
- * decoupling excursion from stroke `weight` (the published `amplitude` contract, no 13th
- * scalar). Pinned to the shipped `boil` brush's wobble (1.4) so `f(1.4) = 1` ⇒ the default
- * boil render is BYTE-IDENTICAL; a consumer lifts excursion by raising `wobble` (or the
- * explicit `amplitude` prop, which wins). A lower-wobble brush wobbles proportionally less.
- */
-export declare const NOISE_WOBBLE_REF = 1.4;

package/dist/components/handmark/freehand.d.ts

@@ -1,69 +0,0 @@
-/**
- * freehand.ts — the VENDORED perfect-freehand geometry core (MIT, tldraw).
- * ─────────────────────────────────────────────────────────────────────────────
- * SPEC §1.1 / §11: glass-ui ships ZERO hard deps. `perfect-freehand` is an
- * OPTIONAL peer; its `getStroke` is the only one of the four engines that
- * produces TRUE variable width (the swelling/tapering crayon nib). We vendor only
- * its *geometry* core (a few hundred LOC, MIT) behind this L2 seam so:
- *
- *   - the default pen/crayon presets (`ribbon: 'stroke'`) NEVER import it — the
- *     bundle treeshakes it away (the shipped stroke-crayon, `ds-crayon-handmark`),
- *   - the `ribbon: 'hull'` opt-in (the future width-variance upgrade) has a
- *     dependency-free, deterministic body engine already in place,
- *   - the pointer-capture half of the library (dead weight to us) never ships.
- *
- * This is the `getStroke` + `getStrokeOutlinePoints` + `getStrokePoints` core
- * from perfect-freehand@1.2.3 (Steve Ruiz, MIT), transcribed to TypeScript with
- * the `getSvgPathFromStroke` median-quad serialiser the references use. The
- * algorithm is verbatim; only the module shape (named exports, vendored vec math)
- * is glass-ui-local.
- *
- * @license MIT — perfect-freehand © Stephen Ruiz Ltd. https://github.com/steveruizok/perfect-freehand
- */
-/** A point: [x, y] or [x, y, pressure]. */
-export type InputPoint = [number, number] | [number, number, number];
-export interface StrokeOptions {
-    size?: number;
-    thinning?: number;
-    smoothing?: number;
-    streamline?: number;
-    easing?: (t: number) => number;
-    simulatePressure?: boolean;
-    start?: {
-        cap?: boolean;
-        taper?: number | boolean;
-        easing?: (t: number) => number;
-    };
-    end?: {
-        cap?: boolean;
-        taper?: number | boolean;
-        easing?: (t: number) => number;
-    };
-    last?: boolean;
-}
-interface StrokePoint {
-    point: number[];
-    pressure: number;
-    distance: number;
-    vector: number[];
-    runningLength: number;
-}
-/**
- * getStrokePoints — resample the raw input into smoothed StrokePoints with
- * running length + per-segment unit vectors (the streamline low-pass).
- */
-export declare function getStrokePoints(points: InputPoint[], options?: StrokeOptions): StrokePoint[];
-/**
- * getStrokeOutlinePoints — walk the StrokePoints, emit left/right offset points
- * (the variable-width hull), with tapered caps.
- */
-export declare function getStrokeOutlinePoints(points: StrokePoint[], options?: StrokeOptions): number[][];
-/** getStroke — the public entry: raw input → variable-width hull outline points. */
-export declare function getStroke(points: InputPoint[], options?: StrokeOptions): number[][];
-/**
- * getSvgPathFromStroke — the canonical median-quad serialiser the references use:
- * each segment's control point is the midpoint of two consecutive outline points,
- * yielding a smooth closed fill `d`-string.
- */
-export declare function getSvgPathFromStroke(stroke: number[][], closed?: boolean): string;
-export {};