@mkbabb/glass-ui 3.10.1 → 3.11.0

package/src/styles/view-transition.css

@@ -60,5 +60,56 @@
 @keyframes gl-vt-slide-in  { from { opacity: 0; translate: 0 var(--vt-rise, 8px); } }
 @keyframes gl-vt-slide-out { to   { opacity: 0; translate: 0 var(--vt-rise, 8px); } }
 
+/* ── gl-shared-element — the named-pair MORPH group (D6.c M6) ──────────────────
+ * Distinct from `.gl-list-item` (a cross-fade of MANY members in a re-rank): a
+ * shared-element morph is ONE element that exists in BOTH the old and new states
+ * under the SAME `view-transition-name`, so the browser MORPHS it in place — the
+ * group interpolates its size+position (transform) while old/new cross-fade. The
+ * editorial case: the gallery card's title IS the dashboard masthead's title, so
+ * the name you clicked GROWS into the name you read (the card → masthead route
+ * morph). The consumer adds `view-transition-class: gl-shared-element` plus a
+ * MATCHED `view-transition-name: <id>` on BOTH the source and destination element
+ * (the MANDATORY runtime rule — ≤1 element per name per state, else the morph is
+ * skipped silently), and wraps the navigation in `useRouteTransition` /
+ * `startViewTransition`.
+ *
+ * The morph rides the SMOOTH register (the 700ms-class spring, C-ANIM-VIZ-MAP T1
+ * §7) — a longer, gentler curve than the list-item cross-fade, because a morph
+ * that travels across the viewport wants room to read. The old/new cross-fade is
+ * softened so the morphing GROUP is the figure and the rest recedes. */
+::view-transition-group(.gl-shared-element) {
+    animation-duration: var(--vt-morph-duration, var(--duration-slow, 500ms));
+    animation-timing-function: var(--vt-morph-ease, var(--spring-smooth, ease-in-out));
+}
+::view-transition-old(.gl-shared-element),
+::view-transition-new(.gl-shared-element) {
+    /* The image pair cross-fades UNDER the group's size/position morph — softer
+       than the group curve so the morph (the size/position travel) is the figure
+       and the pixel cross-fade is the recessive fill. */
+    animation-duration: var(--vt-morph-duration, var(--duration-slow, 500ms));
+    animation-timing-function: var(--vt-ease, var(--spring-smooth, ease-in-out));
+}
+
+/* ── gl-expand — the plate → fullscreen MORPH recipe (D6.c M7) ─────────────────
+ * The expand verb (a plate growing to fullscreen) is a SHARED-ELEMENT morph, not
+ * an opacity jump-cut: the plate IS the fullscreen surface, growing. It is a
+ * specialization of `gl-shared-element` — the SAME named-pair morph, with the
+ * expand register (a touch snappier than a route morph, because the surface stays
+ * in place and only the rect grows, so it wants less travel-room). `ExpandableContainer`
+ * wires the `view-transition-name` plumbing on its plate↔fullscreen surfaces (an
+ * opt-in `viewTransitionName` prop), so a consumer opts in and the open/close
+ * mutation — wrapped in `startViewTransition` — morphs the plate's rect to the
+ * fullscreen rect and back. The named pair is the SAME element across states
+ * (the slot content), so the browser captures one group and grows it. */
+::view-transition-group(.gl-expand) {
+    animation-duration: var(--vt-expand-duration, var(--duration-normal, 240ms));
+    animation-timing-function: var(--vt-expand-ease, var(--spring-bouncy, ease-out));
+}
+::view-transition-old(.gl-expand),
+::view-transition-new(.gl-expand) {
+    animation-duration: var(--vt-expand-duration, var(--duration-normal, 240ms));
+    animation-timing-function: var(--vt-ease, var(--spring-bouncy, ease-out));
+}
+
 /* Keep the non-transitioned UI interactive while the snapshot animates. */
 ::view-transition { pointer-events: none; }

package/dist/components/custom/aurora/constants/shaders/vangogh-medium.glsl.d.ts

