@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/components/custom/dot-matrix/composables/dotMatrixField.d.ts

@@ -0,0 +1,89 @@
+/** A 3-vector. */
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** A row-major 3×3 matrix (the spin matrix the WGSL transcribes column-for-column). */
+export type Mat3 = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/** The depth-fade result — the per-dot opacity + size multipliers. */
+export interface FacingFade {
+    /** The camera-facing opacity multiplier ∈ [facingLo, facingLo+facingHi]. */
+    opacity: number;
+    /** The depth-of-field size taper ∈ [0.6, 1.0]. */
+    size: number;
+    /** The raw facing term ∈ [0,1] (1 = dead-front, 0 = dead-back). */
+    facing: number;
+}
+/** The golden ratio φ = (1+√5)/2 ≈ 1.6180339887. */
+export declare const GOLDEN_RATIO: number;
+/** The golden angle = 2π/φ = π·(3−√5) ≈ 2.39996 rad ≈ 137.508° (the irrational azimuth). */
+export declare const GOLDEN_ANGLE: number;
+/**
+ * The Fibonacci-phyllotaxis position for dot `i` of `N` on the UNIT sphere — the
+ * area-centered half-offset variant (admits ANY `N`, the cheaper no-`acos` `y = cos(polar)`
+ * form). The WGSL `instance_index → unit position` mapping transcribes this EXACTLY (the
+ * F3 round-trip anchor):
+ *
+ *   y     = 1 − 2·(i + 0.5) / N      // y ∈ (−1,1), the cos(polar) — even by AREA
+ *   r     = sqrt(1 − y²)             // ring radius at that latitude
+ *   theta = i · goldenAngle          // the golden-angle azimuth spiral
+ *   pos   = (cos(theta)·r, y, sin(theta)·r)
+ *
+ * This beats lat-long (`theta = 2πi/cols, phi = πj/rows`, which clusters at the poles →
+ * banded rings) because the irrational golden ratio gives near-equal AREA with no
+ * resonance gaps (extremelearning.com.au; arXiv 0912.4540).
+ */
+export declare function fibonacciDot(i: number, n: number): Vec3;
+/** The opacity floor (a dead-back dot stays a faint shell point, never fully gone). */
+export declare const FACING_LO = 0.15;
+/** The opacity facing-gain (dead-front lifts to facingLo + facingHi). */
+export declare const FACING_HI = 0.85;
+/** The size depth-of-field taper base (a dead-back dot is 0.6× the dead-front size). */
+export declare const SIZE_TAPER_BASE = 0.6;
+/** The size depth-of-field taper gain. */
+export declare const SIZE_TAPER_GAIN = 0.4;
+/**
+ * The §T2 depth-fade — the part that makes the dot field READ as a sphere. After the spin,
+ * modulate per-dot opacity + size by the rotated-normal's camera-facing-ness (a SOFT
+ * falloff, NOT a binary back-face cull — the soft fade is what reads as a translucent
+ * shell vs a flat disc). For a sphere centered at origin the surface normal IS the
+ * normalized dot position, so the facing term is the rotated-normal's z:
+ *
+ *   facing  = clamp(n.z · 0.5 + 0.5, 0, 1)            // 1 = dead-front, 0 = dead-back
+ *   opacity = facingLo + facingHi · facing            // 0.15 + 0.85·facing
+ *   size    = 0.6 + 0.4 · facing                      // the DOF dot-size taper
+ *
+ * `depthFade` ∈ [0,1] scales the facing GAIN (depthFade=1 → the full 0.85 shell read;
+ * depthFade=0 → flat uniform opacity, the no-shell degenerate the gate's clause-6 flat-
+ * uniform bite catches).
+ */
+export declare function facingFade(normal: Vec3, depthFade?: number): FacingFade;
+/**
+ * The spin matrix at time `t` — a slow Y-rotation about a gently TILTED axis (a tilted
+ * globe reads more alive than a dead-vertical spin). The axis is the Y-axis tilted by
+ * `axisTilt` (radians) toward +x; the rotation angle is `rate · t`. Returns a row-major
+ * mat3 the WGSL transcribes column-for-column (mat3x3 is column-major → the transpose is
+ * written as the SAME columns). A fixed `renderAt(t)` drives it deterministically for the
+ * π capture (the spin reads at the same `t` on every host).
+ */
+export declare function spinMatrix(t: number, axisTilt: number, rate: number): Mat3;
+/** Apply a row-major mat3 to a Vec3 (the rotated surface normal `n = spin · unitPos`). */
+export declare function applyMat3(m: Mat3, v: Vec3): Vec3;
+/**
+ * The breathing radius scalar at time `t` — a gentle `R·(1 + breathDepth·sin(t·breathRate))`
+ * pulse, the calmest non-dead register (`breathDepth ≈ 0.02`, far below the dot-flow sweep).
+ * Returns the multiplier on the base radius (1 at rest when `depth=0`). The WGSL transcribes
+ * the SAME `1 + depth·sin(t·rate)` form.
+ */
+export declare function breathRadius(t: number, depth: number, rate: number): number;

package/dist/components/custom/dot-matrix/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,61 @@
+import type { OklchStop } from "../../../../composables/color";
+import { type DotMatrixConfig } from "../constants";
+/** The byte size of one dot in the instance buffer (vec4<f32> = unitPos.xyz + sphereIdx). */
+export declare const DOT_BYTES = 16;
+/** The per-sphere offset of the SECOND globe (the reference two-globe composition). */
+export declare const SPHERE2_OFFSET: {
+    readonly x: 0.62;
+    readonly y: 0.32;
+};
+/** The per-sphere scale of the SECOND globe (a smaller satellite). */
+export declare const SPHERE2_SCALE = 0.46;
+/** The transient pointer state the interactive arm writes (closed over, never the config). */
+export interface DotPointerState {
+    /** Normalized-host pointer (0..1) → NDC offset; (0.5,0.5) is screen center. */
+    x: number;
+    y: number;
+    /** 1 while the pointer is over the host, 0 at rest (decays the parallax/dimple). */
+    active: number;
+    /** The repel/attract sign × strength (the dimple direction · velocity scale). */
+    push: number;
+    /** The accel-burst brightness/scale bloom 0..1 (the flick term). */
+    bloom: number;
+    /**
+     * The travel VELOCITY (normalized-host units/sec, the shared field's already-computed
+     * `pointer.velocity` — the dead-lever reclaim). Drives the anisotropic squash/stretch +
+     * the comet-tail wake direction. Mapped to NDC/frame deltas in the shader.
+     */
+    velX: number;
+    velY: number;
+    /** The flick-take ACCEL magnitude (`hypot(pointer.acceleration)`, also unused today). */
+    accelMag: number;
+}
+/** A fresh resting pointer state. */
+export declare function restingPointer(): DotPointerState;
+export declare const DOT_RENDER_UNIFORM_BYTES: number;
+export interface DotUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createDotRenderScratch(): DotUniformScratch;
+/**
+ * Build the STATIC Fibonacci-phyllotaxis instance buffer — `dotCount` dots per sphere,
+ * each `(unitPos.xyz, sphereIdx)`. The second sphere's dots are CONCATENATED with
+ * `sphereIdx = 1` so the shader resolves the per-sphere offset/scale. Built ONCE (the
+ * layout is time-invariant; the spin + depth-fade are per-frame). The WGSL
+ * `instance_index → unit position` mapping reads this buffer (it does NOT re-derive the
+ * phyllotaxis on the GPU — the JS+GPU agree by construction).
+ */
+export declare function buildDotsBuffer(config: DotMatrixConfig): Float32Array;
+/** The total dot instance count for a config (per-sphere × spheres; plane is single). */
+export declare function dotInstanceCount(config: DotMatrixConfig): number;
+/**
+ * Pack the per-frame render uniforms in place. `timeSec` drives the spin matrix + the
+ * breathing; `pointer` carries the interactive parallax/dimple/bloom; `palette` is the
+ * live ColorResolver stops (re-read each frame so a studio edit reaches the buffer).
+ */
+export declare function packDotRenderUniforms(scratch: DotUniformScratch, config: DotMatrixConfig, timeSec: number, resolutionPx: {
+    w: number;
+    h: number;
+}, dpr: number, pointer: DotPointerState, breathRadius: number, palette: OklchStop[]): DotUniformScratch;

