@mkbabb/glass-ui 4.2.0 → 6.0.0

package/dist/components/custom/fourier-field/composables/fourierFieldWGPUSetup.d.ts

@@ -1,31 +0,0 @@
-import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
-import type { OklchStop } from "../../../../composables/color";
-import { type FourierFieldConfig } from "../constants";
-import type { BasisComponent } from "../math";
-export interface FourierWGPUSetupDeps {
-    canvas: HTMLCanvasElement;
-    config: FourierFieldConfig;
-    /** The CPU-minted spectrum (re-read each frame so a source-swap reaches the buffer). */
-    getSpectrum: () => readonly BasisComponent[];
-    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live edit reaches the buffer. */
-    getPalette: () => OklchStop[];
-    /** The single loop parameter `head_t ∈ [0,1)` (the ONE keyframes.js clock). */
-    getHeadT: () => number;
-    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
-    shouldContinue: () => boolean;
-    /** The per-frame pointer hook — useFourierField advances the shared pointer field here. */
-    onFrame?: (timeSec: number) => void;
-    /**
-     * BD.W-VIZ-BROKEN-FIX D6b — the 2-D cursor FOLLOW: a small MODEL-space offset added to
-     * the view-fit center so the whole reconstruction LEANS toward the cursor (the spatial
-     * "follow" beside D6a's velocity scrub). Reuses the EXISTING uFit center uniform (NO new
-     * uniform, NO shader/bridge edit — parity-safe by construction, both arms read the same
-     * fit). `{x:0,y:0}` (the ambient/PRM register) is byte-identical to today.
-     */
-    getPointerLean?: () => {
-        x: number;
-        y: number;
-    };
-}
-/** Build the fourier-field `setupWGPU(device, context, format)` callback. */
-export declare function createFourierWGPUSetup(deps: FourierWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/fourier-field/composables/uniformBridgeWGPU.d.ts

@@ -1,56 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import { type BasisComponent } from "../math";
-/** One phasor lane in the storage buffer: (re, im, index, _pad). */
-export declare const FOURIER_PHASOR_BYTES = 16;
-export declare const FOURIER_COMPUTE_UNIFORM_BYTES = 32;
-export interface FourierUniformScratch {
-    buffer: ArrayBuffer;
-    f32: Float32Array;
-    i32: Int32Array;
-}
-export declare function createFourierComputeScratch(): FourierUniformScratch;
-/** Pack the compute uniforms in place. */
-export declare function packFourierComputeUniforms(scratch: FourierUniformScratch, headT: number, trailArc: number, harmonicN: number, epicycleArmN: number, sampleCount: number, phasorCount: number): FourierUniformScratch;
-export declare const FOURIER_RENDER_UNIFORM_BYTES: number;
-export declare function createFourierRenderScratch(): FourierUniformScratch;
-/** The model→clip fit transform (center + uniform scale) — computed once per spectrum. */
-export interface FourierFit {
-    centerX: number;
-    centerY: number;
-    /** The uniform scale s such that (model − center)·s maps the curve into clip [-1,1] with margin. */
-    scale: number;
-}
-/**
- * Stable view-fit: sample the FULL reconstruction once over the period, bound its bbox,
- * and derive the center + a margin-padded uniform scale. The render's fullscreen pass
- * inverts this transform per fragment so the curve never clips and the scale is fixed.
- */
-export declare function computeFourierFit(spectrum: readonly BasisComponent[]): FourierFit;
-/**
- * Map a MODEL-space head point to the stage's `[0,1]²` UV via the SAME fit + aspect the
- * render's clip→model inverse uses (BD.W-FOURIER-LOOM §2a — the bloom-desync fence). The
- * render maps clip = (model − center)·scale with the x clip un-aspect-corrected (clip.x is
- * scaled by aspect in the inverse), so the forward is:
- *   clipX = (mx − cx)·scale / aspect,  clipY = (my − cy)·scale,  clip ∈ [-1,1].
- * Then UV = (clipX·0.5 + 0.5, 1 − (clipY·0.5 + 0.5))  (CSS y grows DOWN; the lean is folded
- * into `center` upstream so the bloom tracks the LEANED head). The result is NOT clamped —
- * a head that leaves the stage carries the bloom off-edge honestly; the consumer clamps if
- * it must paint a sprite. Pure arithmetic off the cached `fit` — no second CPU fit to drift.
- */
-export declare function headToUnit(headX: number, headY: number, fit: FourierFit, aspect: number): {
-    x: number;
-    y: number;
-};
-/**
- * Convert a CSS-px stroke width to MODEL units (the shader's space). The fit `scale` maps
- * model → clip; clip spans [-1,1] over the min CSS dimension → cssPx-per-clip = canvasCssMin/2.
- * model-per-cssPx = (1/scale)·(2/canvasCssMin).
- */
-export declare function trailWidthToModel(trailWidthPx: number, scale: number, canvasCssMin: number): number;
-/** Pack the render uniforms in place. */
-export declare function packFourierRenderUniforms(scratch: FourierUniformScratch, fit: FourierFit, aspect: number, trailWidthModel: number, peakAlpha: number, headGlowAlpha: number, trailFadeExp: number, trailFloor: number, intensity: number, showEpicycles: boolean, rainbowChain: boolean, squashGain: number, celGain: number, sampleCount: number, armCount: number, palette: OklchStop[]): FourierUniformScratch;
-/**
- * Pack the phasor storage table (re, im, index, _pad) from the CPU-minted spectrum. The
- * WGSL SUMS this per frame — it is the ONLY spectrum upload (no WGSL-side mint).
- */
-export declare function packPhasorTable(spectrum: readonly BasisComponent[]): Float32Array;

package/dist/components/custom/fourier-field/composables/useFourierField.d.ts

@@ -1,63 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import type { OklchStop } from "../../../../composables/color";
-import type { FourierFieldConfig } from "../constants";
-import { type BasisComponent } from "../math";
-export interface UseFourierFieldOptions {
-    config: FourierFieldConfig;
-    /** The active phasor spectrum (CPU-minted; re-read each frame so a source-swap reaches the buffer). */
-    getSpectrum: () => readonly BasisComponent[];
-    /** Resolve the curve-color palette as OKLCh (the demo themes it; default warm-identity). */
-    getPalette: () => OklchStop[];
-    /** When true, hold the deterministic best-frame and never advance (the capture / freeze lever). */
-    freeze?: () => boolean;
-    /** The static deterministic best-frame parameter under `freeze`/PRM. Default 0.34. */
-    frozenT?: number;
-    /** Base forward period for one full traversal at 1× speed, in seconds. Default 16. */
-    periodS?: number;
-    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
-    mode?: "live" | "capture";
-    /**
-     * BD.W-FOURIER-LOOM §2a — the lit-field seam hook. Fired ONCE per frame from INSIDE the
-     * ONE clock's `onFrame` (NO second rAF), AFTER `headT` advances, with the head's `[0,1]²`
-     * UV (or `null` before the canvas is sized). The SFC writes `--ff-head-xy` on its host so
-     * the warm field's phosphor bloom tracks the comet. PRM → fired with the STABLE frozen-T
-     * UV (the bloom seats, no sweep).
-     */
-    onHeadFrame?: (unit: {
-        x: number;
-        y: number;
-    } | null) => void;
-}
-/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
-export interface FourierFieldHandle {
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL fallback). */
-    readonly backend: GpuBackend;
-    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
-    pause: () => void;
-    /** Re-arm the loop. */
-    resume: () => void;
-    /** Re-arm a parked loop on demand. */
-    wake: () => void;
-    /** Draw one frame out-of-loop (capture / thumbnail). */
-    renderAt: (timeSec: number) => void;
-    /** The live `prefers-reduced-motion: reduce` state. */
-    readonly reducedMotion: boolean;
-    /** The current loop parameter `head_t ∈ [0,1)` (the scrubber reads/writes it). */
-    readonly headT: number;
-    /** Scrub the clock directly (the transport scrubber / a pointer drag). */
-    setHeadT: (t: number) => void;
-    /**
-     * BD.W-FOURIER-LOOM §2a — the comet head mapped to the stage's `[0,1]²` UV, off the SAME
-     * cached fit the GPU comet paints from. The SFC writes this to `--ff-head-xy` per frame so
-     * the warm field's phosphor bloom tracks the head (the lit-field seam). `null` before the
-     * canvas is sized. PRM → a STABLE frozen-T value (the bloom seats, no sweep).
-     */
-    headUnit: () => {
-        x: number;
-        y: number;
-    } | null;
-    /** Tear down the renderer + release GPU/GL resources. */
-    dispose: () => void;
-}
-export declare function useFourierField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseFourierFieldOptions): FourierFieldHandle;

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

