@mkbabb/glass-ui 7.0.0 → 9.0.0

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

@@ -1,134 +1,109 @@
-import type { OklchStop } from "../../composables/color";
+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,31 +1,4 @@
-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, makeHarmonicFigure, FOURIER_FIGURES, FOURIER_FIGURE_KEYS, type BasisComponent, type EllipticSpectrumOptions, type HarmonicTerm, } 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 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;
-    /** Outer loudness envelope (scales the per-layer alpha). Overrides `config.intensity` when set; clamped [0, 2]. */
-    intensity?: number;
-}
+export { default as FourierField } from "./FourierField.vue.js";
+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)[];

package/dist/components/fourier-field/renderer/mint.d.ts

@@ -0,0 +1,50 @@
+import { type BasisComponent } from "../math.js";
+/**
+ * The reference stage diagonal in device px — the derivation is on the line above. Every
+ * axis maximum in the tree is this number's consequence, so it is declared once.
+ */
+export declare const FOURIER_REFERENCE_DIAGONAL_PX = 856;
+/** A term survives the mint iff it moves the curve at least this far at the reference stage. */
+export declare const FOURIER_PAINT_FLOOR_PX = 0.5;
+/**
+ * A minted spectrum: the DC anchor, the amplitude-ordered surviving terms, and the model
+ * geometry the fit and the ring law both read. Immutable and reference-stable — the
+ * renderer's re-upload guard is an identity check against this object.
+ */
+export interface MintedSpectrum {
+    /** The amplitude-ordered, paint-floored terms. `length` IS the N axis maximum. */
+    readonly terms: readonly BasisComponent[];
+    /** The hoisted DC term (the curve's centroid) — the anchor the scene is centred on. */
+    readonly dc: readonly [number, number];
+    /** The full reconstruction's bbox half-extents in model units (DC removed). */
+    readonly halfSpanX: number;
+    readonly halfSpanY: number;
+    /** The bbox centre in model units (DC removed) — the fit's centre. */
+    readonly centerX: number;
+    readonly centerY: number;
+    /** The bbox diagonal in model units — the reference-stage mapping's denominator. */
+    readonly diagonal: number;
+    /** `Σ|c_k|` over the terms — the chain's maximum reach from the centre. */
+    readonly chainReach: number;
+}
+/**
+ * Mint a raw spectrum into the shipped one. The input is anything `dftFromPoints`,
+ * `makeHarmonicFigure` or `makeEllipticSpectrum` produced; the output is what the GPU
+ * ever sees.
+ *
+ * Deterministic: the same input array yields the same output, term for term. An empty or
+ * all-sub-floor input still emits its single largest term — a spectrum that draws nothing
+ * is not a fallback, it is a blank stage, and the machine must always have one ring.
+ */
+export declare function mintSpectrum(raw: readonly BasisComponent[]): MintedSpectrum;
+/**
+ * THE RING LAW. A ring is DRAWN iff its own diameter reaches the mark's stroke at the
+ * LIVE stage: `2·|c_k| ≥ markStroke`, both sides in device pixels. Below that rung the
+ * term is still SUMMED and still CHAINED — the scaffold arm and the joint dot stay — only
+ * the circle outline elides, because a circle narrower than the line drawing it is a blob,
+ * not a circle.
+ *
+ * This is why the machine reads at every size with ZERO media queries: the question is
+ * asked of the stage the component is actually in.
+ */
+export declare function ringsAt(minted: MintedSpectrum, stageDiagonalDevicePx: number, markStrokeDevicePx: number): number;

package/dist/components/fourier-field/renderer/uniforms.d.ts