package/dist/components/custom/dot-matrix/composables/useDotMatrix.d.ts

@@ -0,0 +1,34 @@
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
+import type { OklchStop } from "../../../../composables/color";
+import type { DotMatrixConfig } from "../constants";
+export interface UseDotMatrixOptions {
+    config: DotMatrixConfig;
+    /** Resolve the dot-color palette as OKLCh (the demo themes it; default warm-identity). */
+    getPalette: () => OklchStop[];
+    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
+    mode?: "live" | "capture";
+}
+/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
+export interface DotMatrixHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 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 (a pointer/setter that re-introduced motion). */
+    wake: () => void;
+    /** Draw one frame out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** Tear down the renderer + release GPU/GL resources. */
+    dispose: () => void;
+}
+/**
+ * Mount the dot-matrix renderer on `canvasRef`. The WebGPU primary runs the instanced-
+ * billboard render pass over the static phyllotaxis dots buffer; the WebGL2 fallback draws
+ * the SAME instanced billboards (the ONE math source). Returns the uniform lifecycle handle.
+ */
+export declare function useDotMatrix(canvasRef: Ref<HTMLCanvasElement | null>, options: UseDotMatrixOptions): DotMatrixHandle;

package/dist/components/custom/dot-matrix/composables/useDotSphere.d.ts