@@ -1,117 +0,0 @@
-import type { OklchStop } from "../../../composables/color";
-/**
- * Curve-sampling resolution for the stable view-fit bbox pass — the renderer samples the
- * epicycle curve this many times once at mount to size it to the canvas with a fixed
- * margin (so the curve never clips and the scale is constant across the run). 720 = one
- * sample per half-degree of the unit period.
- */
-export declare const FOURIER_FIT_SAMPLES = 720;
-/**
- * The phasor-table uniform ceiling — the WGSL `MAX_PHASORS` #define. The configurator's
- * harmonic count maxes here; a >64-term custom trace books a storage-buffer widen (cheap —
- * the flow-field already uses a storage buffer). The curated ℱ/heart/star set + the
- * generated elliptic spectrum all sit under it.
- */
-export declare const MAX_PHASORS = 64;
-/**
- * The comet-curve sample ceiling — the storage-buffer array bound. The compute pass
- * writes the partial-sum curve point at `M` samples back along the period from the head;
- * the render pass reads them as the comet polyline. 384 gives a smooth bold stroke.
- */
-export declare const MAX_CURVE_SAMPLES = 384;
-/** The palette-stop ceiling — the WGSL `MAX_FOURIER_STOPS` #define. */
-export declare const MAX_FOURIER_STOPS = 4;
-/**
- * The cursor-velocity → head_t clock-coupling gain (BD.W-VIZ-BROKEN-FIX D6 — the weighted
- * scrub). The cursor MOTION (not its absolute X) nudges the loop clock: a flick fast-
- * forwards, a still cursor lets the field drift at its config speed. Velocity-continuous —
- * the head never teleports (the prior `headT = pointerX` absolute-X scrub read as "not
- * following" a 2-D cursor).
- */
-export declare const SCRUB_GAIN = 0.15;
-/**
- * The 2-D cursor-FOLLOW lean depth (BD.W-VIZ-BROKEN-FIX D6b — the spatial follow beside the
- * velocity scrub). A bounded fraction of the model half-span the view-fit center leans
- * toward the cursor, so the whole reconstruction pans TOWARD the cursor on screen (a gentle
- * pull, never a yank — the [[feedback-liquid-weight-universal]] weighted register). At 0
- * the field is byte-identical (the ambient/non-interactive register).
- */
-export declare const FOLLOW_LEAN = 0.12;
-/**
- * The degenerate-tangent guard (BD.W-FOURIER-LOOM §2b). At a cusp the head's instantaneous
- * speed `s = length(head − headBack)` collapses to ~0 and the unit tangent `T = d/s` blows
- * up; below `FOURIER_TANGENT_EPS` the shaders + the GL CPU bead path all fall back to the
- * LAST stable tangent, so `s→0` resolves IDENTICALLY across both engines (the cross-engine
- * cusp-parity fence — one shared constant, no per-engine drift).
- */
-export declare const FOURIER_TANGENT_EPS = 0.0001;
-/**
- * The head squash-and-stretch gain (BD.W-FOURIER-LOOM §2b). The round head bead becomes a
- * volume-preserving anisotropic ellipse: the tangent extent scales `1 + k·ŝ`, the normal
- * extent `1/(1 + k·ŝ)`, where `ŝ` is the normalized head speed. The library identity carries
- * a SMALL non-zero gain (cartoon-weight at rest — the head is never a dead disc); a consumer
- * vivid preset turns it to 11. `0` = the byte-frozen round disc.
- */
-export declare const FOURIER_SQUASH_GAIN = 0.55;
-/**
- * The cartoon cel-shadow gain (BD.W-FOURIER-LOOM §3b). Each chain ring/arm/dot + the comet
- * rope paints a second darker copy OFFSET opposite its travel — the 1940s technicolor ink.
- * The library identity carries a SMALL non-zero gain (a quiet weight under the chain); a
- * consumer vivid preset floors it UP. `0` = no cel pass (byte-frozen). The offset rides the
- * head tangent, mirrored on both engines off the SAME `curveSamples` tangent.
- */
-export declare const FOURIER_CEL_GAIN = 0.35;
-/**
- * The full author schema — the studio's `useConfiguratorState` model. Every field is a
- * tunable the demo configurator drives; the composable resolves it into the uniform table.
- */
-export interface FourierFieldConfig {
-    /** The active phasor spectrum source key — `"elliptic"` (generated) or a curated shape key. */
-    source: string;
-    /** TRUNCATE the partial sum — the harmonic count N (1..min(spectrum.length, MAX_PHASORS)). */
-    harmonics: number;
-    /** Draw the rotating epicycle chain (orthogonal to N). */
-    showEpicycles: boolean;
-    /** How many chain arms to draw (1..N; ≤ the harmonic count). */
-    epicycleArms: number;
-    /** Paint the chain as a warm-anchored hue sweep vs one analogous hue. */
-    rainbowChain: boolean;
-    /** Comet-body length as a fraction of the period (0.15..1.0). */
-    trailArc: number;
-    /** Comet stroke weight in CSS px (1..6). */
-    trailWidth: number;
-    /** Outer loudness envelope (per-layer alpha multiply, 0..2). */
-    intensity: number;
-    /** Character of the generated elliptic spectrum (0.05..0.4 — smooth ellipse → crinkled). */
-    harmonicScale: number;
-    /** Clock speed multiplier (0.25/0.5/1/2). */
-    speed: number;
-    /** The curve-color ramp (the library viz palette; warm default). Resolved via the ColorResolver. */
-    palette: OklchStop[];
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
-    respectReducedMotion: boolean;
-    /** Pointer scrubs `head_t` + a flick injects clock momentum (the W-VIZ-INTERACTION consume). */
-    interactive: boolean;
-    /**
-     * Head squash-and-stretch gain (BD.W-FOURIER-LOOM §2b). The head bead stretches along the
-     * curve tangent on straights, squashes across it on corners (volume-preserving). The
-     * library identity carries a small non-zero default (cartoon-weight at rest); a vivid
-     * consumer preset turns it to 11. 0 = the byte-frozen round disc.
-     */
-    squashGain: number;
-    /**
-     * Cartoon cel-shadow gain (BD.W-FOURIER-LOOM §3b). A second darker copy of the chain + rope,
-     * offset opposite the head travel (the technicolor ink). The library identity carries a
-     * small non-zero default; a vivid consumer preset floors it UP. 0 = no cel pass.
-     */
-    celGain: number;
-}
-/**
- * The warm-cream identity palette (the library default — NOT teal). A two-stop warm-amber
- * ramp over the warm-cream foreground family, resolved via the ColorResolver. The chain's
- * rainbow sweep is warm-anchored over THIS base; a consumer (the demo) themes it through a
- * preset, never a token edit.
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/** The shipped warm-identity default config. */
-export declare const DEFAULT_FOURIER_CONFIG: FourierFieldConfig;

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

