@mkbabb/glass-ui 4.1.0 → 4.2.0

package/dist/components/custom/handmark/geometry.d.ts

@@ -30,6 +30,39 @@ export interface ShapeGeom {
     lines: [number, number][][];
     closed: boolean;
 }
+/**
+ * The boil voice — φ-incommensurate fractal value-noise (RE-INVENT; the masthead
+ * morphology). A 1-D fractal value-noise DISPLACEMENT off the HOUSE `mulberry32`,
+ * NOT a seeded sinusoid (the prior body self-correlated into a near-period — a spell-
+ * check squiggle):
+ *
+ *   disp(t) = Σ_{k=0..OCT-1} aₖ · vnoiseₖ(t·fₖ + φₖ)   normalised by Σaₖ
+ *     fₖ = NOISE_F0 · φ^k   (φ mutually-irrational steps → the sum NEVER closes
+ *                            into a period — the non-periodicity mechanism)
+ *     aₖ = (1/φ)^k          (per-octave decay)
+ *     φₖ = seeded per-octave phase (house mulberry32)
+ *     vnoiseₖ = seeded lattice value-noise, smootherstep-faired
+ *
+ * The four atlas axes:
+ *   - amplitude SCALES with the rendered span (`(x2−x1) × NOISE_AMP_FRAC`), not a
+ *     viewBox-stretched constant (a long word and a short word wobble in proportion);
+ *   - the hump-to-hump spacing is IRREGULAR (the φ-incommensurate octave sum — the
+ *     honest non-periodicity teeth, spacing-CV ~0.41 at the paint count vs the prior
+ *     sinusoid's ~0.14, over 400 seeds);
+ *   - the non-uniform body gives the pf hull a pressure-taper-friendly point stream;
+ *   - the seed is the HOUSE mulberry32 (determinism + per-seed variation), ZERO
+ *     pencil-boil `mulberry32` import.
+ *
+ * ENDPOINT anchor (NOT a body-wide envelope): a narrow cosine taper at the very ends
+ * only (`NOISE_EDGE`), so the ends settle to baseline (no draw-on pop) while the BODY
+ * amplitude stays irregular hump-to-hump (the prior `sin(π·t)` envelope made the body
+ * amplitude smooth-and-uniform — the clean-envelope tell). FILTER-FREE: the wander is
+ * in the control points + the hull width, never a feTurbulence.
+ *
+ * EXPORTED so the measuring gate samples the REAL emitted point-set (never a symbol-
+ * presence regex — the W-GATE-TRUTH-AUDIT discipline).
+ */
+export declare function naturalUnderlinePoints(x1: number, y: number, x2: number, seed: number, segments: number): [number, number][];
 /**
  * Semantic shape → { lines, closed } in the marking space (or a positioned box).
  *
@@ -41,7 +74,7 @@ export interface ShapeGeom {
  * back to the legacy `VB_H − 8` constant so first paint (and jsdom/SSR) still renders
  * a line, replaced the instant the measure lands.
  *
- * `natural` (BA.W-HANDMARK C-2) routes the underline through the procedural
+ * `natural` routes the underline through the φ-incommensurate value-noise
  * `naturalUnderlinePoints` morphology instead of pencil-boil's `wobbleLinePoints`
  * (the masthead `boil` voice); the default underline keeps the pencil-boil line.
  */

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

@@ -19,7 +19,7 @@
  */
 export { default as HandMark, default as InkMark } from "./HandMark.vue";
 export { BRUSHES, resolveBrush, lerpBrush, type Brush, type BrushName, type BlendMode, type TaperSpec, type StampFn, type InkPath, } from "./brush";