@@ -0,0 +1,84 @@
+import { type OklchStop } from "../../../composables/color/index.js";
+import type { BasisComponent } from "../math.js";
+import type { MintedSpectrum } from "./mint.js";
+/** One phasor lane in the storage buffer: (re, im, index, _pad). */
+export declare const FOURIER_PHASOR_BYTES = 16;
+export interface FourierUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createFourierComputeScratch(): FourierUniformScratch;
+export declare function packFourierComputeUniforms(scratch: FourierUniformScratch, headT: number, trailArc: number, harmonicN: number, sampleCount: number, termCount: number): FourierUniformScratch;
+export declare function createFourierRenderScratch(): FourierUniformScratch;
+/** The model→clip fit transform — computed once per spectrum, never per N edit. */
+export interface FourierFit {
+    centerX: number;
+    centerY: number;
+    /** The uniform scale s mapping (model − center)·s into clip [-1,1] with margin. */
+    scale: number;
+}
+/**
+ * The view fit, read straight off the mint. It unions the curve's own bbox with the
+ * chain's reach when the machine shows, because a chain that leaves the stage is a
+ * machine you cannot check. It is FIXED under N: the mint is the only input, so an N edit
+ * never rescales the figure and the "N=1 is genuinely this big" claim stays true.
+ */
+export declare function computeFourierFit(minted: MintedSpectrum, showMachine: boolean): FourierFit;
+/**
+ * Convert a CSS-px stroke to MODEL units. The fit maps model → clip; clip spans [-1,1]
+ * over the min CSS dimension, so cssPx-per-clip is `canvasCssMin/2`.
+ */
+export declare function strokeToModel(strokePx: number, scale: number, canvasCssMin: number): number;
+/**
+ * The resolved ramp: a linear-sRGB LUT plus the two derived pigments the paint law names.
+ * Rebuilt only when the palette itself changes.
+ */
+export interface FourierRamp {
+    /** `FOURIER_LUT_SIZE` linear-sRGB entries, index 0 the ramp head. */
+    readonly lut: Float32Array;
+    /** The ink: the ramp head one step DOWN in L, gamut-mapped at fixed L and hue. */
+    readonly ink: [number, number, number];
+    /** The head core: the ramp head lifted by half a step, chroma preserved. */
+    readonly head: [number, number, number];
+}
+/**
+ * Resolve a palette into the shipped ramp. Chroma is floored at every entry — a ramp that
+ * falls to grey paints a smear where the tail should still be pigment — and every entry
+ * is gamut-mapped, so an out-of-gamut author stop becomes a real colour rather than a
+ * clipped one.
+ */
+export declare function resolveFourierRamp(palette: readonly OklchStop[]): FourierRamp;
+export interface FourierRenderPack {
+    fit: FourierFit;
+    aspect: number;
+    markHalfModel: number;
+    inkOffsetStrokes: number;
+    scaffoldFrac: number;
+    edgeMargin: number;
+    peakAlpha: number;
+    glow: number;
+    squash: number;
+    trailFadeExp: number;
+    trailFloor: number;
+    hueSweep: number;
+    ringStrokeModel: number;
+    showMachine: boolean;
+    rainbowChain: boolean;
+    sampleCount: number;
+    /** The number of chain arms this frame draws — the hue sweep's denominator. */
+    chainCount: number;
+    ramp: FourierRamp;
+}
+/**
+ * Pack the render uniforms in place. `peakAlpha` arrives already multiplied by the
+ * intensity envelope and CLAMPED here — the one place loudness can leave the legal range,
+ * closed at pack time so no fragment can composite past 1.
+ */
+export declare function packFourierRenderUniforms(scratch: FourierUniformScratch, p: FourierRenderPack): FourierUniformScratch;
+/**
+ * Pack the phasor storage table (re, im, index, _pad) from the minted spectrum. The
+ * buffer is sized per-spectrum by the caller — there is no table ceiling, so a 61-term ℱ
+ * and a 2-term foil each pay for exactly what they carry.
+ */
+export declare function packPhasorTable(terms: readonly BasisComponent[]): Float32Array;

package/dist/components/fourier-field/renderer/wgpu.d.ts