@@ -1 +0,0 @@
-export declare const AURORA_VANGOGH_MEDIUM_GLSL = "// \u2500\u2500 Van-Gogh \u2014 DEDICATED atomic-dab body (W-AUR-VANGOGH-REBUILD) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// REBUILT FROM FIRST PRINCIPLES. The prior path routed van-Gogh through the shared\n// oil paintStrokeMedium cascade \u2014 four DENSE layers of LONG-THIN tensor-oriented\n// strokes (lenMul up to 5.2, widMul 0.22) hugging a continuous coherent field. Packed\n// that tight, thin strokes that follow continuous iso-bands MERGE into smooth flowing\n// filaments \u2014 the \"marbled flow-bands\" read (a spirograph/fingerprint, not impasto),\n// AND the per-cell 8-tap structure tensor \u00D7 4 layers \u00D7 9 cells = ~324 sampleBase/pixel\n// made it run at ~4fps. Van Gogh's sky is NOT continuous flow \u2014 it is DISCRETE, SHORT,\n// LOADED comma dabs, separated by visible ground, queued into swirl ROWS.\n//\n// The rebuild is a purpose-built two-layer DAB pass, disjoint from the oil cascade:\n//   \u2022 orientation from the analytic SWIRL flowField (van-Gogh skies ARE swirl rows) +\n//     per-cell angular jitter \u2014 NOT the expensive per-cell tensor (the lag source, and\n//     the marble source: a jittered discrete dab can NOT merge into a continuous\n//     filament the way a tensor-locked thin stroke does).\n//   \u2022 SHORT comma dabs (len/wid \u2248 2.6 : 1 \u2014 a loaded crescent mark, not a 10:1\n//     filament), so each reads as a SEPARABLE atom.\n//   \u2022 SPARSE placement with visible inter-dab ground (density \u2248 0.42), over a darkened\n//     swirl underpainting (the Starry-Night visible ground the bright dabs read over).\n//   \u2022 a single sampleBase per cell + OKLCh broken-color jitter (pigment shimmer);\n//     full-height impasto crown per dab (each catches its own raked glint).\n// This is ~2 layers \u00D7 9 cells \u00D7 ~1 sampleBase \u2248 20/pixel (a ~16\u00D7 cost cut, ~60fps), and\n// jittered short dabs CANNOT marble.\n\n// One atomic comma dab \u2014 a CLEAN analytic crescent SDF (NOT the oil curvedStroke).\n// The oil curvedStroke's spine-projection + rounded end-caps + fwidth-AA + bristle\n// edge each leave a thin sub-pixel skirt, and a field of those skirts over open ground\n// abuts into a faint network of SEAM LINES. A van-Gogh dab needs none of that\n// machinery \u2014 it is a short oriented capsule (rounded line segment) whose half-width\n// tapers along its length (the loaded-head \u2192 dragged-tail comma). The capsule SDF is\n// derivative-free (smoothstep AA against the analytic distance), so no fwidth skirt, no\n// best-of-9 seam. Returns a StrokeHit (coverage/color/alongT/edgeN) for paintOver.\n//   cellSize \u2014 dab cell pitch (UV units); lenMul/widMul \u2014 dab aspect off the cell;\n//   density  \u2014 placement gate (sparse \u2192 visible gaps); seed \u2014 layer decorrelation.\nStrokeHit vangoghDab(vec2 p, float cellSize, float lenMul, float widMul,\n                     float density, float jitterAmt, float angJitter,\n                     vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n  StrokeHit best = noHit();\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      // Sparse density gate \u2014 leaves visible canvas ground between dabs (atomicity).\n      if (hash21(cc * 1.7 + seed * 0.3) > density) continue;\n      vec2 jit = (hash22(cc + seed) - 0.5) * jitterAmt;\n      vec2 center = (cc + 0.5 + jit) * cellSize;\n\n      // Orientation: the analytic swirl flow at the cell center + per-cell angular\n      // jitter (so adjacent dabs FAN \u2014 the divisionist scatter that keeps the dabs from\n      // locking into perfectly-concentric rows) + a flow-noise curl wobble.\n      float ang = (hash21(cc + seed + 11.0) - 0.5) * angJitter;\n      float curl = (fbm(center * 3.1 + seed * 1.9) - 0.5) * (0.18 + 0.3 * uFlowCurl);\n      vec2 dir = rotateDir(safeDir(flow), ang + curl);\n\n      // SHORT comma \u2014 len \u2248 the cell pitch (a contained dab, not a tiling filament).\n      float len = cellSize * lenMul * (0.82 + 0.30 * hash21(cc + seed + 23.0));\n      float halfW = max(cellSize * widMul * (0.86 + 0.28 * hash21(cc + seed + 41.0)), 0.010);\n\n      // Local dab frame: along = projection onto the dab axis (centred 0), perp = cross.\n      vec2 rel = p - center;\n      float along = dot(rel, dir);\n      float perp  = dot(rel, vec2(-dir.y, dir.x));\n      // The comma TAPER: half-width peaks ~1/3 from the loaded head and drags to a fine\n      // tail (the asymmetric crescent). u in [0,1] along the dab from head to tail.\n      float halfLen = len * 0.5;\n      float u = clamp((along + halfLen) / max(len, 1e-5), 0.0, 1.0);\n      float head = smoothstep(0.0, 0.30, u);                 // rounded loaded head\n      float tail = pow(clamp((1.0 - u) / 0.70, 0.0, 1.0), 1.3); // dragged thin tail\n      float prof = clamp(min(head, tail) * 1.05, 0.0, 1.0);\n      float wNow = halfW * prof;\n      // A gentle comma CURVE \u2014 bow the spine sideways so the mark reads as a crescent.\n      float bowAmt = (hash21(cc + seed + 53.0) - 0.5) * halfW * 1.4;\n      float spine = bowAmt * sin(u * PI);                    // 0 at ends, max mid\n      float d = abs(perp - spine);\n      // Derivative-free AA: a fixed fraction of the dab width (no fwidth skirt). Coverage\n      // is 1 in the dab body, smoothly 0 at the edge; outside the [head,tail] span wNow\u21920\n      // so the dab self-terminates with no end-cap blob.\n      float aa = max(halfW * 0.45, 0.002);\n      float cov = (wNow > 1e-5) ? (1.0 - smoothstep(wNow - aa, wNow + aa, d)) : 0.0;\n      if (cov < 0.004) continue;\n\n      // One sampleBase per cell + OKLCh broken-color jitter (pigment patch shimmer). The\n      // dab pigment is chroma-boosted (saturate3 1.22) AND value-lifted (\u00D71.14) at the\n      // SOURCE \u2014 the loaded brush mark deposits BRIGHTER + more saturated pigment than the\n      // base field, so the loaded-mark pixels lift BOTH the \u00A74.1 colourfulness AND the field\n      // mean-luma. The higher mean raises the gap-fraction threshold (meanLum\u00B70.6) so the\n      // moderate-depth inter-dab ground falls below it (the gap-fraction atomicity read is\n      // DECOUPLED from the ground floor depth \u2014 the ground can stay only moderately dark, so\n      // the \u00A74.3 slope is NOT over-steepened, while the bright dabs manufacture the gap). The\n      // dark ground is untouched, so this lifts C + gap WITHOUT a band-conflicting deep ground.\n      vec3 colMid = brokenColorJitter(\n        saturate3(sampleBase(center, t), 1.22),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      // edgeN: 1 at the spine, 0 at the edge (the impasto crown reads it).\n      float edgeN = (wNow > 1e-5) ? clamp(1.0 - d / wNow, 0.0, 1.0) : 0.0;\n      if (cov > best.coverage) {\n        best = StrokeHit(cov, colMid, u, (wNow > 1e-5 ? (perp - spine) / wNow : 0.0), edgeN);\n      }\n    }\n  }\n  return best;\n}\n\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  vec3 result = col;\n  float height = 0.0;\n\n  // The swirl flow basis (van-Gogh sky = swirl rows). Computed ONCE per pixel.\n  vec2 flow = flowField(p, t);\n\n  // Dab cell pitch in UV [0,1]. CHUNKY, SEPARABLE marks \u2014 the big layer is ~1/14 of\n  // the frame so it reads as a distinct loaded brush dab (not a fine speckle, not a\n  // screen-spanning filament). uStrokeScale (authored ~110) modulates the pitch\n  // INVERSELY (higher = finer dabs) around the ~0.07 chunky default; clamped so the\n  // dab never collapses to noise or balloons past one screen. uStrokeAnisotropy\n  // stretches the comma aspect (longer, more directional marks).\n  float pitch = clamp(7.0 / max(uStrokeScale, 20.0), 0.044, 0.12);\n  // The dab LENGTH \u2248 the cell pitch (lenAniso ~1.2-1.7) so a dab sits WITHIN its cell\n  // and leaves visible ground around it \u2014 a longer dab (lenMul > 2) spans neighbour\n  // cells and tiles the field into continuous coverage (no gaps, the gap-fraction floor\n  // miss + the marble). Narrow width keeps it a directional crescent, not a wide shard.\n  // lenAniso/widAniso \u2014 the comma aspect. The W-AUR-VANGOGH-CONFIG reconcile lengthened\n  // the comma (1.25-1.75 \u2192 1.5-2.0) and THINNED it (0.40-0.30 \u2192 0.32-0.24): the rebuilt\n  // dabs measured \u00A74.2 structure-tensor anisotropy A=0.699, BELOW the reference band\n  // floor 0.732 (the dabs read slightly too short-fat \u2192 locally isotropic, dragging mean\n  // A down). A LONGER, THINNER comma hugs the swirl-flow tangent more strongly so the\n  // rendered field reads coherent the way the tensor metric measures it (A lift), while\n  // the thinner width LEAVES MORE inter-dab ground (the gap-fraction atomicity read is\n  // preserved, not closed). The length stays \u2248 the cell pitch so each dab remains a\n  // CONTAINED separable mark, not a tiling filament.\n  float lenAniso = mix(2.1, 2.7, uStrokeAnisotropy);   // comma length / cell pitch (a contained dab)\n  float widAniso = mix(0.23, 0.16, uStrokeAnisotropy); // comma width / cell pitch (a thin loaded crescent)\n\n  // Layer 1 \u2014 the big swirl-row dabs: the loaded gestural marks, SPARSE so the dark\n  // underpainting shows BETWEEN them (the atomicity read \u2014 visible inter-dab ground).\n  // hardness 0.74 \u2014 the loaded brush deposits with a SOFT shoulder, so adjacent dabs\n  // feather instead of razor-clipping into hard polygon shards. jitterAmt 0.85 fully\n  // scatters the cell centres so the placement GRID never reads as a periodic seam.\n  // angJitter EASED 0.55 \u2192 0.38 (the reconcile A lift): a tighter angular spread keeps\n  // adjacent dabs more flow-aligned (coherent) while the per-cell curl wobble still\n  // breaks the perfectly-concentric-rows read (the dabs FAN gently, not lock to a grid).\n  // angJitter eased 0.38 \u2192 0.26 + hardness 0.74 \u2192 0.84 (the \u00A74.2 A lift): a tighter angular\n  // spread keeps adjacent dabs strongly flow-aligned (the structure-tensor coherence) and a\n  // sharper edge gives each dab a STRONGER directional gradient (a soft dab's faint edge\n  // reads weakly anisotropic). The per-cell curl wobble still breaks the perfectly-\n  // concentric-rows read, so the dabs FAN gently rather than locking to a grid.\n  StrokeHit dBig = vangoghDab(p, pitch, lenAniso, widAniso,\n                              0.30, 0.50, 0.08, flow, t, 1.3);\n  // streakFreq raised 14 \u2192 34 (the \u00A74.3 slope fix): a high-frequency streak runs ALONG the\n  // dab spine, injecting fine-scale luma energy that flattens the too-steep \u03B2 WITHOUT\n  // adding new isotropic marks (the along-spine streak stays directional, so the \u00A74.2\n  // anisotropy the long-thin dab carries is preserved \u2014 the band-conflict resolution).\n  paintOver(result, height, dBig, 48.0, 0.34,\n            uImpasto * 0.75 * uStrokeAmount, 0.84, 1.3, 1.0 /* full crown */);\n\n  // Layer 2 \u2014 two-thirds-pitch accent dabs (the divisionist sparkle between the big\n  // marks \u2014 denser placement but still contained dabs, so dark canvas survives between).\n  // angJitter eased 0.5 \u2192 0.34 (same A-lift reasoning \u2014 the accent dabs queue along the\n  // flow rather than scattering isotropically); hardness 0.78 \u2192 0.86 sharpens the gradient.\n  StrokeHit dSml = vangoghDab(p + vec2(-5.1, 8.4), pitch * 0.62, lenAniso * 0.95,\n                              widAniso * 0.95, 0.36, 0.60, 0.20, flow, t, 4.1);\n  paintOver(result, height, dSml, 42.0, 0.22,\n            uImpasto * 0.55 * uStrokeAmount, 0.86, 4.1, 1.0);\n\n  // Layer 3 \u2014 the FINE divisionist flecks (W-AUR-VANGOGH-CONFIG reconcile). The two-layer\n  // field read as a few BIG cobalt dabs over a smooth empty teal ground (the side-by-side\n  // against starry-night-crop.png: the painting is DENSE small varied flecks, not sparse\n  // large marks). The flecks are LONG\u00B7THIN directional commas hugging the swirl tangent\n  // (the A-preserving fleck \u2014 short fat flecks read isotropic and drag \u00A74.2 down). Sparse\n  // density 0.30 keeps the inter-fleck ground open (the gap-fraction atomicity read).\n  // The flecks are FINE (\u22480.42\u00D7 pitch) directional commas, tightly flow-aligned (angJitter\n  // 0.22) and SPARSE (0.30) \u2014 the divisionist sparkle between the loaded marks that keeps\n  // the inter-dab ground open (atomicity) while adding the small-mark mid-band energy. Thin\n  // + flow-aligned so the \u00A74.2 anisotropy the long dabs carry survives the added small marks.\n  StrokeHit dFleck = vangoghDab(p + vec2(8.7, -3.2), pitch * 0.42, lenAniso * 1.0,\n                                widAniso * 0.68, 0.30, 0.85, 0.22, flow, t, 7.7);\n  paintOver(result, height, dFleck, 30.0, 0.16,\n            uImpasto * 0.40 * uStrokeAmount, 0.80, 7.7, 1.0);\n\n  // \u2500\u2500 Flow-aligned GROUND swirl-GROOVING (W-AUR-VANGOGH-CONFIG reconcile) \u2500\u2500\n  // The bare ground between the dabs was a SMOOTH low-frequency teal gradient \u2014 the \u00A74.3\n  // power-spectrum slope ran too STEEP (\u03B2\u2248\u22122.0: too much low-frequency nuclei-field energy\n  // vs the high band). Van Gogh's actual sky has the swirl BRUSHWORK everywhere, so groove\n  // the OPEN GROUND with a flow-aligned ripple. It is SUBTRACTIVE-biased (it only darkens,\n  // never brightens the ground), so it DEEPENS the inter-dab valleys (MORE gap-fraction \u2014\n  // atomicity preserved/strengthened) while injecting the across-flow mid-band luma energy\n  // that flattens \u03B2. Gated to the open ground (low height) via the (1-height) gate so it\n  // never lifts/erodes the loaded dab bodies (the dab read is untouched). Across the swirl\n  // FLOW axis so the grooves run WITH the sky's brushwork direction.\n  // The ground swirl-combing \u2014 a FIXED-global-angle directional grain on the open ground.\n  // A flow-FOLLOWING comb varies its direction with the swirl across the readback window,\n  // so its blurred structure tensor averages toward isotropic (no \u00A74.2 lift). A comb at one\n  // GLOBAL angle (van-Gogh's dominant diagonal stroke grain) is COHERENT over the whole\n  // window \u21D2 every open-ground pixel reads the SAME direction (the \u00A74.2 mean-anisotropy lift\n  // the swirl comb could not reach). Two resolved bands (\u224822 + \u224844 across the global axis \u21D2\n  // ~21px + ~11px at 464px, both in the \u00A74.3 fit window) also feed the \u03B2 flatten. Gated to\n  // the open ground (low height) so the loaded dabs are untouched; SUBTRACTIVE-biased so the\n  // inter-dab valleys deepen (gap-fraction preserved, not filled).\n  vec2 gdir = normalize(vec2(0.82, 0.57));   // the dominant global stroke grain axis\n  float gacross = dot(p, vec2(-gdir.y, gdir.x));\n  float groundGate = 1.0 - smoothstep(0.05, 0.28, height);\n  float groove = sin(gacross * 22.0) + 0.5 * sin(gacross * 44.0 + 1.3);\n  result *= 1.0 - 0.16 * groundGate * (0.5 - 0.5 * groove);\n\n  // Canvas tooth (fine linen weave \u2014 base relief the raking light catches).\n  float tooth1 = vnoise(p * 220.0);\n  float tooth2 = vnoise(p * 220.0 * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n\n  // Relight the accumulated impasto height (raking light catches each dab's crown \u2014\n  // the visible impasto ridge that makes a dab read as a RAISED loaded mark).\n  float canvasBase = tooth * 0.06 * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // The visible Starry-Night GROUND \u2014 the open canvas between dabs (low accumulated\n  // height) darkens toward the deep underpainting, so the bright impasto dabs read as\n  // SEPARABLE atomic marks over a darker field (the dab\u2194ground contrast the user's\n  // \"reads as strokes\" bar needs, AND the painterly-statistics gap-fraction floor \u2014 the\n  // dark inter-dab ground must register as a measurable fraction of the field). 0.30\n  // floor over a WIDER smoothstep (0..0.40): deep enough that the open gaps read as the\n  // dark Starry-Night sky between marks (clearing the 4% gap floor) while the gradual\n  // ramp keeps the gaps reading as flowing underpainting, not the hard black ink LINES a\n  // narrow near-black step (0.26 / 0.0..0.32) produced.\n  // The smoothstep FLOOR starts at 0.10 (not 0): a dab's faint AA coverage TAIL deposits\n  // a sliver of height, and where many tails align along the swirl flow those slivers\n  // accumulate into a faint continuous height ridge that read as thin curved LINES in the\n  // ground. Holding the ground full-dark until a real dab CORE (height > 0.10) lifts out\n  // keeps the open field clean \u2014 only the loaded dab bodies emerge, the tails stay ground.\n  result *= mix(0.115, 1.0, smoothstep(0.085, 0.31, height));\n\n  // The van-Gogh chroma \u2014 a light OKLCh punch. EASED to 0.92 (off 1.04) in the\n  // W-AUR-VANGOGH-CONFIG reconcile: the rebuilt discrete-dab register's per-dab OKLCh\n  // broken-color jitter (the \u00B116\u00B0 hue + \u00B1chroma swing per cell) lifts the field's\n  // colourfulness on its own, so the prior 1.04 punch on TOP overshot the \u00A74.1\n  // reference band (rendered C=100.5 vs the painting's measured 70.67 \u00B1 15/+25 \u2192\n  // ceiling 95.67 \u2014 neon, not Starry Night's rich-but-not-garish blue/gold). The 0.92\n  // demote pulls the rendered colourfulness back IN-band while the broken-color jitter\n  // keeps the per-dab pigment variation (the discrete-stroke read is untouched \u2014 this\n  // is a chroma scale, not a dab-geometry change). Band-anchored on the real painting\n  // (proof:aurora-arresting), NOT a widened band.\n  result = saturate3(result, 1.0);\n  return result;\n}\n\n";

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

