@mkbabb/glass-ui 8.0.0 → 9.0.0

package/dist/components/dock/styles/shell.css

@@ -1 +1 @@
-@layer components{.glass-dock{--glass-blur-resting: blur( calc(var(--glass-blur-resting-radius) * var(--glass-level)) ) saturate(1.2);--dock-surface-blur: var(--glass-blur-resting);--dock-separator-height: calc(var(--dock-h,var(--size-icon-btn)) * 0.5);--dock-collapsed-hover-scale: var(--scale-hover-dock);--dock-stagger-window-size: 0.4;--dock-stagger-step: 0.08;--dock-card-radius: var(--radius-dock-card);--dock-tile-min: 4.5rem;position: relative;z-index: 0;--glass-backdrop: light;--dock-plate-collapsed-tier: var(--glass-veil-wash);--dock-plate-collapsed-border: var(--glass-border-floating);--dock-plate-expanded-tier: var(--glass-veil-dock);--dock-plate-expanded-border: var(--glass-border-dock);contain: layout style;display: inline-flex;align-items: center;white-space: nowrap;max-inline-size: var(--dock-max-inline-size);padding: var(--dock-padding-block,0.375rem) var(--dock-padding-inline,0.5rem);box-shadow: var(--glass-rim-top),var(--glass-rim-bottom),var(--shadow-dock-override,var(--shadow-dock));}.dark .glass-dock{--glass-blur-resting: blur( calc(var(--glass-blur-resting-radius) * var(--glass-level)) ) saturate(1.3) brightness(1.14);}.glass-dock{overflow: visible;}.glass-dock.vertical.always-expanded:not([data-morphing]),.glass-dock.vertical.expanded:not([data-morphing]){overflow-x: visible;overflow-y: auto;scrollbar-width: none;overscroll-behavior-y: contain;}.glass-dock.vertical.always-expanded:not([data-morphing])::-webkit-scrollbar,.glass-dock.vertical.expanded:not([data-morphing])::-webkit-scrollbar{display: none;}.glass-dock.vertical.always-expanded:not([data-morphing]),.glass-dock.vertical.expanded:not([data-morphing]){mask-image: linear-gradient( to bottom,transparent 0,black var(--fade-start,0px),black calc(100% - var(--fade-end,0px)),transparent 100% );animation: gl-fade-start-in linear both,gl-fade-end-out linear both;animation-timeline: scroll(self block),scroll(self block);animation-range: 0 var(--fade-scroll-width),calc(100% - var(--fade-scroll-width)) 100%;}.glass-dock.vertical{display: inline-flex;flex-direction: column;align-items: stretch;justify-content: flex-start;gap: var(--dock-layer-gap,0.375rem);white-space: normal;width: auto;height: auto;max-block-size: var(--dock-max-block-size);padding: var(--dock-padding-block,0.375rem);border-radius: var(--radius-dock);transition: box-shadow var(--dock-motion-standard),transform var(--dock-motion-resize),scale var(--dock-motion-resize);}.glass-dock.vertical[data-morphing]{transition-property: box-shadow,transform;}.glass-dock.vertical:hover,.glass-dock.vertical:active,.glass-dock.vertical[data-held]{will-change: transform;}.glass-dock.vertical{padding: var(--dock-vertical-padding,var(--dock-padding-inline,0.5rem));}.glass-dock.vertical.shape-pill{border-radius: var(--radius-pill);}.glass-dock.vertical.shape-rounded{border-radius: var(--radius-card);}.glass-dock.vertical.shape-card{border-radius: calc( var(--radius-pill) + (var(--dock-card-radius) - var(--radius-pill)) * var(--dock-expand-t) );}.glass-dock:not(.vertical).shape-rounded{border-radius: var(--radius-card);}.glass-dock:not(.vertical).shape-card{border-radius: calc( var(--radius-pill) + (var(--dock-card-radius) - var(--radius-pill)) * var(--dock-expand-t) );}@supports (corner-shape: superellipse(2)){.glass-dock:not(.vertical).shape-card{corner-shape: var(--corner-shape-bigdock);}}.glass-dock:where(.fixed){z-index: var(--z-dock);}.dock-inline{margin: 0 auto;}.dock-sticky{position: sticky;top: 0;z-index: var(--z-dock);margin: 0 auto;}}
+@layer components{.glass-dock{--glass-blur-resting: blur( calc(var(--glass-blur-resting-radius) * var(--glass-level)) ) saturate(1.2);--dock-surface-blur: var(--glass-blur-resting);--dock-separator-height: calc(var(--dock-h,var(--size-icon-btn)) * 0.5);--dock-stagger-window-size: 0.4;--dock-stagger-step: 0.08;--dock-card-radius: var(--radius-dock-card);position: relative;z-index: 0;margin: 0 auto;--glass-backdrop: light;--dock-plate-collapsed-tier: var(--glass-veil-wash);--dock-plate-collapsed-border: var(--glass-border-floating);--dock-plate-expanded-tier: var(--glass-veil-dock);--dock-plate-expanded-border: var(--glass-border-dock);contain: layout style;display: inline-flex;align-items: center;white-space: nowrap;padding: var(--dock-padding-block,0.375rem) var(--dock-padding-inline,0.5rem);box-shadow: var(--glass-rim-top),var(--glass-rim-bottom),var(--shadow-dock-override,var(--shadow-dock));}.dark .glass-dock{--glass-blur-resting: blur( calc(var(--glass-blur-resting-radius) * var(--glass-level)) ) saturate(1.3) brightness(1.14);}.glass-dock{overflow: visible;}.glass-dock.vertical{display: inline-flex;flex-direction: column;align-items: stretch;justify-content: flex-start;gap: var(--dock-layer-gap,0.375rem);white-space: normal;width: auto;height: auto;max-block-size: var(--dock-max-block-size);padding: var(--dock-padding-block,0.375rem);border-radius: var(--radius-dock);transition: box-shadow var(--dock-motion-standard),transform var(--dock-motion-resize),scale var(--dock-motion-resize);}.glass-dock.vertical[data-morphing]{transition-property: box-shadow,transform;}.glass-dock.vertical:hover,.glass-dock.vertical:active,.glass-dock.vertical[data-held]{will-change: transform;}.glass-dock.vertical{padding: var(--dock-vertical-padding,var(--dock-padding-inline,0.5rem));}.glass-dock.vertical.shape-pill{border-radius: var(--radius-pill);}.glass-dock.vertical.shape-rounded{border-radius: var(--radius-card);}.glass-dock.vertical.shape-card{border-radius: calc( var(--radius-pill) + (var(--dock-card-radius) - var(--radius-pill)) * var(--dock-expand-t) );}.glass-dock:not(.vertical).shape-rounded{border-radius: var(--radius-card);}.glass-dock:not(.vertical).shape-card{border-radius: calc( var(--radius-pill) + (var(--dock-card-radius) - var(--radius-pill)) * var(--dock-expand-t) );}@supports (corner-shape: superellipse(2)){.glass-dock:not(.vertical).shape-card{corner-shape: var(--corner-shape-bigdock);}}}