@@ -0,0 +1,28 @@
+import type { WebGPUCanvasFrame } from "../../../composables/glass/webgpu/useWebGPUCanvas.js";
+import type { WebGLCanvasFrame } from "../../../composables/glass/webgl/useWebGLCanvas.js";
+import type { OklchStop } from "../../../composables/color/index.js";
+import { type FourierFieldConfig } from "../constants.js";
+import type { MintedSpectrum } from "./mint.js";
+export interface FourierRendererDeps {
+    canvas: HTMLCanvasElement;
+    config: FourierFieldConfig;
+    /** The minted spectrum — re-read each frame; identity change triggers the re-upload. */
+    getSpectrum: () => MintedSpectrum;
+    /** The resolved palette stops, re-read each frame so a live edit reaches the ramp. */
+    getPalette: () => OklchStop[];
+    /** The single loop parameter `head_t ∈ [0,1)`. */
+    getHeadT: () => number;
+    /** Demand-gate (the renderer's quiescence layer). */
+    shouldContinue: () => boolean;
+    /** The per-frame hook — the clock advances here, inside the substrate's own frame. */
+    onFrame?: (timeSec: number) => void;
+}
+/** Build the fourier-field `setupWGPU(device, context, format)` callback. */
+export declare function createFourierWGPUSetup(deps: FourierRendererDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;
+/**
+ * The WebGL2 seam, declared closed. The substrate picker requires a `setupGL`; this one
+ * acquires nothing and draws nothing — it throws the sentence above, which the picker
+ * surfaces as a renderer error. The result is exactly what the law asks for: no second
+ * renderer, zero canvas pixels, and a status a consumer can read and show.
+ */
+export declare function createFourierUnsupportedSetup(): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

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

@@ -0,0 +1 @@
+export declare const FOURIER_FIELD_COMPUTE_WGSL = "\nconst TAU: f32 = 6.283185307179586;\n\nstruct Phasor {\n  // (re, im, index, _pad)\n  data: vec4<f32>,\n};\n\nstruct ComputeUniforms {\n  // c0: (headT, trailArc, _pad, _pad)\n  c0: vec4<f32>,\n  // ints: (harmonicN, sampleCount, termCount, _pad)\n  ints: vec4<i32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ComputeUniforms;\n@group(0) @binding(1) var<storage, read> phasors: array<Phasor>;\n// curveSamples[i] = (x, y, age, _pad) in MODEL space\n@group(0) @binding(2) var<storage, read_write> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) in MODEL space\n@group(0) @binding(3) var<storage, read_write> chainTips: array<vec4<f32>>;\n\n// The truncated inverse DFT at parameter t over the first n terms \u2014 the transcription of\n// math.ts partialSumAt:  c += vec2(re*cos - im*sin, re*sin + im*cos), angle = TAU*index*t.\nfn partialSumAt(t: f32, n: i32) -> vec2<f32> {\n  var c = vec2<f32>(0.0, 0.0);\n  let lim = min(n, i32(arrayLength(&phasors)));\n  for (var i = 0; i < lim; i = i + 1) {\n    let p = phasors[i].data;\n    let angle = TAU * p.z * t;\n    let cs = cos(angle);\n    let sn = sin(angle);\n    c = c + vec2<f32>(p.x * cs - p.y * sn, p.x * sn + p.y * cs);\n  }\n  return c;\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let i = i32(gid.x);\n  let headT = u.c0.x;\n  let trailArc = u.c0.y;\n  let harmonicN = u.ints.x;\n  let sampleCount = u.ints.y;\n\n  // \u2500\u2500 The comet body \u2500\u2500\n  if (i < sampleCount) {\n    let denom = max(f32(sampleCount - 1), 1.0);\n    let frac = f32(i) / denom;                  // 0 = head, 1 = tail\n    let age = 1.0 - frac;                       // 1 = head, 0 = tail\n    var t = headT - trailArc * frac;\n    t = t - floor(t);                           // fract -> [0,1)\n    let pt = partialSumAt(t, harmonicN);\n    curveSamples[i] = vec4<f32>(pt.x, pt.y, age, 0.0);\n  }\n\n  // \u2500\u2500 The chain tips (k = 0..N). chainTips[0] is the origin. \u2500\u2500\n  if (i <= harmonicN && i < i32(arrayLength(&chainTips))) {\n    let tip = partialSumAt(headT, i);\n    chainTips[i] = vec4<f32>(tip.x, tip.y, 0.0, 0.0);\n  }\n}\n";