@@ -1,35 +0,0 @@
-import type { ConstellationField } from "../constellationField";
-type WanderProp = boolean | {
-    minIdle?: number;
-    jitter?: number;
-};
-type GravityWellProp = boolean | {
-    holdMs?: number;
-    gain?: number;
-    reach?: number;
-    ramp?: number;
-    maxSpeed?: number;
-    soften?: number;
-};
-export interface ConstellationFieldState {
-    field: ConstellationField;
-    /** The wander prop override the render re-layers over the on-mount token read. */
-    wanderOverride: {
-        minIdle?: number;
-        jitter?: number;
-    };
-    /** The well prop override the render re-layers over the on-mount token read. */
-    wellOverride: Exclude<GravityWellProp, boolean>;
-}
-/**
- * Build the per-instance field state. The focal node (AX.W17) is engine-owned:
- * `focalIndex` names the pinned node, `warp` is the per-axis critically-damped
- * spring the engine steps inside `stepField`. `wander`/`gravityWell` absent/false
- * leaves `field.wander`/`field.well` undefined (byte-identical to HEAD — stepField
- * skips the cadence / force pass); `true` / an object seeds the cold state with the
- * built-in defaults + any prop override layered on (the on-mount
- * `readInteractionConfig` token read re-points the un-overridden members, with the
- * returned `*Override` winning over the token in the render closure).
- */
-export declare function createConstellationField(wander: WanderProp, gravityWell: GravityWellProp): ConstellationFieldState;
-export {};

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

