@mkbabb/glass-ui 4.0.0 → 4.1.0

package/dist/components/custom/completion-seal/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CompletionSeal } from "./CompletionSeal.vue";
+export type { CompletionSealProps } from "./CompletionSeal.vue";
+export type { CompletionSealShape } from "./constants";
+export { useCompletionSeal, type UseCompletionSeal, type UseCompletionSealOptions, } from "./composables/useCompletionSeal";

package/dist/components/custom/concentric/Concentric.vue.d.ts

@@ -0,0 +1,39 @@
+import type { ConcentricConfig } from "./constants";
+/**
+ * Concentric — a radial Fourier ring-interference field.
+ *
+ * Concentric ellipsoid rings whose interference is a sum of radial harmonics about
+ * one-or-more centers (the cited radial-Fourier math — `composables/ringField.ts`): the
+ * same Fourier-series vocabulary the dot-flow-field's wave potential uses, so the suite
+ * speaks ONE math language. WebGPU-FIRST: a pure fullscreen fragment pass (the aurora
+ * shape-class) evaluates `f(p,t) = Σ_j Σ_i A_i·sin(k_i·‖p−c_j‖_e − ω_i·t + φ_i)` per
+ * pixel, with a clean WebGL2 GLSL fallback where WebGPU is absent. It composes
+ * `useConcentric` → the `createGpuSubstrate` picker over the ONE canvas lifecycle leaf
+ * (offscreen-pause, live-PRM freeze, consumer-owned DPR) — it never bootstraps its own
+ * context.
+ *
+ * The DEFAULT palette is the warm-cream library identity; the demo themes the rings
+ * through a PRESET (presets-in-consumers — never a library token).
+ */
+type __VLS_Props = {
+    /** The full author schema (the studio's `useConfiguratorState` model). */
+    config?: ConcentricConfig;
+    /**
+     * The declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the render loop
+     * (the substrate's `manual` suspend) when `true`. Wire `<DockBackgroundToggle>`'s
+     * `@update:paused` to this `v-model`.
+     */
+    paused?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    pause: () => void;
+    resume: () => void;
+    wake: () => void;
+    renderAt: (timeSec: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:paused": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/concentric/composables/concentricGLSetup.d.ts

@@ -0,0 +1,18 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { OklchStop } from "../../../../composables/color";
+import { type ConcentricConfig } from "../constants";
+import type { RingCenter } from "./ringField";
+export interface ConcentricGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: ConcentricConfig;
+    getPalette: () => OklchStop[];
+    getCenters: () => RingCenter[];
+    shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — useConcentric advances the shared pointer field +
+     * injects the transient cursor center here (the no-own-rAF discipline). ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createConcentricGLSetup(deps: ConcentricGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/concentric/composables/concentricWGPUSetup.d.ts

@@ -0,0 +1,22 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { OklchStop } from "../../../../composables/color";
+import type { ConcentricConfig } from "../constants";
+import type { RingCenter } from "./ringField";
+export interface ConcentricWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: ConcentricConfig;
+    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live edit reaches the buffer. */
+    getPalette: () => OklchStop[];
+    /** The render centers (author + the transient pointer center) — re-read each frame. */
+    getCenters: () => RingCenter[];
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — useConcentric advances the shared `usePointerVelocityField`
+     * here (the no-own-rAF discipline: the renderer's frame loop FEEDS `tick(delta)`) and
+     * mutates `config.centers` to inject the transient cursor ring-family. ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
+}
+/** Build the concentric `setupWGPU(device, context, format)` callback. */
+export declare function createConcentricWGPUSetup(deps: ConcentricWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/concentric/composables/ringField.d.ts

@@ -0,0 +1,85 @@
+/** A 2-vector. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/**
+ * One CLEAN radial ring component. `amplitude` A_i, `wavelength` λ_i (so k_i = 2π/λ_i),
+ * `phase` φ_i. `ω_i = √(g·k_i)` is derived from the dispersion relation, not stored (the
+ * SAME dispersion the flow field's Gerstner sum uses — the ONE suite dispersion law). A
+ * family carries 1–2 clean low frequencies, NEVER a turbulence octave ladder (the noise
+ * amplifier that read as a blur).
+ */
+export interface RingComponent {
+    amplitude: number;
+    wavelength: number;
+    phase: number;
+}
+/**
+ * A ring origin in domain space [-1,1]² (multi-center → interference). `rotAlpha` is the
+ * per-family tilt of the ellipsoidal frame (radians) — two families at different tilts cross
+ * into rich moiré. It reuses the spare `centers[j].w` uniform lane (no byte-layout change).
+ */
+export interface RingCenter {
+    x: number;
+    y: number;
+    /** Per-center weight (a far center contributes a fainter ring family). */
+    weight: number;
+    /** The per-family ellipsoid tilt (radians); 0 = the un-rotated frame. */
+    rotAlpha: number;
+}
+/** Deep-water gravity constant (normalized; scales the dispersion ω — shared with the flow field). */
+export declare const RING_GRAVITY = 9.81;
+/**
+ * The ellipsoidal radial distance ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²) in the family's
+ * ROTATED frame R(−α): rotate (p − c) by −α, then scale each axis by (a,b). The axis ratio
+ * tilts the rings into ellipses; the rotation tilts the ellipse so crossing families read as
+ * distinct waves. The single radial metric the WGSL shader transcribes.
+ */
+export declare function ellipsoidalRadiusRot(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
+/** The un-rotated ellipsoidal radius (rotAlpha = 0). Kept for the gate's axis-ratio assert. */
+export declare function ellipsoidalRadius(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
+/**
+ * |∇r| of the rotated ellipsoidal radius r = ‖R(−α)(p − c)‖_e. By the chain rule, with
+ * u = R(−α)(p − c) and the scaled coordinates (ux/a, uy/b):
+ *
+ *   ∂r/∂p = Rᵀ · ( ux/a² , uy/b² ) / r   →   |∇r| = sqrt((ux/a²)² + (uy/b²)²) / r
+ *
+ * (the rotation Rᵀ is orthonormal so it does not change the magnitude). At r→0 the gradient
+ * is ill-defined; ε-clamp the denominator. This is the closed-form magnitude the IQ
+ * distance-estimation de = |sin(phase)| / (|cos(phase)|·k·|∇r|) divides by.
+ */
+export declare function ellipsoidalGradMag(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
+/**
+ * The radial-Fourier ring-interference value f(p,t) ∈ ℝ — the multi-center weighted sum of
+ * CLEAN radial sinusoids. The SINGLE math source the WGSL `fs_main` + the GLSL fallback
+ * transcribe. `speed` scales the dispersion ω (the ring-travel speed). Returns the
+ * un-normalized field value (the BEAT ENVELOPE the shader tints through the palette).
+ */
+export declare function sampleRingField(p: Vec2, timeSec: number, centers: readonly RingCenter[], rings: readonly RingComponent[], axisA: number, axisB: number, speed: number): number;
+/**
+ * The IQ gradient-normalized distance-to-isoline INK at p — the per-pixel line strength,
+ * the union (brightest-wins `max`) over every (family × ring) crest. For a sinusoid
+ * s = sin(phase), de ≈ |s| / |∇s| = |sin| / (|cos|·k·|∇r|) is the analytic (domain-units)
+ * distance to the nearest crest everywhere; the SHADER converts it to a constant PIXEL
+ * width via fwidth(phase): dePx = de·gradPhase / fwidth(phase) = |sin|/(|cos|·fwidth(phase)),
+ * then line = 1 − smoothstep(lineHalfW, lineHalfW+aa, dePx) with lineHalfW/aa in pixels. The
+ * JS takes `phaseDeriv` as the per-pixel phase derivative (the fwidth(phase) analogue) so a
+ * node round-trip matches the shader exactly; a bare call uses a representative default.
+ *
+ * Returns { ink, env } — ink ∈ [0,1] the line strength (the alpha/brightness), env the raw
+ * beat-envelope value (the hue driver, identical to sampleRingField).
+ */
+export declare function ringIsolineInk(p: Vec2, timeSec: number, centers: readonly RingCenter[], rings: readonly RingComponent[], axisA: number, axisB: number, speed: number, lineHalfW: number, aa: number, phaseDeriv?: number): {
+    ink: number;
+    env: number;
+};
+/**
+ * Build a CLEAN beating ring FAMILY — 1–2 low-frequency radial sinusoids, NOT a turbulence
+ * octave ladder. `baseWavelength` ≈ 0.18 sets the ring spacing; a second harmonic at
+ * 0.5×base (optional) adds a subtle inner-ring texture without busying the field. The
+ * amplitudes are FLAT (energy is not the point — clean lines are), so each crest paints a
+ * crisp isoline. Distinct families get slightly different base wavelengths (a small Δλ) so
+ * they BEAT into the moiré envelope — the "distinct waves."
+ */
+export declare function buildRingFamily(baseWavelength: number, harmonics?: number, phaseSeed?: number): RingComponent[];

package/dist/components/custom/concentric/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,14 @@
+import type { OklchStop } from "../../../../composables/color";
+import type { RingCenter } from "./ringField";
+import { type ConcentricConfig } from "../constants";
+export declare const CONCENTRIC_UNIFORM_BYTES: number;
+/** The field-amplitude normalization scale (field → [0,1] for the palette ramp). */
+export declare const CONCENTRIC_FIELD_NORM = 0.55;
+export interface ConcentricUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createConcentricScratch(): ConcentricUniformScratch;
+/** Pack the concentric uniforms in place. */
+export declare function packConcentricUniforms(scratch: ConcentricUniformScratch, config: ConcentricConfig, timeSec: number, aspect: number, palette: OklchStop[], centersOverride?: readonly RingCenter[]): ConcentricUniformScratch;

package/dist/components/custom/concentric/composables/useConcentric.d.ts

@@ -0,0 +1,35 @@
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
+import type { OklchStop } from "../../../../composables/color";
+import type { ConcentricConfig } from "../constants";
+export interface UseConcentricOptions {
+    config: ConcentricConfig;
+    /** Resolve the field-value 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 ConcentricHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL fallback). */
+    readonly backend: GpuBackend;
+    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
+    pause: () => void;
+    /** Re-arm the loop. */
+    resume: () => void;
+    /** Re-arm a parked loop on demand. */
+    wake: () => void;
+    /** Draw one frame out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** Tear down the renderer + release GPU/GL resources. */
+    dispose: () => void;
+}
+/**
+ * Mount the concentric renderer on `canvasRef`. The WebGPU primary + the WebGL2 fallback are
+ * BOTH pure fullscreen fragment passes evaluating the SAME radial-Fourier field (the ONE
+ * math source `ringField.ts`), so the picker is the only seam. Returns the uniform lifecycle
+ * handle.
+ */
+export declare function useConcentric(canvasRef: Ref<HTMLCanvasElement | null>, options: UseConcentricOptions): ConcentricHandle;

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

@@ -0,0 +1,67 @@
+import type { RingComponent, RingCenter } from "./composables/ringField";
+import type { OklchStop } from "../../../composables/color";
+/** Compile-time ring-component cap — mirrors the WGSL `MAX_RINGS` #define. */
+export declare const MAX_RINGS = 8;
+/** Compile-time center cap — mirrors the WGSL `MAX_CENTERS` #define. */
+export declare const MAX_CENTERS = 4;
+/** Compile-time palette cap — mirrors the WGSL `MAX_RING_STOPS` #define. */
+export declare const MAX_RING_STOPS = 4;
+/** The render mode — traveling crest-lines, static elevation-contour, or both. */
+export type ConcentricRenderMode = "traveling-rings" | "static-contour" | "both";
+/** Map a render mode to the shader int (the uniform `ints.w` lane). */
+export declare function renderModeToInt(mode: ConcentricRenderMode): number;
+/**
+ * The full author schema — the studio's `useConfiguratorState` model. Every field is a
+ * tunable the demo configurator drives; the SFC resolves it into the uniform table.
+ */
+export interface ConcentricConfig {
+    /** The ring origins (1..MAX_CENTERS) — a multi-center sum produces ring interference. */
+    centers: RingCenter[];
+    /** The clean radial sum-of-sines table (1..2 frequencies — NOT a turbulence ladder). */
+    ringComponents: RingComponent[];
+    /** The ellipsoidal-norm axis ratio (a, b) — the tilted-disc depth implication. */
+    axisRatio: [number, number];
+    /** The ring-travel speed (scales ω). */
+    speed: number;
+    /** The stroke half-width (field-distance units; the IQ line thickness). */
+    lineWidth: number;
+    /** The stroke AA softness (field-distance units; the edge feather). */
+    lineSoftness: number;
+    /** The render mode — traveling crest-lines · static elevation-contour · both. */
+    renderMode: ConcentricRenderMode;
+    /** The contour-level count for the static-contour mode (4..24). */
+    contourLevels: number;
+    /** The beat detune — the second ring's wavelength offset that makes the families BEAT. */
+    beatDetune: number;
+    /** The field-value color ramp (the demo themes it); resolved via the ColorResolver. */
+    palette: OklchStop[];
+    /** The ground color (default transparent so it reads over the page; demo sets it). */
+    background: OklchStop | "transparent";
+    /** Pointer adds a transient ring center (a local perturbation about the cursor). */
+    interactive: boolean;
+    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    respectReducedMotion: boolean;
+}
+/**
+ * The warm-cream identity palette (the library default — NOT a themed hue). A three-stop
+ * warm ramp over the warm-cream foreground family, resolved via the ColorResolver: a soft
+ * cream trough, a warm amber mid, a deeper ember crest — so the ring LINES read as warm
+ * light interference. A consumer (the demo) themes it through a PRESET, never a token edit.
+ */
+export declare const WARM_IDENTITY_PALETTE: OklchStop[];
+/**
+ * Build the default clean beating ring table — one base ring + a slightly-detuned twin so
+ * the field BEATS into a low-frequency moiré envelope (the "distinct waves"). NOT the
+ * retired 5-octave Phillips turbulence ladder.
+ */
+export declare function buildDefaultRingComponents(baseWavelength?: number, beatDetune?: number): RingComponent[];
+/** The default clean beating ring table (2 detuned low-frequency rings). */
+export declare const DEFAULT_RING_COMPONENTS: RingComponent[];
+/**
+ * Two ring FAMILIES offset on the diagonal at different tilts — the default interference: a
+ * moiré BEAT where the two tilted-ellipsoid families cross (the literal "ellipsoid lines
+ * forming distinct waves").
+ */
+export declare const DEFAULT_CENTERS: RingCenter[];
+/** The shipped warm-identity default config — thin bright LINES that beat into waves. */
+export declare const DEFAULT_CONCENTRIC_CONFIG: ConcentricConfig;

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

@@ -0,0 +1,5 @@
+export { default as Concentric } from "./Concentric.vue";
+export { useConcentric, type ConcentricHandle, type UseConcentricOptions, } from "./composables/useConcentric";
+export { type ConcentricConfig, type ConcentricRenderMode, renderModeToInt, DEFAULT_CONCENTRIC_CONFIG, DEFAULT_RING_COMPONENTS, DEFAULT_CENTERS, WARM_IDENTITY_PALETTE, buildDefaultRingComponents, MAX_RINGS, MAX_CENTERS, MAX_RING_STOPS, } from "./constants";
+export { type RingComponent, type RingCenter, type Vec2, sampleRingField, ringIsolineInk, ellipsoidalRadius, ellipsoidalRadiusRot, ellipsoidalGradMag, buildRingFamily, RING_GRAVITY, } from "./composables/ringField";
+export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/concentric/shaders/concentric.glsl.d.ts

@@ -0,0 +1,4 @@
+/** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
+export declare const CONCENTRIC_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]\u00B2 domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
+/** The concentric fragment source — the aurora-class radial-Fourier isoline render. */
+export declare const CONCENTRIC_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define RING_GRAVITY 9.81\n#define MAX_RINGS 8\n#define MAX_CENTERS 4\n#define MAX_RING_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uSpeed;\nuniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio\nuniform float uFieldNorm;     // field \u2192 [0,1] amplitude scale\nuniform float uAspect;\nuniform int   uCenterCount;\nuniform int   uRingCount;\nuniform int   uStopCount;\nuniform int   uRenderMode;    // 0 traveling-rings \u00B7 1 static-contour \u00B7 2 both\nuniform float uHasBackground;\nuniform vec3  uLine;          // (lineHalfWidth, aaSoftness, contourLevels) \u2014 stroke geometry\nuniform vec3  uBg;            // themed background (linear-sRGB)\nuniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)\nuniform vec4  uCenters[MAX_CENTERS]; // (x, y, weight, rotAlpha)\nuniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// rotated ellipsoidal radius \u2014 transcribes ringField.ts ellipsoidalRadiusRot.\nfloat ellipsoidalRadiusRot(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {\n  float ca = cos(rotAlpha);\n  float sa = sin(rotAlpha);\n  float px = p.x - center.x;\n  float py = p.y - center.y;\n  float rx = ca * px + sa * py;\n  float ry = -sa * px + ca * py;\n  float dx = rx / max(axisA, 1e-4);\n  float dy = ry / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// |\u2207r| of the rotated ellipsoidal radius \u2014 transcribes ringField.ts ellipsoidalGradMag.\nfloat ellipsoidalGradMag(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {\n  float ca = cos(rotAlpha);\n  float sa = sin(rotAlpha);\n  float px = p.x - center.x;\n  float py = p.y - center.y;\n  float rx = ca * px + sa * py;\n  float ry = -sa * px + ca * py;\n  float a = max(axisA, 1e-4);\n  float b = max(axisB, 1e-4);\n  float sx = rx / a;\n  float sy = ry / b;\n  float r = sqrt(sx * sx + sy * sy);\n  float gx = sx / a;\n  float gy = sy / b;\n  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);\n}\n\n// f(p,t) \u2014 the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).\nfloat sampleRingField(vec2 p, float t) {\n  float acc = 0.0;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec4 cj = uCenters[j];\n    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, uAxis.x, uAxis.y);\n    float centerSum = 0.0;\n    for (int i = 0; i < MAX_RINGS; i++) {\n      if (i >= uRingCount) break;\n      vec3 r = uRings[i];\n      float k = TAU / max(r.y, 1e-4);\n      float omega = sqrt(RING_GRAVITY * k) * uSpeed;\n      float theta = k * radius - omega * t + r.z;\n      centerSum += r.x * sin(theta);\n    }\n    acc += centerSum * cj.z;\n  }\n  return acc;\n}\n\n// The IQ gradient-normalized isoline ink + the beat envelope (transcribes ringIsolineInk).\n// Returns vec2(ink, env).\nvec2 ringIsolineInk(vec2 p, float t) {\n  float ink = 0.0;\n  float env = 0.0;\n  float lineHalfW = uLine.x;\n  float aa = uLine.y;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec4 cj = uCenters[j];\n    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, uAxis.x, uAxis.y);\n    float gradR = ellipsoidalGradMag(p, cj.xy, cj.w, uAxis.x, uAxis.y);\n    for (int i = 0; i < MAX_RINGS; i++) {\n      if (i >= uRingCount) break;\n      vec3 r = uRings[i];\n      float k = TAU / max(r.y, 1e-4);\n      float omega = sqrt(RING_GRAVITY * k) * uSpeed;\n      float phase = k * radius - omega * t + r.z;\n      float s = sin(phase);\n      float cphase = abs(cos(phase));\n      float gradPhase = max(k * gradR, 1e-4);\n      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).\n      float de = abs(s) / max(cphase * gradPhase, 1e-4);\n      // Convert to PIXELS via fwidth(phase) so the stroke is a constant pixel width.\n      float dPx = max(fwidth(phase), 1e-4);\n      float dePx = de * gradPhase / dPx;\n      float lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);\n      // Analytic anti-aliasing: fade lines where the rings pack tighter than a pixel can\n      // resolve (fwidth(phase) \u2273 \u03C0, near a center / under DPR) so the field stays thin LINES\n      // instead of flooding to a bright slab (IQ filterwidth).\n      float aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);\n      lineV *= aliasFade;\n      float w = r.x * cj.z;\n      ink = max(ink, lineV * w);\n      env += s * w;\n    }\n  }\n  return vec2(clamp(ink, 0.0, 1.0), env);\n}\n\n// The topographic-contour operator (transcribes contourInk).\nfloat contourInk(float envValue, float levels) {\n  float fN = envValue * levels;\n  float band = abs(fract(fN + 0.5) - 0.5);\n  float aaW = max(fwidth(fN), 1e-4);\n  return 1.0 - smoothstep(uLine.x, uLine.x + uLine.y, band / aaW);\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  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n\n  vec2 ie = ringIsolineInk(p, uTime);\n  float ink = ie.x;\n  float env = ie.y;\n\n  if (uRenderMode == 1) {\n    ink = contourInk(env * uFieldNorm, max(uLine.z, 1.0));\n  } else if (uRenderMode == 2) {\n    ink = max(ink, contourInk(env * uFieldNorm, max(uLine.z, 1.0)));\n  }\n  ink = clamp(ink, 0.0, 1.0);\n\n  // The beat-envelope drives the warm-family tone across the ramp (cream\u2194amber\u2194ember) so the\n  // crossing families read as warm-light interference (the warm-cream identity).\n  float v = clamp(0.5 + env * uFieldNorm, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(v);\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n\n  if (uHasBackground > 0.5) {\n    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));\n    fragColor = vec4(mix(bg, rgb, ink), 1.0);\n    return;\n  }\n  float alpha = ink;\n  fragColor = vec4(rgb * alpha, alpha);\n}";

package/dist/components/custom/concentric/shaders/concentric.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst RING_GRAVITY: f32 = 9.81;\nconst MAX_RINGS: i32 = 8;\nconst MAX_CENTERS: i32 = 4;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uAxisA, uAxisB)\n  u0: vec4<f32>,\n  // ints: (uCenterCount, uRingCount, uStopCount, uRenderMode)  // 0 rings \u00B7 1 contour \u00B7 2 both\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, _pad, _pad) \u2014 field \u2192 [0,1] scale\n  norm: vec4<f32>,\n  // line: (lineHalfWidth, aaSoftness, contourLevels, _pad) \u2014 stroke geometry (field units)\n  line: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, rotAlpha)\n  centers: array<vec4<f32>, 4>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\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// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance in the family's ROTATED frame R(\u2212\u03B1): rotate (p \u2212 c) by\n// \u2212\u03B1, then scale by (a,b). Transcribes ringField.ts ellipsoidalRadiusRot.\nfn ellipsoidalRadiusRot(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let dx = rx / max(axisA, 1e-4);\n  let dy = ry / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// |\u2207r| of the rotated ellipsoidal radius \u2014 closed-form (the IQ distance-estimation\n// denominator). Transcribes ringField.ts ellipsoidalGradMag.\nfn ellipsoidalGradMag(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let a = max(axisA, 1e-4);\n  let b = max(axisB, 1e-4);\n  let sx = rx / a;\n  let sy = ry / b;\n  let r = sqrt(sx * sx + sy * sy);\n  let gx = sx / a;\n  let gy = sy / b;\n  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// CLEAN radial sinusoids (the BEAT ENVELOPE; transcribes ringField.ts sampleRingField).\nfn sampleRingField(p: vec2<f32>, t: f32) -> f32 {\n  var acc = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);\n    var centerSum = 0.0;\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let theta = k * radius - omega * t + r.z;\n      centerSum = centerSum + r.x * sin(theta);\n    }\n    acc = acc + centerSum * cj.z;\n  }\n  return acc;\n}\n\n// The IQ gradient-normalized isoline INK + the beat ENVELOPE \u2014 the per-pixel line strength\n// (brightest-wins union over every family \u00D7 ring crest) and the raw envelope (the hue\n// driver). Transcribes ringField.ts ringIsolineInk.\nstruct InkEnv { ink: f32, env: f32, };\nfn ringIsolineInk(p: vec2<f32>, t: f32) -> InkEnv {\n  var ink = 0.0;\n  var env = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  let lineHalfW = u.line.x;\n  let aa = u.line.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);\n    let gradR = ellipsoidalGradMag(p, cj.xy, cj.w, axisA, axisB);\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let phase = k * radius - omega * t + r.z;\n      let s = sin(phase);\n      let cphase = abs(cos(phase));\n      let gradPhase = max(k * gradR, 1e-4);\n      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).\n      let de = abs(s) / max(cphase * gradPhase, 1e-4);\n      // Convert the domain-units distance to PIXELS via fwidth(phase) (the device\n      // per-pixel phase change) so the stroke is a constant pixel width everywhere \u2014\n      // lineHalfW/aa are in pixels (NOT fwidthFine, Compatibility-Mode safe).\n      let dPx = max(fwidth(phase), 1e-4);\n      let dePx = de * gradPhase / dPx;\n      var lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);\n      // Analytic anti-aliasing: where the rings pack tighter than the pixel can resolve\n      // (fwidth(phase) \u2273 \u03C0, near a center / under DPR), FADE the line out instead of\n      // flooding to a solid mass (IQ filterwidth \u2014 the aliasing-fade that keeps the field\n      // thin LINES, not a bright slab where the rings converge).\n      let aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);\n      lineV = lineV * aliasFade;\n      let w = r.x * cj.z;\n      ink = max(ink, lineV * w);\n      env = env + s * w;\n    }\n  }\n  var oe: InkEnv;\n  oe.ink = clamp(ink, 0.0, 1.0);\n  oe.env = env;\n  return oe;\n}\n\n// The topographic-contour operator: the isolines of the STATIC interference envelope at N\n// evenly-spaced heights. de_contour = |fract(f\u00B7N + 0.5) \u2212 0.5| / |fwidth(f\u00B7N)| \u2014 the IQ\n// contour-line form. fwidth is the device pixel-derivative safety clamp on the composite\n// ONLY (NOT fwidthFine \u2014 Compatibility-Mode safe on Metal/WebKit).\nfn contourInk(envValue: f32, levels: f32) -> f32 {\n  let fN = envValue * levels;\n  let band = abs(fract(fN + 0.5) - 0.5);\n  // fwidth is the device pixel-derivative safety clamp (NOT fwidthFine \u2014 Compatibility-Mode\n  // safe on Metal/WebKit).\n  let aaW = max(fwidth(fN), 1e-4);\n  return 1.0 - smoothstep(u.line.x, u.line.x + u.line.y, band / aaW);\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n  let mode = u.ints.w;  // 0 traveling-rings \u00B7 1 static-contour \u00B7 2 both\n  let levels = u.line.z;\n\n  // The isoline strokes (the LINES) + the beat envelope (the HUE).\n  let oe = ringIsolineInk(p, t);\n  var ink = oe.ink;\n  let env = oe.env;\n\n  // The static-contour mode draws elevation lines of the (static) envelope.\n  if (mode == 1) {\n    ink = contourInk(env * u.norm.x, max(levels, 1.0));\n  } else if (mode == 2) {\n    ink = max(ink, contourInk(env * u.norm.x, max(levels, 1.0)));\n  }\n  // fwidth safety clamp on the final line composite (Compatibility-Mode safe).\n  ink = clamp(ink, 0.0, 1.0);\n\n  // The beat-envelope drives the warm-family tone across the ramp (cream\u2194amber\u2194ember) so the\n  // crossing ring families read as warm-light interference; the saturated mid-amber reads on\n  // BOTH the cream page and the dark page (the warm-cream identity, NOT a themed hue).\n  let v = clamp(0.5 + env * u.norm.x, 0.0, 1.0);\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: composite the lit line over the themed bg.\n    let bg = clamp(linearToSrgb(u.bg.rgb), vec3<f32>(0.0), vec3<f32>(1.0));\n    let outRgb = mix(bg, rgb, ink);\n    return vec4<f32>(outRgb, 1.0);\n  }\n  // transparent ground: the LINE carries the alpha \u2014 the page reads through the troughs.\n  let alpha = ink;\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/confirm-dialog/ConfirmDialog.vue.d.ts

@@ -9,11 +9,11 @@ type __VLS_ModelProps = {
     "open"?: boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_13: {}, __VLS_36: {};
+declare var __VLS_35: {}, __VLS_64: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_13) => any;
+    default?: (props: typeof __VLS_35) => any;
 } & {
-    action?: (props: typeof __VLS_36) => any;
+    action?: (props: typeof __VLS_64) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/components/custom/constellation/Constellation.vue.d.ts

@@ -4,8 +4,13 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
     speed: number;
     count: number;
     opacityCeiling: number;
+    parallax: number;
     pointerReactive: boolean;
     warpOnClick: boolean;
+    wander: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
     gravityWell: boolean | {
         holdMs?: number;
         gain?: number;
@@ -14,10 +19,6 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
         maxSpeed?: number;
         soften?: number;
     };
-    wander: boolean | {
-        minIdle?: number;
-        jitter?: number;
-    };
     pinned: boolean | number;
     accentEdges: boolean;
     pinnedDrift: boolean | {

package/dist/components/custom/constellation/composables/constellationGLSetup.d.ts

@@ -0,0 +1,10 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { ConstellationRenderState } from "./constellationWGPUSetup";
+export interface ConstellationGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    onResize?: (w: number, h: number) => void;
+    shouldContinue: () => boolean;
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createConstellationGLSetup(deps: ConstellationGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/constellation/composables/constellationWGPUSetup.d.ts

@@ -0,0 +1,19 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import { type ConstellationUniformValues, type PackedNode, type PackedEdge } from "./uniformBridgeWGPU";
+/** The per-frame render state the renderer resolves (the stepped field → packed rows). */
+export interface ConstellationRenderState {
+    nodes: PackedNode[];
+    edges: PackedEdge[];
+    uniforms: ConstellationUniformValues;
+}
+export interface ConstellationWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    /** Advance the field + the shared pointer field one renderer frame, return the packed render state. */
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    /** Size the canvas backing store (returns the resolved backing-store [w,h] in device px). */
+    onResize?: (w: number, h: number) => void;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+}
+/** Build the constellation `setupWGPU(device, context, format)` callback. */
+export declare function createConstellationWGPUSetup(deps: ConstellationWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/constellation/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,66 @@
+/** Floats per node row (one vec4). */
+export declare const NODE_FLOATS = 4;
+/** Bytes per node row. */
+export declare const NODE_BYTES: number;
+/** The pre-sized node storage buffer byte length. */
+export declare const NODES_BUFFER_BYTES: number;
+/** Floats per edge row (2 vec4s). */
+export declare const EDGE_FLOATS = 8;
+/** Bytes per edge row. */
+export declare const EDGE_BYTES: number;
+/** The pre-sized edge storage buffer byte length. */
+export declare const EDGES_BUFFER_BYTES: number;
+export declare const CONSTELLATION_UNIFORM_BYTES = 112;
+export interface ConstellationUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+}
+export declare function createConstellationScratch(): ConstellationUniformScratch;
+/** The per-frame uniform values the render reads (resolved JS-side). */
+export interface ConstellationUniformValues {
+    resolutionX: number;
+    resolutionY: number;
+    dpr: number;
+    kVis: number;
+    time: number;
+    lineWidth: number;
+    opacityCeiling: number;
+    /** The field-yields-to-type `--constellation-alpha` global dimmer. */
+    alpha: number;
+    edgeAlpha: number;
+    edgeFocusAlpha: number;
+    edgeAccentAlpha: number;
+    edgeFloor: number;
+    /** Premultiplied-ready RGBA (`[0,1]`) — `node`/`nodeDim`/`line`/`accent`. */
+    node: [number, number, number, number];
+    nodeDim: [number, number, number, number];
+    line: [number, number, number, number];
+    accent: [number, number, number, number];
+}
+/** Pack the constellation uniforms in place. */
+export declare function packConstellationUniforms(scratch: ConstellationUniformScratch, v: ConstellationUniformValues): ConstellationUniformScratch;
+/** A pre-sized node scratch (`MAX_NODES` rows × NODE_FLOATS). */
+export declare function createNodeScratch(): Float32Array;
+/** A pre-sized edge scratch (`E_MAX` rows × EDGE_FLOATS). */
+export declare function createEdgeScratch(): Float32Array;
+/** A packed node row in screen-px: `(x, y, radius, dim)`. */
+export interface PackedNode {
+    x: number;
+    y: number;
+    r: number;
+    dim: number;
+}
+/** Pack `count` node rows into the scratch (clamped to MAX_NODES). Returns the count packed. */
+export declare function packNodes(scratch: Float32Array, nodes: readonly PackedNode[]): number;
+/** A packed edge row: `(ax, ay, bx, by, alpha, accent, focus)`. */
+export interface PackedEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    alpha: number;
+    accent: number;
+    focus: number;
+}
+/** Pack `count` edge rows into the scratch (clamped to E_MAX). Returns the count packed. */
+export declare function packEdges(scratch: Float32Array, edges: readonly PackedEdge[]): number;

package/dist/components/custom/constellation/composables/useConstellation.d.ts

@@ -1,9 +1,12 @@
 import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
 import { type ConstellationField, type ConstellationProps } from "../constellationField";
 /** The imperative seam the SFC re-exposes via `defineExpose`. */
 export interface ConstellationExpose {
     field: ConstellationField;
     isFrozen: Ref<boolean>;
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 instanced twin). */
+    backend: () => GpuBackend;
     warpTo(a: {
         x: number;
         y: number;
@@ -13,14 +16,4 @@ export interface ConstellationExpose {
     warpSettled(): boolean;
     pinNode(idx: number): void;
 }
-/**
- * Drive a `<Constellation>` instance. `props` is the REACTIVE (defaulted) prop
- * surface — the per-frame live-read props (`pointerReactive`/`opacityCeiling`/
- * `accentEdges`/`drawOverlay`) are read off `props.x` INSIDE the render loop so a
- * bound `:opacity-ceiling` updates without a remount (the Vue 3.5 reactive-prop
- * read; the SFC `defineProps` destructure transform does not reach a composable
- * argument, so the live reads stay on `props`). `hostRef`/`canvasRef` are the SFC
- * template refs. Returns the imperative expose object the SFC spreads into
- * `defineExpose`.
- */
 export declare function useConstellation(props: ConstellationProps, hostRef: Ref<HTMLElement | null>, canvasRef: Ref<HTMLCanvasElement | null>): ConstellationExpose;

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

@@ -59,3 +59,36 @@ export declare const DEFAULT_PINNED_DRIFT_JITTER = 8000;
  *  ≥ ~0.72·BASE_WIDTH ≈ 922px (incl. the 1280 export frame — byte-identical
  *  there by construction); below it the marks stop crushing sub-pixel. */
 export declare const DEFAULT_K_FLOOR = 0.72;
+/**
+ * The maximum node count the points/edges buffers pre-size for (the slider cap — a count
+ * above this is clamped at upload). ≫ this BOOKS the compute neighbor-bin path.
+ */
+export declare const MAX_NODES = 256;
+/**
+ * The per-node max degree budget — the edge buffer is pre-sized at `MAX_NODES · MAX_DEGREE`
+ * so the CPU all-pairs scan never overflows it (a denser-than-degree neighborhood drops the
+ * weakest edges, never re-allocates). 12 is a generous incident-edge ceiling for a
+ * distance-threshold ε-proximity graph at the default link/count.
+ */
+export declare const MAX_DEGREE = 12;
+/** The pre-sized edge instance budget (`MAX_NODES · MAX_DEGREE`). */
+export declare const E_MAX: number;
+/**
+ * The pointer-parallax depth default (§6). Each node carries a seeded depth `z ∈ [0,1]`;
+ * the pointer offsets node screen positions by `parallax · z · (pointer − center)` — a
+ * cheap pointer-parallax giving the flat lattice apparent depth (the Awwwards "living
+ * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not a
+ * behavior break). 0 = the flat lattice (no parallax).
+ */
+export declare const DEFAULT_PARALLAX = 0.08;
+/**
+ * The base node radius band (CSS px) the DPR-aware SDF circle sizes within (the §1 "Node
+ * size" config axis). `seedField` rolls each node's radius in `[NODE_R_MIN, NODE_R_MIN +
+ * NODE_R_SPREAD)` (the prior `1.6 + rng()*1.6` band, named); the WGSL/GLSL fragment SDF
+ * sizes `half = radius · uKVis · uDpr / uResolution` so the disc samples at full device
+ * resolution and is AA'd by the pixel-footprint derivative — crisp at ANY DPR.
+ */
+export declare const NODE_R_MIN = 1.6;
+export declare const NODE_R_SPREAD = 1.6;
+/** The hairline edge half-width (CSS px) the instanced segment-quad fragment AAs. */
+export declare const DEFAULT_LINE_WIDTH = 1;

package/dist/components/custom/constellation/constellationField.d.ts

@@ -39,4 +39,34 @@ export declare function refitField(field: ConstellationField, prevW: number, pre
  * `setWarpTarget` to a random node when it elapses AND the spring has settled
  * (a click-warp in flight pre-empts the cadence — `warpSettled` reports false).
  */
-export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number): void;
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number, pointerVel?: ConstellationPointer | null): void;
+import type { ConstellationEdge } from "./constellationTypes";
+/**
+ * Scan the proximity graph and return its edge SET (the `1 − d²/reach²` distance-falloff
+ * weight per pair within `reach = link·k`). `accentIndex ≥ 0` marks the edges incident on
+ * that node (the flagged-node tether). Pure + node-testable; the render loop calls it each
+ * frame and uploads the result to the instanced-lines storage buffer.
+ *
+ * `eMax` caps the result (the pre-sized buffer budget). When the scan would exceed it, the
+ * WEAKEST overflow edges are dropped (a denser-than-budget neighborhood keeps its strongest
+ * links — never re-allocates the GPU buffer mid-frame).
+ */
+export declare function buildEdges(field: ConstellationField, link: number, accentIndex?: number, eMax?: number): ConstellationEdge[];
+/**
+ * Append the POINTER-WEB tether edges to an existing edge set (the `drawPointerWeb` math
+ * relocated): the cursor is a "virtual node" whose incident edges (to every node within
+ * `reach`) carry `focus = 1` (the render strokes them at the focus alpha). No-op when the
+ * pointer is inactive (`x < 0`). The `eMax` budget is shared with the ambient set.
+ */
+export declare function appendPointerWeb(edges: ConstellationEdge[], field: ConstellationField, link: number, pointer: ConstellationPointer | null, eMax?: number): void;
+/**
+ * The parallax-offset SCREEN position for a node (§6). Offsets the node by
+ * `parallax · z · (pointer − center)` — a cheap pointer-parallax giving the flat lattice
+ * apparent depth (deeper nodes — higher `z` — shift more, the Awwwards "living network"
+ * register). When the pointer is inactive the offset is 0 (the flat lattice). Pure; the
+ * render loop maps each node's `(x,y)` through this before writing the GPU position buffer.
+ */
+export declare function parallaxNodePos(node: ConstellationNode, pointer: ConstellationPointer | null, w: number, h: number, parallax: number): {
+    x: number;
+    y: number;
+};