package/dist/components/fourier-field/FourierField.vue.d.ts

@@ -1,48 +1,50 @@
-import type { ColorResolver, OklchStop } from "../../composables/color/index.js";
+import type { OklchStop } from "../../composables/color/index.js";
 import { type BasisComponent } from "./math.js";
-import type { FourierFieldConfig } from "./constants.js";
+import { type FourierFieldConfig } from "./constants.js";
 import type { RendererStatus } from "../../composables/glass/webgpu/rendererStatus.js";
 /**
- * FourierField — a Fourier epicycle field on the GPU substrate, a
- * sibling primitive to Aurora, GooBlob, and DotFlowField. A chain of rotating circles
- * stacked tip-to-tail draws the reconstructing partial-sum curve; a glowing comet head
- * leads the fading trail. WebGPU-FIRST: the compute pass writes the partial-sum curve +
- * the epicycle chain tips, the fullscreen-fragment render pass composites the SDF field; a
- * WebGL2 GLSL twin is the fallback. It composes `useFourierField` with the
- * `createGpuSubstrate` picker over the ONE canvas lifecycle leaf (offscreen-pause, live-PRM
- * freeze, consumer-owned DPR) and the SHARED `usePointerVelocityField` (the pointer SCRUBS
- * the reconstruction).
+ * FourierField — the drawing machine.
  *
- * The DEFAULT palette is the warm-cream library identity (`--viz-fourier` warm-amber); a
- * demo Teal/cool preset stays demo-LOCAL (presets-in-consumers — never a library token).
+ * Aurora is weather and the blob is a creature; this one is the substrate whose motion is
+ * a CHECKABLE CLAIM. Every frame is the truncated inverse transform of a fixed spectrum,
+ * `Σ c_k·e^{2πikt}`, and a reader can verify it: the rings are the terms, the chain is the
+ * sum, the head is where the parameter currently is. Nothing decorative moves.
  *
- * Visual bundles live in config presets. An ambient-background consumer passes `color` and the
- * `colorResolver` for a thin warm default preserving the recessive look; the studio passes
- * the full `config` + `spectrum` + `getPalette`.
+ * The two payoffs are CLOSURE — every index is an integer, so the figure completes exactly
+ * at `t = 1` — and ASSEMBLY — the spectrum is amplitude-ordered, so every step of the N
+ * axis adds the largest remaining correction rather than the next arbitrary frequency.
+ *
+ * WebGPU only. There is one renderer, because a second one would be a second paint law,
+ * and where WebGPU is absent the field declares it and paints nothing.
  */
 type __VLS_Props = {
-    /** The full author config (the studio's `useConfiguratorState` model). Defaults to the warm identity. */
+    /** The author config. Defaults to the shipped identity. */
     config?: FourierFieldConfig;
-    /** An explicit CPU-minted spectrum (a curated shape's DFT). When absent, a seeded elliptic spectrum is generated. */
+    /** An explicit spectrum. When absent, the config's `source` decides. */
     spectrum?: readonly BasisComponent[];
-    /** Resolve the curve palette as OKLCh (the studio themes it). When absent, `color`/`config.palette` is used. */
+    /** Resolve the ramp as OKLCh (the studio themes it). Wins over `color`. */
     getPalette?: () => OklchStop[];
-    /** Ambient-consumer color seam — a `var()`/`light-dark()` token or a literal; derives a warm 2-stop palette. */
+    /** Ambient-consumer colour seam — a token or a literal; derives a two-stop ramp. */
     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 for the generated spectrum. */
     seed?: string;
-    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
+    /** Hold the clock. The figure stays live; only time stops. */
     freeze?: boolean;
+    /**
+     * The pointer scrubs and flicks the clock, and the host becomes a real slider.
+     * `false` is the decor mount: no listeners, no role, no tab stop.
+     */
+    interactive?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     backend: () => import("../../composables/glass/webgpu/useGpuSubstrate.js").GpuBackend;
     pause: () => void;
     resume: () => void;
     wake: () => void;
-    renderAt: (timeSec: number) => void;
     setHeadT: (t: number) => void;
+    /** The live loop parameter. Unwrapped on the exposed proxy, so a transport binds it. */
+    headT: Readonly<import("vue").Ref<number, number>>;
+    flick: (turnsPerSec: number) => void;
     rendererStatus: Readonly<import("vue").Ref<RendererStatus, RendererStatus>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     rendererStatus: (status: RendererStatus) => any;
@@ -51,6 +53,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
 }>, {
     seed: string;
     freeze: boolean;
+    interactive: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/fourier-field/clock.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The substrate-travel spring, bound by JOB rather than by a remembered pair. This module
+ * owns exactly one invariant about it — the damping fraction it CONSUMES — because that is
+ * what decides whether a flick can rewind the drawing.
+ */
+export declare const FOURIER_TRAVEL_SPRING: import("../../composables/motion/index.js").SpringPresetRow;
+/** The consumed damping fraction. At or above this, a flick has no backward frames. */
+export declare const FOURIER_SETTLE_ZETA_FLOOR = 0.82;
+export interface FourierClockInput {
+    /** Seconds elapsed since the last step. */
+    dt: number;
+    /** The config's speed multiplier. */
+    speed: number;
+    /** The pointer's horizontal velocity, or 0 when the pointer is not driving. */
+    scrubVelocity: number;
+    /** The pointer field's transient flick burst (0..1), or 0. */
+    burst: number;
+    /** Whether the pointer is engaged at all this step. */
+    engaged: boolean;
+    /** Hold the parameter and clear the momentum. */
+    frozen: boolean;
+}
+export interface FourierClock {
+    /** The loop parameter `head_t ∈ [0,1)`. */
+    readonly headT: number;
+    /** The current rate offset (turns/s) the flick spring is carrying. */
+    readonly momentum: number;
+    /** Advance one step; returns the rate the step actually used (never negative). */
+    step: (input: FourierClockInput) => number;
+    /** Seat the parameter directly. Takes no spring — a hand's position is not physics. */
+    set: (t: number) => void;
+    /** Inject one impulse in turns per second, capped by the advance budget. */
+    flick: (turnsPerSec: number) => void;
+}
+export declare function createFourierClock(): FourierClock;

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

@@ -1,134 +1,109 @@
 import type { OklchStop } from "../../composables/color/index.js";
+import type { FOURIER_FIGURES } from "./math.js";
+/** The palette-stop ceiling — the WGSL `MAX_FOURIER_STOPS` binding size. */
+export declare const MAX_FOURIER_STOPS = 4;
 /**
- * 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.
+ * The CPU-resolved OKLab ramp resolution. The palette is sampled into this many entries
+ * once per palette change and uploaded as a table, so the shader never runs an OKLab
+ * conversion per fragment and the ink, the mark and the head all read ONE ramp.
  */
-export declare const FOURIER_FIT_SAMPLES = 720;
+export declare const FOURIER_LUT_SIZE = 16;
 /**
- * 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.
+ * The tail chroma floor. A ramp that lets chroma fall to zero paints a grey smear at the
+ * trail's end — the blob disease. Every LUT entry is floored here.
  */
-export declare const MAX_PHASORS = 64;
+export declare const FOURIER_TAIL_CHROMA_FLOOR = 0.1;
 /**
- * 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.
+ * THE INK STEP. The ink is the mark's own ramp head taken one step DOWN in lightness and
+ * then gamut-mapped at fixed L and hue, so it is a real pigment rather than a wash. This
+ * is the module's own ramp step, and it is what solves mark:ink into the [1.5, 3.0]:1
+ * band in BOTH schemes at once.
  */
-export declare const MAX_CURVE_SAMPLES = 384;
-/** The palette-stop ceiling — the WGSL `MAX_FOURIER_STOPS` #define. */
-export declare const MAX_FOURIER_STOPS = 4;
+export declare const FOURIER_INK_DELTA_L = 0.22;
 /**
- * The cursor-velocity → head_t clock-coupling gain. Cursor motion (not 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 (an absolute-X `headT = pointerX` scrub reads as "not
- * following" a 2-D cursor).
+ * THE HEAD LIFT. The comet head's core is the ramp head lifted by half the ink step, with
+ * chroma preserved. The head is light-led and stays in the palette family — it is never a
+ * white specular, which reads as trite and shiny and belongs to no rung.
  */
-export declare const SCRUB_GAIN = 0.15;
+export declare const FOURIER_HEAD_DELTA_L = 0.11;
 /**
- * The comet ribbon's TAIL width as a fraction of the head width (the head→tail taper). At the
- * head (age 1) the stroke is the full `trailWidth`; at the tail (age 0) it is `RIBBON_TAIL_FRAC`
- * of it. The taper is `f(age) = RIBBON_TAIL_FRAC + (1 − RIBBON_TAIL_FRAC)·age` (LINEAR, so the
- * age-0.5 MID-BODY is `RIBBON_TAIL_FRAC + (1 − RIBBON_TAIL_FRAC)·0.5` of the head). Declared
- * ONCE here + MIRRORED verbatim as the `RIBBON_TAIL_FRAC` const in BOTH shaders (the GLSL twin
- * cannot import a TS constant); keep the three copies equal so the
- * mid-body floor below can never drift off the taper.
+ * The chain's hue sweep, in radians, ridden symmetrically about the palette hue. Measured
+ * swept range 10.3°–50.5° off a warm anchor, which is why the chain cannot reach
+ * chartreuse by construction rather than by a clamp.
  */
-export declare const RIBBON_TAIL_FRAC = 0.4;
-/** The mid-body taper fraction (age 0.5) — the width the {@link RIBBON_HEAD_FLOOR_PX} floor targets. */
-export declare const RIBBON_MID_TAPER_FRAC: number;
+export declare const FOURIER_CHAIN_HUE_SWEEP = 0.35;
+/** The scaffold stroke as a fraction of the mark stroke — the chain is a rung below the curve. */
+export declare const FOURIER_SCAFFOLD_STROKE_FRAC = 0.4;
+/** The three mark-stroke rungs in CSS px. Three rungs, three visibly distinct pictures. */
+export declare const FOURIER_STROKE_RUNGS: readonly [4, 8, 12];
 /**
- * The MID-BODY minimum in CSS px (the B1 "≥2.5px CSS mid-body at every DPR, never a 1px
- * hairline polyline" bar). The width is DPR-independent by construction (converted to model
- * via `canvasCssMin` = backing ÷ dpr), so a CSS-px floor holds at every DPR.
+ * The flick's advance cap in turns. A full flick advances the clock by at most half a
+ * figure (`|∫flick| = v/ω² ≤ FOURIER_FLICK_TURNS`), so the machine stays checkable: the
+ * reader can always see where the head went.
  */
-export declare const RIBBON_MID_FLOOR_PX = 2.5;
+export declare const FOURIER_FLICK_TURNS = 0.5;
+/** The cursor-velocity → clock-rate scrub gain (turns per second per unit pointer velocity). */
+export declare const FOURIER_SCRUB_GAIN = 0.15;
+/** Base forward period for one full traversal at 1× speed, in seconds. */
+export declare const FOURIER_PERIOD_S = 16;
+/** The keyboard scrub quanta in turns: fine (←/→) and coarse (↑/↓). */
+export declare const FOURIER_QUANTUM_FINE: number;
+export declare const FOURIER_QUANTUM_COARSE: number;
 /**
- * The HEAD-width floor in CSS px (the `trailWidth` clamp in `trailWidthToModel`). Sized so the
- * mid-body (head × {@link RIBBON_MID_TAPER_FRAC}) clears {@link RIBBON_MID_FLOOR_PX} — even a
- * consumer setting `trailWidth: 1` gets a ≥2.5px mid-body. A hair over the exact quotient for
- * float safety.
+ * The device-pixel-ratio cap. Consumed locally: the curve is a thin stroke over mostly
+ * empty stage, so it is worth resolving sharply, and 2× is where the sharpness stops
+ * being visible and starts being fill rate.
  */
-export declare const RIBBON_HEAD_FLOOR_PX: number;
+export declare const FOURIER_DPR_CAP = 2;
+/** The number of curve samples the comet body is built from. */
+export declare const FOURIER_CURVE_SAMPLES = 384;
 /**
- * The degenerate-tangent guard ( §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).
+ * The degenerate-tangent guard. At a cusp the head's instantaneous speed collapses and
+ * the unit tangent blows up; below this the shader falls back to the last stable tangent.
  */
 export declare const FOURIER_TANGENT_EPS = 0.0001;
-/**
- * The head squash-and-stretch gain ( §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 ( §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 spectrum source: the seeded generator, or a curated closed figure by key. */
+export type FourierSource = "elliptic" | keyof typeof FOURIER_FIGURES;
 /**
  * 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.
+ * tunable a control drives, and every one of them changes the picture.
  */
 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)). */