@@ -1,35 +0,0 @@
-import type { Ref } from "vue";
-import type { ConstellationField, ConstellationPointer, ConstellationRipple } from "../constellationField";
-/** The substrate handle the wiring reads (`wake` re-arms a parked surface). */
-interface CanvasHandle {
-    wake: () => void;
-    reducedMotion: boolean;
-}
-export interface UseConstellationPointerOptions {
-    host: HTMLElement | null;
-    canvas: HTMLCanvasElement;
-    field: ConstellationField;
-    pointer: ConstellationPointer;
-    ripples: ConstellationRipple[];
-    handle: CanvasHandle;
-    /** The hoisted client→canvas-local mapper ref the exposed `warpTo(clientX,clientY)` reads. */
-    toLocalRef: Ref<((e: {
-        clientX: number;
-        clientY: number;
-    }) => ConstellationPointer | null) | null>;
-    pointerReactive: boolean;
-    warpOnClick: boolean;
-    gravityWell: boolean;
-    /** The deterministic-capture predicate — a frozen capture registers NO listeners. */
-    isFrozen: boolean;
-}
-/**
- * Wire the constellation pointer listeners on the host. Sets the hoisted
- * `toLocal` mapper (the deck-scale invariant — BOTH the ripple path AND the warp
- * path read this ONE mapper), then registers the three independent listener
- * blocks gated by their respective prop flags (each PRM-gated + capture-gated).
- * No teardown is returned: the listeners ride the component's lifetime (the host
- * element is torn down with the component), matching the prior inline behaviour.
- */
-export declare function useConstellationPointer(opts: UseConstellationPointerOptions): void;
-export {};

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

