@mkbabb/glass-ui 3.12.0 → 4.0.0

package/dist/color.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./color-C5ls_QF7.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./color-DweYl7pE.js";
 export { c as cssToOklch, i as defaultBlobColorResolver, o as deriveBlobPalette, n as deriveHue, e as gamutMapStop, a as oklchStopToHex, s as oklchToGammaRgb, t as oklchToLinear, r as warmCatchLight };

package/dist/command.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-CefCj5mt.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-DdtWXxOK.js";
 export { r as Command, t as CommandDialog, s as CommandEmpty, a as CommandGroup, e as CommandInput, n as CommandItem, o as CommandList, i as CommandSeparator, c as CommandShortcut };

package/dist/components/custom/animated-digit/AnimatedDigit.vue.d.ts

@@ -22,6 +22,14 @@ import type { HTMLAttributes } from "vue";
  *    it from the formatted string length.
  *  - `mode`: `"absolute"` (default) or `"progress"` — passes through to
  *    `useAnimatedNumber`.
+ *
+ * AZ.W-METRIC-UNIFY — AnimatedDigit keeps its OWN local `placeholder: "—"`
+ * default (NOT the shared `coalesceMetric` leaf). It is a distinct animated
+ * single-glyph reel, not a static value-display card: it damps the FORMATTED
+ * number toward its target and its empty-check fires only on `null`/`undefined`
+ * (its `value` is `number | null | undefined` — there is no `""` empty string to
+ * coalesce). Folding it onto the value-card core would conflate two different
+ * surfaces. The keep is deliberate.
  */
 export type AnimatedDigitMode = "absolute" | "progress";
 export interface AnimatedDigitProps {

package/dist/components/custom/aurora/constants/presets.d.ts

@@ -1,19 +1,14 @@
 /**
  * Aurora v4.1 — library config shape.
  *
- * Authored THEMED presets (Sky, Dawn, Meadow, Deliberative, Day9, Oil Impasto,
+ * Authored presets (Sky, Dawn, Meadow, Deliberative, Day9, Oil Impasto,
  * Oil Gestural, Oil Van Gogh, Crayon Sunset, Crayon Rainbow, Crayon Ocean)
  * live in the consumer — see demo/stories/aurora/presets.ts.
  *
- * Per memory rule "Presets in consumers": named THEMED presets belong in each
- * consumer project, not in the library. The library exports only the shape, a
- * minimum-viable DEFAULT_AURORA_CONFIG, and — the one deliberate exception
- * (E22 / d-paper-aurora M4) — the `PAPER_WASH_GROUND` CALIBRATION partial: a
- * recessive-ground crayon TUNING (not a themed palette) whose deft tooth dials
- * are LIBRARY CANON so a data-ground aurora reads as paper-on-tooth without each
- * consumer dial-tuning the same recessive calibration by hand (the
- * `proof:aurora-paper-ground` gate locks it). It carries NO palette/nuclei — the
- * consumer spreads it over its own pole-derived pigment (page-glow IS data-glow).
+ * Per memory rule "Presets in consumers": named themed presets belong in
+ * each consumer project, not in the library. The library exports only the
+ * shape + a minimum-viable DEFAULT_AURORA_CONFIG for the component's own
+ * type-check ergonomics.
  */
 import type { OklchStop } from "../../../../composables/color";
 export type { OklchStop };
@@ -119,14 +114,6 @@ export interface AuroraConfig {
     granulation: number;
     impasto: number;
     brokenColor: number;
-    /**
-     * The medium's own paper-tooth multiplier (`uCanvasGrain` — `mediums.glsl.ts`
-     * `result *= 1 + tooth*toothAmp*uCanvasGrain`). The themed mediums ride the
-     * sub-0.1 band; the RECESSIVE-ground `crayon` preset (PAPER_WASH_GROUND) rides
-     * a higher tooth multiplier (~0.5) so the dry tooth is FELT at the clamped
-     * ground ceiling where a hue-tint dies — texture is cheap to the eye, flat hue
-     * is expensive (the d-paper-aurora load-bearing physics).
-     */
     canvasGrain: number;
     /**
      * AW.W4.2 — the impasto relight direction (the movable directional source the
@@ -195,34 +182,18 @@ export declare const MAX_STOPS = 8;
  */
 export declare const DEFAULT_AURORA_CONFIG: AuroraConfig;
 /**
- * `PAPER_WASH_GROUND` — the library-canon recessive-ground crayon calibration.
- *
- * The deft tooth dials the paper-aurora hybrid needs, pinned ONCE at the library
- * level so a data-ground aurora reads as pigment-on-paper-tooth — NOT a dead hue
- * tint, NOT a screen-like gradient — without each consumer hand-tuning the same
- * recessive calibration (the root-repo law: the calibration lives in the library;
- * the consumer never dial-tunes it). It is a PARTIAL: it carries NO palette /
- * nuclei / motion — the consumer SPREADS it over its own pole-derived pigment so
- * the page-glow stays the data-glow (the keystone the smooth-medium swap preserves
- * verbatim; only the DEPOSITION changes from a gradient to a dry-tooth multiply).
- *
- * The pinned dials (the named stopping rules, d-paper-aurora M1):
- *   - `medium: "crayon"`        — the DRY tooth-multiply (a TEXTURE, not strokes;
- *                                 admissible behind data where the four
- *                                 stroke-deposition mediums are forbidden).
- *   - `granulation: 0.30`       — pigment settles in the paper tooth (felt-at-rest).
- *   - `canvasGrain: 0.5`        — the medium's tooth multiplier, lifted so the dry
- *                                 tooth survives the clamped ground ceiling.
- *   - `strokeAmount: 0.35`      — the crayon PRESSURE (how hard the tooth bites);
- *                                 LOW (recessive — the tooth is felt, never a slab).
- *   - `strokeAnisotropy: 0.5`   — moderate directional squash; never high enough to
- *                                 read as STROKES (crumb-texture, not brushwork).
- * Plus the recessive guards: `saturation < 1` (the ground spends NO chroma budget —
- * the pops live in the icons), no impasto/sheen (`impasto: 0`, single layer), and a
- * felt `paperGrain` floor.
+ * `PAPER_WASH_GROUND` — the library-canon recessive-ground crayon calibration
+ * (BA.W-ATLAS-RECONCILE A-4a; d6 9467bd16 adopt). A pure PRESET PARTIAL (no
+ * palette/nuclei/motion) pinning the recessive crayon-ground deposition dials so a
+ * data-ground aurora reads as paper-on-tooth without each consumer dial-tuning the
+ * same recessive calibration by hand. It carries NO palette/nuclei — the consumer
+ * spreads it over its own pole-derived pigment (page-glow IS data-glow):
+ * `const cfg = { ...consumerBase, ...PAPER_WASH_GROUND }`.
  *
- * Spread it: `const cfg = { ...consumerBase, ...PAPER_WASH_GROUND }` — the
- * calibration wins the deposition dials, the consumer keeps the pigment + nuclei.
+ * House-rule clean (presets-in-consumers): this is the LIBRARY's own recessive-ground
+ * IDENTITY, not a consumer theme — admissible at the root. `satisfies
+ * Partial<AuroraConfig>` holds (every key is a first-class `AuroraConfig` field at
+ * HEAD; the `crayon` medium is `uMedium==4`).
  */
 export declare const PAPER_WASH_GROUND: {
     readonly medium: "crayon";

package/dist/components/custom/aurora/constants/renderMode.d.ts

@@ -12,6 +12,8 @@ export type AuroraRenderMode = "webgl" | "css" | "auto";
  * `"css"` pass through unchanged.
  *
  * `"auto"` resolves to `"css"` when ANY low-power signal is present:
+ *   - a SOFTWARE WebGL renderer (SwiftShader / llvmpipe / MS Basic Render — the
+ *     GPU-blocklisted path; see {@link isSoftwareWebGLRenderer}),
  *   - `navigator.hardwareConcurrency <= 4` (few logical cores),
  *   - `prefers-reduced-motion: reduce`,
  *   - `navigator.connection.saveData === true` (Data Saver on).

package/dist/components/custom/aurora/constants/shaders/mediums.glsl.d.ts

@@ -1,2 +1,2 @@
 export declare const AURORA_MEDIUMS_PRE_BRUSH_GLSL = "// \u2500\u2500 Medium overlays \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\n// \u2500\u2500 Structure-tensor / edge-tangent-flow (AW.W4.1) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The keystone of the painterly engine: derive stroke orientation from the COLOR\n// FIELD's OWN structure, not a hand-authored flow pattern. A 3x3 Sobel over\n// luma(sampleBase) yields the gradient (Gx,Gy); the 2x2 structure tensor\n// J = [[Gx\u00B2, GxGy],[GxGy, Gy\u00B2]] eigen-decomposes closed-form into the MINOR\n// eigenvector (the edge-TANGENT \u2014 least color change, the stroke direction; the\n// MAJOR eigenvector is the gradient/edge-NORMAL and would make strokes cross the\n// bands) and the coherence A = (\u03BB1-\u03BB2)/(\u03BB1+\u03BB2). Low-coherence (flat) zones relax\n// toward the smooth fallbackDir by (1-A) so tensor noise never reads as jitter.\n// Single-pass small-tap WebGL2 form; the Gaussian-smoothed multi-tap + LIC smear\n// is the AW.W7 WebGPU multi-pass fold. Returns vec3(tangent.x, tangent.y, A).\nvec3 structureTensorField(vec2 p, float t, vec2 fallbackDir) {\n  float e = 0.0035; // small-tap neighborhood (edge-mask scale)\n  // 3x3 luma samples.\n  float l00 = dot(sampleBase(p + vec2(-e, -e), t), W_LUMA);\n  float l10 = dot(sampleBase(p + vec2( 0.0, -e), t), W_LUMA);\n  float l20 = dot(sampleBase(p + vec2( e, -e), t), W_LUMA);\n  float l01 = dot(sampleBase(p + vec2(-e, 0.0), t), W_LUMA);\n  float l21 = dot(sampleBase(p + vec2( e, 0.0), t), W_LUMA);\n  float l02 = dot(sampleBase(p + vec2(-e, e), t), W_LUMA);\n  float l12 = dot(sampleBase(p + vec2( 0.0, e), t), W_LUMA);\n  float l22 = dot(sampleBase(p + vec2( e, e), t), W_LUMA);\n  // Sobel derivatives.\n  float Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  float Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  // Structure tensor components.\n  float Jxx = Gx * Gx;\n  float Jyy = Gy * Gy;\n  float Jxy = Gx * Gy;\n  // Closed-form 2x2 eigenvalues: \u03BB = 0.5(tr \u00B1 sqrt((Jxx-Jyy)\u00B2 + 4Jxy\u00B2)).\n  float tr = Jxx + Jyy;\n  float disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  float lambdaMaj = 0.5 * (tr + disc);\n  float lambdaMin = 0.5 * (tr - disc);\n  // The MAJOR eigenvector points along the gradient (the edge NORMAL); the MINOR\n  // is its perpendicular \u2014 the edge TANGENT (the stroke direction). The principal\n  // angle is \u03B8 = 0.5\u00B7atan2(2\u00B7Jxy, Jxx-Jyy); this form is robust at Jxy\u22480 (where the\n  // (\u03BB-Jyy, Jxy) eigenvector formula collapses to a zero vector). The tangent is at\n  // \u03B8 + 90\u00B0. Guard the fully-isotropic (no-gradient) degenerate case \u2192 fallback dir.\n  vec2 tangent;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    float theta = 0.5 * atan(2.0 * Jxy, Jxx - Jyy); // major (gradient) angle\n    tangent = vec2(-sin(theta), cos(theta));          // perpendicular = tangent\n  }\n  // Coherence A in [0,1] \u2014 high where one eigenvalue dominates (a strong edge),\n  // ~0 in flat zones. Relax toward the smooth fallback by (1 - A).\n  float A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  // Coherence-weighted blend: full tensor in coherent zones, smooth in flat ones.\n  // Resolve the 180\u00B0 sign ambiguity toward the fallback so the blend is continuous.\n  if (dot(tangent, fallbackDir) < 0.0) tangent = -tangent;\n  // The blend weight is a low-power curve (A^0.35) so even MODERATE-coherence zones queue\n  // strongly along the tangent (a flowing van-Gogh band reads coherent the way the\n  // structure-tensor metric measures it; a linear A under-orients the mid-band and the\n  // rendered field reads too isotropic \u2014 the \u00A74.2 anisotropy lift). The flat-zone (A\u22480)\n  // relax to the fallback survives (0^0.35=0), so tensor noise never reads as jitter.\n  float blendW = pow(A, 0.28);\n  vec2 dir = normalize(mix(fallbackDir, tangent, blendW) + 1e-6);\n  return vec3(dir, A);\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation \u2014 pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding \u2014 faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth \u2014 tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n";
-export declare const AURORA_MEDIUMS_POST_BRUSH_GLSL = "// \u2500\u2500 Medium id constants (mirror uniformBridge.ts MEDIUM_ID \u2014 the uMedium ladder) \u2500\u2500\n// The StrokeProfile selector (AX.W12 + AX.W13) dispatches on the medium id: oil,\n// van-Gogh, and oil-pastel each AUTHOR a first-class profile in profileFor.\n#define MEDIUM_OIL 3\n#define MEDIUM_CRAYON 4\n#define MEDIUM_VANGOGH 5\n#define MEDIUM_OILPASTEL 6\n\n// \u2500\u2500 Crayon \u2014 DRY wax pigment on paper tooth (first-class medium, uMedium==4) \u2500\u2500\n// Crayon is not strokes. It's dry pigment crumbs dragged across paper tooth \u2014 the\n// DRY tooth-multiply model: anisotropic tooth noise multiplied into the base, a hard\n// SCUMBLE that lets the lower color show through the broken upper layer, and stable\n// OKLCh broken-color pigment patches. NO sheen, NO burnish film \u2014 that waxy gloss is\n// the OIL-PASTEL deposition's signature (mediumOilPastel), distinct from dry crayon\n// (AX.W13 slice 8 F1 \u2014 the split). Crayon shares the SUBSTRATE (the structure-tensor\n// orientation, the tooth noise, OKLCh brokenColorJitter), not the dispatch body.\nvec3 mediumCrayon(vec3 col, vec2 p, float t) {\n  // Orient the deposition along the structure-tensor edge-tangent (the bridge forces\n  // tensor for crayon, so read the tensor field directly).\n  vec2 flow = structureTensorField(p, t, flowField(p, t)).xy;\n  float ang = atan(flow.y, flow.x);\n  float ca = cos(-ang), sa = sin(-ang);\n  vec2 pr = vec2(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  // \u2500\u2500 Paper TOOTH height field \u2014 the relief the dry pigment rides. Anisotropic\n  // (squished along flow, coarse cross-flow). Peaks = ridges, valleys = paper pits.\n  float t1 = vnoise(vec2(pr.x * scale * aniso, pr.y * scale));\n  float t2 = vnoise(vec2(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + 11.0);\n  float t3 = vnoise(vec2(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + 23.0);\n  float tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  // \u2500\u2500 DRY TOOTH-MULTIPLY \u2014 the crayon multiplies the tooth relief into the base\n  // color (dark in the pits, bright on the ridges). The pressure (uStrokeAmount) sets\n  // how hard the multiply bites. This is the DRY model \u2014 no pigment build-up, no sheen.\n  float pressure = clamp(uStrokeAmount, 0.0, 1.0);\n  float bite = mix(0.18, 0.46, pressure);        // multiply strength\n  vec3 result = col * (1.0 - bite * (0.5 - tooth));\n\n  // \u2500\u2500 HARD SCUMBLE \u2014 a broken upper layer that lets the lower color show through the\n  // gaps. A coarse mask gates a HARD (high-contrast) dragged pass so the dry crayon\n  // reads as broken pigment crumbs, not a smooth wash. Drag follows the tensor flow.\n  float scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2(pr.x * scale * 0.55, pr.y * scale * 0.22) + 7.0));\n  float scumbleCoverage = scumbleMask * pressure * 0.7;     // hard broken upper layer\n  vec3 paper = col * mix(0.80, 0.94, pressure);             // the paper showing through\n  result = mix(paper, result, scumbleCoverage);\n\n  // \u2500\u2500 Broken-color pigment: stable wax/pigment patches in OKLCh (W5), not flicker.\n  vec2 pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  float pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + 19.0));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + 17.0),\n    hash21(pigmentCell * 2.1 + 31.0),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  // Crayon is saturation-amplified (the wax chroma punch \u2014 but DRY, no sheen).\n  result = saturate3(result, 1.08);\n\n  return result;\n}\n\n// \u2500\u2500 StrokeProfile \u2014 the oil-stroke parameter vector (AX.W12, slice 8 F6) \u2500\u2500\u2500\u2500\u2500\u2500\n// The SBR \"stroke = parameter vector\" canon (facet 11): the per-mode if-ladder knobs\n// become struct FIELDS \u2014 logic-as-DATA, not an imperative branch. profileFor(medium,\n// mode) populates the profile for a (medium, mode) pair; paintStrokeLayers(profile) runs\n// the four-layer bestOil/paintOver cascade off it. A new medium (the W13 van-Gogh /\n// oil-pastel profiles) AUTHORS a profile entry \u2014 it never edits a monolith.\nstruct StrokeProfile {\n  int   shapeType;   // 0 tapered, 1 load-drag, 2 dab, 3 even, 4 comma/crescent\n  float bristleAmp;  // edge raggedness 0..0.5\n  float streakFreq;  // internal-streak spatial frequency\n  float streakAmp;   // internal-streak amplitude\n  float impastoAmp;  // paint-thickness contribution (the relight reads the height)\n  float hardness;    // edge-compositing crispness 0..1\n  float toothScale;  // canvas-tooth (linen weave) spatial frequency\n  float toothAmp;    // canvas-tooth amplitude\n  float pigmentSat;  // pigment saturation boost (OKLCh chroma scale)\n  float densityBig;  // layer-1 (big gestural) placement density gate\n  float densityMed;  // layer-2 (medium body) placement density gate\n  float densitySml;  // layer-3 (small dabs) placement density gate\n  float energyGrade; // AX.W13 \u2014 SBR energy-grade magnitude (0 off; 1 the van-Gogh\n                     // Starry-Night length cascade). The energy grade is a PROFILE\n                     // field, NOT a buried uMedium==5 bestOil branch (slice 8 F0).\n  float impastoFloor;// AX.W13 \u2014 the per-stroke height-crown floor (0.4 oil falloff;\n                     // 1.0 van-Gogh FULL-height crown so each dab catches its glint).\n  float densityFill; // AX.W13 \u2014 layer-4 fill-dab density. Oil/oil-pastel fill the\n                     // bald spots (0.95, full coverage); van-Gogh sets it LOW so the\n                     // sparse atomic dabs keep their visible inter-stroke ground gaps\n                     // (the atomicity read \u2014 a 0.95 fill would close every gap to a smear).\n  float groundFloor; // AX.W13 \u2014 the bare-ground darken floor. The gaps between strokes\n                     // (low accumulated height) multiply toward this floor, so van-Gogh's\n                     // sparse atomic dabs read over a visibly darker underpainting (the\n                     // Starry-Night visible ground). Oil/oil-pastel keep 1.0 (no darken).\n};\n\n// The (medium, mode) -> StrokeProfile selector. The if-ladder's knobs are the profile's\n// fields; a new medium adds a CASE here (never an edit to a dispatch body). mode is the\n// uStrokeMode oil-stroke sub-mode (0 oil, 1 palette-knife, 3 brushwork). crayon\n// (uMedium==4) is a PEER tooth-multiply medium that never reaches the stroke cascade.\n// The painterly STROKE mediums are oil (MEDIUM_OIL), van-Gogh (MEDIUM_VANGOGH) and\n// oil-pastel (MEDIUM_OILPASTEL) \u2014 each AUTHORS its own profile entry below.\nStrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) \u2014 balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType \u2014 tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    240.0,  // toothScale\n    0.09,   // toothAmp\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade \u2014 oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor \u2014 oil's 0.4+0.6\u00B7edgeN crown falloff\n    0.92,   // densityFill \u2014 oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the \u00A74.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the prior round-dab speckle.\n    1.0     // groundFloor \u2014 oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // \u2500\u2500 Van-Gogh \u2014 first-class atomic comma/crescent dabs (slice 8 F0). NOT a length\n  // modulation of oil: sparse high-contrast SEPARABLE marks with their own asymmetric\n  // shape, the full Starry-Night energy cascade (energyGrade=1), and full-height\n  // impasto crowns so each dab catches its own glint. The mode sub-modes don't apply\n  // (van-Gogh has its own grammar), so this returns early.\n  if (medium == MEDIUM_VANGOGH) {\n    prof.shapeType   = 4;     // comma / crescent \u2014 the divisionist atomic dab\n    prof.bristleAmp  = 0.22;  // a touch of raggedness on the loaded head\n    prof.streakFreq  = 16.0;  // within-stroke streaks (the loaded comma) \u2014 kept in the\n                              // FFT inertial band (a too-fine streak falls past the \u00A74.3\n                              // resolved-band edge and reads as steeper, not shallower)\n    prof.streakAmp   = 0.22;\n    prof.impastoAmp  = 1.1;   // paint per atomic dab \u2014 eased off 1.5 so the impasto crown\n                              // does not push the dab past the PBR-Neutral 0.8 highlight\n                              // knee (where it compresses + loses the directional contrast\n                              // the \u00A74.2 anisotropy reads)\n    prof.hardness    = 0.92;  // crisp separable edges (visible inter-stroke gaps)\n    prof.toothScale  = 220.0;\n    prof.toothAmp    = 0.06;\n    prof.pigmentSat  = 0.60;  // the van-Gogh chroma \u2014 pulled DOWN off the hand-set 1.12\n                              // so the rendered colorfulness lands inside [55.67, 95.67]\n                              // (the hand-set punch + the saturated indigo/cobalt/yellow\n                              // ramp pushed C past the garish ceiling \u2014 \u00A74.1 bidirectional)\n    // SPARSE-BUT-FLOWING placement \u2014 visible inter-stroke canvas gaps (the atomicity read)\n    // yet enough directional coverage that the swirl-rows read as coherent flowing bands\n    // (the \u00A74.2 anisotropy needs the strokes to dominate the gradient field; too-sparse\n    // gates left large flat-ground regions that read isotropic and dragged mean A down).\n    prof.densityBig  = 0.58;\n    prof.densityMed  = 0.68;\n    prof.densitySml  = 0.74;\n    prof.energyGrade = 1.0;   // the full Starry-Night length cascade (the profile field)\n    prof.impastoFloor = 1.0;  // FULL-height crowns \u2014 every atomic dab catches its glint\n    prof.densityFill = 0.30;  // a LIGHT directional fill \u2014 textures the dark ground with\n                              // flow-aligned fine strokes so the gaps carry directional\n                              // gradient (the \u00A74.2 A lift: an untextured dark ground reads\n                              // isotropic) WHILE staying open enough that the bright atomic\n                              // dabs still read separable over it (the gap-fraction floor\n                              // stays satisfied \u2014 the fill is fine + dark, not a smear).\n    prof.groundFloor = 0.31;  // darken the bare-ground gaps to the visible Starry-Night\n                              // underpainting so the bright impasto dabs read separable \u2014\n                              // the dab\u2194ground contrast injects MID-scale energy (the \u00A74.3\n                              // \u03B2-flatten: the PBR-Neutral highlight compression concentrated\n                              // energy at low-k and steepened \u03B2). 0.31 is the balance point:\n                              // deep enough to hold \u03B2 in-band, light enough that the textured\n                              // ground keeps the \u00A74.2 coherence the too-dark 0.26 floor cost.\n    return prof;\n  }\n\n  // \u2500\u2500 Oil-pastel \u2014 broad smeared directional strokes deposited via the brush engine\n  // (slice 8 F1). Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear \u2014 a round dab reads locally\n                              // isotropic (steep \u03B2 / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the \u00A74.2\n                              // coherence + adds the directional mid-band the \u00A74.3 slope\n                              // needs (the round-dab profile rolled \u03B2 off to \u22122.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear \u2014 adds the mid/high-band the smooth\n                              // round-dab profile lacked (the \u03B2-too-steep fix); the\n                              // directional along-spine streak flattens the \u00A74.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY \u2014 soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma \u2014 eased off 1.16 so the rendered C clears\n                              // the \u00A74.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER \u2014 a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (\u03B2\u2248\u22122.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the \u22125/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage \u2014 but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local \u00A74.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade \u2014 varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the \u22125/3 cascade the uniform-length 0.0 grade lacked,\n                              // the \u00A74.3 \u03B2-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // \u2500\u2500 Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife \u2014 razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork \u2014 heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n\n// The single parameterized four-layer stroke cascade (AX.W12). The four hand-unrolled\n// bestOil/paintOver invocations collapse into ONE body driven by the profile + the\n// uniform-derived per-layer scale/anisotropy multipliers (which are mode-INVARIANT \u2014 the\n// per-layer offsets, seeds, and len/wid muls are fixed across modes, so they stay here as\n// the cascade's structure; only the profile's knobs differentiate the medium). The\n// mode passes through for the two mode-special-cased shapes (knife layer-3 dabs +\n// layer-4 fill shape), which are placement details of the cascade, not profile knobs.\nvoid paintStrokeLayers(inout vec3 col, inout float height, StrokeProfile prof,\n                       int mode, vec2 p, float t) {\n  // Scales & multipliers from uniforms (mode-invariant cascade structure).\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three primary layers: big gestural, medium body, small dabs.\n  // W-AUR-STUDIO D5 \u2014 the \u22125/3 radii respacing was MEASURED + REVERTED (recorded, not\n  // silently struck). The \u03C6-adjacent geometric candidate (2.4 / 1.45 / 0.87, a fixed\n  // \u22481.66\u00D7 step) moved oil-pastel \u03B2 \u22122.534 \u2192 \u22122.413 \u2014 TOWARD the \u22125/3 band but NOT into\n  // it (floor \u22121.85), so the keep-iff-into-band gate failed. The single-pass WebGL2 path\n  // is the true limiter (HC-aurora \u00A75): the oil-pastel \u03B2 + the oil/oil-pastel anisotropy\n  // residual is the named AY.W-AUR-T5 multi-pass anisotropic-Kuwahara candidate. The\n  // hand-set 2.4 / 1.1 / 0.45 stays \u2014 it is van-Gogh's landed-band spacing.\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  // Strokes are elongated HARD (long\u00B7thin) so the rendered field reads strongly\n  // directional \u2014 the \u00A74.2 structure-tensor anisotropy lift. A short fat dab is locally\n  // isotropic and drags the measured A down; a long thin stroke that hugs the tensor\n  // tangent is what gives Starry Night its A\u22480.83. The width muls are pulled tighter to\n  // keep the long\u00B7thin aspect.\n  float lenMulBig = mix(3.0, 5.2, uStrokeAnisotropy);\n  float widMulBig = mix(0.42, 0.22, uStrokeAnisotropy);\n  float lenMulMed = mix(2.8, 4.8, uStrokeAnisotropy);\n  float widMulMed = mix(0.40, 0.21, uStrokeAnisotropy);\n  float lenMulSml = mix(2.2, 3.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.36, 0.23, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter \u2014 no grid\n  vec2 flow = flowField(p, t);\n\n  // Layer 1 \u2014 big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           prof.densityBig, prof.shapeType, prof.bristleAmp, flow, t, 1.3,\n                           prof.energyGrade);\n  paintOver(col, height, hBig, prof.streakFreq * 0.7, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 1.3, prof.impastoFloor);\n\n  // Layer 2 \u2014 medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, prof.densityMed, prof.shapeType, prof.bristleAmp, flow, t, 2.7,\n                           prof.energyGrade);\n  paintOver(col, height, hMed, prof.streakFreq, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 2.7, prof.impastoFloor);\n\n  // Layer 3 \u2014 small strokes (more frequent, smaller). Even the knife layer-3 stays the\n  // medium's DIRECTIONAL shape, not a round dab \u2014 the round-dab sparkle was a fine-scale\n  // isotropic speckle that dragged the \u00A74.2 anisotropy down + rolled the \u00A74.3 slope shallow.\n  int smlShape = prof.shapeType;\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 0.9, prof.densitySml, smlShape,\n                           prof.bristleAmp * 0.85, flow, t, 4.1, prof.energyGrade);\n  paintOver(col, height, hSml, prof.streakFreq * 1.4, prof.streakAmp * 0.6,\n            uImpasto * prof.impastoAmp * 0.45 * uStrokeAmount, prof.hardness, 4.1, prof.impastoFloor);\n\n  // Layer 4 \u2014 fill strokes (dense, fine) \u2014 cover bald spots. The density is\n  // PROFILE-driven (prof.densityFill): oil/oil-pastel fill to full coverage; van-Gogh\n  // keeps it sparse so the bare-ground gaps between its atomic dabs survive. The fill is\n  // ELONGATED + flow-oriented (NOT a round dab) \u2014 a dense round-dab fill is locally\n  // isotropic and was the dominant \u00A74.2 anisotropy sink; an oriented fine stroke keeps the\n  // fill directional so the whole field reads coherent.\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(2.0, 3.2, uStrokeAnisotropy);\n  float widMulFill = mix(0.34, 0.24, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : prof.shapeType; // knife=even; others inherit the medium's directional shape\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 0.8, prof.densityFill, fillShape,\n                            prof.bristleAmp * 0.6, flow, t, 8.9, prof.energyGrade);\n  // The fill is a low-relief, low-streak base coat \u2014 it covers bald spots WITHOUT adding\n  // fine bright speckle (a high-impasto/high-streak fill caught a per-dab glint that read\n  // as isotropic noise over the directional macro strokes \u2014 the \u00A74.2/\u00A74.3 sink). Its\n  // positional jitter is tamed too so the fill strokes stay flow-aligned, not scattered.\n  paintOver(col, height, hFill, prof.streakFreq * 1.2, prof.streakAmp * 0.35,\n            uImpasto * prof.impastoAmp * 0.18 * uStrokeAmount, prof.hardness * 0.9, 8.9, prof.impastoFloor);\n\n  // Optional crosshatch layer\n  if (uStrokeLayers == 2) {\n    vec2 flow2 = vec2(-flow.y, flow.x);\n    StrokeHit hX = bestOil(p + vec2(7.3, -2.1), sMed, lenMulMed * 0.9, widMulMed,\n                           jitterAmt, prof.densityMed * 0.7, prof.shapeType, prof.bristleAmp, flow2, t, 6.5,\n                           prof.energyGrade);\n    paintOver(col, height, hX, prof.streakFreq, prof.streakAmp * 0.85,\n              uImpasto * prof.impastoAmp * 0.55 * uStrokeAmount, prof.hardness, 6.5, prof.impastoFloor);\n  }\n}\n\n// The shared stroke-medium SUBSTRATE finish (AX.W12 + AX.W13): paint the four-layer\n// cascade off the profile, then canvas-tooth + relight + saturation. The three painterly\n// STROKE mediums (oil / van-Gogh / oil-pastel) each AUTHOR their own profile and call\n// this \u2014 the substrate is shared, the PROFILE (not a dispatch-body fork) differentiates\n// the medium (slice 8 F6). mode passes through for the cascade's mode-special-cased shapes.\nvec3 paintStrokeMedium(vec3 col, vec2 p, float t, StrokeProfile prof, int mode) {\n  vec3 result = col;\n  // AW.W4.2 \u2014 accumulated paint HEIGHT across the stroke layers. The relight reads\n  // its gradient for the normal; the canvas tooth seeds the base relief.\n  float height = 0.0;\n  paintStrokeLayers(result, height, prof, mode, p, t);\n\n  // Canvas tooth \u2014 linen weave\n  float tooth1 = vnoise(p * prof.toothScale);\n  float tooth2 = vnoise(p * prof.toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * prof.toothAmp * uCanvasGrain;\n\n  // AW.W4.2 \u2014 relight the accumulated paint height with the movable uLightDir\n  // source (diffuse + Blinn specular, in LINEAR before aces()). The canvas tooth\n  // is the base relief term so the weave also catches the raking light.\n  float canvasBase = tooth * prof.toothAmp * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // AX.W13 \u2014 the visible ground. The bare-ground gaps (low accumulated stroke height)\n  // multiply toward prof.groundFloor, so van-Gogh's sparse atomic dabs read as separable\n  // marks over a darker underpainting (oil/oil-pastel keep groundFloor=1.0 \u2192 no-op). The\n  // smoothstep keeps the impasto dabs (high height) at full value; only the open ground\n  // between them darkens.\n  result *= mix(prof.groundFloor, 1.0, smoothstep(0.0, 0.38, height));\n\n  // Pigment saturation boost\n  result = saturate3(result, prof.pigmentSat);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // The oil medium is a thin body: fetch the oil profile (mode-dispatched), paint via\n  // the shared stroke substrate.  uStrokeMode: 0 oil (gestural), 1 knife, 3 brushwork.\n  int mode = uStrokeMode;\n  StrokeProfile prof = profileFor(MEDIUM_OIL, mode);\n  return paintStrokeMedium(col, p, t, prof, mode);\n}\n\n// AX.W13 \u2014 the van-Gogh atomic-stroke medium is now a FIRST-CLASS body, NOT a\n// mediumOil passthrough (slice 8 F0). It composes its OWN vangogh StrokeProfile (the\n// comma/crescent shapeType, sparse high-contrast atomic placement with visible\n// inter-stroke gaps, the full Starry-Night energy-grade cascade as a PROFILE field,\n// and full-height impasto crowns) through the shared stroke substrate. The bridge forces\n// the ETF (tensor) orientation so the swirl-rows queue along the color field's tangent;\n// the within-stroke OKLCh broken color (paintOver) + the OKLab stroke OVER-composite\n// give pigment-true atom-level shimmer. No subject matter \u2014 the \"source image\" is the\n// generated nuclei field, so dabs trace its iso-bands (the Starry-Night swirl-rows).\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  StrokeProfile prof = profileFor(MEDIUM_VANGOGH, 0);\n  return paintStrokeMedium(col, p, t, prof, 0);\n}\n\n// AX.W13 \u2014 the oil-pastel medium (uMedium==6) is a DISTINCT stroke-deposition body,\n// split out of the dry-crayon tooth-multiply (mediumCrayon) (slice 8 F1). It DEPOSITS\n// broad smeared directional strokes via the same brush engine with a creamy soft\n// hardness, heavy pigment build-up where strokes overlap, and a chroma punch \u2014 the\n// stroke-deposition model that gives oil-pastel its depth and less-uniform read.\n// Shares the SUBSTRATE (the stroke cascade + tooth + relight) with oil/van-Gogh, NOT\n// the dispatch body of dry crayon. The bridge forces tensor orientation.\nvec3 mediumOilPastel(vec3 col, vec2 p, float t) {\n  StrokeProfile prof = profileFor(MEDIUM_OILPASTEL, 0);\n  return paintStrokeMedium(col, p, t, prof, 0);\n}";
+export declare const AURORA_MEDIUMS_POST_BRUSH_GLSL: string;

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

@@ -0,0 +1 @@
+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/color-swatch/ColorSwatch.vue.d.ts

@@ -0,0 +1,22 @@
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    /** The chip edge size. `sm` = 28px, `md` = 32px (default). */
+    size?: "sm" | "md";
+    /** Render the uppercase hex code beside the swatch. Default `false`. */
+    showHex?: boolean;
+    class?: HTMLAttributes["class"];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    showHex: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/color-swatch/index.d.ts

@@ -0,0 +1 @@
+export { default as ColorSwatch } from "./ColorSwatch.vue";

package/dist/components/custom/configurator/Configurator.vue.d.ts

@@ -3,14 +3,14 @@ import { type ConfiguratorDensity } from "./density";
 /**
  * Scroll behavior for the controls column.
  *
- * - `auto`   — overflow-y-auto with `.scroll-fade-y` mask; controls scroll
- *              when their intrinsic height exceeds the host. Default.
- * - `always` — controls always render scroll affordance (mask + thin
- *              scrollbar). Use when authors want a fixed-height studio
- *              regardless of content.
- * - `never`  — controls do not scroll; host grows to content height. Use
- *              for popover/sheet hosts that already manage their own
- *              overflow.
+ * - `auto`   — the controls column renders a <FadingScroll axis="y"> scroll-port
+ *              (sharp at rest, feathered while overflowing); controls scroll when
+ *              their intrinsic height exceeds the host. Default.
+ * - `always` — same <FadingScroll> scroll-port + thin scrollbar. Use when
+ *              authors want a fixed-height studio regardless of content.
+ * - `never`  — controls do not scroll; host grows to content height. Renders a
+ *              plain div (no FadingScroll). Use for popover/sheet hosts that
+ *              already manage their own overflow.
  */
 export type ConfiguratorScrollMode = "auto" | "always" | "never";
 /**
@@ -106,6 +106,17 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
         }) => any;
     } & {
         default?: (props: {}) => any;
+    } & {
+        controls?: (props: {
+            layers: readonly {
+                id: string;
+                label: string;
+            }[] | undefined;
+            activeLayer: string | undefined;
+            selectLayer: (id: string) => void;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
     } & {
         footer?: (props: {
             reset: () => void;

package/dist/components/custom/configurator/ConfiguratorRow.vue.d.ts

@@ -25,6 +25,22 @@ import { type ConfiguratorDensity } from "./density";
  * and the token-driven CSS rule overrides the Tailwind gap. The
  * `"comfortable"` rung is functionally identical to the no-density
  * fallback; it exists so consumers can be explicit.
+ *
+ * # ConfiguratorRow vs LabeledField — recorded divergence (AZ.W-METRIC-UNIFY §B)
+ *
+ * Both are "label (+ meta) above/beside a slotted control", but they are NOT
+ * interchangeable — they emphasize DIFFERENT features:
+ *  - **ConfiguratorRow** (this) — for TOKEN / PRESET controls. Carries the
+ *    token-`name` reference, the opt-in `reset` affordance (`canReset`), and the
+ *    four-rung `density` axis (local-prop-over-inject). No a11y for/id wiring.
+ *  - **LabeledField** — for FORM fields. Carries the `for`/`id` label↔control
+ *    a11y wiring (`controlId`/`labelId`/`errorId`), the `tooltip`, the `required`
+ *    asterisk, and the `aria-live` `error` region.
+ *
+ * Reach for ConfiguratorRow inside a `<Configurator>` for token sliders/selects;
+ * reach for LabeledField for accessible form inputs. The divergence is recorded
+ * (NOT a forced merge — no ≥2-consumer shared-chassis need surfaced) in
+ * `docs/precepts/design-idioms.md §9`, alongside the `cn`/`focus-ring` keeps.
  */
 type __VLS_Props = {
     /** Display label (top-left, primary). */

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

@@ -1,81 +1,12 @@
-import { type HTMLAttributes } from "vue";
-import { type ConstellationField } from "./constellationField";
-/**
- * Constellation — a slow, geometric proximity-graph lattice on a Canvas2D
- * surface. Nodes drift + bounce; near nodes link with distance-falloff
- * hairlines; the web leans toward the cursor and taps ripple. It composes the
- * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
- * reduced-motion freeze for free (no hand-rolled RAF-park).
- *
- * The lattice ships NEUTRAL. A branded skin (a focal ring, a callout label) is
- * the consumer's `drawOverlay(ctx, field, now)` pass — it runs AFTER the four
- * neutral passes and receives the live field so it can pin itself to a real
- * node. Zero deck-domain content lives in the component.
- *
- * Palette reads the FULL `--constellation-*` legibility set off the canvas (the
- * node/node-dim/line colors + the edge-alpha multipliers + the field-yields-to-
- * type `--constellation-alpha` knob; neutral fallbacks), so a consumer override
- * or a dark-mode flip re-tints AND re-weights the lattice (AX.W17).
- *
- * The focal node + click-to-warp (AX.W17) is a first-class engine concept: with
- * `warpOnClick`, a click warps the focal node to the nearest drifting node via a
- * critically-damped spring stepped INSIDE the substrate's single rAF (no
- * `useSpring`, no second rAF). The consumer paints the focal mark at
- * `field.warp.{x,y}` in its `drawOverlay`.
- */
-type __VLS_Props = {
-    /** Node count. Default 64. */
-    count?: number;
-    /** Link distance in px (the falloff reach). Default 132. */
-    link?: number;
-    /** Drift speed. Default 0.16. */
-    speed?: number;
-    /**
-     * Seed for a REPRODUCIBLE field. A `number` or `string` (hashed) seeds the
-     * shared `mulberry32`; omit for a fresh `Math.random` field each mount.
-     */
-    seed?: number | string;
-    /** Steer-toward-cursor + tap ripples. Default true; auto-off under reduced-motion. */
-    pointerReactive?: boolean;
-    /**
-     * Click-to-warp (AX.W17). A click warps the focal node to the nearest
-     * drifting node and SPRINGS it there (a critically-damped path, chasing a
-     * LIVE drifting target). INDEPENDENT of `pointerReactive` — warp works on a
-     * static (non-ripple) lattice, and ripples work without warp. Default false;
-     * auto-off under reduced-motion (the click does NOT warp — the focal mark
-     * stays put; the stated PRM policy). The low-level `warpTo(...)` imperative
-     * method (via `defineExpose`) is the seam this prop sugars.
-     */
-    warpOnClick?: boolean;
-    /**
-     * Auto-DRIFT (AY.W-CON1). A periodic auto-pick re-points the focal node to a
-     * RANDOM node on a jittered cadence — the wander source on the SAME warp
-     * spring (the 2nd half of the AX.W17 "drift + warp are ONE mechanic" thesis;
-     * no second rAF, no second mechanic). `true` uses the default cadence
-     * (8–16s, the slides rhythm); `{ minIdle?, jitter? }` tunes it (ms). Default
-     * OFF — `wander` absent leaves `field.wander` undefined, byte-identical to
-     * HEAD. PRM-gated by the WARP precedent: the cadence lives inside the
-     * `!reducedMotion` step block, so under reduced-motion it never advances and
-     * the focal mark stays at its seed (NOT fire-but-freeze).
-     */
-    wander?: boolean | {
-        minIdle?: number;
-        jitter?: number;
-    };
-    /**
-     * Pointer-held GRAVITY-WELL (AY.W-CON2). Hold the pointer over the lattice and
-     * the nodes within reach are PULLED toward it (an inverse-square force on the
-     * SAME engine, no second rAF); release and the field cools back to `speed`.
-     * INDEPENDENT of `warpOnClick` and `pointerReactive` (a consumer can
-     * hold-to-pull on a non-ripple, non-warp lattice). `true` uses the tokenised
-     * `--constellation-well-*` defaults; an object overrides the gains. Default
-     * OFF — `gravityWell` absent leaves `field.well` undefined (byte-identical to
-     * HEAD; `stepField` skips the force pass). PRM-gated by the WARP precedent: the
-     * held-timer block lives inside `!reducedMotion`, so under reduced-motion the
-     * well never arms; AND the well STATE resets to neutral on the PRM-true edge
-     * (no half-ramped force frozen on).
-     */
-    gravityWell?: boolean | {
+import { type ConstellationProps } from "./constellationField";
+declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, import("./composables/useConstellation").ConstellationExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ConstellationProps> & Readonly<{}>, {
+    link: number;
+    speed: number;
+    count: number;
+    opacityCeiling: number;
+    pointerReactive: boolean;
+    warpOnClick: boolean;
+    gravityWell: boolean | {
         holdMs?: number;
         gain?: number;
         reach?: number;
@@ -83,70 +14,19 @@ type __VLS_Props = {
         maxSpeed?: number;
         soften?: number;
     };
-    /**
-     * Deterministic-capture freeze (AY.W-CON3). When `true`, the lattice lays
-     * out ONE reproducible STATIC frame and does NOT advance — seeded layout
-     * (set `seed` for a stable field ACROSS runs; an unseeded freeze still
-     * freezes but lays out a one-shot `Math.random` frame), no `stepField`, no
-     * ripple / warp / wander / well advance, and a FROZEN `now` handed to
-     * `drawOverlay` so a phase-driven skin (`(now % T) / T`) resolves to a fixed
-     * value (the pulse-ring radius is identical frame-over-frame). Omit to
-     * AUTO-DERIVE from `location.search` matching `export | print | freeze` (the
-     * deploy-pipeline contract — a consumer's pptx / print / screenshot capture
-     * gets a stable frame with zero per-consumer wiring). An explicit
-     * `:freeze="false"` forces live even under a capture URL. Unifies with the
-     * reduced-motion one-static-frame path — `freeze || reducedMotion` is the
-     * single static-frame predicate; the capture takes no input (the pointer /
-     * warp / well listeners are NOT registered under freeze).
-     */
-    freeze?: boolean;
-    class?: HTMLAttributes["class"];
-    /**
-     * The skin seam. Runs after the neutral passes with the live field, so a
-     * consumer paints its own focal mark pinned to a real node — read
-     * `field.warp.{x,y}` for the spring-eased focal position when `warpOnClick`
-     * is on. The branded content (a domain accent, a callout label) lives HERE,
-     * in the consumer. Under `freeze` it receives a FROZEN `now`, so a phase-
-     * driven mark resolves to a fixed value.
-     */
-    drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    /** The live field (the low-level imperative seam — for a custom overlay). */
-    field: ConstellationField;
-    /**
-     * The resolved deterministic-capture predicate (AY.W-CON3) — `true` when the
-     * lattice is laying out a frozen static frame (`freeze` prop OR a
-     * `?export|print|freeze` URL OR reduced-motion via the substrate). A read-only
-     * test/debug seam (the π freeze-live spec reads it to confirm the auto-derive
-     * fired without inferring from drift).
-     */
-    isFrozen: import("vue").ComputedRef<boolean>;
-    /**
-     * Imperative warp (AX.W17). Two call shapes:
-     *   `warpTo(localPoint)`              — `{x, y}` already in canvas-local px
-     *                                        (the lower primitive).
-     *   `warpTo(clientX, clientY)`        — client coords, mapped via the
-     *                                        deck-scale `toLocal` (the sugar
-     *                                        `warpOnClick` calls internally).
-     * The focal node re-points to the nearest drifting node + springs there.
-     * Returns the chosen node index, or -1 on a degenerate no-op. No-op under
-     * reduced-motion (the spring does not advance while the substrate is frozen).
-     */
-    warpTo(a: {
-        x: number;
-        y: number;
-    } | number, b?: number): number;
-    /**
-     * Imperatively ARM the gravity-well at a canvas-LOCAL point (AY.W-CON2) — the
-     * π-lane test seam that drives the well WITHOUT racing a real held-pointer
-     * gesture + the held-timer. Sets the well position + `target = 1` directly (the
-     * timer is bypassed; the ramp still eases `strength` over the next frames). No-op
-     * when `gravityWell` is off (no `field.well`). Returns true when the well armed.
-     */
-    holdWellAt(x: number, y: number): boolean;
-    /** Imperatively RELEASE the well (AY.W-CON2) — `target → 0`, the field cools. */
-    releaseWell(): void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    wander: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
+    pinned: boolean | number;
+    accentEdges: boolean;
+    pinnedDrift: boolean | {
+        wanderFrac?: number;
+        durMs?: number;
+        minIdle?: number;
+        jitter?: number;
+    };
+    warpAutoRelease: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -0,0 +1,41 @@
+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;
+};
+type PinnedDriftProp = boolean | {
+    wanderFrac?: number;
+    durMs?: number;
+    minIdle?: number;
+    jitter?: 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, pinned?: boolean | number, pinnedDrift?: PinnedDriftProp, warpAutoRelease?: boolean): ConstellationFieldState;
+export {};

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

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

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

@@ -0,0 +1,35 @@
+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 {};