+    /** The spectrum source. An unknown key throws at config time rather than painting a default. */
+    source: FourierSource;
+    /**
+     * The partial-sum term count N. Its live domain is `[1, spectrum.length]`, where the
+     * length is what the mint emitted — there is no constant maximum anywhere.
+     */
     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. */
+    /** Draw the machine: the rings, the arms and the joint dots. */
+    showMachine: boolean;
+    /** Sweep the chain's hue about the palette anchor rather than painting one hue. */
     rainbowChain: boolean;
-    /** Comet-body length as a fraction of the period (0.15..1.0). */
+    /** Comet-body length as a fraction of the period (0.15..1). */
     trailArc: number;
-    /** Comet stroke weight in CSS px (1..6). */
-    trailWidth: number;
-    /** Outer loudness envelope (per-layer alpha multiply, 0..2). */
+    /** The mark stroke in CSS px — one of {@link FOURIER_STROKE_RUNGS}. */
+    markStroke: number;
+    /**
+     * The ink's offset from its mark, in stroke widths, taken along this segment's own
+     * tangent and opposite the travel. Below ½ the ink hides under its mark; above 1 it
+     * detaches and reads as a second line.
+     */
+    inkOffset: number;
+    /** The head's squash-and-stretch gain (0..1). 0 is a dead round disc. */
+    squash: number;
+    /** The head halo's strength (0..0.3). */
+    glow: number;
+    /** Outer loudness envelope (0..2). Above 1 the pack clamps, and the row says so. */
     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). */