@@ -1,36 +0,0 @@
-import type { ConstellationPalette, ConstellationWellConfig } from "./constellationField";
-/**
- * The reference layout width (px) the field's node geometry is authored against. A
- * live canvas's `k = width / BASE_WIDTH` scales every base-width length (the well
- * reach/speed, the node spacing) so a 600px and a 1280px canvas read the same shape.
- */
-export declare const BASE_WIDTH = 1280;
-/**
- * The neutral palette FALLBACK the draw passes read when the `--constellation-*`
- * color/alpha tokens are absent (SSR / no-token mount). The fallbacks mirror the §5c
- * light-arm token defaults so a no-token mount still reads recessive-but-legible.
- */
-export declare const DEFAULT_PALETTE: ConstellationPalette;
-/**
- * Warp spring DEFAULTS — `--constellation-warp-*` tokens override these on mount.
- * `WARP_RESPONSE` is the keyframes.js angular PERIOD (s, NOT a settle-duration);
- * `WARP_ZETA = 1.0` is critically damped so a focal mark never rings/overshoots.
- */
-export declare const WARP_RESPONSE = 0.55;
-export declare const WARP_ZETA = 1;
-/**
- * Gravity-well tuning DEFAULTS (AY.W-CON2). The `--constellation-well-*` tokens
- * override these on mount via `field.well.cfg`; these stay the fallback. SET by the
- * §6 egg-live π readback (the field-perturbs-then-cools capture is the binding
- * truth) — a moderate gain over a generous reach, a brisk ramp, a tight no-slingshot
- * speed cap, and the singularity-soften floor.
- */
-export declare const DEFAULT_WELL_CONFIG: ConstellationWellConfig;
-/**
- * Auto-DRIFT cadence DEFAULTS (AY.W-CON1 source; tokenised in AY.W-CON2). The
- * `--constellation-wander-idle`/`-wander-jitter` tokens override these on mount; a
- * prop `{ minIdle, jitter }` still wins over the token. The 8s/8s default rhythm
- * re-targets the focal mark every 8–16s (the slides cadence).
- */
-export declare const DEFAULT_WANDER_IDLE = 8000;
-export declare const DEFAULT_WANDER_JITTER = 8000;

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

@@ -1,18 +0,0 @@
-import type { ConstellationField, ConstellationPalette, ConstellationPointer, ConstellationRipple } from "./constellationField";
-import { DEFAULT_PALETTE } from "./constants";
-export { DEFAULT_PALETTE };
-/**
- * Resolve the FULL neutral palette + legibility weights off a canvas's resolved
- * custom properties (AX.W17). The colors AND the alpha multipliers route through
- * the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
- * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read.
- */
-export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
-/** Pass 1 — hairline edges between any two nodes within `link` px (alpha falls off with distance). */
-export declare function drawEdges(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette, opacityCeiling?: number): void;
-/** Pass 2 — ambient node dots. */
-export declare function drawNodes(ctx: CanvasRenderingContext2D, field: ConstellationField, palette: ConstellationPalette, opacityCeiling?: number): void;
-/** Pass 3 — the cursor joins the web: faint links to nodes within reach + a soft cursor node. */
-export declare function drawPointerWeb(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette, pointer: ConstellationPointer | null, opacityCeiling?: number): void;
-/** Pass 4 — tap ripples: expanding rings that fade over ~0.9s; consumed entries are spliced. */
-export declare function drawRipples(ctx: CanvasRenderingContext2D, field: ConstellationField, now: number, ripples: ConstellationRipple[], palette: ConstellationPalette, opacityCeiling?: number): void;

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