@@ -0,0 +1,34 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { OklchStop } from "../../../../composables/color";
+import { type DotMatrixConfig } from "../constants";
+import { restingPointer, type DotPointerState } from "./uniformBridgeWGPU";
+export interface DotSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: DotMatrixConfig;
+    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame. */
+    getPalette: () => OklchStop[];
+    /** The live transient pointer state (the interactive parallax/dimple/bloom). */
+    pointer: DotPointerState;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /** The per-frame pointer hook — advances the shared field (the no-own-rAF discipline). */
+    onFrame?: (timeSec: number) => void;
+    /**
+     * The live `prefers-reduced-motion` state (read lazily — the handle resolves AFTER the
+     * setup closure is built). When true the frame PINS uTime to a fixed √φ rung so the spin
+     * AND the per-dot twinkle `sin` are bit-identical across runs (the deterministic static
+     * frame — G9). Capture mode is already deterministic via `renderAt(fixedT)`.
+     */
+    getReducedMotion?: () => boolean;
+}
+/** Build the dot-matrix `setupWGPU(device, context, format)` callback. */
+export declare function createDotWGPUSetup(deps: DotSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;
+/**
+ * Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes — the SAME
+ * instanced billboards via `gl.drawArraysInstanced`. It seeds the SAME JS phyllotaxis dot
+ * buffer the WGSL primary uses + splices the SHARED GLSL color chunk (the ONE color source
+ * → no drift between backends). No Canvas2D anywhere (§E).
+ */
+export declare function createDotGLSetup(deps: DotSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;
+export { restingPointer };

package/dist/components/custom/dot-matrix/constants.d.ts

@@ -0,0 +1,72 @@
+import type { OklchStop } from "../../../composables/color";
+/** Compile-time dot cap — mirrors the WGSL/GLSL instance-buffer array bound. */
+export declare const MAX_DOTS = 4000;
+/** Compile-time palette cap — mirrors the WGSL `MAX_DOT_STOPS` #define. */
+export declare const MAX_DOT_STOPS = 4;
+/** Pointer interaction mode — a repel pushes dots off the surface, attract pulls them in. */
+export type DotPointerMode = "repel" | "attract";
+/** The dot layout register — a 3D phyllotaxis SPHERE (kept) or a flat 2D background PLANE. */
+export type DotLayout = "sphere" | "plane";
+/**
+ * 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.
+ * A NEW schema (no prior `dot-matrix`, no MIGRATION row).
+ */
+export interface DotMatrixConfig {
+    /** Dot count on the sphere surface (500–MAX_DOTS; the reference's fine field). */
+    dotCount: number;
+    /** Sphere radius as a fraction of the view min-dimension (0.2–0.9). */
+    radius: number;
+    /** Base dot billboard radius in px @ 1× (DPR-aware → crisp). */
+    dotSize: number;
+    /** The subtle resting opacity (0–1). */
+    baseOpacity: number;
+    /** Depth-fade strength (0–1; high = strong translucent-shell read). */
+    depthFade: number;
+    /** The slow dignified Y-spin in rad/s (0–0.3). */
+    rotationSpeed: number;
+    /** The rotation-axis tilt in degrees (a tilted globe reads more alive; ~23°). */
+    axisTilt: number;
+    /** The globe count (1 default; the reference two-globe composition is 2). */
+    spheres: 1 | 2;
+    /** The sub-perceptual breathing radius-pulse depth (0 default; demo 0.02). */
+    breathing: number;
+    /** The dot-color ramp (the demo themes it mono-white); resolved via the ColorResolver. */
+    palette: OklchStop[];
+    /** The ground color (the demo sets near-black; default transparent). */
+    background: OklchStop | "transparent";
+    /** The layout register — 3D sphere (kept preset) or a flat 2D background plane (the default). */
+    layout: DotLayout;
+    /** Pointer parallax + repel + accel-burst (the §T7 interaction). */
+    interactive: boolean;
+    /** repel ↔ attract (the dimple direction). */
+    pointerMode: DotPointerMode;
+    /** The pointer-parallax depth (0–0.3; the screen-center tracks the cursor). */
+    parallax: number;
+    /** The cursor-gravity well depth — how far a near dot is pulled toward the cursor (NDC). */
+    gravityStrength: number;
+    /** The cursor-gravity well radius — the falloff width (NDC; WIDE → many dots feel it). */
+    gravityRadius: number;
+    /**
+     * The resting per-dot TWINKLE rate (the living-constellation floor): each dot's opacity
+     * breathes on an `instance_index`-hashed phase at this rate (0 = a dead-still field; the
+     * demo lifts it). Frozen under PRM (the `sin` reads the pinned capture time).
+     */
+    twinkle: number;
+    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    respectReducedMotion: boolean;
+}
+/**
+ * The warm-cream identity palette (the library default — NOT teal). A two-stop warm-amber
+ * ramp over the warm-cream foreground family, mirroring the dot-flow `WARM_IDENTITY_PALETTE`.
+ * A consumer (the demo) themes it mono-warm-white-on-near-black through a PRESET, never a
+ * token edit.
+ */
+export declare const WARM_IDENTITY_PALETTE: OklchStop[];
+/**
+ * The shipped warm-identity default config — the §T5 SUBTLE + CALM register: ONE calm
+ * warm-cream globe of fine dots on a transparent ground (the glass card shows through),
+ * slowly rotating on a tilted axis. The depth-fade carries the sphere read; the second
+ * sphere + the breathing + the near-black ground are DEMO presets (presets-in-consumers).
+ */
+export declare const DEFAULT_DOT_MATRIX_CONFIG: DotMatrixConfig;

package/dist/components/custom/dot-matrix/index.d.ts

@@ -0,0 +1,5 @@
+export { default as DotMatrix } from "./DotMatrix.vue";
+export { useDotMatrix, type DotMatrixHandle, type UseDotMatrixOptions, } from "./composables/useDotMatrix";
+export { type DotMatrixConfig, type DotPointerMode, type DotLayout, DEFAULT_DOT_MATRIX_CONFIG, WARM_IDENTITY_PALETTE, MAX_DOTS, MAX_DOT_STOPS, } from "./constants";
+export { type Vec3, type Mat3, type FacingFade, fibonacciDot, facingFade, spinMatrix, applyMat3, breathRadius, GOLDEN_RATIO, GOLDEN_ANGLE, FACING_LO, FACING_HI, SIZE_TAPER_BASE, SIZE_TAPER_GAIN, } from "./composables/dotMatrixField";
+export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/dot-matrix/shaders/dot-matrix.glsl.d.ts

@@ -0,0 +1,4 @@
+/** The instanced-billboard VERTEX shader (gl_VertexID quad + instanced dot attribute). */
+export declare const DOT_MATRIX_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_DOT_STOPS 4\n#define GOLDEN_ANGLE 2.399963229728653\n\n// \u2500\u2500 The \u221A\u03C6 proportion ladder (the liquid-lens constants; the line-for-line WGSL twin) \u2500\u2500\n#define PI_CONST 3.141592653589793\n#define TAU 6.283185307179586\n#define PHI 1.618033988749895\n#define SQRT_PHI 1.272019649514069\n#define INV_SQRT_PHI 0.7861513777574233\n#define INV_PHI2 0.3819660112501051\n#define VEL_SCALE 0.18\n#define STRETCH_GAIN 2.4\n#define WAKE_GAIN 12.0\n#define LENS_MAGNIFY SQRT_PHI\n#define RIM_CHROMA 1.0\n#define VIGNETTE_FLOOR INV_PHI2\n#define CAST_OFFSET 0.9\n#define CAST_DARK 0.0\n#define CAST_ALPHA 0.55\n\n// The static quad corner (6 verts: two triangles) + the instanced per-dot data. The draw is\n// 12 verts/instance: gl_VertexID 0..5 the lit dot, 6..11 the cartoon offset-CAST shadow (the\n// SAME instanced draw, zero new buffer). The corner is re-derived from gl_VertexID % 6.\nin vec4 aDot;             // (unitPos.xyz, sphereIdx) \u2014 instanced (divisor 1)\n\nuniform vec4 uU0;         // (resX, resY, dpr, time)\nuniform vec4 uU1;         // (radius, dotSize, baseOpacity, aspect)\nuniform vec4 uU2;         // (facingLo, facingHi, sizeLo, sizeHi)\nuniform vec4 uU3;         // (parallax, pointerPush, pointerBloom, pointerActive)\nuniform vec4 uU4;         // (pointerX, pointerY, sphere2Scale, breathRadius)\nuniform vec4 uU5;         // (sphere2OffsetX, sphere2OffsetY, hasBackground, _pad)\nuniform vec4 uU6;         // (layout, gravityStrength, gravityRadius, planeScale)\nuniform vec4 uU7;         // (velX, velY, twinkleRate, wakeStrength)\nuniform mat3 uSpin;       // the slow tilted Y-rotation\n\nout vec2 vLocal;          // [-1,1] billboard-local for the SDF circle\nout float vBright;        // facing-driven brightness\nout float vAlpha;         // facing-driven opacity\nout float vTone;          // palette tone (0 = bright cream near-front, 1 = amber rim)\nout float vCast;          // 1 = the cartoon offset-cast shadow billboard, 0 = the lit dot\n\nfloat facingTerm(vec3 n) {\n  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front\n}\n\nvoid main() {\n  // The two-triangle quad corners (6 verts), re-derived per gl_VertexID (no aCorner buffer).\n  vec2 cornerLUT[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0, 1.0), vec2(1.0, -1.0), vec2(1.0, 1.0)\n  );\n  bool isCast = gl_VertexID >= 6;\n  vec2 aCorner = cornerLUT[gl_VertexID % 6];\n\n  vec3 unitPos = aDot.xyz;\n  float sphereIdx = aDot.w;\n\n  float breath = uU4.w;\n  float pAct = uU3.w;\n  vec2 pointerNdc = vec2(uU4.x * 2.0 - 1.0, 1.0 - uU4.y * 2.0);\n  bool isPlane = uU6.x > 0.5;\n  float gravStrength = uU6.y;\n  float gravRadius = max(uU6.z, 1e-3);\n  float planeScale = uU6.w;\n  // The reclaimed travel velocity \u2192 the lens-frame vector (host +y is DOWN \u2192 flip to NDC +up).\n  vec2 velRaw = vec2(uU7.x, -uU7.y);\n  float vmag = length(velRaw) * VEL_SCALE;\n  vec2 vdir = length(velRaw) > 1e-5 ? velRaw / max(length(velRaw), 1e-5) : vec2(0.0);\n  float wake = uU7.w;       // the spring-engaged active (\u03B6=0.7) \u2192 the wake LAGS + overshoots\n  float twkRate = uU7.z;\n  // The per-dot twinkle phase \u2014 an on-GPU instance hash (no new buffer); uTime pinned under PRM.\n  float twkPhase = fract(sin(float(gl_InstanceID) * 12.9898) * 43758.5453) * TAU;\n  float twk = twkRate * sin(uU0.w * (twkRate + 0.6) + twkPhase);\n\n  vec2 center2d;\n  float facing;\n  float sizeTaper;\n  float burstScale;\n  float facingOpacity;\n  float burstBright;\n  float castLobe = 0.0;\n\n  if (isPlane) {\n    // \u2500\u2500 The 2D-PLANE register \u2192 the DIRECTIONAL LIQUID LENS \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    vec2 base2d = unitPos.xy * planeScale;\n\n    // 1. ANTICIPATION \u2014 the lens LEADS its math-center along travel.\n    vec2 wellC = pointerNdc + vdir * wake * (gravRadius * INV_PHI2 * 0.4);\n    vec2 toLens = wellC - base2d;\n\n    // 2. SQUASH / STRETCH \u2014 measure distance in a frame STRETCHED along travel.\n    float along = dot(toLens, vdir);\n    float perp = dot(toLens, vec2(-vdir.y, vdir.x));\n    float stretch = 1.0 + clamp(vmag * STRETCH_GAIN, 0.0, INV_SQRT_PHI);\n    float dE = length(vec2(along / stretch, perp * stretch));\n    float well = gravStrength * exp(-(dE * dE) / (2.0 * gravRadius * gravRadius)) * pAct;\n    vec2 lift = toLens * well;\n\n    // 3. COMET-TAIL WAKE \u2014 a pull streamed BEHIND the lens (follow-through).\n    float behind = max(0.0, -along);\n    float tail = wake * exp(-(behind * behind) / (gravRadius * gravRadius)) * vmag * WAKE_GAIN;\n    lift -= vdir * tail * gravRadius;\n    vec2 burstPull = toLens * (uU3.z * 0.4 * exp(-(dE * dE) / (gravRadius * gravRadius))) * pAct;\n    center2d = base2d + lift + burstPull;\n\n    // 4. LENS OPTICS \u2014 magnify + brightness + the chromatic rim.\n    float nearness = exp(-(dE * dE) / (2.0 * gravRadius * gravRadius));\n    facing = nearness;\n    sizeTaper = 0.8 + LENS_MAGNIFY * nearness * pAct;\n    burstScale = 1.0 + uU3.z * 0.6 * nearness;\n    float wakeGlow = behind * vmag * 1.4 * pAct;\n    // 5. CONTENT-DEFERENTIAL VIGNETTE \u2014 dense edges, clear center; the lens re-densifies it.\n    float presence = mix(VIGNETTE_FLOOR, 1.0, smoothstep(0.0, 1.0, length(base2d) / max(planeScale, 1e-3)));\n    presence = max(presence, nearness * pAct);\n    facingOpacity = (uU2.x + uU2.y * (0.5 + twk + 0.6 * nearness * pAct)) * presence;\n    burstBright = 1.0 + (0.5 * nearness + wakeGlow + uU3.z * 0.8 * nearness) * pAct;\n    castLobe = nearness * pAct;\n  } else {\n    // \u2500\u2500 The 3D-SPHERE register \u2192 the SAME directional lens (one warp idiom) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    float sphereScale = uU1.x;\n    vec2 sphereOffset = vec2(0.0);\n    if (sphereIdx > 0.5) {\n      sphereScale = uU1.x * uU4.z;\n      sphereOffset = vec2(uU5.x, uU5.y);\n    }\n    vec3 n = uSpin * unitPos;\n    facing = facingTerm(n);\n    vec2 screenN = n.xy * sphereScale + sphereOffset;\n    vec2 toLensS = pointerNdc - screenN;\n    float alongS = dot(toLensS, vdir);\n    float perpS = dot(toLensS, vec2(-vdir.y, vdir.x));\n    float stretchS = 1.0 + clamp(vmag * STRETCH_GAIN, 0.0, INV_SQRT_PHI);\n    float dES = length(vec2(alongS / stretchS, perpS * stretchS));\n    float pd = dES;\n    float well = exp(-(dES * dES) / (2.0 * gravRadius * gravRadius)) * gravStrength * uU3.y * pAct * facing;\n    vec2 lift = -toLensS * well;\n    float behindS = max(0.0, -alongS);\n    float tailS = wake * exp(-(behindS * behindS) / (gravRadius * gravRadius)) * vmag * WAKE_GAIN * facing;\n    lift -= vdir * tailS * gravRadius * sign(uU3.y);\n    vec2 parallaxOff = pointerNdc * uU3.x * pAct;\n    center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;\n    float nearnessS = exp(-(dES * dES) / (2.0 * gravRadius * gravRadius)) * facing;\n    sizeTaper = uU2.z + uU2.w * facing + LENS_MAGNIFY * 0.4 * nearnessS * pAct;\n    burstScale = 1.0 + uU3.z * exp(-(dES * dES) / (gravRadius * gravRadius));\n    float wakeGlowS = behindS * vmag * 1.0 * pAct * facing;\n    facingOpacity = uU2.x + uU2.y * facing + uU2.y * twk * facing;\n    burstBright = 1.0 + (uU3.z * 0.8 * exp(-(dES * dES) / (gravRadius * gravRadius)) + wakeGlowS) * pAct;\n    castLobe = nearnessS * pAct;\n  }\n\n  float dotR = uU1.y * sizeTaper * burstScale;\n  float offX = aCorner.x * dotR;\n  float offY = aCorner.y * dotR;\n\n  // THE CARTOON OFFSET-CAST \u2014 verts 6..11 are a dark, lower-\u03B1 duplicate offset along a \u221A\u03C6\n  // light vector (down-right), gated by castLobe so the lobe appears only under the lens.\n  vec2 lightVec = normalize(vec2(SQRT_PHI, -1.0)) * CAST_OFFSET * dotR;\n  vec2 castShift = isCast ? lightVec : vec2(0.0);\n  float castStrength = isCast ? smoothstep(0.05, 0.5, castLobe) : 1.0;\n\n  vLocal = aCorner;\n  vCast = isCast ? 1.0 : 0.0;\n  if (isCast) {\n    vBright = CAST_DARK;\n    vAlpha = clamp(uU1.z * CAST_ALPHA * facingOpacity * castStrength, 0.0, 1.0);\n    vTone = 1.0;\n  } else {\n    vBright = facingOpacity * burstBright;\n    vAlpha = clamp(uU1.z * facingOpacity * burstBright, 0.0, 1.0);\n    // The chromatic RIM refraction (REPLACES the old depth-only 1.0-facing tone \u2014 EXCISED).\n    float rim = smoothstep(0.25, 0.6, 1.0 - facing) * RIM_CHROMA;\n    vTone = clamp(max(1.0 - facing, rim * facing), 0.0, 1.0);\n  }\n\n  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the\n  // final clip-space x divides by aspect so a wide canvas does not squash it into an ellipse.\n  float aspect = max(uU1.w, 1e-4);\n  gl_Position = vec4((center2d.x + offX + castShift.x) / aspect, center2d.y + offY + castShift.y, 0.0, 1.0);\n}";
+/** The crisp fwidth-SDF dot fragment (the ONE AA canon; splices the shared color chunk). */
+export declare const DOT_MATRIX_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_DOT_STOPS 4\n\nin vec2 vLocal;\nin float vBright;\nin float vAlpha;\nin float vTone;\nin float vCast;\nout vec4 fragColor;\n\nuniform vec4 uBg;                       // (background.rgb, hasBackground)\nuniform int  uStopCount;\nuniform vec3 uPalette[MAX_DOT_STOPS];   // linear-sRGB stops\n\nconst mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);\n\n// PI in scope for the spliced OKLCH hue fns (the procedural-color chunk contract:\n// the consumer splices the matrices chunk + DEFINES PI FIRST \u2014 see\n// procedural-color.glsl.ts \u00A7\"PI being in scope\"). The dot SDF main() reads only the\n// OKLAB path, but the whole spliced chunk still compiles, so PI must be declared.\n#define PI 3.141592653589793\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\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 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];\n  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];\n  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvoid main() {\n  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon; ~1px band at any DPR).\n  float d = length(vLocal) - 1.0;\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage < 0.002) discard;\n  // The cartoon-cast billboard collapses to nothing away from the lens \u2014 drop the dead quads.\n  if (vCast > 0.5 && vAlpha < 0.003) discard;\n\n  vec3 lin = samplePaletteLin(vTone) * clamp(vBright, 0.0, 1.6);\n  float alpha = vAlpha * coverage;\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  fragColor = vec4(rgb * alpha, alpha);\n}";

package/dist/components/custom/dot-matrix/shaders/dot-matrix.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const DOT_MATRIX_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_DOT_STOPS: i32 = 4;\n// The golden-angle constant (transcribes dotMatrixField.ts GOLDEN_ANGLE = PI*(3-sqrt5)).\nconst GOLDEN_ANGLE: f32 = 2.399963229728653;\n\n// \u2500\u2500 The \u221A\u03C6 proportion ladder (the liquid-lens constants; Aristotelian, no magic numbers) \u2500\u2500\nconst PHI: f32 = 1.618033988749895;        // the golden ratio \u03C6\nconst SQRT_PHI: f32 = 1.272019649514069;   // \u221A\u03C6\nconst INV_SQRT_PHI: f32 = 0.7861513777574233;  // 1/\u221A\u03C6 \u2248 the squash/stretch cap\nconst INV_PHI2: f32 = 0.3819660112501051;  // 1/\u03C6\u00B2 \u2248 the anticipation-lead rung\n// The velocity (normalized-host/sec) \u2192 NDC/lens-frame scale: a sweep across the host reads as a\n// strong-but-bounded ellipse. The lens constants ladder off \u221A\u03C6 off this scaled vmag.\nconst VEL_SCALE: f32 = 0.18;\nconst STRETCH_GAIN: f32 = 2.4;             // vmag \u2192 ellipse eccentricity gain\nconst WAKE_GAIN: f32 = 12.0;               // the comet-tail displacement gain (spike-calibrated)\nconst LENS_MAGNIFY: f32 = SQRT_PHI;        // the dot SWELLS \u221A\u03C6\u00D7 under the lens core (over the 0.8 base)\nconst RIM_CHROMA: f32 = 1.0;               // the chromatic-rim tone gain (samples the warmer amber stop)\nconst VIGNETTE_FLOOR: f32 = INV_PHI2;      // the resting center-clear floor (dense edges, clear center)\n// The cartoon 1940s offset-cast: a darkened, lower-\u03B1, offset duplicate billboard (the SAME\n// instanced draw, verts 6..11). The light vector is a \u221A\u03C6-proportioned down-right cast.\nconst CAST_OFFSET: f32 = 0.9;              // the cast displacement (\u00D7 dot radius), down-right\nconst CAST_DARK: f32 = 0.0;               // the cast samples pure-dark (a shadow lobe, not a tint)\nconst CAST_ALPHA: f32 = 0.55;             // the cast's lower opacity (under the lit dot)\n\nstruct Dot {\n  // (unitPos.xyz, sphereIdx)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct Uniforms {\n  // u0: (uResolutionX, uResolutionY, uDpr, uTime)\n  u0: vec4<f32>,\n  // u1: (uRadius, uDotSize, uBaseOpacity, uAspect)\n  u1: vec4<f32>,\n  // u2: (uFacingLo, uFacingHi, uSizeLo, uSizeHi)\n  u2: vec4<f32>,\n  // u3: (uParallax, uPointerPush, uPointerBloom, uPointerActive)\n  u3: vec4<f32>,\n  // u4: (uPointerX, uPointerY, uSphere2Scale, uBreathRadius)\n  u4: vec4<f32>,\n  // u5: (uSphere2OffsetX, uSphere2OffsetY, uHasBackground, _pad)\n  u5: vec4<f32>,\n  // u6: (uLayout, uGravityStrength, uGravityRadius, uPlaneScale)  // layout: 0 sphere \u00B7 1 plane\n  u6: vec4<f32>,\n  // u7: (uVelX, uVelY, uTwinkleRate, uWakeStrength)  // the reclaimed travel-velocity lane\n  u7: vec4<f32>,\n  spin: mat3x3<f32>,\n  // ints: (uStopCount, uDotCount, uSpheres, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb, _pad)\n  bg: vec4<f32>,\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n@group(0) @binding(1) var<storage, read> dots: array<Dot>;\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// The \u00A7T2 depth-fade (transcribes dotMatrixField.ts facingFade): the rotated-normal's z\n// \u2192 a SOFT facing term \u2192 opacity + size ramps. NOT a binary back-face cull.\nfn facingTerm(n: vec3<f32>) -> f32 {\n  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front, 0 = dead-back\n}\n\n// A 2D dot product \u2014 the local 'let dot = dots[ii].data' SHADOWS the WGSL 'dot()' builtin\n// inside vs_main, so the lens math calls this helper instead (the same value, un-shadowed).\nfn dot2(a: vec2<f32>, b: vec2<f32>) -> f32 {\n  return a.x * b.x + a.y * b.y;\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.x;\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\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the SDF circle\n  @location(1) bright: f32,        // facing-driven brightness [0, ~1.6]\n  @location(2) alpha: f32,         // facing-driven opacity\n  @location(3) tone: f32,          // palette tone (0 = bright cream near-front, 1 = amber rim)\n  @location(4) cast: f32,          // 1 = the cartoon offset-cast shadow billboard, 0 = the lit dot\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vi: u32,\n  @builtin(instance_index) ii: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space (camera-facing by construction).\n  // 12 verts/instance: 0..5 the LIT dot, 6..11 the cartoon offset-CAST shadow duplicate (the\n  // SAME instanced draw, zero new buffer \u2014 the 1940s layered-offset cast as a binding precept).\n  var corners = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),\n  );\n  let isCast = vi >= 6u;\n  let local = corners[vi % 6u];\n\n  let dot = dots[ii].data;\n  var unitPos = dot.xyz;          // the STATIC phyllotaxis position (JS-computed)\n  let sphereIdx = dot.w;\n\n  let breath = u.u4.w;\n  let pAct = u.u3.w;\n  let pointerNdc = vec2<f32>(u.u4.x * 2.0 - 1.0, 1.0 - u.u4.y * 2.0);\n  let isPlane = u.u6.x > 0.5;\n  let gravStrength = u.u6.y;\n  let gravRadius = max(u.u6.z, 1e-3);\n  let planeScale = u.u6.w;\n  // The reclaimed travel velocity \u2192 the lens-frame vector (host +y is DOWN \u2192 flip to NDC +up).\n  let velRaw = vec2<f32>(u.u7.x, -u.u7.y);\n  let vmag = length(velRaw) * VEL_SCALE;\n  let vdir = select(vec2<f32>(0.0, 0.0), velRaw / max(length(velRaw), 1e-5), length(velRaw) > 1e-5);\n  let wake = u.u7.w;             // the spring-engaged active (\u03B6=0.7) \u2192 the wake LAGS + overshoots\n  let twkRate = u.u7.z;\n  // The per-dot twinkle phase \u2014 an on-GPU instance_index hash (no new buffer); the resting\n  // field becomes a LIVING warm constellation. uTime is pinned under PRM (deterministic capture).\n  let twkPhase = fract(sin(f32(ii) * 12.9898) * 43758.5453) * TAU;\n  let twk = twkRate * sin(u.u0.w * (twkRate + 0.6) + twkPhase);\n\n  var center2d: vec2<f32>;\n  var facing: f32;\n  var sizeTaper: f32;\n  var burstScale: f32;\n  var facingOpacity: f32;\n  var burstBright: f32;\n  var castLobe: f32 = 0.0;       // the cartoon-cast strength (nearness\u00B7pAct), set per-register\n\n  if (isPlane) {\n    // \u2500\u2500 The 2D-PLANE register \u2192 the DIRECTIONAL LIQUID LENS \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A heavy liquid-glass lens dragged across a taut warm membrane: it LEADS its travel,\n    // STRETCHES the gathered dots along the travel axis, drags an ember comet-tail WAKE behind,\n    // and MAGNIFIES+refracts the lattice beneath it. (Replaces the symmetric 'toCursor*well' \u2014\n    // clean break, no alias, no dual path; the reclaimed velocity makes the warp directional.)\n    let base2d = unitPos.xy * planeScale;\n\n    // 1. ANTICIPATION \u2014 the lens LEADS its math-center along travel (dots ahead feel it early).\n    let wellC = pointerNdc + vdir * wake * (gravRadius * INV_PHI2 * 0.4);\n    let toLens = wellC - base2d;\n\n    // 2. SQUASH / STRETCH \u2014 measure distance in a frame STRETCHED along travel (vol-preserving).\n    let along = dot2(toLens, vdir);\n    let perp = dot2(toLens, vec2<f32>(-vdir.y, vdir.x));\n    let stretch = 1.0 + clamp(vmag * STRETCH_GAIN, 0.0, INV_SQRT_PHI);\n    let dE = length(vec2<f32>(along / stretch, perp * stretch));\n    let well = gravStrength * exp(-(dE * dE) / (2.0 * gravRadius * gravRadius)) * pAct;\n    var lift = toLens * well;\n\n    // 3. COMET-TAIL WAKE \u2014 a pull streamed BEHIND the lens (overlapping action; follow-through).\n    let behind = max(0.0, -along);\n    let tail = wake * exp(-(behind * behind) / (gravRadius * gravRadius)) * vmag * WAKE_GAIN;\n    lift = lift - vdir * tail * gravRadius;\n    // The flick BURST over-extends the gather then the spring snaps it (the cartoon take).\n    let burstPull = toLens * (u.u3.z * 0.4 * exp(-(dE * dE) / (gravRadius * gravRadius))) * pAct;\n    center2d = base2d + lift + burstPull;\n\n    // 4. LENS OPTICS \u2014 the ellipse nearness drives magnify + brightness + the chromatic rim.\n    let nearness = exp(-(dE * dE) / (2.0 * gravRadius * gravRadius));\n    facing = nearness;\n    sizeTaper = 0.8 + LENS_MAGNIFY * nearness * pAct;        // the dot SWELLS (a lens magnifies)\n    burstScale = 1.0 + u.u3.z * 0.6 * nearness;\n    // the comet-tail also reads via LUMINANCE (trailing dots glow \u221D behind\u00B7vmag \u2014 the PRIMARY\n    // wake witness; the displacement alone is fragile, the spike proved).\n    let wakeGlow = behind * vmag * 1.4 * pAct;\n    // 5. CONTENT-DEFERENTIAL VIGNETTE \u2014 dense edges, clear center (the field FRAMES the content);\n    // the cursor-lens RE-DENSIFIES the center it enters (the calm-until-touched duality).\n    var presence = mix(VIGNETTE_FLOOR, 1.0, smoothstep(0.0, 1.0, length(base2d) / max(planeScale, 1e-3)));\n    presence = max(presence, nearness * pAct);\n    // the resting TWINKLE floor + the lens bloom; the vignette modulates the whole field.\n    facingOpacity = (u.u2.x + u.u2.y * (0.5 + twk + 0.6 * nearness * pAct)) * presence;\n    burstBright = 1.0 + (0.5 * nearness + wakeGlow + u.u3.z * 0.8 * nearness) * pAct;\n    castLobe = nearness * pAct;   // the cartoon offset-cast under the magnified lozenge\n  } else {\n    // \u2500\u2500 The 3D-SPHERE register (the KEPT preset \u2014 \"good\") \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    var sphereScale = u.u1.x;       // uRadius\n    var sphereOffset = vec2<f32>(0.0, 0.0);\n    if (sphereIdx > 0.5) {\n      sphereScale = u.u1.x * u.u4.z;             // uRadius * uSphere2Scale\n      sphereOffset = vec2<f32>(u.u5.x, u.u5.y);  // uSphere2Offset\n    }\n    let n = u.spin * unitPos;       // the rotated surface NORMAL (the \u00A7T2 facing source)\n    facing = facingTerm(n);\n    let screenN = n.xy * sphereScale + sphereOffset;\n    // The SAME screen-space DIRECTIONAL LENS as the plane (one warp idiom, both registers \u2014\n    // the dim-idiom, no second mechanism): the surface dots smear toward the cursor ALONG\n    // travel + carry a wake (a finger pressing a dot-globe through glass). Bounded by 'facing'\n    // so the near hemisphere leads + the silhouette can't tear.\n    let toLensS = pointerNdc - screenN;\n    let alongS = dot2(toLensS, vdir);\n    let perpS = dot2(toLensS, vec2<f32>(-vdir.y, vdir.x));\n    let stretchS = 1.0 + clamp(vmag * STRETCH_GAIN, 0.0, INV_SQRT_PHI);\n    let dES = length(vec2<f32>(alongS / stretchS, perpS * stretchS));\n    let pd = dES;\n    // A repel pushes OUT, an attract pulls IN (u.u3.y sign); facing bounds the near hemisphere.\n    let well = exp(-(dES * dES) / (2.0 * gravRadius * gravRadius)) * gravStrength * u.u3.y * pAct * facing;\n    var lift = -toLensS * well;     // toward (attract) / away (repel) per the u3.y sign baked above\n    // The comet-tail WAKE on the near hemisphere (streams behind the cursor along travel).\n    let behindS = max(0.0, -alongS);\n    let tailS = wake * exp(-(behindS * behindS) / (gravRadius * gravRadius)) * vmag * WAKE_GAIN * facing;\n    lift = lift - vdir * tailS * gravRadius * sign(u.u3.y);\n    let parallaxOff = pointerNdc * u.u3.x * pAct;\n    center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;\n    let nearnessS = exp(-(dES * dES) / (2.0 * gravRadius * gravRadius)) * facing;\n    sizeTaper = u.u2.z + u.u2.w * facing + LENS_MAGNIFY * 0.4 * nearnessS * pAct;  // the lens magnify\n    burstScale = 1.0 + u.u3.z * exp(-(dES * dES) / (gravRadius * gravRadius));\n    let wakeGlowS = behindS * vmag * 1.0 * pAct * facing;\n    facingOpacity = u.u2.x + u.u2.y * facing + u.u2.y * twk * facing;  // the twinkle rides the facing\n    burstBright = 1.0 + (u.u3.z * 0.8 * exp(-(dES * dES) / (gravRadius * gravRadius)) + wakeGlowS) * pAct;\n    castLobe = nearnessS * pAct;    // the cartoon offset-cast under the smeared near-hemisphere\n  }\n\n  let dotR = u.u1.y * sizeTaper * burstScale;            // uDotSize \u00B7 taper \u00B7 burst\n  let offX = local.x * dotR;\n  let offY = local.y * dotR;\n\n  // THE CARTOON OFFSET-CAST (the 1940s layered-offset shadow, a binding precept). Verts 6..11\n  // are a darkened, lower-\u03B1 duplicate billboard offset along a \u221A\u03C6 light vector (down-right),\n  // keyed off castLobe (nearness\u00B7pAct) so the shadow lobe appears ONLY under the magnified lens\n  // lozenge. When castLobe \u2248 0 the cast collapses to alpha 0 (the fragment discards it).\n  let lightVec = normalize(vec2<f32>(SQRT_PHI, -1.0)) * CAST_OFFSET * dotR;\n  let castShift = select(vec2<f32>(0.0, 0.0), lightVec, isCast);\n  let castStrength = select(1.0, smoothstep(0.05, 0.5, castLobe), isCast);\n\n  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the\n  // final clip-space x divides by aspect so a wide canvas does not squash it into an\n  // ellipse (aspect \u2265 1 \u2192 x shrinks; aspect < 1 \u2192 x grows). This keeps the dot quads round\n  // AND the sphere circular in PIXELS regardless of the canvas aspect.\n  let aspect = max(u.u1.w, 1e-4);\n  let clipX = (center2d.x + offX + castShift.x) / aspect;\n  let clipY = center2d.y + offY + castShift.y;\n\n  var out: VSOut;\n  out.pos = vec4<f32>(clipX, clipY, 0.0, 1.0);\n  out.local = local;\n  out.cast = select(0.0, 1.0, isCast);\n  if (isCast) {\n    // The cast is a dark shadow lobe \u2014 full dark tone, lower \u03B1, gated by the cast strength.\n    out.bright = CAST_DARK;\n    out.alpha = clamp(u.u1.z * CAST_ALPHA * facingOpacity * castStrength, 0.0, 1.0);\n    out.tone = 1.0;\n  } else {\n    out.bright = facingOpacity * burstBright;\n    out.alpha = clamp(u.u1.z * facingOpacity * burstBright, 0.0, 1.0);\n    // The chromatic RIM refraction (REPLACES the old depth-only '1.0 - facing' tone \u2014 EXCISED,\n    // no double-write, no legacy). At rest the tone reads the depth/edge; under the lens a faint\n    // RIM band glows the warmer-amber stop (tone \u2192 1), the iOS-27 glass chromatic refraction.\n    let rim = smoothstep(0.25, 0.6, 1.0 - facing) * RIM_CHROMA;\n    out.tone = clamp(max(1.0 - facing, rim * facing), 0.0, 1.0);\n  }\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon \u2014 the band is ~1px wide at\n  // any DPR/zoom, so fine sub-2px dots stay crisp). d = |uv| - 1; aa = fwidth(d).\n  let d = length(in.local) - 1.0;\n  let aa = max(fwidth(d), 1e-4);\n  let coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage < 0.002) { discard; }\n  // The cartoon-cast billboard collapses to nothing away from the lens \u2014 drop the dead quads.\n  if (in.cast > 0.5 && in.alpha < 0.003) { discard; }\n\n  // The palette tints the dot by DEPTH (near-front cream \u2192 rim amber); the brightness lights\n  // the core. The near hemisphere reads as the bright warm-cream stop, the rim/far fading to\n  // the darker amber \u2014 the translucent dot-shell on both grounds.\n  let lin = samplePaletteLin(in.tone) * clamp(in.bright, 0.0, 1.6);\n  let alpha = in.alpha * coverage;\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n  // Premultiplied-alpha output (the translucent dot-shell additive over the clear).\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/easing/EasingPicker.vue.d.ts

@@ -20,11 +20,11 @@ type __VLS_ModelProps = {
     modelValue?: EasingPickerValue;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_73: {
+declare var __VLS_78: {
     value: EasingPickerValue;
 };
 type __VLS_Slots = {} & {
-    footer?: (props: typeof __VLS_73) => any;
+    footer?: (props: typeof __VLS_78) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: EasingPickerValue | undefined) => any;

package/dist/components/custom/easing/composables/useEasingPicker.d.ts

@@ -47,6 +47,11 @@ export interface UseEasingPickerReturn {
     easingFn: ComputedRef<EasingFn>;
     /** The complete re-parseable readout literal for the active mode. */
     readout: ComputedRef<string>;
+    /** Whether the steps-mode readout round-trips through value.js `parseSteps`
+     *  back to the live (n, term) — the boundary-law proof that the painted
+     *  staircase IS a re-parseable value.js literal, not a hand-rolled string
+     *  the catalogue cannot read back. `true` in bezier mode (no steps literal). */
+    reparseOk: ComputedRef<boolean>;
     /** The full v-model payload (mode + css + fn + raw params). */
     value: ComputedRef<EasingPickerValue>;
     /** Two SVG-space handle coords `[{x,y},{x,y}]` (bezier mode). */

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -45,9 +45,20 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel: string;
     collapseLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    'expand-trigger'?: (props: {
+        expand: () => void;
+        label: string;
+    }) => any;
+} & {
     default?: (props: {
         fullscreen: boolean;
     }) => any;
+} & {
+    'fullscreen-chrome'?: (props: {
+        collapse: () => void;
+        label: string;
+        fullscreen: boolean;
+    }) => any;
 } & {
     default?: (props: {
         fullscreen: boolean;

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

@@ -1,61 +1,58 @@
-import type { ColorResolver } from "../../../composables/color";
+import type { ColorResolver, OklchStop } from "../../../composables/color";
+import { type BasisComponent } from "./math";
+import type { FourierFieldConfig } from "./constants";
 /**
- * FourierField — a Fourier epicycle field on a Canvas2D surface, a sibling
- * primitive to Aurora and GooBlob. A seeded elliptic spectrum reconstructs a
- * slow, never-ending closed curve via the inverse DFT; a fading comet trail
- * chases the curve's head, and (in the `hero` preset) the nested epicycle
- * circles and arms draw underneath in a harmonious second hue. It composes the
- * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
- * reduced-motion freeze for free — no hand-rolled RAF-park.
+ * FourierField — a Fourier epicycle field on the GPU substrate (BC.W-VIZ-FOURIER), 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 genuinely-absent-tail fallback (the §E "WebGPU everywhere"
+ * mandate — the Canvas2D renderer is RETIRED). It composes `useFourierField` → 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).
  *
- * Color resolves through the same INJECTED `colorResolver` seam as GooBlob: the
- * field paints the gamma-sRGB triple it returns. The prop is REQUIRED — pass
- * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` so a `var()` /
- * `light-dark()` token, an `oklch()` / `hsl()` / hex string all resolve. A
- * `var()` token is first resolved to a concrete `rgb()` against the host's
- * inherited color-scheme, then re-resolved on a color change AND on a dark-mode
- * toggle so the field retints with the theme.
+ * 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).
  *
- * `variant` is the configuration BUNDLE, not a recolour of one curve: `hero`
- * draws a few big phasors with the epicycles ON and a warm trail feel; `final`
- * draws a denser elliptic spectrum with the epicycles OFF. One engine, two
- * presets. The hue itself always comes from the consumer's `color`.
- *
- * BB.W-CARVE3 — the ~475-line renderer lives in `composables/useFourierField.ts`
- * (the colocation symmetry Aurora/`useAurora.ts`, GooBlob/`useMetaballRenderer.ts`
- * and Constellation/`useConstellation.ts` already carry). The SFC stays thin: the
- * props, the two template refs, and the single `useFourierField(props, …)` call.
+ * The `variant: "hero"|"final"` prop is RETIRED (BC.W-VIZ-FOURIER — the bundles fold into
+ * config presets, MIGRATION row). An ambient-background consumer passes `color` (+ the
+ * `colorResolver`) for a thin warm default preserving the recessive look; the studio passes
+ * the full `config` + `spectrum` + `getPalette`.
  */
 type __VLS_Props = {
-    /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. Default `hero`. */
-    variant?: "hero" | "final";
-    /** Base CSS color (any form the resolver understands; a `var()`/`light-dark()` token resolves against the host). */
-    color: string;
-    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
-    colorResolver: ColorResolver;
-    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    /** 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). When absent, `color`/`config.palette` is used. */
+    getPalette?: () => OklchStop[];
+    /** Ambient-consumer color seam — a `var()`/`light-dark()` token or a literal; derives a warm 2-stop 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;
-    /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). Default false. */
+    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
     freeze?: boolean;
-    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
-     *  resolved `peakAlpha`/`headGlowAlpha` at the PAINT layer (a per-LAYER
-     *  multiply, not a uniform CSS opacity). Default 1 (the bundle's resting
-     *  loudness); clamped [0, 2] — the field's ~2 upper bound lets a hero push
-     *  brighter than the recessed default without runaway. */
+    /** Outer loudness envelope (scales the per-layer alpha). When set, overrides `config.intensity`; clamped [0,2]. */
     intensity?: number;
-    /** OPTIONAL injected clock — a getter returning the loop parameter `t ∈ [0,1)`.
-     *  When BOUND, the render reads `clock()` (a controllable studio clock: pause,
-     *  scrub, speed); when ABSENT (the ambient face), the autonomous
-     *  `(now / durationMs) % 1` frame-time loop is the DEFAULT. `freeze` /
-     *  `prefers-reduced-motion` still short-circuit to `frozenT` regardless — the
-     *  ambient bundle is unchanged. The SOLE additive seam (BA.W-FOURIER-STUDIO). */
-    clock?: () => number;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    variant: "hero" | "final";
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    backend: () => import("../../../composables/glass/webgpu").GpuBackend;
+    pause: () => void;
+    resume: () => void;
+    wake: () => void;
+    renderAt: (timeSec: number) => void;
+    setHeadT: (t: number) => void;
+    headUnit: () => {
+        x: number;
+        y: number;
+    } | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     seed: string;
     freeze: boolean;
-    intensity: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -0,0 +1,24 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { OklchStop } from "../../../../composables/color";
+import { type FourierFieldConfig } from "../constants";
+import { type BasisComponent } from "../math";
+export interface FourierGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: FourierFieldConfig;
+    getSpectrum: () => readonly BasisComponent[];
+    getPalette: () => OklchStop[];
+    getHeadT: () => number;
+    shouldContinue: () => boolean;
+    onFrame?: (timeSec: number) => void;
+    /**
+     * BD.W-VIZ-BROKEN-FIX D6b — the 2-D cursor FOLLOW (model-space center lean). Mirrors the
+     * WGSL arm exactly (both read the SAME uFit center) — parity-safe by construction.
+     * `{x:0,y:0}` (ambient/PRM) is byte-identical to today.
+     */
+    getPointerLean?: () => {
+        x: number;
+        y: number;
+    };
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createFourierGLSetup(deps: FourierGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

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

@@ -0,0 +1,31 @@
+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;