@@ -1,31 +0,0 @@
-import type { ColorResolver, OklchStop } from "../../../composables/color";
-import type { FourierFieldConfig } from "./constants";
-import type { BasisComponent } from "./math";
-export { default as FourierField } from "./FourierField.vue";
-export { comp, positionsAt, partialSumAt, dftFromPoints, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
-export { DEFAULT_FOURIER_CONFIG, WARM_IDENTITY_PALETTE, MAX_PHASORS, MAX_CURVE_SAMPLES, type FourierFieldConfig, } from "./constants";
-export { useFourierField, type FourierFieldHandle, type UseFourierFieldOptions, } from "./composables/useFourierField";
-/**
- * The props a consumer forwards when wrapping `<FourierField>` (the GPU-substrate epicycle
- * field; ships via `/fourier-field`). Mirrors the component's inline `defineProps` shape (an
- * SFC cannot export its inline props type). BC.W-VIZ-FOURIER — the `variant: "hero"|"final"`
- * enum is RETIRED (folds into config presets); the renderer is the WGSL-primary GPU substrate.
- */
-export interface FourierFieldProps {
-    /** The full author config (the studio's `useConfiguratorState` model). Defaults to the warm identity. */
-    config?: FourierFieldConfig;
-    /** An explicit CPU-minted spectrum (a curated shape's DFT). When absent, a seeded elliptic spectrum is generated. */
-    spectrum?: readonly BasisComponent[];
-    /** Resolve the curve palette as OKLCh (the studio themes it). */
-    getPalette?: () => OklchStop[];
-    /** Ambient-consumer color seam — a `var()`/`light-dark()` token or a literal; derives a warm palette. */
-    color?: string;
-    /** The color resolver (the GooBlob/Aurora seam) — required when `color` is a `var()` token. */
-    colorResolver?: ColorResolver;
-    /** Extra seed mixed into the generated elliptic spectrum PRNG. Default "". */
-    seed?: string;
-    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
-    freeze?: boolean;
-    /** Outer loudness envelope (scales the per-layer alpha). Overrides `config.intensity` when set; clamped [0, 2]. */
-    intensity?: number;
-}

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

@@ -1,86 +0,0 @@
-/**
- * One Fourier phasor. `index` is the integer frequency (a counter-rotating pair
- * is `+1` and `-1`); `coefficient` is the complex coefficient `[re, im]`;
- * `amplitude`/`phase` are its polar form (carried for callers that prefer the
- * polar read — the reconstruction uses the rectangular `coefficient`).
- */
-export interface BasisComponent {
-    index: number;
-    coefficient: [number, number];
-    amplitude: number;
-    phase: number;
-}
-/**
- * Build a {@link BasisComponent} from a frequency index and its rectangular
- * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
- */
-export declare function comp(index: number, re: number, im: number): BasisComponent;
-/**
- * The epicycle chain at parameter `t`: the running tip of each phasor stacked on
- * the last, starting at the origin. `positions[0]` is `[0, 0]`; the final entry
- * is the curve point — the inverse-DFT sum `Σ c_k * exp(2*pi*i*k*t)` at the same
- * `t`. `maxCircles` truncates the chain (draw fewer arms than the spectrum
- * carries).
- */
-export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
-/**
- * The PARTIAL-SUM curve point at parameter `t` over the FIRST `maxTerms` phasors
- * — the inverse-DFT truncated summation `Σ_{k<maxTerms} c_k * exp(2*pi*i*k*t)`.
- * It is {@link positionsAt} truncated at `maxTerms` and read at the FINAL tip:
- * the single curve POINT (not the whole chain). The truncation axis is the SAME
- * one `positionsAt`'s `maxCircles` arg drives — `maxCircles` reads the whole
- * chain truncated, `partialSumAt` reads only its endpoint — so the studio's
- * N-harmonics slider can draw the assembling chain (`positionsAt(.., N)`) AND the
- * resolving curve point (`partialSumAt(.., t, N)`) off the ONE axis. Sweeping `t`
- * over `[0,1)` and joining the points traces the partial-sum CURVE: at `maxTerms`
- * = 1 a single ellipse, growing toward the full reconstruction as `maxTerms`
- * climbs to `components.length` (the reference's "watch it sum" beauty).
- *
- * `maxTerms` omitted (or ≥ `components.length`) is the full reconstruction — the
- * same point `positionsAt(components, t)` returns at its final tip.
- */
-export declare function partialSumAt(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
-/**
- * The forward DFT — the inverse of {@link positionsAt}. Takes a closed sequence
- * of `[x, y]` samples around a curve (treated as the complex signal `x + i·y`,
- * uniformly spaced in the parameter `t ∈ [0, 1)`) and returns the
- * {@link BasisComponent} spectrum that {@link positionsAt} reconstructs.
- *
- * Frequencies run symmetrically around 0 — `0, +1, -1, +2, -2, …` up to the
- * Nyquist limit — which is the index ordering the epicycle chain wants (the big
- * low-order phasors first). The DC term (`index 0`) is the curve's centroid; the
- * caller can subtract it (draw the chain centered) or keep it (draw at the
- * sampled position).
- *
- * General: any point set drives it (a glyph outline, a hand-traced path, a
- * digitized signature). It is NOT a special case — it is the literal forward
- * transform whose inverse already ships as `positionsAt`.
- */
-export declare function dftFromPoints(points: [number, number][]): BasisComponent[];
-/** Tuning for {@link makeEllipticSpectrum}. */
-export interface EllipticSpectrumOptions {
-    /**
-     * How many smaller higher-order harmonics to layer on top of the dominant
-     * counter-rotating pair (the dominant pair is always present). Default 4.
-     * The `final` preset passes a larger count for a denser, busier curve.
-     */
-    harmonics?: number;
-    /**
-     * Peak magnitude of the higher-order harmonics relative to the dominant
-     * phasor. Smaller keeps the curve a clean, smooth ellipse with a little
-     * character; larger crinkles it. Default ~0.22.
-     */
-    harmonicScale?: number;
-}
-/**
- * Emit a procedural elliptic spectrum: a DOMINANT counter-rotating pair (index
- * `+1` and `-1`) of UNEQUAL magnitude — the inequality is what draws a tilted
- * ellipse rather than a circle — plus a few smaller higher-order harmonics with
- * random small magnitudes and phases for character. Lower orders carry more
- * weight (a `1 / order` falloff), so the curve stays large, smooth and
- * few-big-phasor; the `harmonics` knob lifts it to the denser `final` look.
- *
- * Deterministic in `rng`: the same seeded `() => number` yields the same
- * spectrum, so a frozen frame reproduces exactly.
- */
-export declare function makeEllipticSpectrum(rng: () => number, opts?: EllipticSpectrumOptions): BasisComponent[];

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

@@ -1,4 +0,0 @@
-/** The full-screen-triangle vertex shader (the aurora/concentric pattern). */
-export declare const FOURIER_FIELD_VERT_GLSL = "#version 300 es\nin vec2 aPosition;\nout vec2 vClip;\nvoid main() {\n  vClip = aPosition;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}\n";
-/** The fragment SDF — the GLSL twin of fourier-field.render.wgsl.ts's fs_main. */
-export declare const FOURIER_FIELD_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_CURVE_SAMPLES 256\n#define MAX_PHASORS 64\n// BD.W-FOURIER-LOOM \u00A72b \u2014 MUST equal the WGSL twin + FOURIER_TANGENT_EPS (constants.ts).\n#define TANGENT_EPS 1e-4\n#define SPEED_REF_HALFWIDTHS 6.0\n\nin vec2 vClip;\nout vec4 fragColor;\n\nuniform vec4 uFit;          // (centerX, centerY, scale, aspect)\nuniform vec4 uTrail;        // (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\nuniform vec4 uEnv;          // (trailFloor, intensity, showEpicycles, rainbowChain)\nuniform vec4 uLoom;         // (squashGain, celGain, _pad, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b\nuniform int  uSampleCount;\nuniform int  uArmCount;\nuniform int  uStopCount;\nuniform vec3 uPalette[4];   // linear-sRGB stops\n// curveSamples[i] = (x, y, age) in MODEL space; chainTips[k] = (x, y) in MODEL space.\nuniform vec3 uCurve[MAX_CURVE_SAMPLES];\nuniform vec2 uChain[MAX_PHASORS];\n\nconst float PI = 3.141592653589793;\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Negative-safe cube root (the WGSL chunk's cbrt3 twin; the GLSL chunk inlines it).\nvec3 cbrt3(vec3 v) { return sign(v) * pow(abs(v), vec3(1.0 / 3.0)); }\n\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  vec3 labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i0]);\n  vec3 labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i1]);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvec3 chainColorLin(float seg, bool rainbow) {\n  vec3 baseLin = uPalette[0];\n  if (!rainbow) return baseLin;\n  vec3 lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  vec3 lch = oklabToOklch(lab);\n  float hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0));\n  vec3 lifted = vec3(0.66, max(lch.y, 0.14), lch.z + hueShift);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\nfloat segDist(vec2 p, vec2 a, vec2 b) {\n  vec2 pa = p - a;\n  vec2 ba = b - a;\n  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame (T, \u015D), the GLSL twin of the WGSL headFrame.\n// The cusp guard returns +x as the stable fallback when s \u2264 TANGENT_EPS \u2014 identical to the\n// WGSL twin + the CPU bead path.\nstruct HeadFrame { vec2 T; float sHat; };\nHeadFrame headFrame(vec2 head, vec2 headBack, float halfW) {\n  vec2 d = head - headBack;\n  float s = length(d);\n  HeadFrame fr;\n  if (s <= TANGENT_EPS) { fr.T = vec2(1.0, 0.0); fr.sHat = 0.0; return fr; }\n  fr.T = d / s;\n  float refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  fr.sHat = clamp(s / refScale, 0.0, 1.0);\n  return fr;\n}\n\n// The volume-preserving anisotropic head distance (the WGSL headAniso twin).\nfloat headAniso(vec2 p, vec2 head, HeadFrame fr, float k) {\n  float g = 1.0 + k * fr.sHat;\n  vec2 n = vec2(-fr.T.y, fr.T.x);\n  vec2 rel = p - head;\n  float along = dot(rel, fr.T) / g;\n  float across = dot(rel, n) * g;\n  return length(vec2(along, across));\n}\n\nvoid main() {\n  vec2 center = uFit.xy;\n  float scale = max(uFit.z, 1e-6);\n  float aspect = max(uFit.w, 1e-4);\n  // clip \u2192 model (the inverse of model\u2192clip fit).\n  vec2 p = center + vec2(vClip.x * aspect, vClip.y) / scale;\n\n  float aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n  float trailWidth = uTrail.x;            // already in model units (packed CPU-side)\n  float peak = uTrail.y * uEnv.y;\n  float headGlow = uTrail.z * uEnv.y;\n  float fadeExp = uTrail.w;\n  float trailFloor = uEnv.x;\n  bool showEpicycles = uEnv.z > 0.5;\n  bool rainbow = uEnv.w > 0.5;\n  float squashGain = uLoom.x;            // FOURIER-LOOM \u00A72b\n  float celGain = uLoom.y;               // FOURIER-LOOM \u00A73b\n  float halfW = trailWidth * 0.5;\n\n  // \u00A72b \u2014 the head travel frame (SAME uCurve[0]/[1] the WGSL twin reads \u2192 parity).\n  HeadFrame headFr;\n  headFr.T = vec2(1.0, 0.0);\n  headFr.sHat = 0.0;\n  if (uSampleCount >= 2) {\n    headFr = headFrame(uCurve[0].xy, uCurve[1].xy, halfW);\n  }\n  vec2 celOff = -headFr.T * halfW * 1.4;\n\n  vec4 accum = vec4(0.0);\n\n  // \u00A73b \u2014 the cartoon CEL-SHADOW: a darker offset copy of the rope + chain, opposite travel,\n  // painted FIRST (under the lit chain). PRM-static; celGain = 0 \u2192 no pass (byte-frozen).\n  if (celGain > 0.001) {\n    vec3 ink = vec3(0.0);\n    float celA = clamp(celGain, 0.0, 1.0);\n    for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {\n      if (i >= uSampleCount - 1) break;\n      vec2 sa = uCurve[i].xy + celOff;\n      vec2 sb = uCurve[i + 1].xy + celOff;\n      float d = segDist(p, sa, sb);\n      float cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n      if (cover < 0.002) continue;\n      float m = cover * celA * peak;\n      accum = vec4(ink * m, m) + accum * (1.0 - m);\n    }\n    if (showEpicycles && uArmCount >= 1) {\n      for (int k = 0; k < MAX_PHASORS; k++) {\n        if (k >= uArmCount) break;\n        vec2 a = uChain[k] + celOff;\n        vec2 b = uChain[k + 1] + celOff;\n        float dArm = segDist(p, a, b);\n        float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n        float m = armMask * celA * peak * 0.7;\n        accum = vec4(ink * m, m) + accum * (1.0 - m);\n      }\n    }\n  }\n\n  if (showEpicycles && uArmCount >= 1) {\n    for (int k = 0; k < MAX_PHASORS; k++) {\n      if (k >= uArmCount) break;\n      vec2 a = uChain[k];\n      vec2 b = uChain[k + 1];\n      float seg = float(k) / max(float(uArmCount - 1), 1.0);\n      vec3 lin = chainColorLin(seg, rainbow);\n      float radius = length(b - a);\n      float dRing = abs(length(p - a) - radius);\n      float ringW = max(halfW * 0.45, aa);\n      float ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n      float dArm = segDist(p, a, b);\n      float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n      float dotR = max(halfW * 0.7, aa * 2.0);\n      float dDot = length(p - a);\n      float dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n      float m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n      vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n      accum = vec4(rgb * m, m) + accum * (1.0 - m);\n    }\n  }\n\n  for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {\n    if (i >= uSampleCount - 1) break;\n    vec3 sa = uCurve[i];\n    vec3 sb = uCurve[i + 1];\n    float d = segDist(p, sa.xy, sb.xy);\n    float cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    if (cover < 0.002) continue;\n    float age = max(sa.z, sb.z);\n    float a = peak * pow(age, fadeExp);\n    a = max(a, peak * trailFloor) * cover;\n    vec3 lin = samplePaletteLin(1.0 - age * 0.4);\n    vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n    accum = vec4(rgb * a, a) + accum * (1.0 - a);\n  }\n\n  if (uSampleCount >= 1) {\n    vec2 head = uCurve[0].xy;\n    // \u00A72b \u2014 the squash-and-stretch anisotropic head (collapses to the round disc at rest).\n    float dHead = headAniso(p, head, headFr, squashGain);\n    float coreR = halfW * 1.5;\n    float haloR = coreR * 3.0;\n    vec3 headRgb = clamp(linearToSrgb(samplePaletteLin(0.0)), vec3(0.0), vec3(1.0));\n    float halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    accum = vec4(headRgb * halo, halo) + accum * (1.0 - halo);\n    float core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4(headRgb * core, core) + accum * (1.0 - core);\n    float spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4(vec3(1.0) * spec, spec) + accum * (1.0 - spec);\n  }\n\n  fragColor = accum;\n}\n";

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

@@ -1 +0,0 @@
-export declare const FOURIER_FIELD_RENDER_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_CURVE_SAMPLES: i32 = 384;\nconst MAX_PHASORS: i32 = 64;\nconst MAX_FOURIER_STOPS: i32 = 4;\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the degenerate-tangent guard (must equal FOURIER_TANGENT_EPS in\n// constants.ts + the GL CPU bead path so a cusp resolves IDENTICALLY across both engines).\nconst TANGENT_EPS: f32 = 1e-4;\n// The speed yardstick: the head speed (model units between curveSamples[0] and [1]) is\n// normalized against this many trail half-widths so \u015D \u2208 [0,1] is scale-free + parity-safe.\nconst SPEED_REF_HALFWIDTHS: f32 = 6.0;\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct RenderUniforms {\n  // r0: (centerX, centerY, scale, aspect)  \u2014 model\u2192clip fit transform\n  r0: vec4<f32>,\n  // r1: (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\n  r1: vec4<f32>,\n  // r2: (trailFloor, intensity, showEpicycles, rainbowChain)\n  r2: vec4<f32>,\n  // r3: (squashGain, celGain, _pad, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b\n  r3: vec4<f32>,\n  // ints: (sampleCount, armCount, stopCount, _pad)\n  ints: vec4<i32>,\n  // palette stops: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n// curveSamples[i] = (x, y, age, _pad) in MODEL space\n@group(0) @binding(1) var<storage, read> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) in MODEL space\n@group(0) @binding(2) var<storage, read> chainTips: array<vec4<f32>>;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n// A warm-anchored chain hue sweep over the palette base \u2014 the rainbow chain register.\n// Tilts the base hue by a tight warm-ward band so the chain stays colourful but warm.\nfn chainColorLin(seg: f32, rainbow: bool) -> vec3<f32> {\n  let baseLin = u.palette[0].rgb;\n  if (!rainbow) { return baseLin; }\n  let lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  let lch = oklabToOklch(lab);\n  // warm-anchored: a touch cool at the root climbing warm toward the tips.\n  let hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0)); // radians (~ -26\u00B0..+66\u00B0)\n  let h = lch.z + hueShift;\n  let lifted = vec3<f32>(0.66, max(lch.y, 0.14), h);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\n// Distance from point p to segment ab (model space).\nfn segDist(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {\n  let pa = p - a;\n  let ba = b - a;\n  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame: the unit tangent T from curveSamples[0]\n// (head) vs [1] (one step back) + the normalized speed \u015D \u2208 [0,1]. The cusp guard returns\n// the +x axis as the stable fallback when s \u2264 TANGENT_EPS, identical to the GL CPU path.\nstruct HeadFrame { T: vec2<f32>, sHat: f32, };\nfn headFrame(head: vec2<f32>, headBack: vec2<f32>, halfW: f32) -> HeadFrame {\n  let d = head - headBack;\n  let s = length(d);\n  var out: HeadFrame;\n  if (s <= TANGENT_EPS) {\n    out.T = vec2<f32>(1.0, 0.0);\n    out.sHat = 0.0;\n    return out;\n  }\n  out.T = d / s;\n  let refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  out.sHat = clamp(s / refScale, 0.0, 1.0);\n  return out;\n}\n\n// The volume-preserving anisotropic head distance: project (p \u2212 head) onto T and T\u22A5, stretch\n// the tangent extent by (1 + k\u00B7\u015D) and squeeze the normal extent by 1/(1 + k\u00B7\u015D), then length.\n// k = 0 (or \u015D = 0) collapses to the round disc length(p \u2212 head) \u2014 byte-frozen at rest.\nfn headAniso(p: vec2<f32>, head: vec2<f32>, fr: HeadFrame, k: f32) -> f32 {\n  let g = 1.0 + k * fr.sHat;\n  let n = vec2<f32>(-fr.T.y, fr.T.x);\n  let rel = p - head;\n  let along = dot(rel, fr.T) / g;\n  let across = dot(rel, n) * g;\n  return length(vec2<f32>(along, across));\n}\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) model: vec2<f32>,   // model-space coordinate of this fragment\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // Full-screen triangle (covers the viewport with 3 verts).\n  var p = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -3.0), vec2<f32>(-1.0, 1.0), vec2<f32>(3.0, 1.0),\n  );\n  let clip = p[vi];\n  // Inverse of the model\u2192clip fit: clip = (model \u2212 center)\u00B7scale, aspect-corrected x.\n  // \u2192 model = center + clip\u00B7(1/scale), x un-aspect-corrected.\n  let center = u.r0.xy;\n  let scale = max(u.r0.z, 1e-6);\n  let aspect = max(u.r0.w, 1e-4);\n  let model = center + vec2<f32>(clip.x * aspect, clip.y) / scale;\n\n  var out: VSOut;\n  out.pos = vec4<f32>(clip, 0.0, 1.0);\n  out.model = model;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let p = in.model;\n  // AA feather: one device pixel in model units (fwidth of the model coord).\n  let aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n\n  let trailWidth = u.r1.x;                // already in model units (packed CPU-side)\n  let peak = u.r1.y * u.r2.y;             // peakAlpha \u00B7 intensity\n  let headGlow = u.r1.z * u.r2.y;\n  let fadeExp = u.r1.w;\n  let trailFloor = u.r2.x;\n  let sampleCount = u.ints.x;\n  let armCount = u.ints.y;\n  let showEpicycles = u.r2.z > 0.5;\n  let rainbow = u.r2.w > 0.5;\n  let squashGain = u.r3.x;                 // FOURIER-LOOM \u00A72b\n  let celGain = u.r3.y;                    // FOURIER-LOOM \u00A73b\n  let halfW = trailWidth * 0.5;\n\n  // BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame (the SAME curveSamples[0]/[1] both engines\n  // read \u2192 parity by construction). The cel offset (\u00A73b) rides \u2212T (opposite travel).\n  var headFr: HeadFrame;\n  headFr.T = vec2<f32>(1.0, 0.0);\n  headFr.sHat = 0.0;\n  if (sampleCount >= 2) {\n    headFr = headFrame(curveSamples[0].xy, curveSamples[1].xy, halfW);\n  }\n  let celOff = -headFr.T * halfW * 1.4;    // the ink lags behind the travel\n\n  var accum = vec4<f32>(0.0);              // premultiplied accumulation\n\n  // \u2500\u2500 \u00A73b \u2014 the cartoon CEL-SHADOW: a darker offset copy of the chain + rope, opposite\n  //    travel, painted FIRST (it sits UNDER the lit chain). PRM-static (the frozen-T travel\n  //    frame is a fixed offset, no live sweep). celGain = 0 \u2192 no pass (byte-frozen). \u2500\u2500\n  if (celGain > 0.001) {\n    let ink = vec3<f32>(0.0);              // pure ink \u2014 the technicolor 2-tone shadow\n    let celA = clamp(celGain, 0.0, 1.0);\n    // the rope cel (one offset distance-to-curve band).\n    for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {\n      if (i >= sampleCount - 1) { break; }\n      let sa = curveSamples[i].xy + celOff;\n      let sb = curveSamples[i + 1].xy + celOff;\n      let d = segDist(p, sa, sb);\n      let cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n      if (cover < 0.002) { continue; }\n      let m = cover * celA * peak;\n      accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);\n    }\n    // the chain cel (arms only \u2014 the bold scaffold ink).\n    if (showEpicycles && armCount >= 1) {\n      for (var k = 0; k < MAX_PHASORS; k = k + 1) {\n        if (k >= armCount) { break; }\n        let a = chainTips[k].xy + celOff;\n        let b = chainTips[k + 1].xy + celOff;\n        let dArm = segDist(p, a, b);\n        let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n        let m = armMask * celA * peak * 0.7;\n        accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);\n      }\n    }\n  }\n\n  // \u2500\u2500 Epicycle scaffolding (orbit rings + arms + joint dots) UNDER the curve \u2500\u2500\n  if (showEpicycles && armCount >= 1) {\n    for (var k = 0; k < MAX_PHASORS; k = k + 1) {\n      if (k >= armCount) { break; }\n      let a = chainTips[k].xy;\n      let b = chainTips[k + 1].xy;\n      let seg = f32(k) / max(f32(armCount - 1), 1.0);\n      let lin = chainColorLin(seg, rainbow);\n      // orbit RING around a (radius = arm length).\n      let radius = length(b - a);\n      let dRing = abs(length(p - a) - radius);\n      let ringW = max(halfW * 0.45, aa);\n      let ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n      // ARM segment a\u2192b.\n      let dArm = segDist(p, a, b);\n      let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n      // joint DOT at a.\n      let dotR = max(halfW * 0.7, aa * 2.0);\n      let dDot = length(p - a);\n      let dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n      let m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n      let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n      // over-composite (premultiplied).\n      accum = vec4<f32>(rgb * m, m) + accum * (1.0 - m);\n    }\n  }\n\n  // \u2500\u2500 The comet TRAIL \u2014 min-distance to the curve polyline, per-segment age fade \u2500\u2500\n  for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {\n    if (i >= sampleCount - 1) { break; }\n    let sa = curveSamples[i];\n    let sb = curveSamples[i + 1];\n    let d = segDist(p, sa.xy, sb.xy);\n    let cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    if (cover < 0.002) { continue; }\n    let age = max(sa.z, sb.z);            // 1 at head, 0 at tail\n    var a = peak * pow(age, fadeExp);\n    a = max(a, peak * trailFloor);\n    a = a * cover;\n    let lin = samplePaletteLin(1.0 - age * 0.4); // warm core, lighter tail\n    let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n    accum = vec4<f32>(rgb * a, a) + accum * (1.0 - a);\n  }\n\n  // \u2500\u2500 The comet HEAD \u2014 squash-and-stretch (\u00A72b) halo + saturated core + white specular.\n  //    dHead is the volume-preserving anisotropic distance off the travel frame; at rest\n  //    (sHat=0) or squashGain=0 it collapses to the round disc length(p \u2212 head). \u2500\u2500\n  if (sampleCount >= 1) {\n    let head = curveSamples[0].xy;\n    let dHead = headAniso(p, head, headFr, squashGain);\n    let coreR = halfW * 1.5;\n    let haloR = coreR * 3.0;\n    let headLin = samplePaletteLin(0.0);\n    let headRgb = clamp(linearToSrgb(headLin), vec3<f32>(0.0), vec3<f32>(1.0));\n    // soft halo\n    let halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    accum = vec4<f32>(headRgb * halo, halo) + accum * (1.0 - halo);\n    // saturated core\n    let core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4<f32>(headRgb * core, core) + accum * (1.0 - core);\n    // white specular\n    let spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4<f32>(vec3<f32>(1.0) * spec, spec) + accum * (1.0 - spec);\n  }\n\n  return accum;\n}\n";

package/dist/components/custom/glass-panel/GlassPanel.vue.d.ts

@@ -1,49 +0,0 @@
-import { type GlassTier } from "../../../composables/glass/useGlassRenderer";
-import { type Surface } from "../../ui/_shared/useSurfaceAxis";
-/**
- * Surface-tier vocabulary for the CSS rendering branch. Mirrors the v0.8
- * five-rung ladder declared in `tokens.css §8` and consumed by the
- * `.glass-{wash,quiet,resting,floating,overlay}` utility classes.
- *
- * v0.8.6 — `default | medium | elevated` retired (per audit U.W0.C-b §21).
- */
-export type GlassPanelVariant = "wash" | "quiet" | "resting" | "floating" | "overlay";
-export interface GlassPanelProps {
-    /** Force a specific rendering tier */
-    tier?: GlassTier;
-    /** Blur radius (default: 16) */
-    blur?: number;
-    /** Refraction strength 0-1 (default: 0.3) */
-    refraction?: number;
-    /** Chromatic aberration strength 0-1 (default: 0) */
-    chromaticAberration?: boolean;
-    /** Glass surface tier for the CSS rendering branch (v0.8 5-rung ladder). */
-    variant?: GlassPanelVariant;
-    /** Surface decoration register (BA.W-SURFACE-AXIS) — the SHARED
-     *  {glass·veil·opaque} axis. `glass` (default) renders the variant's plain
-     *  glass rung; `veil` overlays the borderless/rimless text-legibility plate;
-     *  `opaque` sets `--glass-level:0` (the solid-card escape). Orthogonal to
-     *  `variant`/`tier`, exactly as `surface` is on `<Card>`. */
-    surface?: Surface;
-    /** Additional classes */
-    class?: string;
-}
-declare var __VLS_1: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<GlassPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassPanelProps> & Readonly<{}>, {
-    blur: number;
-    variant: GlassPanelVariant;
-    surface: Surface;
-    refraction: number;
-    chromaticAberration: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/glass-panel/index.d.ts

@@ -1,2 +0,0 @@
-export { default as GlassPanel } from "./GlassPanel.vue";
-export type { GlassPanelProps, GlassPanelVariant } from "./GlassPanel.vue";

package/dist/components/custom/goo-blob/GooBlob.vue.d.ts

@@ -1,71 +0,0 @@
-import type { BlobMood, BlobConfig, BlobVariant } from "./types";
-/**
- * GooBlob — a gooey metaball creature on a WebGL2 canvas.
- *
- * Renders a pulsing SDF body with orbiting satellites that periodically merge in,
- * get absorbed, then re-emerge. Mood, pointer-attraction and a deterministic
- * satellite system drive the motion. The renderer composes the `createGpuSubstrate`
- * picker — the WebGPU-first `metaball.wgsl` primary OR the WebGL2 `metaball.frag`
- * fallback (BB.W-VIZ-SUITE / W-GOOBLOB-WGPU), selected once by `navigator.gpu`
- * feature-detect; it never bootstraps its own context.
- *
- * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
- * oklchToGammaRgb`): the blob paints the GAMMA-sRGB triple of the `color` prop. A
- * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly; a `var(--token)` is
- * un-wrapped to a concrete string by the SFC's `resolveTokenColor` leaf BEFORE the
- * renderer sees it (the DOM-free renderer contract).
- *
- * Config is resolved with a loud discipline: either
- * `provide(BLOB_CONFIG_KEY, cfg)` from an ancestor OR pass an explicit `config`
- * prop. A mount with NEITHER throws — there is no silent reactive-defaults
- * synthesis. A consumer that genuinely wants the stock tuning passes
- * `BLOB_CONFIG_DEFAULTS` explicitly.
- */
-type __VLS_Props = {
-    /** Base CSS color string (a `var()`/`oklch()`/`lab()`/`hsl()`/hex form; resolved
-     *  internally through the `/color` leaf to a gamma-sRGB triple). */
-    color: string;
-    /**
-     * REQUIRED unless an ancestor `provide(BLOB_CONFIG_KEY, …)` supplies it.
-     * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.
-     */
-    config?: BlobConfig;
-    /**
-     * BC.W-GOOBLOB-PLAIN — the render-variant axis. `"blob"` is the STAGE-1
-     * shadowless lightless fill-only floor; `"meatball"` (default) is the full lit
-     * register. When set it WINS the resolved config's `variant` (the per-instance
-     * override); unset, the config's own `variant` rules. STAGE 1's `uStage` gate
-     * strips the lit/shadow blocks for the `"blob"` register.
-     */
-    variant?: BlobVariant;
-    /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
-    seed?: string;
-    /**
-     * AX.W16 — the declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the
-     * render loop (the substrate's `manual` suspend) when `true` and restarts it when
-     * `false`. This is the EXACT shape `<DockBackgroundToggle>` wears — wire its
-     * `@update:paused` to this `v-model` and the blob's animation stops/starts for ALL
-     * users. The imperative `pause()`/`resume()` defineExpose handles bind the SAME
-     * renderer seam (no parallel pause path); the prop owns the default.
-     */
-    paused?: boolean;
-};
-declare function nudge(): void;
-declare function setMood(m: BlobMood): void;
-declare function pulse(): void;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    nudge: typeof nudge;
-    setMood: typeof setMood;
-    pulse: typeof pulse;
-    currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
-    pause: () => void;
-    resume: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    click: () => any;
-    "update:paused": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: (() => any) | undefined;
-    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

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