@@ -1,102 +0,0 @@
-import type { ConstellationField, ConstellationWarpConfig, ConstellationWellConfig } from "./constellationField";
-import { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA } from "./constants";
-export { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA };
-/**
- * Read the NUMERIC interaction-tuning tokens (the warp spring + the gravity-well
- * gains) off a canvas's resolved custom properties — ONCE on mount (AY.W-CON2),
- * via `parseFloat`, NOT per-frame `getComputedStyle` (the hot loop stays clean).
- * Returns `{ warp, well }` configs the field carries; every member falls back to
- * the shipped default when the token is absent (an SSR / no-token mount reads the
- * byte-identical spring). The tokens are PLAIN numbers (`0.55`, `12000`), immune
- * to the W30 `light-dark()`-into-Canvas2D leak (they never reach a `fillStyle`).
- */
-export declare function readInteractionConfig(canvas: HTMLCanvasElement): {
-    warp: ConstellationWarpConfig;
-    well: ConstellationWellConfig;
-    wander: {
-        minIdle: number;
-        jitter: number;
-    };
-};
-/**
- * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
- * composed inside `stepField` (NO new rAF): ease `well.strength` toward
- * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
- * inverse-square pull toward the held point onto each node within `cfg.reach`
- * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
- * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
- * invariant — so a released well re-settles). No-ops (entirely skipped) when
- * `field.well` is undefined → the default render is byte-identical to HEAD.
- *
- * `dt` is clamped to {@link WARP_DT_CLAMP} (the same park-resume guard the warp
- * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
- */
-export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;
-/**
- * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
- * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
- * "Lattice point" = the nearest drifting NODE (the constellation has NO fixed
- * lattice). `excludeIdx` drops a node from the candidate set (the focal node
- * excludes ITSELF, so a cursor-on-focal warp no-ops). Returns `-1` if no
- * eligible node exists (empty field, or only the excluded node).
- */
-export declare function nearestNode(field: ConstellationField, px: number, py: number, excludeIdx?: number): number;
-/**
- * Advance the focal-node warp spring one `dt` (seconds). A per-axis 2nd-order
- * critically-damped integrator over `field.warp.{x,y}` toward the LIVE position
- * of `field.nodes[field.warp.targetIdx]` — re-read EACH frame, so the spring
- * CHASES a drifting target and arrives ON it (the identity-ride). No-ops when no
- * warp is active (`targetIdx < 0`). `dt` is clamped to {@link WARP_DT_CLAMP} so a
- * tab-throttle / offscreen-park-resume gap cannot teleport the mark.
- *
- *   x += v·dt ;  v += (−2ζω·v − ω²·(x − target))·dt
- *
- * Reads `(response, ζ)` from `field.warpCfg` (the tokenised override — AY.W-CON2),
- * falling back to the shipped `WARP_RESPONSE`/`WARP_ZETA` defaults. `ω = 2π/response`
- * is the keyframes.js `(response, dampingFraction)` convention (the SHARED house
- * model — `ω₀` is the angular frequency, `response` its ANGULAR PERIOD, NOT a
- * settle-duration; at ζ=1 the 2%-settle is `t₂ ≈ 5.83/ω₀ ≈ 0.93·response`). NO
- * second ω formula is minted (the ω-reconcile). NOT its rAF — the FORBID-useSpring
- * contract (a second rAF would defeat the parked-substrate one-path freeze).
- */
-export declare function warpStep(field: ConstellationField, dt: number): void;
-/**
- * Point the warp at a node INDEX (the live target-source seam). The focal node
- * re-points to `idx`; the spring chases `nodes[idx]`'s LIVE position FROM the
- * focal mark's CURRENT position (`warp.{x,y}`) — a continuous spring-eased path,
- * never a snap. The component seeds `warp.{x,y}` at field-center on first layout,
- * so even the first warp springs from a real start point. `idx < 0` clears the
- * warp (the focal mark is removed). Re-pointing does NOT zero the velocity, so a
- * mid-flight re-target curves smoothly toward the new node.
- */
-export declare function setWarpTarget(field: ConstellationField, idx: number): void;
-/**
- * Warp the focal node to the nearest drifting node to a canvas-LOCAL px point
- * (the `warpTo(point)` primitive). The DEGENERATE case — the click's UNCONSTRAINED
- * nearest node is already the current focal (cursor on/closest to the focal mark)
- * — NO-OPS (returns the current focal; a click on yourself does not re-warp). Any
- * OTHER click re-points to the nearest node, with the focal EXCLUDED from the
- * candidate set (you never re-warp to yourself; the next-nearest wins). Returns
- * the chosen node index, or `-1` when no eligible node exists. The component's
- * `warpTo(clientX, clientY)` sugar maps client→local px via `toLocal` first.
- */
-export declare function warpTo(field: ConstellationField, px: number, py: number): number;
-/**
- * Is the warp spring ARRIVED on its target (AY.W-CON1)? True when there is no
- * active target (`targetIdx < 0`) OR the focal's gap to its LIVE target node is
- * within {@link WARP_SETTLE_BAND}. A click-warp in flight (hundreds of px out)
- * reports NOT arrived, so a user click always PRE-EMPTS the auto-drift cadence
- * (the wander only re-targets a spring that has reached its current node). The
- * gate is POSITION-only by design — a critically-damped spring tracking a drifting
- * node carries a non-zero steady-state velocity forever, so a velocity term would
- * never clear on a live field.
- */
-export declare function warpSettled(field: ConstellationField): boolean;
-/**
- * Pick a random eligible node index for the auto-drift re-target (AY.W-CON1) —
- * any node EXCEPT the current `focalIndex` (so the focal actually MOVES). `rng`
- * is the seeded `() => number` in `[0, 1)`. A degenerate field (≤1 node, or only
- * the current focal) returns the current focal, which `setWarpTarget` no-ops
- * cleanly (no crash, no jump).
- */
-export declare function pickWanderTarget(field: ConstellationField, rng: () => number): number;

package/dist/components/custom/dock/composables/useDockMorphWindow.d.ts

@@ -1,15 +0,0 @@
-import { type Ref } from "vue";
-/** The morph-window handlers the GlassDock SFC wires. */
-export interface DockMorphWindow {
-    markTransitioning: () => void;
-    onDockTransitionDone: (event: TransitionEvent) => void;
-    clearTransitionTimer: () => void;
-}
-/**
- * Own the `isTransitioning` flag's morph-window lifecycle. `markTransitioning`
- * (every `visualExpanded` flip) bumps a private generation so any in-flight
- * morph's pending timer / `transitionend` self-cancels (the A→B→A no-skip /
- * no-queue invariant); `onDockTransitionDone` resolves the flag on a resize-morph
- * property finishing. Clears its timer on unmount.
- */
-export declare function useDockMorphWindow(dockEl: Ref<HTMLElement | null>, isTransitioning: Ref<boolean>): DockMorphWindow;

package/dist/components/custom/dock/composables/useDockShellProps.d.ts