-export { shapeGeom, serialize, boilLines, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
+export { shapeGeom, serialize, boilLines, naturalUnderlinePoints, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
 export { ink, type SVGFragment } from "./ink";
 export { grainFilter, hasGrain } from "./texture";
 export { getStroke, getStrokePoints, getSvgPathFromStroke, type StrokeOptions, type InputPoint, } from "./freehand";

package/dist/components/custom/icon-chip/types.d.ts

@@ -71,6 +71,16 @@ export interface IconChipProps {
      * untouched. Default `false` (byte-identical to the reference register).
      */
     saturated?: boolean;
+    /**
+     * The QUIET glass register (BD.W-GLASS-ATOM-REGISTER cross-link). The DEFAULT
+     * chip keeps its loud `in srgb` brand-overlay plate (AW.W26 fence); this opt-in
+     * routes the chip through the shared `.glass-atom` warm-glass capsule instead —
+     * a transmissive lozenge with the warm floor + the `--glass-blur-quiet` backdrop
+     * + the keyed rim, tinted by `--glass-fill-tint` toward the event hue. Two
+     * registers, exactly like Badge: loud brand pop (default) vs quiet glass lens
+     * (opt-in). Default `false`.
+     */
+    glass?: boolean;
     /**
      * Entrance choreography — composes the shipped `vReveal` directive. A numeric
      * value is the `--d` stagger index; `true` is index 0. PRM-gated by `vReveal`'s

package/dist/components/custom/paper-backdrop/PaperBackdrop.vue.d.ts

@@ -13,6 +13,24 @@ export interface PaperBackdropProps {
     opacity?: number | string;
     /** Override turbulence frequency (advisory only — swaps the texture var). */
     frequency?: PaperBackdropFrequency;
+    /**
+     * BD.W-PAGE-FIELD — mount the WARM COLORFUL FIELD plane beneath the grain.
+     * When set, a `.paper-field` cel plane (amber→terracotta→sand at FIELD
+     * lightness, drifting on the compositor) paints UNDER the grain, so every
+     * glass surface over it reads transmissive/warm instead of gray. The grain
+     * rides ON TOP at its multiply opacity — one backdrop, two stacked planes.
+     * Opt-in (presets-in-consumers demo-chassis contract); the library glass
+     * primitive is UNCHANGED.
+     */
+    field?: boolean;
+    /**
+     * The warm route hue request (any degree). The field CLAMPS it to the warm
+     * band [25,95] IN THE CSS, so a cool/teal value cannot paint cool. Wire
+     * `warmFieldHue(category)` here per route.
+     */
+    fieldHue?: number | string;
+    /** The field rung intensity (0.85 ground / 1.0 vivid hero / 0 = neutral). */
+    fieldIntensity?: number | string;
     /** Additional class names. */
     class?: HTMLAttributes["class"];
 }

package/dist/components/custom/paper-grid/composables/paperGrid.d.ts

@@ -9,29 +9,6 @@ export declare const CURL_EPS = 0.012;
 export declare function potentialFBM(p: Vec2): number;
 /** The 2D curl of the scalar fbm potential (the JS twin of `curlFBM`). */
 export declare function curlFBM(p: Vec2): Vec2;
-/**
- * The IQ domain warp displacement at `g` (in grid space) at time `t`. TWO counter-flowing
- * curl terms at different scales/speeds (Alex Harri counter-flow — never visibly loops):
- *
- *   g += curlFBM(g·warpScale  + t·warpSpeed ) · amplitude
- *   g += curlFBM(g·warpScale2 − t·warpSpeed2) · (amplitude·0.5)
- *
- * Returns the warp DISPLACEMENT (the caller adds it onto `g`). A SHALLOW warp (one level,
- * LOW amplitude, LOW spatial frequency) keeps the lines a clearly-readable grid — the
- * inverse-coherence target (LARGE structures from LOW spatial frequency).
- */
-export declare function curlWarp(g: Vec2, t: number, warpScale: number, warpSpeed: number, warpScale2: number, warpSpeed2: number, amplitude: number): Vec2;
-/**
- * The LOCAL cursor-bulge displacement at `g` (grid space). A Gaussian falloff about
- * `cursor` presses the grid AWAY from (repel, strength > 0) or TOWARD (attract, strength
- * < 0) the cursor inside `radius`, coherent everywhere else (the iOS-control-centre feel):
- *
- *   bulge = strength · exp(−d²/(2·radius²)); g += normalize(g−cursor) · bulge
- *
- * Returns the bulge DISPLACEMENT (the caller adds it onto `g`). The sign of `strength`
- * picks repel (+) vs attract (−).
- */
-export declare function cursorBulge(g: Vec2, cursor: Vec2, strength: number, radius: number): Vec2;
 /**
  * The Ben Golus derivative-AA grid line coverage at `g` (grid space). `targetWidth` is the
  * desired line half-width in GRID UNITS (the caller passes `lineWidthPx / minorPitchPx` so
@@ -59,17 +36,29 @@ export declare function gridCoverage(g: Vec2, targetWidth: number, uvDeriv: Vec2
 export interface PaperGridSampleParams {
     /** The grid scale (view / minorPitch → LARGER cells = smaller scale). */
     gridScale: number;
-    warpScale: number;
-    warpSpeed: number;
-    warpScale2: number;
-    warpSpeed2: number;
-    amplitude: number;
+    /** The traveling-wave front direction. */
+    waveDir: Vec2;
+    /** The crest-band spatial frequency. */
+    waveK: number;
+    /** The front speed (ω). */
+    waveOmega: number;
+    /** The crest-band width. */
+    waveSigma: number;
+    /** Max per-cell twist angle at the crest (rad). */
+    twistMax: number;
+    /** Max per-cell shear at the crest. */
+    shearMax: number;
+    /** The spring-eased envelope amplitude (0..1; PRM snaps to 0). */
+    amp: number;
     /** The cursor in GRID space. */
     cursor: Vec2;
+    /** The cursor-swirl peak twist (rad). */
     bulgeStrength: number;
     bulgeRadius: number;
-    /** +1 repel, −1 attract. */
+    /** +1 repel, −1 attract (signs the swirl). */
     bulgeMode: number;
+    /** 1 = cursor swirl on. */
+    interactive: number;
     /** Golus target half-widths in grid units (minor + major). */
     targetWidth: number;
     targetWidthMajor: number;
@@ -81,10 +70,36 @@ export interface PaperGridSampleParams {
     fieldAlpha: number;
     /** The FIXED per-axis derivative (the JS round-trip; shaders use dpdx/dpdy). */
     uvDeriv: Vec2;
+    /** The filled-FACE opacity (0 → the face evaporates → byte-identical to HEAD). */
+    faceAlpha?: number;
+    /** The slope-shade ∇H Lambert gain. */
+    faceReliefGain?: number;
+    /** The volume-preserving squash (the inset retreats at the crest). */
+    squashK?: number;
+    /** The base inset-square coverage. */
+    baseInset?: number;
+    /** The fixed cel key-light direction. */
+    lightDir?: Vec2;
+}
+/** The face-shade scalars the FACE composite reads (the numeric-parity witness — FOLD B/C/D). */
+export interface PaperGridFace {
+    /** The crest envelope at the pre-twist driver cc (FOLD A). */
+    env: number;
+    /** The sheet height at the driver cc (= env; the named leaf scalar). */
+    h: number;
+    /** The Lambert slope-shade [0,1] against the fixed key-light. */
+    shade: number;
+    /** The squashed inset-square face coverage [0,1]. */
+    faceCov: number;
+    /** The composited face alpha (FOLD D — face·faceAlpha·fieldAlpha, NO h-term). */
+    faceA: number;
+    /** The ramp parameter mix(shade, h) keying the multi-stop warm-divergent ink (FOLD B). */
+    rampT: number;
 }
 export declare function samplePaperGrid(uv: Vec2, t: number, p: PaperGridSampleParams): {
     line: number;
     alpha: number;
+    face: PaperGridFace;
 };
 /** The grid scale from the view + minor pitch (LARGER cells = smaller scale). */
 export declare function gridScaleFor(viewExtentPx: number, minorPitchPx: number): number;

package/dist/components/custom/paper-grid/composables/paperGridGLSetup.d.ts

@@ -5,6 +5,8 @@ export interface PaperGridGLSetupDeps {
     canvas: HTMLCanvasElement;
     config: PaperGridConfig;
     getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
     shouldContinue: () => boolean;
     /**
      * The per-frame pointer hook — usePaperGrid advances the shared pointer field + derives

package/dist/components/custom/paper-grid/composables/paperGridWGPUSetup.d.ts

@@ -4,8 +4,10 @@ import type { Vec2 } from "./paperGrid";
 export interface PaperGridWGPUSetupDeps {
     canvas: HTMLCanvasElement;
     config: PaperGridConfig;
-    /** The transient pointer cursor in GRID space — re-read each frame (the pointer bulge). */
+    /** The transient pointer cursor in GRID space — re-read each frame (the cursor swirl). */
     getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
     /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
     shouldContinue: () => boolean;
     /**

package/dist/components/custom/paper-grid/composables/uniformBridgeWGPU.d.ts

@@ -1,6 +1,6 @@
 import type { PaperGridConfig } from "../constants";
 import type { Vec2 } from "./paperGrid";
-export declare const PAPER_GRID_UNIFORM_BYTES = 144;
+export declare const PAPER_GRID_UNIFORM_BYTES = 224;
 export interface PaperGridUniformScratch {
     buffer: ArrayBuffer;
     f32: Float32Array;
@@ -13,4 +13,4 @@ export declare function createPaperGridScratch(): PaperGridUniformScratch;
  * `aspect` corrects the domain x. The line ink resolves the warm `--foreground` identity
  * (the demo themes it via a preset, never a token edit).
  */
-export declare function packPaperGridUniforms(scratch: PaperGridUniformScratch, config: PaperGridConfig, timeSec: number, aspect: number, viewExtentPx: number, cursor: Vec2): PaperGridUniformScratch;
+export declare function packPaperGridUniforms(scratch: PaperGridUniformScratch, config: PaperGridConfig, timeSec: number, aspect: number, viewExtentPx: number, cursor: Vec2, amp: number): PaperGridUniformScratch;

package/dist/components/custom/paper-grid/constants.d.ts

@@ -17,12 +17,18 @@ export interface PaperGridConfig {
     majorAlpha: number;
     /** Line width in device-px — one crisp pixel via Golus AA. */
     lineWidth: number;
-    /** Wave amplitude in CELL units — how far the lines bow (the liquid; subtle = "felt, not loud"). */
-    waveAmplitude: number;
-    /** Wave spatial frequency (λ multiple) — LOW = the whole sheet bows together (coherent, not noise). */
-    waveScale: number;
-    /** The slow warp drift (ω-scale). */
-    waveSpeed: number;
+    /** Max per-cell twist angle at the crest (rad ≈ 15° — a clear lean, never a tumble; ≤ ~18° floor). */
+    twistMax: number;
+    /** Max per-cell shear at the crest — a small skew so the box MORPHS, not just rotates. */
+    shearMax: number;
+    /** The traveling-wave front direction (a gentle diagonal). */
+    waveDir: [number, number];
+    /** The crest-band spatial frequency (LOW — cells per crest). */
+    waveK: number;
+    /** The front speed (slow — inertia). */
+    waveOmega: number;
+    /** The crest-band width (a localized front, not a global pulse). */
+    waveSigma: number;
     /** The GLOBAL subtlety knob — 1 demo, ~0.12 suffusion (the site-wide background). */
     fieldAlpha: number;
     /** How far the cursor pushes the grid (the local bulge). */
@@ -33,6 +39,28 @@ export interface PaperGridConfig {
     bulgeMode: "repel" | "attract";
     /** The line ink (the warm `--foreground` identity by default — NEVER teal-on-navy). */
     lineColor: OklchStop;
+    /**
+     * The filled-FACE opacity — **default `0`** so the face EVAPORATES → byte-identical to the
+     * line-only HEAD render (every `proof:viz-papergrid` cage clause + the warm-identity fence
+     * stay GREEN). The demo `PAPER_GRID_PRESET_RIPPLE` lifts it (presets-in-consumers).
+     */
+    faceAlpha: number;
+    /** The slope-shade gain (the ∇H Lambert relief — higher = steeper crest/trough contrast). */
+    faceRelief: number;
+    /** The volume-preserving SQUASH: the plateau inset retreats at the crest so the face inflates. */
+    squashK: number;
+    /** The base inset-square coverage (the soft tile inside the warped cell, 0..0.5 grid units). */
+    baseInset: number;
+    /**
+     * The 3-stop warm-DIVERGENT face ramp (FOLD B — height-keyed, NOT a 2-point mid-park `mix`):
+     * trough → mid → crest. ALL hues ∈ [20,90] (rose-umber → ember/amber → warm-wheat) so the
+     * teal-navy purge is clear by construction. `proof:viz-papergrid` clause reds a hue ∈ [180,280].
+     */
+    faceWarmLo: OklchStop;
+    faceWarmMid: OklchStop;
+    faceWarmHi: OklchStop;
+    /** The fixed cel key-light direction (upper-right) the slope-shade Lamberts against. */
+    lightDir: [number, number];
     /** The ground (default transparent so it suffuses over the page). */
     background: OklchStop | "transparent";
     /** Pointer bulge (§4/§8) — on (demo) / off (suffusion). */
@@ -48,6 +76,16 @@ export interface PaperGridConfig {
  * through a PRESET, never a token edit. NEVER teal/navy (h in [180,280] reds P5).
  */
 export declare const WARM_IDENTITY_INK: OklchStop;
+/**
+ * The library-default FACE ramp stops — a CALM warm-divergent fold the face would paint IF lit
+ * (the `faceAlpha:0` default keeps the face evaporated, so these never paint at HEAD; they are
+ * the warm-identity SSR fallback the vivid demo preset overrides). ALL hues ∈ [20,90] — the
+ * teal-navy purge clear by construction (`proof:viz-papergrid` reds a hue ∈ [180,280] here).
+ *   trough → rose-umber, mid → ember-amber, crest → warm-wheat.
+ */
+export declare const FACE_WARM_LO: OklchStop;
+export declare const FACE_WARM_MID: OklchStop;
+export declare const FACE_WARM_HI: OklchStop;
 /**
  * The shipped warm-identity default config — evenly-spaced, LARGE 64px cells, a crisp fine
  * rule with a bolder major rule every 5 cells, on a slowly breathing liquid curl-flow sheet

package/dist/components/custom/paper-grid/index.d.ts

@@ -1,5 +1,5 @@
 export { default as PaperGrid } from "./PaperGrid.vue";
 export { usePaperGrid, type PaperGridHandle, type UsePaperGridOptions, } from "./composables/usePaperGrid";
-export { type PaperGridConfig, DEFAULT_PAPER_GRID_CONFIG, WARM_IDENTITY_INK, PAPER_GRID_MAX_MAJOR_EVERY, } from "./constants";
-export { type Vec2, type PaperGridSampleParams, potentialFBM, curlFBM, curlWarp, cursorBulge, gridCoverage, samplePaperGrid, gridScaleFor, CURL_EPS, } from "./composables/paperGrid";
+export { type PaperGridConfig, DEFAULT_PAPER_GRID_CONFIG, WARM_IDENTITY_INK, FACE_WARM_LO, FACE_WARM_MID, FACE_WARM_HI, PAPER_GRID_MAX_MAJOR_EVERY, } from "./constants";
+export { type Vec2, type PaperGridSampleParams, type PaperGridFace, potentialFBM, curlFBM, gridCoverage, samplePaperGrid, gridScaleFor, CURL_EPS, } from "./composables/paperGrid";
 export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/paper-grid/shaders/paper-grid.glsl.d.ts

@@ -1,4 +1,4 @@
 /** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
 export declare const PAPER_GRID_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]\u00B2 domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
 /** The paper-grid fragment source — the liquid AA-grid (the same field as the WGSL primary). */
-export declare const PAPER_GRID_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define TAU 6.283185307179586\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uGridScale;\nuniform float uMajorEvery;\nuniform float uAspect;\nuniform vec4  uWarp;          // (warpScale, warpSpeed, warpScale2, warpSpeed2)\nuniform float uAmplitude;\nuniform vec4  uGrid;          // (targetWidth, targetWidthMajor, minorAlpha, majorAlpha)\nuniform float uFieldAlpha;\nuniform float uHasBackground;\nuniform vec4  uCursor;        // (cursorX, cursorY, bulgeStrength, bulgeRadius)\nuniform float uBulgeMode;     // +1 repel / \u22121 attract\nuniform vec3  uLineColor;     // linear-sRGB ink\nuniform vec3  uBg;            // linear-sRGB themed bg\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// The shared divergence-free 2D-curl operator (flow.glsl.ts) \u2014 the prototype declares\n// potentialFBM; the host defines its BODY below the splice (GLSL forward-declaration).\n\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi \u2014 the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n\n\n// \u2500\u2500 The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) \u2500\u2500\nfloat hash21(float x, float y) {\n  float px = fract(x * 0.1031);\n  float py = fract(y * 0.1031);\n  float pz = fract(x * 0.1031);\n  float d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px += d;\n  py += d;\n  pz += d;\n  return fract((px + py) * pz);\n}\n\nfloat valueNoise(float x, float y) {\n  float ix = floor(x);\n  float iy = floor(y);\n  float fx = x - ix;\n  float fy = y - iy;\n  float ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  float uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  float a = hash21(ix, iy);\n  float b = hash21(ix + 1.0, iy);\n  float c = hash21(ix, iy + 1.0);\n  float d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n\n// The 3-octave scalar fbm potential \u2014 the curl chunk's forward-declared potentialFBM body.\nfloat potentialFBM(vec2 p) {\n  float v = 0.0;\n  float amp = 0.5;\n  float freq = 1.0;\n  float px = p.x;\n  float py = p.y;\n  for (int i = 0; i < 3; i++) {\n    v += amp * valueNoise(px * freq, py * freq);\n    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) \u2014 same rotation as the shared chunk.\n    float rx = 0.8 * px - 0.6 * py;\n    float ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\n// \u2500\u2500 \u00A73 The global curl-flow domain warp (transcribes paperGrid.ts curlWarp) \u2500\u2500\nvec2 curlWarp(vec2 g, float t) {\n  float warpScale = uWarp.x;\n  float warpSpeed = uWarp.y;\n  float warpScale2 = uWarp.z;\n  float warpSpeed2 = uWarp.w;\n  vec2 a = curlFBM(vec2(g.x * warpScale + t * warpSpeed, g.y * warpScale + t * warpSpeed));\n  vec2 b = curlFBM(vec2(g.x * warpScale2 - t * warpSpeed2, g.y * warpScale2 - t * warpSpeed2));\n  return vec2(a.x * uAmplitude + b.x * uAmplitude * 0.5, a.y * uAmplitude + b.y * uAmplitude * 0.5);\n}\n\n// \u2500\u2500 \u00A74 The local pointer bulge (transcribes paperGrid.ts cursorBulge) \u2500\u2500\nvec2 cursorBulge(vec2 g) {\n  vec2 cursor = uCursor.xy;\n  float strength = uCursor.z * uBulgeMode;  // bulgeStrength \u00D7 bulgeMode (+repel / \u2212attract)\n  float radius = max(uCursor.w, 1e-4);\n  vec2 toC = g - cursor;\n  float d = length(toC);\n  float bulge = strength * exp(-(d * d) / (2.0 * radius * radius));\n  if (d < 1e-5) return vec2(0.0);\n  return (toC / d) * bulge;\n}\n\n// \u2500\u2500 \u00A71 The Ben Golus derivative-AA grid coverage (transcribes paperGrid.ts gridCoverage) \u2500\u2500\nfloat gridCoverage(vec2 g, float targetWidth, vec2 uvDeriv) {\n  vec2 gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  vec2 drawWidth = clamp(vec2(targetWidth), uvDeriv, vec2(0.5));\n  vec2 lineAA = uvDeriv * 1.5;\n  vec2 grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);\n  grid2 *= clamp(vec2(targetWidth) / max(drawWidth, vec2(1e-6)), vec2(0.0), vec2(1.0));\n  grid2 = mix(grid2, vec2(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2(0.0), vec2(1.0)));\n  return max(grid2.x, grid2.y);\n}\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 uv = vec2(vUv.x * aspect, vUv.y);\n\n  // \u00A75 the per-pixel kernel: warp + bulge the grid coordinate, then two-tier Golus.\n  vec2 g = uv * uGridScale;\n  g += curlWarp(g, uTime);\n  g += cursorBulge(g);\n\n  // The screen-space derivative of g (Golus): length(vec2(dFdx, dFdy)) per axis (the actual\n  // backing-store pixel \u2014 NOT a CSS sub-pixel, the blur-kill).\n  vec2 dv = vec2(\n    length(vec2(dFdx(g.x), dFdy(g.x))),\n    length(vec2(dFdx(g.y), dFdy(g.y)))\n  );\n\n  float minor = gridCoverage(g, uGrid.x, dv);\n  float me = max(uMajorEvery, 1.0);\n  float major = gridCoverage(g / me, uGrid.y, dv / me);\n  float line = max(minor * uGrid.z, major * uGrid.w);\n\n  vec3 col = clamp(linearToSrgb(uLineColor), vec3(0.0), vec3(1.0));\n  if (uHasBackground > 0.5) {\n    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));\n    float a = line * uFieldAlpha;\n    fragColor = vec4(mix(bg, col, a), 1.0);\n    return;\n  }\n  float a = line * uFieldAlpha;\n  fragColor = vec4(col * a, a);  // premultiplied over transparent\n}";
+export declare const PAPER_GRID_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define TAU 6.283185307179586\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uGridScale;\nuniform float uMajorEvery;\nuniform float uAspect;\nuniform vec4  uWarp;          // (warpScale, warpSpeed, warpScale2, warpSpeed2)\nuniform float uAmplitude;\nuniform vec4  uGrid;          // (targetWidth, targetWidthMajor, minorAlpha, majorAlpha)\nuniform float uFieldAlpha;\nuniform float uHasBackground;\nuniform vec4  uCursor;        // (cursorX, cursorY, swirlStrength, swirlRadius)\nuniform float uBulgeMode;     // +1 repel / \u22121 attract (signs the swirl)\nuniform float uInteractive;   // 1 = cursor swirl on\nuniform vec4  uWave;          // (waveDirX, waveDirY, waveK, waveOmega)\nuniform vec4  uWave2;         // (waveSigma, twistMax, shearMax, amp)\nuniform vec3  uLineColor;     // linear-sRGB ink\nuniform vec3  uBg;            // linear-sRGB themed bg\n// \u2500\u2500 The FACE (BD.W-PAPERGRID-FACE) \u2014 the height-lit filled cell interior \u2500\u2500\nuniform vec4  uFace;          // (faceAlpha, faceRelief, squashK, baseInset)\nuniform vec2  uLightDir;      // the cel key-light direction\nuniform vec3  uFaceLo;        // linear-sRGB rose-umber trough (FOLD B, 3-stop)\nuniform vec3  uFaceMid;       // linear-sRGB ember-amber mid\nuniform vec3  uFaceHi;        // linear-sRGB warm-wheat crest\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// The 3-stop warm-divergent FACE ramp (FOLD B \u2014 height-keyed, NOT a 2-point mid-park). All stops\n// warm hue \u2208 [20,90]; linear-space (the OETF runs in main, FOLD E).\nvec3 faceRamp(float rampT) {\n  float s = clamp(rampT, 0.0, 1.0);\n  if (s < 0.5) {\n    return mix(uFaceLo, uFaceMid, s * 2.0);\n  }\n  return mix(uFaceMid, uFaceHi, (s - 0.5) * 2.0);\n}\n\n// The shared divergence-free 2D-curl operator (flow.glsl.ts) \u2014 the prototype declares\n// potentialFBM; the host defines its BODY below the splice (GLSL forward-declaration).\n\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi \u2014 the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n\n\n// \u2500\u2500 The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) \u2500\u2500\nfloat hash21(float x, float y) {\n  float px = fract(x * 0.1031);\n  float py = fract(y * 0.1031);\n  float pz = fract(x * 0.1031);\n  float d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px += d;\n  py += d;\n  pz += d;\n  return fract((px + py) * pz);\n}\n\nfloat valueNoise(float x, float y) {\n  float ix = floor(x);\n  float iy = floor(y);\n  float fx = x - ix;\n  float fy = y - iy;\n  float ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  float uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  float a = hash21(ix, iy);\n  float b = hash21(ix + 1.0, iy);\n  float c = hash21(ix, iy + 1.0);\n  float d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n\n// The 3-octave scalar fbm potential \u2014 the curl chunk's forward-declared potentialFBM body.\nfloat potentialFBM(vec2 p) {\n  float v = 0.0;\n  float amp = 0.5;\n  float freq = 1.0;\n  float px = p.x;\n  float py = p.y;\n  for (int i = 0; i < 3; i++) {\n    v += amp * valueNoise(px * freq, py * freq);\n    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) \u2014 same rotation as the shared chunk.\n    float rx = 0.8 * px - 0.6 * py;\n    float ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\n// The shared traveling-wave CELL-WARP chunk (waveField.glsl.ts \u2014 cellTwist/cursorSwirl/\n// travelingEnvelope; spliced AFTER valueNoise + potentialFBM bodies + the curlFBM chunk).\n// paper-grid + concentric share this EXACTLY (the C3 cure: the boxes twist about their own\n// center, the lines stay locally straight \u2014 never the retired LINE-warp).\n\n#ifndef WAVE_FIELD_TAU\n#define WAVE_FIELD_TAU 6.283185307179586\n#endif\n\n// The traveling-wave envelope \u2014 a moving Gaussian crest band sweeping along waveDir.\nfloat travelingEnvelope(vec2 pivot, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma) {\n  float coord = dot(pivot, waveDir) * waveK - t * waveOmega;\n  float crest = fract(coord / WAVE_FIELD_TAU);\n  float z = (crest - 0.5) * 2.0;\n  return exp(-(z * z) / max(waveSigma, 1e-3));\n}\n\n// The curl-direction scalar \u2014 the smooth low-freq director the per-cell twist follows.\nfloat curlScalar(vec2 cc, float t) {\n  vec2 f = curlFBM(vec2(cc.x * 0.5 + t * 0.08, cc.y * 0.5 - t * 0.06));\n  return clamp(f.x, -1.0, 1.0);\n}\n\n// The directed-twist FLOOR (the visibility cure): keep the curl SIGN (adjacent cells lean\n// together) but floor the magnitude so a crest-band cell ALWAYS rotates decisively.\n#ifndef WAVE_FIELD_TWIST_FLOOR\n#define WAVE_FIELD_TWIST_FLOOR 0.62\n#endif\nfloat directedTwist(float s, float floorMag) {\n  float mag = max(floorMag, abs(s));\n  float sgn = tanh(s * 6.0);\n  return sgn * mag;\n}\n\n// \u2500\u2500 The FACE leaf (the structurally-absent RE-INVENT \u2014 height-lit filled cell interior) \u2500\u2500\n// Defined ABOVE cellTwist: cellTwist rides cellHeight via the driver so twist + face read ONE\n// envelope.\n\n// The sheet displacement at a cell center = the EXACT traveling-wave scalar the twist rides.\nfloat cellHeight(vec2 cc, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma, float amp) {\n  return travelingEnvelope(cc, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n}\n\n// The pre-twist driver (FOLD A): the cell pivot cc + the crest envelope env the twist AND the\n// face both ride. The face samples height/relief at THIS pre-twist cc (floor(twisted_g) at the\n// crest lights a NEIGHBOUR cell). cc in .xy, env in .z.\nvec3 cellDriver(vec2 g, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n                float waveSigma, float amp) {\n  float cs = max(cellSize, 1e-3);\n  vec2 cc = (floor(g / cs) + 0.5) * cs;\n  float env = cellHeight(cc, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec3(cc, env);\n}\n\n// The central-difference slope of cellHeight across a cell (eps = 0.5\u00B7cellSize) \u2014 derivative-\n// FREE (NO dFdx on the height) \u2192 Safari WebGL2-safe. Returns \u2207H.\nvec2 faceRelief(vec2 cc, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n                float waveSigma, float amp) {\n  float eps = max(cellSize, 1e-3) * 0.5;\n  float hxp = cellHeight(cc + vec2(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hxm = cellHeight(cc - vec2(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hyp = cellHeight(cc + vec2(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hym = cellHeight(cc - vec2(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec2((hxp - hxm) / (2.0 * eps), (hyp - hym) / (2.0 * eps));\n}\n\n// Soft inset-square coverage inside a (warped) cell \u2014 the filled FACE plateau. d is the distance\n// into the cell from the nearest gutter (the Golus triangle-wave); the inset retreats as it grows\n// (the squash). aa = the shader's fwidth(g) (JS passes a fixed uvDeriv).\nfloat facePlateau(vec2 g, float inset, vec2 uvDeriv) {\n  vec2 tri = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  float d = min(tri.x, tri.y);\n  float aa = max(uvDeriv.x, uvDeriv.y) * 1.5;\n  return smoothstep(inset, inset + 2.0 * aa, d);\n}\n\n// The cell-local twist about each cell's own center, gated by the traveling wave + directed\n// by the curl flow. amp is the spring-eased envelope amplitude the JS host drives. FOLD C: the\n// TWIST_FLOOR is crest-gated by env so OFF-crest cells relax to flat calm paper (the traveling\n// read, not static foil).\nvec2 cellTwist(vec2 g, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n               float waveSigma, float twistMax, float shearMax, float amp) {\n  vec3 drv = cellDriver(g, cellSize, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  vec2 cc = drv.xy;\n  float env = drv.z;\n  float floorMag = WAVE_FIELD_TWIST_FLOOR * env;   // FOLD C: crest-gated floor\n  float theta = twistMax * env * directedTwist(curlScalar(cc, t), floorMag);\n  float shear = shearMax * env * directedTwist(curlScalar(cc + vec2(17.3, 9.1), t), floorMag);\n  vec2 local = g - cc;\n  float ct = cos(theta);\n  float st = sin(theta);\n  vec2 rot = vec2(ct * local.x - st * local.y, st * local.x + ct * local.y);\n  rot.x += shear * rot.y;   // a small skew so the box MORPHS, not just rotates\n  return cc + rot;\n}\n\n// The CONTINUOUS traveling-wave FLOW warp \u2014 the SMOOTH twin of cellTwist (no per-cell seam;\n// for the level-set contours that shatter into a mesh under the cell discontinuity).\nvec2 waveFlow(vec2 g, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma,\n              float twistMax, float amp) {\n  float env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  vec2 f = curlFBM(vec2(g.x * 0.6 + t * 0.05, g.y * 0.6 - t * 0.04));\n  vec2 f2 = curlFBM(vec2(g.x * 1.1 - t * 0.03, g.y * 1.1 + t * 0.035));\n  float k = twistMax * env;\n  return g + (f + f2 * 0.5) * k;\n}\n\n// The local cursor swirl \u2014 the finger twists the cells around it (re-aimed cursorBulge).\nvec2 cursorSwirl(vec2 g, vec2 cursor, float strength, float radius) {\n  vec2 to = g - cursor;\n  float d2 = dot(to, to);\n  float r = max(radius, 1e-4);\n  float theta = strength * exp(-d2 / (2.0 * r * r));\n  float ct = cos(theta);\n  float st = sin(theta);\n  return cursor + vec2(ct * to.x - st * to.y, st * to.x + ct * to.y);\n}\n\n// The LOW-octave value-noise topography \u2014 the scalar field concentric extracts contours of.\nfloat heightField(vec2 p, float octavesF, float seed) {\n  float v = 0.0;\n  float amp = 0.5;\n  float freq = 1.0;\n  float px = p.x + seed;\n  float py = p.y - seed;\n  int n = int(clamp(octavesF, 1.0, 6.0));\n  for (int i = 0; i < 6; i++) {\n    if (i >= n) break;\n    v += amp * valueNoise(px * freq, py * freq);\n    float rx = 0.8 * px - 0.6 * py;\n    float ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\n// The \u03C9=\u221A(g\u00B7k) breathing swell \u2014 basins inflate/deflate with weight.\nfloat waveSwell(float t, float phase) {\n  return sin(t * 0.35 + phase) * 0.5 + sin(t * 0.21 + phase * 1.7) * 0.5;\n}\n\n\n// \u2500\u2500 \u00A71 The Ben Golus derivative-AA grid coverage (transcribes paperGrid.ts gridCoverage) \u2500\u2500\nfloat gridCoverage(vec2 g, float targetWidth, vec2 uvDeriv) {\n  vec2 gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  vec2 drawWidth = clamp(vec2(targetWidth), uvDeriv, vec2(0.5));\n  vec2 lineAA = uvDeriv * 1.5;\n  vec2 grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);\n  grid2 *= clamp(vec2(targetWidth) / max(drawWidth, vec2(1e-6)), vec2(0.0), vec2(1.0));\n  grid2 = mix(grid2, vec2(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2(0.0), vec2(1.0)));\n  return max(grid2.x, grid2.y);\n}\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 uv = vec2(vUv.x * aspect, vUv.y);\n\n  // \u00A75 the per-pixel kernel: CELL-TWIST + cursor-swirl the grid coordinate, then two-tier Golus.\n  // cellTwist rotates each cell about its OWN center (the boxes twist, the lines stay locally\n  // straight \u2014 the C3 cure) gated by a traveling Gaussian crest; cursorSwirl twists the cells\n  // about the finger. The Golus dv reads the FINAL twisted coord (the crisp-line fence survives).\n  vec2 g0 = uv * uGridScale;\n  // FOLD A \u2014 the PRE-twist driver: the face samples height/relief at THIS cc (floor(twisted_g)\n  // at the crest lights a NEIGHBOUR cell). cellTwist rides the SAME driver, so twist + face fuse.\n  vec3 drv = cellDriver(g0, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);\n  vec2 cc = drv.xy;\n  vec2 g = cellTwist(g0, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.y, uWave2.z, uWave2.w);\n  if (uInteractive > 0.5) {\n    g = cursorSwirl(g, uCursor.xy, uCursor.z * uBulgeMode, uCursor.w);\n  }\n\n  // The screen-space derivative of g (Golus): length(vec2(dFdx, dFdy)) per axis (the actual\n  // backing-store pixel \u2014 NOT a CSS sub-pixel, the blur-kill).\n  vec2 dv = vec2(\n    length(vec2(dFdx(g.x), dFdy(g.x))),\n    length(vec2(dFdx(g.y), dFdy(g.y)))\n  );\n\n  float minor = gridCoverage(g, uGrid.x, dv);\n  float me = max(uMajorEvery, 1.0);\n  float major = gridCoverage(g / me, uGrid.y, dv / me);\n  float line = max(minor * uGrid.z, major * uGrid.w);\n\n  // \u2500\u2500 The FACE (BD.W-PAPERGRID-FACE) \u2014 height-lit filled cell interior \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // Sample height/relief at the pre-twist driver cc (FOLD A); Lambert the \u2207H slope against the\n  // fixed cel key-light; squash the inset so the crest face inflates; multi-stop warm-divergent\n  // ramp keyed on mix(shade, h) (FOLD B); the ink through the production OETF (FOLD E).\n  float h      = cellHeight(cc, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);\n  vec2  grad   = faceRelief(cc, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);\n  vec3  n      = normalize(vec3(-grad * uFace.y, 1.0));\n  float shade  = clamp(0.5 + dot(n, normalize(vec3(uLightDir, 1.0))) * 0.5, 0.0, 1.0);\n  float inset  = uFace.w * (1.0 - uFace.z * h);            // squash & stretch\n  float face   = facePlateau(g, inset, dv);\n  float rampT  = clamp(shade * 0.5 + h * 0.5, 0.0, 1.0);   // FOLD B \u2014 height-keyed crest\n  vec3  faceInk = clamp(linearToSrgb(faceRamp(rampT)), vec3(0.0), vec3(1.0));\n  float faceA  = face * uFace.x * uFieldAlpha;             // FOLD D \u2014 one field-blend scalar\n\n  vec3 col = clamp(linearToSrgb(uLineColor), vec3(0.0), vec3(1.0));\n  if (uHasBackground > 0.5) {\n    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));\n    vec3 base = mix(bg, faceInk, faceA);\n    float a = line * uFieldAlpha;\n    fragColor = vec4(mix(base, col, a), 1.0);\n    return;\n  }\n  // transparent ground: the FACE composites UNDER the line, the SOURCE-OVER operator in\n  // PREMULTIPLIED space. faceAlpha:0 \u2192 faceA=0 \u2192 the face term vanishes \u2192 vec4(col\u00B7line, line) =\n  // byte-identical to the HEAD line-only render.\n  vec3 linePremult = (col * line) * uFieldAlpha;          // line layer (the FieldAlpha subtlety)\n  float lineA = line * uFieldAlpha;\n  vec3 facePremult = faceInk * faceA;                     // face layer premultiplied (faceA folds field)\n  vec3 outPremult = linePremult + facePremult * (1.0 - lineA);\n  float a = lineA + faceA * (1.0 - lineA);\n  fragColor = vec4(outPremult, a);  // premultiplied over transparent\n}";

package/dist/components/custom/paper-grid/shaders/paper-grid.wgsl.d.ts

@@ -1 +1 @@
-export declare const PAPER_GRID_WGSL = "\nconst TAU: f32 = 6.283185307179586;\n\n// \u2500\u2500 Paper-grid uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct PaperGridUniforms {\n  // u0: (uTime, uGridScale, uMinorPitch, uMajorEvery)\n  u0: vec4<f32>,\n  // warp: (uWarpScale, uWarpSpeed, uWarpScale2, uWarpSpeed2)\n  warp: vec4<f32>,\n  // warp2: (uAmplitude, uAspect, _pad, _pad)\n  warp2: vec4<f32>,\n  // grid: (uTargetWidth, uTargetWidthMajor, uMinorAlpha, uMajorAlpha)\n  grid: vec4<f32>,\n  // field: (uFieldAlpha, uHasBackground, _pad, _pad)\n  field: vec4<f32>,\n  // cursor: (uCursorX, uCursorY, uBulgeStrength, uBulgeRadius)\n  cursor: vec4<f32>,\n  // cursor2: (uBulgeMode, uInteractive, _pad, _pad)\n  cursor2: vec4<f32>,\n  // line: (uLineColor.rgb (linear), _pad)\n  line: vec4<f32>,\n  // bg: (uBg.rgb (linear), _pad)\n  bg: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: PaperGridUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// \u2500\u2500 The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) \u2500\u2500\n// A quintic-faded 2D value-noise fbm potential \u2014 the SAME basis the dot-flow-field carries\n// (so the suite speaks ONE noise basis). DECLARED ABOVE the curl splice (WGSL has no forward\n// declaration \u2014 a function may only call one declared earlier).\nfn hash21(x: f32, y: f32) -> f32 {\n  var px = fract(x * 0.1031);\n  var py = fract(y * 0.1031);\n  var pz = fract(x * 0.1031);\n  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px = px + d;\n  py = py + d;\n  pz = pz + d;\n  return fract((px + py) * pz);\n}\n\nfn valueNoise(x: f32, y: f32) -> f32 {\n  let ix = floor(x);\n  let iy = floor(y);\n  let fx = x - ix;\n  let fy = y - iy;\n  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  let a = hash21(ix, iy);\n  let b = hash21(ix + 1.0, iy);\n  let c = hash21(ix, iy + 1.0);\n  let d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n\n// The 3-octave scalar fbm potential \u2014 the host noise basis the curl operator wraps.\nfn potentialFBM(p: vec2f) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var px = p.x;\n  var py = p.y;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(px * freq, py * freq);\n    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) \u2014 same rotation as the shared chunk.\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The shared divergence-free 2D-curl operator (flow.wgsl.ts \u2014 the FIRST WGSL curl consumer).\n\nconst CURL_EPS: f32 = 0.012;\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nfn curlFBM(p: vec2f) -> vec2f {\n  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);\n  return vec2f(g.y, -g.x);\n}\n\n\n// \u2500\u2500 \u00A73 The \"liquid\": the global curl-flow domain warp (transcribes paperGrid.ts curlWarp) \u2500\u2500\n// TWO counter-flowing curl terms at different scales/speeds (Alex Harri counter-flow \u2014 never\n// visibly loops). A SHALLOW, LOW-frequency warp keeps the lines a clearly-readable grid.\nfn curlWarp(g: vec2f, t: f32) -> vec2f {\n  let warpScale = u.warp.x;\n  let warpSpeed = u.warp.y;\n  let warpScale2 = u.warp.z;\n  let warpSpeed2 = u.warp.w;\n  let amp = u.warp2.x;\n  let a = curlFBM(vec2f(g.x * warpScale + t * warpSpeed, g.y * warpScale + t * warpSpeed));\n  let b = curlFBM(vec2f(g.x * warpScale2 - t * warpSpeed2, g.y * warpScale2 - t * warpSpeed2));\n  return vec2f(a.x * amp + b.x * amp * 0.5, a.y * amp + b.y * amp * 0.5);\n}\n\n// \u2500\u2500 \u00A74 The pointer bulge: a LOCAL Gaussian warp (transcribes paperGrid.ts cursorBulge) \u2500\u2500\nfn cursorBulge(g: vec2f) -> vec2f {\n  let cursor = u.cursor.xy;\n  let strength = u.cursor.z * u.cursor2.x;  // bulgeStrength \u00D7 bulgeMode (+repel / \u2212attract)\n  let radius = max(u.cursor.w, 1e-4);\n  let toC = g - cursor;\n  let d = length(toC);\n  let bulge = strength * exp(-(d * d) / (2.0 * radius * radius));\n  if (d < 1e-5) { return vec2f(0.0); }\n  return (toC / d) * bulge;\n}\n\n// \u2500\u2500 \u00A71 The crisp line: Ben Golus derivative-AA grid coverage (transcribes gridCoverage) \u2500\u2500\n// targetWidth is the line half-width in GRID UNITS (lineWidthPx / minorPitchPx); uvDeriv is\n// the per-axis screen-space derivative of g (length(vec2(dpdx, dpdy)) per axis). Returns\n// line coverage [0..1] \u2014 exactly N device-pixels wide at ANY DPR/zoom (the blur-kill).\nfn gridCoverage(g: vec2f, targetWidth: f32, uvDeriv: vec2f) -> f32 {\n  // triangle wave per axis: 0 at a line, 1 at the cell center.\n  let gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  let drawWidth = clamp(vec2f(targetWidth), uvDeriv, vec2f(0.5));\n  let lineAA = uvDeriv * 1.5;\n  // smoothstep with edge0 > edge1 (Golus) \u2192 a falling edge.\n  var grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);\n  // preserve thin-line intensity where the line is sub-drawWidth.\n  grid2 = grid2 * clamp(vec2f(targetWidth) / max(drawWidth, vec2f(1e-6)), vec2f(0.0), vec2f(1.0));\n  // Moir\u00E9 suppression: fade toward the average where the cell packs tighter than a pixel.\n  grid2 = mix(grid2, vec2f(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2f(0.0), vec2f(1.0)));\n  return max(grid2.x, grid2.y);\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4f,\n  @location(0) uv: vec2f,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2f, 3>(\n    vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4f(c, 0.0, 1.0);\n  out.uv = vec2f(c.x, c.y);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4f {\n  let aspect = max(u.warp2.y, 1e-4);\n  // aspect-correct the domain x so the cells read square.\n  let uv = vec2f(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n  let gridScale = u.u0.y;\n\n  // \u00A75 the per-pixel kernel: warp + bulge the grid coordinate, then two-tier Golus.\n  var g = uv * gridScale;\n  g = g + curlWarp(g, t);\n  g = g + cursorBulge(g);\n\n  // The screen-space derivative of g (Golus): length(vec2(dpdx, dpdy)) per axis. fwidth-class\n  // derivative reads the ACTUAL backing-store pixel (NOT fwidthFine \u2014 Compatibility-Mode safe).\n  let dv = vec2f(\n    length(vec2f(dpdx(g.x), dpdy(g.x))),\n    length(vec2f(dpdx(g.y), dpdy(g.y))),\n  );\n\n  let minor = gridCoverage(g, u.grid.x, dv);\n  // The major tier evals at g / majorEvery with its own derivative scaling.\n  let me = max(u.u0.w, 1.0);\n  let major = gridCoverage(g / me, u.grid.y, dv / me);\n  let line = max(minor * u.grid.z, major * u.grid.w);\n\n  let col = clamp(linearToSrgb(u.line.rgb), vec3f(0.0), vec3f(1.0));\n  let hasBg = u.field.y;\n  if (hasBg > 0.5) {\n    // opaque ground: composite the ink over the themed bg.\n    let bg = clamp(linearToSrgb(u.bg.rgb), vec3f(0.0), vec3f(1.0));\n    let a = line * u.field.x;\n    let outRgb = mix(bg, col, a);\n    return vec4f(outRgb, 1.0);\n  }\n  // transparent ground: the LINE carries the alpha \u2014 the page reads through the cells.\n  let a = line * u.field.x;\n  return vec4f(col * a, a);  // premultiplied over transparent\n}\n";
+export declare const PAPER_GRID_WGSL = "\nconst TAU: f32 = 6.283185307179586;\n\n// \u2500\u2500 Paper-grid uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct PaperGridUniforms {\n  // u0: (uTime, uGridScale, uMinorPitch, uMajorEvery)\n  u0: vec4<f32>,\n  // face: (uFaceAlpha, uFaceRelief, uSquashK, uBaseInset) \u2014 the height-lit FACE (re-points the retired warp lane)\n  face: vec4<f32>,\n  // warp2: (uAmplitude, uAspect, uLightDirX, uLightDirY) \u2014 aspect + the cel key-light\n  warp2: vec4<f32>,\n  // grid: (uTargetWidth, uTargetWidthMajor, uMinorAlpha, uMajorAlpha)\n  grid: vec4<f32>,\n  // field: (uFieldAlpha, uHasBackground, _pad, _pad)\n  field: vec4<f32>,\n  // cursor: (uCursorX, uCursorY, uSwirlStrength, uSwirlRadius)\n  cursor: vec4<f32>,\n  // cursor2: (uBulgeMode, uInteractive, _pad, _pad)\n  cursor2: vec4<f32>,\n  // line: (uLineColor.rgb (linear), _pad)\n  line: vec4<f32>,\n  // bg: (uBg.rgb (linear), _pad)\n  bg: vec4<f32>,\n  // wave: (waveDirX, waveDirY, waveK, waveOmega) \u2014 the traveling-wave crest\n  wave: vec4<f32>,\n  // wave2: (waveSigma, twistMax, shearMax, amp) \u2014 the cell-twist envelope (amp: spring-eased)\n  wave2: vec4<f32>,\n  // faceLo: (rose-umber trough .rgb (linear), _pad) \u2014 the warm-divergent ramp (FOLD B, 3-stop)\n  faceLo: vec4<f32>,\n  // faceMid: (ember-amber mid .rgb (linear), _pad)\n  faceMid: vec4<f32>,\n  // faceHi: (warm-wheat crest .rgb (linear), _pad)\n  faceHi: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: PaperGridUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// \u2500\u2500 The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) \u2500\u2500\n// A quintic-faded 2D value-noise fbm potential \u2014 the SAME basis the dot-flow-field carries\n// (so the suite speaks ONE noise basis). DECLARED ABOVE the curl splice (WGSL has no forward\n// declaration \u2014 a function may only call one declared earlier).\nfn hash21(x: f32, y: f32) -> f32 {\n  var px = fract(x * 0.1031);\n  var py = fract(y * 0.1031);\n  var pz = fract(x * 0.1031);\n  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px = px + d;\n  py = py + d;\n  pz = pz + d;\n  return fract((px + py) * pz);\n}\n\nfn valueNoise(x: f32, y: f32) -> f32 {\n  let ix = floor(x);\n  let iy = floor(y);\n  let fx = x - ix;\n  let fy = y - iy;\n  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  let a = hash21(ix, iy);\n  let b = hash21(ix + 1.0, iy);\n  let c = hash21(ix, iy + 1.0);\n  let d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n\n// The 3-octave scalar fbm potential \u2014 the host noise basis the curl operator wraps.\nfn potentialFBM(p: vec2f) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var px = p.x;\n  var py = p.y;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(px * freq, py * freq);\n    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) \u2014 same rotation as the shared chunk.\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The shared divergence-free 2D-curl operator (flow.wgsl.ts \u2014 the FIRST WGSL curl consumer).\n\nconst CURL_EPS: f32 = 0.012;\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nfn curlFBM(p: vec2f) -> vec2f {\n  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);\n  return vec2f(g.y, -g.x);\n}\n\n\n// The shared traveling-wave CELL-WARP chunk (waveField.wgsl.ts \u2014 cellTwist/cursorSwirl/\n// travelingEnvelope; splices AFTER valueNoise + curlFBM are declared). paper-grid + concentric\n// share this EXACTLY \u2014 the cell-local twist replaces the retired LINE-warp (the C3 cure: the\n// boxes twist about their own center, the lines stay locally straight).\n\nconst WAVE_FIELD_TAU: f32 = 6.283185307179586;\n\n// The traveling-wave envelope \u2014 a moving Gaussian crest band sweeping along waveDir.\nfn travelingEnvelope(pivot: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32) -> f32 {\n  let coord = dot(pivot, waveDir) * waveK - t * waveOmega;\n  let crest = fract(coord / WAVE_FIELD_TAU);\n  let z = (crest - 0.5) * 2.0;\n  return exp(-(z * z) / max(waveSigma, 1e-3));\n}\n\n// The curl-direction scalar \u2014 the smooth low-freq director the per-cell twist follows.\nfn curlScalar(cc: vec2f, t: f32) -> f32 {\n  let f = curlFBM(vec2f(cc.x * 0.5 + t * 0.08, cc.y * 0.5 - t * 0.06));\n  return clamp(f.x, -1.0, 1.0);\n}\n\n// The directed-twist FLOOR (the visibility cure): keep the curl SIGN (adjacent cells lean\n// together) but floor the magnitude so a crest-band cell ALWAYS rotates decisively.\nconst WAVE_FIELD_TWIST_FLOOR: f32 = 0.62;\nfn directedTwist(s: f32, floorMag: f32) -> f32 {\n  let mag = max(floorMag, abs(s));\n  let sgn = tanh(s * 6.0);\n  return sgn * mag;\n}\n\n// \u2500\u2500 The FACE leaf (the structurally-absent RE-INVENT \u2014 height-lit filled cell interior) \u2500\u2500\n// DECLARED ABOVE cellTwist (no WGSL forward declaration): cellTwist rides cellHeight via the\n// driver so twist + face read ONE envelope.\n\n// The sheet displacement at a cell center = the EXACT traveling-wave scalar the twist rides.\nfn cellHeight(cc: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32, amp: f32) -> f32 {\n  return travelingEnvelope(cc, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n}\n\n// The pre-twist driver (FOLD A): the cell pivot cc + the crest envelope env the twist AND the\n// face both ride. The face samples height/relief at THIS pre-twist cc (the crest twist crosses\n// the cell boundary \u2192 floor(twisted_g) would light a NEIGHBOUR cell). cc in .xy, env in .z.\nfn cellDriver(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec3f {\n  let cs = max(cellSize, 1e-3);\n  let cc = (floor(g / cs) + 0.5) * cs;\n  let env = cellHeight(cc, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec3f(cc, env);\n}\n\n// The central-difference slope of cellHeight across a cell (eps = 0.5\u00B7cellSize) \u2014 derivative-\n// FREE (NO dFdx on the height) \u2192 Safari WebGL2-safe. Returns \u2207H.\nfn faceRelief(cc: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec2f {\n  let eps = max(cellSize, 1e-3) * 0.5;\n  let hxp = cellHeight(cc + vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hxm = cellHeight(cc - vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hyp = cellHeight(cc + vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hym = cellHeight(cc - vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec2f((hxp - hxm) / (2.0 * eps), (hyp - hym) / (2.0 * eps));\n}\n\n// Soft inset-square coverage inside a (warped) cell \u2014 the filled FACE plateau. d is the\n// distance into the cell from the nearest gutter (the Golus triangle-wave); the inset retreats\n// as it grows (the squash). aa = the shader's fwidth(g) (JS passes a fixed uvDeriv).\nfn facePlateau(g: vec2f, inset: f32, uvDeriv: vec2f) -> f32 {\n  let tri = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  let d = min(tri.x, tri.y);\n  let aa = max(uvDeriv.x, uvDeriv.y) * 1.5;\n  return smoothstep(inset, inset + 2.0 * aa, d);\n}\n\n// The cell-local twist about each cell's own center, gated by the traveling wave + directed\n// by the curl flow. amp is the spring-eased envelope amplitude the JS host drives. FOLD C: the\n// TWIST_FLOOR is crest-gated by env so OFF-crest cells relax to flat calm paper (the traveling\n// read, not static foil).\nfn cellTwist(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n             waveSigma: f32, twistMax: f32, shearMax: f32, amp: f32) -> vec2f {\n  let drv = cellDriver(g, cellSize, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let cc = drv.xy;\n  let env = drv.z;\n  let floorMag = WAVE_FIELD_TWIST_FLOOR * env;   // FOLD C: crest-gated floor\n  let theta = twistMax * env * directedTwist(curlScalar(cc, t), floorMag);\n  let shear = shearMax * env * directedTwist(curlScalar(cc + vec2f(17.3, 9.1), t), floorMag);\n  let local = g - cc;\n  let ct = cos(theta);\n  let st = sin(theta);\n  var rot = vec2f(ct * local.x - st * local.y, st * local.x + ct * local.y);\n  rot.x = rot.x + shear * rot.y;   // a small skew so the box MORPHS, not just rotates\n  return cc + rot;\n}\n\n// The CONTINUOUS traveling-wave FLOW warp \u2014 the SMOOTH twin of cellTwist (no per-cell seam;\n// for the level-set contours that shatter into a mesh under the cell discontinuity).\nfn waveFlow(g: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32,\n            twistMax: f32, amp: f32) -> vec2f {\n  let env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  let f = curlFBM(vec2f(g.x * 0.6 + t * 0.05, g.y * 0.6 - t * 0.04));\n  let f2 = curlFBM(vec2f(g.x * 1.1 - t * 0.03, g.y * 1.1 + t * 0.035));\n  let k = twistMax * env;\n  return g + (f + f2 * 0.5) * k;\n}\n\n// The local cursor swirl \u2014 the finger twists the cells around it (re-aimed cursorBulge).\nfn cursorSwirl(g: vec2f, cursor: vec2f, strength: f32, radius: f32) -> vec2f {\n  let to = g - cursor;\n  let d2 = dot(to, to);\n  let r = max(radius, 1e-4);\n  let theta = strength * exp(-d2 / (2.0 * r * r));\n  let ct = cos(theta);\n  let st = sin(theta);\n  return cursor + vec2f(ct * to.x - st * to.y, st * to.x + ct * to.y);\n}\n\n// The LOW-octave value-noise topography \u2014 the scalar field concentric extracts contours of.\nfn heightField(p: vec2f, octavesF: f32, seed: f32) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var px = p.x + seed;\n  var py = p.y - seed;\n  let n = i32(clamp(octavesF, 1.0, 6.0));\n  for (var i = 0; i < 6; i = i + 1) {\n    if (i >= n) { break; }\n    v = v + amp * valueNoise(px * freq, py * freq);\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The \u03C9=\u221A(g\u00B7k) breathing swell \u2014 basins inflate/deflate with weight.\nfn waveSwell(t: f32, phase: f32) -> f32 {\n  return sin(t * 0.35 + phase) * 0.5 + sin(t * 0.21 + phase * 1.7) * 0.5;\n}\n\n\n// \u2500\u2500 \u00A71 The crisp line: Ben Golus derivative-AA grid coverage (transcribes gridCoverage) \u2500\u2500\n// targetWidth is the line half-width in GRID UNITS (lineWidthPx / minorPitchPx); uvDeriv is\n// the per-axis screen-space derivative of g (length(vec2(dpdx, dpdy)) per axis). Returns\n// line coverage [0..1] \u2014 exactly N device-pixels wide at ANY DPR/zoom (the blur-kill).\nfn gridCoverage(g: vec2f, targetWidth: f32, uvDeriv: vec2f) -> f32 {\n  // triangle wave per axis: 0 at a line, 1 at the cell center.\n  let gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  let drawWidth = clamp(vec2f(targetWidth), uvDeriv, vec2f(0.5));\n  let lineAA = uvDeriv * 1.5;\n  // smoothstep with edge0 > edge1 (Golus) \u2192 a falling edge.\n  var grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);\n  // preserve thin-line intensity where the line is sub-drawWidth.\n  grid2 = grid2 * clamp(vec2f(targetWidth) / max(drawWidth, vec2f(1e-6)), vec2f(0.0), vec2f(1.0));\n  // Moir\u00E9 suppression: fade toward the average where the cell packs tighter than a pixel.\n  grid2 = mix(grid2, vec2f(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2f(0.0), vec2f(1.0)));\n  return max(grid2.x, grid2.y);\n}\n\n// \u2500\u2500 The 3-stop warm-divergent FACE ramp (FOLD B \u2014 height-keyed, NOT a 2-point mid-park) \u2500\u2500\n// trough (faceLo) \u2192 mid (faceMid) \u2192 crest (faceHi), keyed on rampT = mix(shade, h). All stops\n// are warm hue \u2208 [20,90] (the teal-navy purge clear by construction). Linear-space stops; the\n// fs_main routes the result through the production OETF (FOLD E).\nfn faceRamp(rampT: f32) -> vec3f {\n  let s = clamp(rampT, 0.0, 1.0);\n  if (s < 0.5) {\n    return mix(u.faceLo.rgb, u.faceMid.rgb, s * 2.0);\n  }\n  return mix(u.faceMid.rgb, u.faceHi.rgb, (s - 0.5) * 2.0);\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4f,\n  @location(0) uv: vec2f,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2f, 3>(\n    vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4f(c, 0.0, 1.0);\n  out.uv = vec2f(c.x, c.y);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4f {\n  let aspect = max(u.warp2.y, 1e-4);\n  // aspect-correct the domain x so the cells read square.\n  let uv = vec2f(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n  let gridScale = u.u0.y;\n\n  // \u00A75 the per-pixel kernel: CELL-TWIST + cursor-swirl the grid coordinate, then two-tier Golus.\n  // cellTwist rotates each cell about its OWN center (the boxes twist, the lines stay locally\n  // straight \u2014 the C3 cure) gated by a traveling Gaussian crest; cursorSwirl twists the cells\n  // about the finger. The Golus dv reads the FINAL twisted coord (the crisp-line fence survives).\n  let g0 = uv * gridScale;\n  // FOLD A \u2014 the PRE-twist driver: the face samples height/relief at THIS cc (floor(twisted_g)\n  // at the crest lights a NEIGHBOUR cell). cellTwist rides the SAME driver, so twist + face fuse.\n  let drv = cellDriver(g0, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);\n  let cc = drv.xy;\n  var g = cellTwist(g0, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.y, u.wave2.z, u.wave2.w);\n  if (u.cursor2.y > 0.5) {\n    // bulgeMode (cursor2.x: +repel / \u2212attract) signs the swirl direction.\n    g = cursorSwirl(g, u.cursor.xy, u.cursor.z * u.cursor2.x, u.cursor.w);\n  }\n\n  // The screen-space derivative of g (Golus): length(vec2(dpdx, dpdy)) per axis. fwidth-class\n  // derivative reads the ACTUAL backing-store pixel (NOT fwidthFine \u2014 Compatibility-Mode safe).\n  let dv = vec2f(\n    length(vec2f(dpdx(g.x), dpdy(g.x))),\n    length(vec2f(dpdx(g.y), dpdy(g.y))),\n  );\n\n  let minor = gridCoverage(g, u.grid.x, dv);\n  // The major tier evals at g / majorEvery with its own derivative scaling.\n  let me = max(u.u0.w, 1.0);\n  let major = gridCoverage(g / me, u.grid.y, dv / me);\n  let line = max(minor * u.grid.z, major * u.grid.w);\n\n  // \u2500\u2500 The FACE (BD.W-PAPERGRID-FACE) \u2014 height-lit filled cell interior \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // Sample height/relief at the pre-twist driver cc (FOLD A); Lambert the \u2207H slope against the\n  // fixed cel key-light; squash the inset so the crest face inflates; multi-stop warm-divergent\n  // ramp keyed on mix(shade, h) (FOLD B); the ink through the production OETF (FOLD E).\n  let h     = cellHeight(cc, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);\n  let grad  = faceRelief(cc, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);\n  let n     = normalize(vec3f(-grad * u.face.y, 1.0));\n  let shade = clamp(0.5 + dot(n, normalize(vec3f(u.warp2.zw, 1.0))) * 0.5, 0.0, 1.0);\n  let inset = u.face.w * (1.0 - u.face.z * h);            // squash & stretch\n  let face  = facePlateau(g, inset, dv);\n  let rampT = clamp(shade * 0.5 + h * 0.5, 0.0, 1.0);     // FOLD B \u2014 height-keyed crest\n  let faceInk = clamp(linearToSrgb(faceRamp(rampT)), vec3f(0.0), vec3f(1.0));\n  let faceA = face * u.face.x * u.field.x;                // FOLD D \u2014 one field-blend scalar\n\n  let col = clamp(linearToSrgb(u.line.rgb), vec3f(0.0), vec3f(1.0));\n  let hasBg = u.field.y;\n  if (hasBg > 0.5) {\n    // opaque ground: the face fills the cell, the ink over the themed bg, the line on top.\n    let bg = clamp(linearToSrgb(u.bg.rgb), vec3f(0.0), vec3f(1.0));\n    let base = mix(bg, faceInk, faceA);\n    let a = line * u.field.x;\n    let outRgb = mix(base, col, a);\n    return vec4f(outRgb, 1.0);\n  }\n  // transparent ground: the FACE composites UNDER the line, the SOURCE-OVER operator in\n  // PREMULTIPLIED space (the page reads through the gutters). faceAlpha:0 \u2192 faceA=0 \u2192 the face\n  // term vanishes \u2192 vec4f(col\u00B7line, line) = byte-identical to the HEAD line-only render.\n  let linePremult = (col * line) * u.field.x;            // line layer (the FieldAlpha global subtlety)\n  let lineA = line * u.field.x;\n  let facePremult = faceInk * faceA;                     // face layer premultiplied (faceA folds field.x)\n  let outPremult = linePremult + facePremult * (1.0 - lineA);\n  let a = lineA + faceA * (1.0 - lineA);\n  return vec4f(outPremult, a);                           // premultiplied over transparent\n}\n";

package/dist/components/custom/selectable-chip/chipVariants.d.ts

@@ -0,0 +1,39 @@
+import { type VariantProps } from "class-variance-authority";
+/**
+ * chipVariants — the ONE congruent chip recipe (BD.W-CHIP-CONGRUENT-GLASS).
+ *
+ * The chip family (ToggleChip · SelectableChip + the toggle-group children)
+ * collapses to ONE `chipVariants({ size })`: a stadium-pill warm-glass LENS that
+ * PUNCHES when you pick it. Survival of the fittest — `selectableChipVariants`
+ * (`sm`/`md`/`lg`) + the `ToggleChip` `chip`/`cell` axis collapse here (clean
+ * break, no alias — the no-legacy law). The three SFCs stay DISTINCT (bool toggle
+ * vs tonal picker vs glyph tile) but render the SAME register.
+ *
+ * The recipe is STRUCTURE + the shared-register hooks: it COMPOSES the read-only
+ * shared registers, never re-forks a parallel glass/cartoon/motion system —
+ *   · `.glass-chip`         — the chip-family material/motion layer (the warm idle
+ *                             floor + the `--glass-fill-tint` plate tint + the ONE
+ *                             scale write + the `::after` colour-flood punch).
+ *   · `.glass-capsule`      — the warm-transmissive lozenge BODY (fill + rim +
+ *                             shadow + blur, on `--radius-pill` → the stadium
+ *                             end-cap at every rung). Radius is INVARIANT — the
+ *                             capsule re-rounds itself at every height; no
+ *                             `rounded-*` rung (retires the 4/6/10px grab-bag).
+ *   · `.glass-capsule-hover`— the SHARED specular-lift + press-snap on hover.
+ *   · `.accent-tone`        — the contrast-floored tonal channels (idle fill /
+ *                             active band / active edge / contrast-safe ink).
+ *
+ * The geometry: radius invariant (the capsule's `--radius-pill`); only padding/
+ * text vary, on a √φ ladder (φ≈1.618). The `cell` is the ONE documented exception
+ * (`.glass-chip--cell` → `--radius-card`): a 72px icon+label tile is a CARD, not a
+ * pill — a DELIBERATE 2-silhouette family, composing the SAME material + motion.
+ *
+ * NO scale CVA — the ONE `scale` write lives on `.glass-chip` (hover/press/punch
+ * folded into a single source of truth; a CVA `hover:scale-*` would collide).
+ * The CVA carries no `color-mix(…--primary…)` literal — the tonal COLOUR is the
+ * `.accent-tone` register's.
+ */
+export declare const chipVariants: (props?: ({
+    size?: "cell" | "sm" | "lg" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ChipVariants = VariantProps<typeof chipVariants>;

package/dist/components/custom/selectable-chip/selectableChipVariants.d.ts

@@ -1,23 +1,15 @@
-import { type VariantProps } from "class-variance-authority";
 /**
- * SelectableChip — the public face of the BC.W-ACCENT-TONE tonal register: a
- * reka-`Toggle` selectable chip that READS `.accent-tone` (idle `--accent-fill`
- * floored ≥3:1, active `--accent-band` + `--accent-edge` rim + the contrast-safe
- * `--accent-ink` label). A tag/filter/tool picker is ONE element, golden-by-
- * construction — the tonal channels are owned by the register, not hand-rolled
- * per-state `color-mix(…)`.
+ * selectableChipVariants — the public name for the SelectableChip face of the ONE
+ * shared `chipVariants` recipe (BD.W-CHIP-CONGRUENT-GLASS).
  *
- * The recipe is STRUCTURE + the register hook: it applies `.accent-tone` (the
- * channel mint), the idle/active PAINT (off the register channels), and the size
- * axis (the padding/radius/text-size). The tonal COLOUR is the register; this CVA
- * carries no `color-mix(…--primary…)` literal (the N-paste the register collapses).
- *
- * The motion register matches the §6 interactive family (the ToggleChip precedent):
- * the SURFACE legs (bg/border/color) ride `--duration-fast`/`--ease-standard`; the
- * `scale` TRANSFORM leg rides `--spring-smooth`, so the chip lifts on hover + settles
- * on press like every sibling control.
+ * The chip family collapsed to ONE congruent stadium-pill warm-glass register
+ * (`./chipVariants`). SelectableChip reads it through this stable name; the
+ * `size` axis (`sm`/`md`/`lg`/`cell`) IS the shared axis. No second recipe, no
+ * grab-bag — the tonal channels are the `.accent-tone` register's, the lens is
+ * `.glass-chip` over `.glass-capsule`. Clean break: the prior per-state
+ * `color-mix(…--primary…)` literals + the `rounded-sm`/`-md`/`-lg` grab-bag are
+ * GONE (no alias — the no-legacy law); this file is the public re-point, not a
+ * parallel CVA.
  */
-export declare const selectableChipVariants: (props?: ({
-    size?: "sm" | "lg" | "md" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type SelectableChipVariants = VariantProps<typeof selectableChipVariants>;
+export { chipVariants as selectableChipVariants } from "./chipVariants";
+export type { ChipVariants as SelectableChipVariants } from "./chipVariants";

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

@@ -4,15 +4,23 @@
  * full-width jump reaches the cap and a tiny hop stays near 1. The token is the
  * authority; this is the no-token floor.
  *
- * BC.W-LIQUID-TAB — lifted 1.08 → 1.15 so a FAST liquid-tab pull visibly swells the
- * pill (the gel-squish READS as liquid, glass-dock-codebase.md §3.4) — still capped
- * LOW (≤1.2, the anti-taffy-pull bar). The cap is shared by the click travel-squish
- * AND the drag pull-morph (the SOLE cap source — the constant + the token in
- * lockstep, never a fork); the volume-preserving reciprocal pairing
- * (`scale: var(--stretch) calc(1/var(--stretch))`) is unchanged — only the magnitude
- * lifts.
+ * BD.W-TABS-LIQUID — re-tuned 1.18 → 1.11. The `--tab-blob` area-inflation channel now
+ * carries the 5-beat "grow"/overshoot, so the per-axis travel-squish cap drops: the FENCE
+ * is the COMPOSED visible bbox area (`blob × stretch`) ≤ ~1.14, NOT the bare per-axis
+ * scalar. The cap is shared by the click travel-squish AND the drag pull-morph (the SOLE
+ * cap source — the constant + the token in lockstep, never a fork); the volume-preserving
+ * reciprocal pairing (`scale: var(--stretch) calc(1/var(--stretch))`) is unchanged.
  */
-export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.15;
+export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.11;
+/**
+ * BD.W-TABS-LIQUID — fallback for `--tab-indicator-blob-max` when the cascade leaves it
+ * unset: the 5-beat blob's area-inflation overshoot peak. The 2nd `useLiquidFlex` channel
+ * drives `--tab-blob` toward this on the grow-overshoot beat, then de-inflates to 1 at
+ * arrival (shrink-to-fit). Kept LOW (~1.045) so the COMPOSED bbox area (`blob × stretch` ≈
+ * blob², the squish being volume-preserving) clears the ≤ ~1.14 anti-taffy fence. The
+ * token is the authority; this is the no-token floor (the SOLE blob-cap source).
+ */
+export declare const DEFAULT_INDICATOR_BLOB_MAX = 1.045;
 /**
  * The travel-progress fraction at which the squish RELEASES — the Material
  * "grow then shrink" close, keyed to ARRIVAL (BA.W-TABS). The squish opens with

package/dist/components/custom/timeline/ScrubberTimeline.vue.d.ts

@@ -7,6 +7,22 @@
  *
  * AA.A4 §S-16 — the `aria-valuenow` binding coerces `Number(modelValue ?? 0)`
  * so a numeric attribute always renders (axe `aria-required-attr` regression).
+ *
+ * BD.W-TIMELINE-RAIL-UNIFY (LEG 2) — the head is RE-INVENTED as a warm-glass
+ * liquid lozenge. The four cartoon beats COMPOSE shipped engines only (no new
+ * motion engine): travel rides a `useSpring`/SpringProgress position written
+ * to `transform: translateX()` (NEVER `style.left` — Safari composites
+ * transform, not left); `useLiquidFlex` `"tanh"` velocity-squish multiplies
+ * into the SAME matrix (vol-preserving, cap ≤1.12); `useSpringPress` grab
+ * anticipation; the velocity term is the head spring's own derivative (the
+ * self-extinguishing per-frame velocity SpringProgress already computes — the
+ * GOLDEN §0 "drive off the spring derivative" path, no free-running rAF); the
+ * fill LAGS the head on a slower spring clock; release settles ζ<1 on the
+ * cartoon-punch clock; a one-shot accent-flood ripples on landing. Always
+ * visible (the
+ * `opacity:0`-until-hover is RETIRED — the affordance must be present during
+ * keyboard/touch scrub). The bead seats φ-INSIDE the channel; the 44px touch
+ * target is an invisible `::before` halo, decoupled from the visible bead.
  */
 type __VLS_Props = {
     /** 0..1 scrubber position. */

package/dist/components/custom/timeline/geometry.d.ts

@@ -16,14 +16,6 @@
  */
 import { type ComputedRef, type Ref } from "vue";
 import type { TimelineSegment } from "./types";
-/**
- * Resolve a segment's gradient declaration to a CSS background expression.
- * - `string` (raw CSS): consumed verbatim — caller controls direction.
- * - `{from, to}` pair: expanded to `linear-gradient(90deg, from, to)`.
- * - undefined: falls through to the `--timeline-segment-default-gradient`
- *   token (consumer can override on the primitive or via a section-tone).
- */
-export declare function gradientFor(seg: TimelineSegment): string;
 /**
  * Fill percentage per state. Explicit `progress` wins; otherwise the
  * canonical mapping (pending=0, active=0.5, completed=1). Clamped to