+    /** Character of the GENERATED spectrum (0..1). Inert for a curated source. */
+    richness: number;
+    /** Clock speed multiplier. */
     speed: number;
-    /** The curve-color ramp (the library viz palette; warm default). Resolved via the ColorResolver. */
+    /** The curve-color ramp. */
     palette: OklchStop[];
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    /** One static frame then park under `prefers-reduced-motion: reduce`. */
     respectReducedMotion: boolean;
-    /** Pointer scrubs `head_t` + a flick injects clock momentum (the consume). */
-    interactive: boolean;
-    /**
-     * Head squash-and-stretch gain ( §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 ( §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. */
+/** The shipped default config. */
 export declare const DEFAULT_FOURIER_CONFIG: FourierFieldConfig;

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

@@ -1,29 +1,4 @@
-import type { ColorResolver, OklchStop } from "../../composables/color/index.js";
-import type { FourierFieldConfig } from "./constants.js";
-import type { BasisComponent } from "./math.js";
 export { default as FourierField } from "./FourierField.vue.js";
-export { comp, positionsAt, partialSumAt, dftFromPoints, makeEllipticSpectrum, makeHarmonicFigure, FOURIER_FIGURES, FOURIER_FIGURE_KEYS, type BasisComponent, type EllipticSpectrumOptions, type HarmonicTerm, } from "./math.js";
-export { DEFAULT_FOURIER_CONFIG, WARM_IDENTITY_PALETTE, MAX_PHASORS, MAX_CURVE_SAMPLES, type FourierFieldConfig, } from "./constants.js";
-export { useFourierField, type FourierFieldHandle, type UseFourierFieldOptions, } from "./composables/useFourierField.js";
-/**
- * The props a consumer forwards when wrapping `<FourierField>` (the GPU-substrate epicycle
- * field; ships via `/fourier-field`). Mirrors the component's inline `defineProps` shape because
- * an SFC cannot export its inline props type. Visual bundles live in 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;
-}
+export { dftFromPoints, partialSumAt, positionsAt, makeEllipticSpectrum, makeHarmonicFigure, FOURIER_FIGURES, FOURIER_FIGURE_KEYS, type BasisComponent, } from "./math.js";
+export { mintSpectrum, ringsAt, type MintedSpectrum } from "./renderer/mint.js";
+export { DEFAULT_FOURIER_CONFIG, type FourierFieldConfig } from "./constants.js";

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

@@ -1,8 +1,7 @@
 /**
- * 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`).
+ * 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 (the reconstruction uses the rectangular `coefficient`).
  */
 export interface BasisComponent {
     index: number;
@@ -11,101 +10,94 @@ export interface BasisComponent {
     phase: number;
 }
 /**
- * Build a {@link BasisComponent} from a frequency index and its rectangular
- * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
+ * Build a {@link BasisComponent} from a frequency index and its rectangular coefficient,
+ * 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).
+ * 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. `maxCircles` truncates the chain.
  */
-export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
+export declare function positionsAt(components: readonly 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.
+ * The PARTIAL-SUM curve point at `t` over the first `maxTerms` phasors — the truncated
+ * inverse DFT `Σ_{k<maxTerms} c_k · e^{2πi·k·t}`. It is {@link positionsAt} read at its
+ * final tip without building the chain, so the fit pass and the N axis share one
+ * evaluator. Sweeping `t` over `[0,1)` traces the partial-sum curve: at `maxTerms = 1` a
+ * single ellipse, growing toward the full reconstruction as `maxTerms` climbs.
  */
-export declare function partialSumAt(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
+export declare function partialSumAt(components: readonly 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).
+ * The forward DFT — the inverse of {@link positionsAt}. Takes a closed sequence of
+ * `[x, y]` samples around a curve (the complex signal `x + i·y`, uniformly spaced in
+ * `t ∈ [0, 1)`) and returns the spectrum {@link positionsAt} reconstructs.
  *
- * 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`.
+ * Frequencies run symmetrically around 0 — `0, +1, -1, +2, -2, …` up to Nyquist. The DC
+ * term (`index 0`) is the curve's centroid; the mint hoists it out as the fit anchor.
+ * Any point set drives it: a glyph outline, a hand-traced path, a digitized signature.
  */
-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;
-}
+export declare function dftFromPoints(points: readonly [number, number][]): BasisComponent[];
 /**
- * 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.
+ * 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 higher-order harmonics with a `1/order` falloff.
+ *
+ * `richness` ∈ `[0,1]` is the ONE character knob: 0 is a clean ellipse, 1 a crinkled
+ * figure. It drives both how many harmonics are offered and how loud they are; the mint's
+ * paint floor then decides how many of them survive, so the axis maximum is honest
+ * per-seed rather than pinned to a constant.
  *
- * Deterministic in `rng`: the same seeded `() => number` yields the same
- * spectrum, so a frozen frame reproduces exactly.
+ * Deterministic in `rng`: the same seeded `() => number` yields the same spectrum.
  */
-export declare function makeEllipticSpectrum(rng: () => number, opts?: EllipticSpectrumOptions): BasisComponent[];
+export declare function makeEllipticSpectrum(rng: () => number, richness?: number): BasisComponent[];
 /** One integer-index harmonic term of a {@link FOURIER_FIGURES} recipe (polar form). */
 export interface HarmonicTerm {
-    /** The INTEGER frequency index (a closed figure requires integers — the period-1 fence). */
+    /** The INTEGER frequency index — a closed figure requires integers (the period-1 fence). */
     index: number;
     /** The phasor magnitude (relative; the figure is scale-fit at render). */
     mag: number;
-    /** The phase offset in turns (0..1 — multiplied by 2π; a phase rotates the figure). */
+    /** The phase offset in TURNS (0..1 — multiplied by 2π). */
     phase: number;
 }
 /**
- * Build a {@link BasisComponent} spectrum from a closed-figure recipe (a list of integer-index
- * {@link HarmonicTerm}s). The recipe's `phase` is in TURNS; the rectangular coefficient is
- * `mag·(cos, sin)` at `2π·phase`. The result CLOSES (all indices integer) — feed it straight
- * to `partialSumAt`/`positionsAt`.
+ * Build a spectrum from a closed-figure recipe. Because every index is an INTEGER,
+ * `e^{2πi·k·t}` has period 1, so the sum CLOSES at `t = 1` by construction — no term can
+ * leave the figure open. Two counter-rotating integer phasors trace an epicycloid whose
+ * symmetry order is `|p − q|`; a third small term adds character without breaking closure.
  */
 export declare function makeHarmonicFigure(terms: readonly HarmonicTerm[]): BasisComponent[];
 /**
- * The curated FLOWER / closed-epicycle figure catalogue — few-term integer-ratio harmonic
- * stacks, each a deliberate figure (the symmetry order is `|p − q|` for the dominant pair).
- * Selectable/cyclable by key; the LIBRARY beauty register the `boring` random ellipse lacked.
- * The magnitudes stay large + few-phasor so the figure reads bold, not crinkled.
+ * The curated closed-figure catalogue — few-term integer-ratio harmonic stacks, each a
+ * deliberate figure (the symmetry order is `|p − q|` for the dominant pair). Every entry
+ * states its own honest term count: two terms draw a foil, three draw a spirograph.
  */
-export declare const FOURIER_FIGURES: Record<string, HarmonicTerm[]>;
+export declare const FOURIER_FIGURES: {
+    trefoil: {
+        index: number;
+        mag: number;
+        phase: number;
+    }[];
+    quatrefoil: {
+        index: number;
+        mag: number;
+        phase: number;
+    }[];
+    pentafoil: {
+        index: number;
+        mag: number;
+        phase: number;
+    }[];
+    hexafoil: {
+        index: number;
+        mag: number;
+        phase: number;
+    }[];
+    spiro: {
+        index: number;
+        mag: number;
+        phase: number;
+    }[];
+};
 /** The ordered figure keys (the demo/consumer cycle order). */
-export declare const FOURIER_FIGURE_KEYS: string[];
+export declare const FOURIER_FIGURE_KEYS: (keyof typeof FOURIER_FIGURES)[];