@@ -1,131 +0,0 @@
-import { type ComputedRef } from "vue";
-export type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
-export interface DockCommonProps {
-    fitContent?: boolean;
-    position?: "fixed" | "inline" | "sticky";
-    alwaysExpanded?: boolean;
-    /**
-     * Corner treatment.
-     *   `"pill"`    — the stadium silhouette (default).
-     *   `"rounded"` — a finite rounded radius (`--radius-xl`).
-     *   `"card"`    — the AW.W3b big-dock card shell: a finite concentric
-     *                 radius (`--dock-card-radius`, default `--radius-3xl`)
-     *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
-     *                 Collapsed it returns to a pill; the pill↔card swap
-     *                 morphs on the `--dock-motion-resize` spring. AX.W56's
-     *                 squircle policy applies `corner-shape:
-     *                 var(--corner-shape-bigdock)` here under `@supports
-     *                 (corner-shape: superellipse(2))` — the big-dock is the ONE
-     *                 surface where the superellipse reads (cards/pills stay
-     *                 round); the border-radius arc is the cross-engine contract.
-     *
-     * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
-     * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
-     * the horizontal-root shape rules (closing that documented-but-dead prop),
-     * so `shape` now paints on a horizontal dock too.
-     */
-    shape?: "pill" | "rounded" | "card";
-    /**
-     * Layout axis of the dock. `"horizontal"` (default) lays items out
-     * left-to-right and animates `width`; `"vertical"` lays items out
-     * top-to-bottom and animates `height`. IGNORED under `variant="rail"` /
-     * `"instrument-strip"` (those force vertical by construction).
-     */
-    orientation?: "horizontal" | "vertical";
-    /**
-     * Density controls dock padding, gaps, layer height, and inherited
-     * dock control sizing. Root CSS variables can override each density.
-     */
-    density?: DockDensity;
-    /**
-     * Overflow strategy when the expanded content exceeds the dock's
-     * axis cap (`--dock-max-inline-size` horizontally,
-     * `--dock-max-block-size` vertically). The ONE knob governing every
-     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
-     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
-     * which all touched overflow divergently).
-     *   `"grow"`   — content grows to fit then overflows visibly past
-     *                the cap (the default; nothing clips or scrolls).
-     *   `"wrap"`   — expanded content wraps to multiple rows via CONTENT-DRIVEN
-     *                intrinsic flex-wrap (the `.dock-overflow-wrap` recipe). The
-     *                dock shrink-wraps to content and caps that intrinsic width
-     *                at `max-inline-size: var(--dock-max-inline-size)`, so the row
-     *                reflows to N rows EXACTLY when its intrinsic width exceeds
-     *                the cap — at ANY viewport width — and collapses to one row
-     *                when it fits (no viewport breakpoint). The wrapped multi-row silhouette lifts
-     *                onto the card/floating shadow tier as the dock expands.
-     *                HORIZONTAL-ONLY: a vertical rail grows-to-fit + clamps via
-     *                `--dock-max-block-size` (its own overflow story), so the
-     *                `.dock-overflow-wrap` class is not emitted for a vertical
-     *                orientation.
-     *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
-     *                scroll the active layer on the inline axis
-     *                (`.dock-scroll-x`); vertical rails scroll on the
-     *                block axis (`.dock-scroll-y`), keeping the
-     *                `max-block-size` cap. The rounded pill masks the
-     *                scroll edge; the scrollbar is hidden. The axis is
-     *                chosen automatically from `orientation`.
-     */
-    overflow?: "grow" | "wrap" | "scroll";
-    /**
-     * When set, the dock root establishes an inline-size container query
-     * subject (`container-type: inline-size; container-name: <value>`) so
-     * descendants can query the named container via `@container <value>
-     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
-     * container subject does NOT silently change the dock's clip shell
-     * (AT.W7-dock-a — the prior clip-lift was folded out; use
-     * `overflow="wrap"` to allow multi-line content).
-     *
-     * T.B audit §1.3 cornerstone: the cluster's container subject must
-     * live on the dock primitive, never on a descendant whose intrinsic
-     * size the dock relies on.
-     */
-    containerName?: string;
-}
-export interface DockVariantProps extends DockCommonProps {
-    variant?: "dock";
-    /** Idle-collapse delay in ms (default 2000). DOCK-ONLY — a rail never collapses. */
-    collapseDelay?: number;
-    /** Start in the collapsed state (default true). DOCK-ONLY — a rail is always expanded. */
-    startCollapsed?: boolean;
-    /**
-     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
-     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
-     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
-     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
-     * `layout` is the IN-cap arrangement.
-     *
-     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
-     * does not read as a collapsible pill, and no width morph means no
-     * per-frame grid reflow). The canonical pairing is
-     * `shape="card" layout="grid"` (the props stay independent — no
-     * auto-implication of `shape`). DOCK-ONLY — the grid is a horizontal big-dock
-     * arrangement, never a rail's.
-     */
-    layout?: "linear" | "grid";
-}
-export interface DockRailProps extends DockCommonProps {
-    variant: "rail" | "instrument-strip";
-}
-export type DockProps = DockVariantProps | DockRailProps;
-export declare function dockBranch(p: DockProps): p is DockVariantProps;
-/** The resolved shell-prop computeds the GlassDock SFC binds. */
-export interface DockShellProps {
-    containerStyle: ComputedRef<Record<string, string> | undefined>;
-    collapseDelay: ComputedRef<number>;
-    startCollapsed: ComputedRef<boolean>;
-    layoutValue: ComputedRef<"linear" | "grid">;
-    variant: ComputedRef<"dock" | "rail" | "instrument-strip">;
-    shape: ComputedRef<"pill" | "rounded" | "card">;
-    orientation: ComputedRef<"horizontal" | "vertical">;
-    density: ComputedRef<DockDensity>;
-    scrollClass: ComputedRef<string | null>;
-    alwaysExpanded: ComputedRef<boolean>;
-    fitContent: ComputedRef<boolean>;
-}
-/**
- * Derive the dock's resolved shell props off the raw `props`. The defaults the
- * prior `withDefaults` object held are applied at each read site via `?? default`
- * (every shared default has exactly one resolution point — the one-path precept).
- */
-export declare function useDockShellProps(props: DockProps): DockShellProps;

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

@@ -1,23 +0,0 @@
-/**
- * The ONE dock-morph spring authority — the iOS-26 interruptible-physics tuning the
- * dock's single `SpringProgress` orchestrator (`dockMorphContext.ts`) AND the
- * `useLayerTransition` engine both read. Co-located here so the `response`/`damping`
- * pair is defined ONCE rather than duplicated at the top of each composable (the two
- * prior copies were a DRY hazard — a re-tune had to touch both).
- */
-export declare const DOCK_SPRING: {
-    readonly response: 0.32;
-    readonly dampingFraction: 0.7;
-};
-/**
- * The CSS properties whose `transitionend` the dock-morph window watches to know a
- * resize-morph has settled (`useDockMorphWindow.ts`). A `transitionend` on any other
- * property is ignored.
- */
-export declare const RESIZE_MORPH_PROPS: Set<string>;
-/** `Symbol()` label for the `DockContext` injection key (`dockContext.ts`). */
-export declare const DOCK_CONTEXT_LABEL = "glass-ui:dock-context";
-/** `Symbol()` label for the `DockLayerGroupContext` injection key (`dockLayerContext.ts`). */
-export declare const DOCK_LAYER_GROUP_LABEL = "glass-ui:dock-layer-group";
-/** `Symbol()` label for the `DockMorphContext` injection key (`dockMorphContext.ts`). */
-export declare const DOCK_MORPH_LABEL = "glass-ui:dock-morph-context";

package/dist/components/custom/fourier-field/presets.d.ts

@@ -1,54 +0,0 @@
-export interface VariantPreset {
-    /** Higher-order harmonics layered over the dominant counter-rotating pair. */
-    harmonics: number;
-    /** Peak magnitude of those harmonics relative to the dominant phasor. */
-    harmonicScale: number;
-    /** Draw the nested epicycle circles + arms underneath the curve. */
-    epicycles: boolean;
-    /** Comet-trail capacity (frames of head history). ~1/3 of the period so the
-     *  comet reads as a substantial arc, not a stub (the fourier-analysis bar). */
-    trailLength: number;
-    /** Hue offset (degrees) of the epicycle second hue away from the outline hue. */
-    epicycleHueShift: number;
-    /** Forward-clock period for one full curve traversal, in ms. */
-    durationMs: number;
-    /** A constant per-variant seed used under `freeze` so a capture is deterministic. */
-    frozenSeed: string;
-    /** The parameter `t` of the static best-frame painted under `freeze`. */
-    frozenT: number;
-    /** Comet-trail PEAK alpha (the head segment). The reference trail rides ~0.9
-     *  near-opaque — present, not the prior 0.45 hairline whisper. */
-    peakAlpha: number;
-    /** Trail stroke weight in CSS px (the reference is a BOLD 3.5px stroke, not
-     *  the prior 1.6 hairline). The single biggest faintness lever. */
-    trailWidth: number;
-    /** Head-glow alpha — the STRONGEST layer (head-forward: > peakAlpha). */
-    headGlowAlpha: number;
-    /** Head-glow `shadowBlur` bloom radius, in px. */
-    headGlowBlur: number;
-    /** The comet HEAD DOT radius in CSS px (the reference's glowing tip — a
-     *  saturated core + white highlight + soft halo). 0 disables it. */
-    headDotRadius: number;
-    /** Epicycle scaffolding alphas ÷ peak (hero only; {0,0} disables the scaffold).
-     *  The reference circles/arms are PRESENT (≈0.5/0.75), not the prior 0.18 ghost. */
-    epicycleRatios: {
-        circle: number;
-        arm: number;
-    };
-    /** Epicycle circle / arm stroke weights in CSS px (the reference uses a bold
-     *  ≈2.5/2 chain, the joints carry filled dots). */
-    epicycleWidths: {
-        circle: number;
-        arm: number;
-    };
-    /** Paint the epicycle chain as a rainbow across the spectrum (the
-     *  fourier-analysis signature) vs one analogous second hue. Hero only. */
-    epicycleRainbow: boolean;
-    /** Trail persistence exponent — SOFT (1..2), never the quadratic that kills the body. */
-    trailFadeExp: number;
-    /** Min trail alpha ÷ peak — the body survives, never decays to 0. The
-     *  reference body reads near-uniform; the floor sits HIGH (≈0.35) so the
-     *  comet body has real presence on cream too (the light-mode floor fork). */
-    trailFloor: number;
-}
-export declare const PRESETS: Record<"hero" | "final", VariantPreset>;

package/dist/components/custom/goo-blob/composables/buildMetaballProgram.d.ts

@@ -1,18 +0,0 @@
-import { type MetaballUniformLocations } from "./uploadBlobUniforms";
-/** The compiled-program handles the renderer closes over + tears down. */
-export interface MetaballProgram {
-    prog: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    vao: WebGLVertexArrayObject;
-    buf: WebGLBuffer;
-    locs: MetaballUniformLocations;
-}
-/**
- * Compile the metaball shader, build the full-quad VAO, and resolve the uniform
- * location cache on a fresh context. Leaves `BLEND` enabled with the
- * premultiplied-alpha `(ONE, ONE_MINUS_SRC_ALPHA)` blend func (the source's
- * setup), `prog` in use, and the VAO bound — the caller's `resize`/`drawFrame`
- * re-bind as needed.
- */
-export declare function buildMetaballProgram(gl: WebGL2RenderingContext): MetaballProgram;

package/dist/components/custom/goo-blob/composables/uploadBlobUniforms.d.ts

@@ -1,41 +0,0 @@
-import type { BlobConfig, MoodParams } from "../types";
-import type { BlobPointer } from "./useBlobPointer";
-import type { BlobSatelliteSystem } from "./useBlobSatellites";
-import { MAX_SATS, TRAIL_N, MAX_BLOB_STOPS, POS_SCALE, UNIFORM_NAMES } from "../constants";
-import type { UniformName } from "../constants";
-export { MAX_SATS, TRAIL_N, MAX_BLOB_STOPS, POS_SCALE, UNIFORM_NAMES };
-export type { UniformName };
-/** The cached uniform-location set the GL setup builds once per context. */
-export interface MetaballUniformLocations {
-    U: Record<UniformName, WebGLUniformLocation | null>;
-    satPosLocs: (WebGLUniformLocation | null)[];
-    satRadLocs: (WebGLUniformLocation | null)[];
-    satOpLocs: (WebGLUniformLocation | null)[];
-    trailPosLocs: (WebGLUniformLocation | null)[];
-    trailRadLocs: (WebGLUniformLocation | null)[];
-    paletteLocs: (WebGLUniformLocation | null)[];
-}
-/** The per-frame state the renderer resolves and hands to the upload leaf. */
-export interface BlobFrameState {
-    /** The mood params for this frame (`mood.params.value`). */
-    params: MoodParams;
-    /** The resolved base-color gamma-sRGB triple. */
-    rgb: [number, number, number];
-    /** The tempo-integrated motion clock (ms). */
-    simTimeMs: number;
-    /** The substrate's seconds clock for this frame (the pulse-phase axis). */
-    timeSec: number;
-    /** A CONCRETE → gamma-sRGB triple resolver (the renderer's memoised `/color` leaf). */
-    resolveColor: (css: string) => [number, number, number];
-    /** The Fresnel rim color (CONCRETE — the SFC un-wrapped any var()-token). */
-    rimColor: string;
-    /** The multi-stop palette (CONCRETE strings; EMPTY → falls back to base). */
-    paletteStops: string[];
-}
-/**
- * Write the resolved frame state into the metaball program's uniforms and issue
- * the draw call. Pure: it mutates GL state only (the bound program/VAO + the
- * uniform values) and never reads the renderer's closure. The body is the
- * byte-identical lift of the prior inline `drawFrame` uniform-upload section.
- */
-export declare function uploadBlobUniforms(gl: WebGL2RenderingContext, prog: WebGLProgram, vao: WebGLVertexArrayObject, locs: MetaballUniformLocations, canvas: HTMLCanvasElement, config: BlobConfig, pointer: BlobPointer, satellites: BlobSatelliteSystem, frame: BlobFrameState): void;