@mkbabb/glass-ui 3.13.0 → 4.0.1

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

@@ -1,3 +1,4 @@
+import { type Surface } from "../../ui/_shared/useSurfaceAxis";
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
@@ -6,6 +7,10 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /** Surface decoration register for the fullscreen overlay
+     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
+     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
+    surface?: Surface;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -21,6 +26,10 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /** Surface decoration register for the fullscreen overlay
+     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
+     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
+    surface?: Surface;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -31,6 +40,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
 }> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
+    surface: Surface;
     buttonPosition: "left" | "right";
     expandLabel: string;
     collapseLabel: string;

package/dist/components/custom/fading-scroll/FadingScroll.vue.d.ts

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    /** Scroll axis. `"x"` is the horizontal strip, `"y"` the vertical column. Default `"x"`. */
+    axis?: "x" | "y";
+    /** Feather the start edge once scrolled past the start. Default `true`. */
+    fadeStart?: boolean;
+    /** Feather the end edge while trailing overflow remains. Default `true`. */
+    fadeEnd?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    axis: "x" | "y";
+    fadeStart: boolean;
+    fadeEnd: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/fading-scroll/composables/useFadingScroll.d.ts

@@ -0,0 +1,31 @@
+import type { MaybeRef, Ref } from "vue";
+export interface UseFadingScrollOptions {
+    /** Scroll axis. `"x"` reads scrollLeft/Width; `"y"` reads scrollTop/Height. Default `"x"`. */
+    axis?: "x" | "y";
+    /** Feather the start edge once scrolled past the start. Default `true`. */
+    fadeStart?: boolean;
+    /** Feather the end edge while trailing overflow remains. Default `true`. */
+    fadeEnd?: boolean;
+}
+export interface UseFadingScrollControls {
+    /** True when this composable is the ACTIVE writer (the native timeline is absent). */
+    readonly active: Readonly<Ref<boolean>>;
+    /** Re-measure the scroll state and rewrite the customs. Safe to call manually. */
+    measure: () => void;
+    /** Detach all listeners/observers. Auto-called on unmount in a component scope. */
+    stop: () => void;
+}
+/**
+ * Drive the per-edge `--fade-start` / `--fade-end` mask-width customs off an
+ * element's live scroll state, the JS fallback for the native `scroll(self)`
+ * timeline. On a supporting engine this attaches NOTHING (the CSS recipe is the
+ * sole writer); on a non-supporting engine it measures `scrollLeft/Top`,
+ * `scrollWidth/Height − clientWidth/Height`, a `ResizeObserver` (the shared
+ * `useResizeObserver` substrate) + a rAF-coalesced `scroll` listener, writing
+ * `--fade-start = --fade-scroll-width` only past `scroll > 0` and `--fade-end`
+ * only while trailing overflow remains. The customs default to `0px` (no
+ * feather) so the at-rest no-overflow edge is SHARP.
+ *
+ * @param target the scroll-port element (the same element the CSS customs apply to)
+ */
+export declare function useFadingScroll(target: MaybeRef<HTMLElement | null>, options?: UseFadingScrollOptions): UseFadingScrollControls;

package/dist/components/custom/fading-scroll/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The module-scope constants for the FadingScroll family — the colocation home
+ * (`proof:colocation`) the dir owes once it carries a complex composable. Both
+ * were promoted out of `composables/useFadingScroll.ts` verbatim.
+ */
+/**
+ * True when the engine genuinely supports a `scroll()` timeline — the CSS recipe
+ * in `utilities/base.css` then owns the visual axis on the compositor and the
+ * `useFadingScroll` composable becomes the inert (non-attaching) path. Module-level
+ * so the feature gate is computed once. (Mirrors `useScrollProgress`'s twin.)
+ */
+export declare const NATIVE_SCROLL_TIMELINE: boolean;
+/**
+ * Tolerance (CSS px) absorbing scroll-snap jitter — `snap-mandatory` parks the
+ * active card a few px off the true start, so the start edge reads as sharp until
+ * the user genuinely scrolls past the first child. Promoted verbatim from the
+ * bespoke `PresetPickerRow` SNAP_TOLERANCE.
+ */
+export declare const SNAP_TOLERANCE = 12;

package/dist/components/custom/fading-scroll/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FadingScroll } from "./FadingScroll.vue";
+export { useFadingScroll, type UseFadingScrollOptions, type UseFadingScrollControls, } from "./composables/useFadingScroll";

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

@@ -1,4 +1,4 @@
-import { type ColorResolver } from "../../../composables/color";
+import type { ColorResolver } from "../../../composables/color";
 /**
  * FourierField — a Fourier epicycle field on a Canvas2D surface, a sibling
  * primitive to Aurora and GooBlob. A seeded elliptic spectrum reconstructs a
@@ -20,6 +20,11 @@ import { type ColorResolver } from "../../../composables/color";
  * 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.
  */
 type __VLS_Props = {
     /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. Default `hero`. */
@@ -38,7 +43,19 @@ type __VLS_Props = {
      *  loudness); clamped [0, 2] — the field's ~2 upper bound lets a hero push
      *  brighter than the recessed default without runaway. */
     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<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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";
+    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/useFourierField.d.ts

@@ -0,0 +1,39 @@
+import { type ShallowRef } from "vue";
+import { type ColorResolver } from "../../../../composables/color";
+/**
+ * The renderer of `<FourierField>` — the Fourier-epicycle field on a Canvas2D
+ * surface. Lifted out of the SFC into this composable (BB.W-CARVE3) so the
+ * component file matches the colocation symmetry its GL/canvas siblings already
+ * carry: Aurora→`useAurora.ts`, GooBlob→`useMetaballRenderer.ts`,
+ * Constellation→`useConstellation.ts`. The SFC stays thin (props + the two
+ * template refs + the single `useFourierField(props, …)` call).
+ *
+ * It composes the `useCanvas2D` substrate, inheriting the offscreen /
+ * tab-hidden / reduced-motion freeze for free (no hand-rolled RAF-park). Color
+ * resolves through the INJECTED `colorResolver` seam (the GooBlob model): a
+ * `var()`/`light-dark()` 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.
+ */
+export interface FourierFieldRenderProps {
+    /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. */
+    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. */
+    seed: string;
+    /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). */
+    freeze: boolean;
+    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the resolved alphas at the PAINT layer; clamped [0, 2]. */
+    intensity: number;
+    /** OPTIONAL injected clock — a getter returning the loop parameter `t ∈ [0,1)` (the studio's controllable clock). */
+    clock?: () => number;
+}
+/** The template refs the SFC owns; the composable reads them once the host is in the tree. */
+export interface FourierFieldRefs {
+    hostRef: Readonly<ShallowRef<HTMLElement | null>>;
+    canvasRef: Readonly<ShallowRef<HTMLCanvasElement | null>>;
+}
+export declare function useFourierField(props: FourierFieldRenderProps, { hostRef, canvasRef }: FourierFieldRefs): void;

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

@@ -0,0 +1,7 @@
+/**
+ * Curve-sampling resolution for the stable view-fit bbox pass — the renderer
+ * samples the epicycle curve this many times once at mount to size it to the
+ * canvas with a fixed margin (so the curve never clips and the scale is constant
+ * across the run). 720 = one sample per half-degree of the unit period.
+ */
+export declare const FOURIER_FIT_SAMPLES = 720;

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

@@ -1,6 +1,6 @@
 import type { ColorResolver } from "../../../composables/color";
 export { default as FourierField } from "./FourierField.vue";
-export { comp, positionsAt, dftFromPoints, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
+export { comp, positionsAt, partialSumAt, dftFromPoints, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
 /** The configuration-BUNDLE axis — `hero` (epicycles on, fewer harmonics) vs
  *  `final` (epicycles off, denser). Not a recolour of one curve; one engine,
  *  two presets. */

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

@@ -23,6 +23,23 @@ export declare function comp(index: number, re: number, im: number): BasisCompon
  * carries).
  */
 export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
+/**
+ * The PARTIAL-SUM curve point at parameter `t` over the FIRST `maxTerms` phasors
+ * — the inverse-DFT truncated summation `Σ_{k<maxTerms} c_k * exp(2*pi*i*k*t)`.
+ * It is {@link positionsAt} truncated at `maxTerms` and read at the FINAL tip:
+ * the single curve POINT (not the whole chain). The truncation axis is the SAME
+ * one `positionsAt`'s `maxCircles` arg drives — `maxCircles` reads the whole
+ * chain truncated, `partialSumAt` reads only its endpoint — so the studio's
+ * N-harmonics slider can draw the assembling chain (`positionsAt(.., N)`) AND the
+ * resolving curve point (`partialSumAt(.., t, N)`) off the ONE axis. Sweeping `t`
+ * over `[0,1)` and joining the points traces the partial-sum CURVE: at `maxTerms`
+ * = 1 a single ellipse, growing toward the full reconstruction as `maxTerms`
+ * climbs to `components.length` (the reference's "watch it sum" beauty).
+ *
+ * `maxTerms` omitted (or ≥ `components.length`) is the full reconstruction — the
+ * same point `positionsAt(components, t)` returns at its final tip.
+ */
+export declare function partialSumAt(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
 /**
  * The forward DFT — the inverse of {@link positionsAt}. Takes a closed sequence
  * of `[x, y]` samples around a curve (treated as the complex signal `x + i·y`,

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

@@ -1,4 +1,5 @@
 import { type GlassTier } from "../../../composables/glass/useGlassRenderer";
+import { type Surface } from "../../ui/_shared/useSurfaceAxis";
 /**
  * Surface-tier vocabulary for the CSS rendering branch. Mirrors the v0.8
  * five-rung ladder declared in `tokens.css §8` and consumed by the
@@ -18,6 +19,12 @@ export interface GlassPanelProps {
     chromaticAberration?: boolean;
     /** Glass surface tier for the CSS rendering branch (v0.8 5-rung ladder). */
     variant?: GlassPanelVariant;
+    /** Surface decoration register (BA.W-SURFACE-AXIS) — the SHARED
+     *  {glass·veil·opaque} axis. `glass` (default) renders the variant's plain
+     *  glass rung; `veil` overlays the borderless/rimless text-legibility plate;
+     *  `opaque` sets `--glass-level:0` (the solid-card escape). Orthogonal to
+     *  `variant`/`tier`, exactly as `surface` is on `<Card>`. */
+    surface?: Surface;
     /** Additional classes */
     class?: string;
 }
@@ -26,8 +33,9 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<GlassPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassPanelProps> & Readonly<{}>, {
-    variant: GlassPanelVariant;
     blur: number;
+    variant: GlassPanelVariant;
+    surface: Surface;
     refraction: number;
     chromaticAberration: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -4,8 +4,10 @@ import type { BlobMood, BlobConfig } from "./types";
  *
  * Renders a pulsing SDF body with orbiting satellites that periodically merge in,
  * get absorbed, then re-emerge. Mood, pointer-attraction and a deterministic
- * satellite system drive the motion. The renderer composes the `useWebGLCanvas`
- * substrate — it never bootstraps its own context.
+ * satellite system drive the motion. The renderer composes the `createGpuSubstrate`
+ * picker — the WebGPU-first `metaball.wgsl` primary OR the WebGL2 `metaball.frag`
+ * fallback (BB.W-VIZ-SUITE / W-GOOBLOB-WGPU), selected once by `navigator.gpu`
+ * feature-detect; it never bootstraps its own context.
  *
  * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
  * oklchToGammaRgb`): the blob paints the GAMMA-sRGB triple of the `color` prop. A

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

@@ -0,0 +1,24 @@
+import type { BlobConfig } from "../types";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+import type { BlobFrameState } from "./uploadBlobUniforms";
+/** The total uniform-buffer byte size (16-aligned). */
+export declare const BLOB_WGPU_UNIFORM_BYTES: number;
+/**
+ * The packed scratch buffer + the dual ArrayBuffer views. A frame refills this in place
+ * (no per-frame allocation) — mirroring the GLSL bridge's per-frame `gl.uniformNf` writes.
+ */
+export interface BlobWGPUUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createBlobWGPUUniformScratch(): BlobWGPUUniformScratch;
+/**
+ * Pack the resolved blob frame state into the uniform scratch buffer. The byte layout
+ * mirrors the WGSL `Uniforms` struct EXACTLY, and the resolved-value math is the
+ * BYTE-IDENTICAL twin of `uploadBlobUniforms.ts` (the same `* 0.5 * POS_SCALE` mapping,
+ * the same `reachFactor`/`orbitWiden`/`maxReach` derivations). Returns the same scratch
+ * (the caller `queue.writeBuffer`s `scratch.buffer`).
+ */
+export declare function packBlobWGPUUniforms(scratch: BlobWGPUUniformScratch, canvas: HTMLCanvasElement, config: BlobConfig, pointer: BlobPointer, satellites: BlobSatelliteSystem, frame: BlobFrameState): BlobWGPUUniformScratch;

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

@@ -24,24 +24,41 @@ export interface UseMetaballRendererOptions {
     satellites: BlobSatelliteSystem;
     config: BlobConfig;
 }
-/** The renderer's public control surface — pause/resume the demand loop. */
+/** The renderer's public control surface — pause/resume + wake the demand loop. */
 export interface UseMetaballRendererReturn {
     pause: () => void;
     resume: () => void;
+    /**
+     * BA.W-GOO-REDRESS — re-arm the demand-parked loop on demand (the public twin
+     * of the internal `color`/`paletteStops` wake watchers). The SFC's pointer-wake
+     * wire calls this so a first hover over a fully-parked blob (all satellites
+     * orbiting → the AX.W16 quiescence gate has parked the rAF) repaints on the
+     * SAME frame instead of waiting up to an orbit horizon for the next scheduled
+     * satellite wake (root cause 2 / BA-goo-3). It is the EXISTING substrate wake
+     * handle — NO new rAF, NO second wake path (the single-substrate-loop invariant).
+     */
+    wake: () => void;
 }
 /**
- * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
+ * The GooBlob renderer — composes the `createGpuSubstrate` picker (BB.W-VIZ-SUITE /
+ * W-GOOBLOB-WGPU): the WebGPU-first `metaball.wgsl` primary OR the WebGL2
+ * `metaball.frag.ts` fallback, selected ONCE by `navigator.gpu` feature-detect. Both
+ * backends compose the SAME `createCanvasLifecycle` leaf (AU.W6), so the demand-driven
+ * scheduling + offscreen-park + live-PRM-freeze are byte-identical across backends.
  *
- * This module owns ONLY the metaball-specific concerns: compiling the shader,
- * building the quad + uniform cache (the `buildMetaballProgram` leaf), and
- * uploading the per-frame uniforms (the `uploadBlobUniforms` leaf) derived from the
- * mood / pointer / satellite systems and the resolved base color. The generic
- * WebGL2 lifecycle — context creation, the suspend/resume model, the demand-driven
- * rAF loop, the tab-visibility owner, the ResizeObserver, and the
- * webglcontextlost/restored robustness — lives in the substrate; this renderer
- * threads its behaviour through the substrate's
- * `setup`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does NOT call
- * `getContext("webgl2")` itself (the single-bootstrap contract).
+ * This module owns ONLY the metaball-specific concerns: compiling the shader, building
+ * the quad + uniform cache (the WebGL2 `buildMetaballProgram` leaf) OR the WGSL pipeline
+ * + the typed-struct uniform buffer (the WGSL `createBlobWGPUSetup` leaf), and the
+ * per-frame SIMULATION advance + uniform upload derived from the mood / pointer /
+ * satellite systems and the resolved base color. The simulation advance is SHARED — the
+ * `resolveFrame(timeSec)` closure advances the systems and returns the settled
+ * `BlobFrameState`; the WebGL2 `drawFrame` and the WGSL `frame` both call it, so the
+ * physics is substrate-agnostic and only the upload+draw leg differs. The generic
+ * lifecycle (context creation, the suspend/resume model, the demand-driven rAF loop, the
+ * tab-visibility owner, the ResizeObserver, and the context-loss self-heal) lives in the
+ * substrate; this renderer threads its behaviour through the substrate's
+ * `setupGL`/`setupWGPU`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does
+ * NOT call `getContext("webgl2")`/`navigator.gpu` itself (the single-bootstrap contract).
  *
  * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
  * oklchToGammaRgb`) — the GAMMA-sRGB triple fed straight into the base-color uniform

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

@@ -0,0 +1,23 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { BlobConfig } from "../types";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+import type { BlobFrameState } from "./uploadBlobUniforms";
+export interface BlobWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: BlobConfig;
+    pointer: BlobPointer;
+    satellites: BlobSatelliteSystem;
+    /** Resolve the per-frame state (advances the sim, returns the settled values). */
+    resolveFrame: (timeSec: number) => BlobFrameState | null;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /** Reduced-motion read (the substrate owns the query; the renderer drives tempo). */
+    getReducedMotion: () => boolean;
+}
+/**
+ * Build the goo-blob `setupWGPU(device, context, format)` callback. Closes over the
+ * blob-specific state (config/pointer/satellites + the renderer's resolveFrame) — the
+ * same closures the WebGL2 `setup` threads.
+ */
+export declare function createBlobWGPUSetup(deps: BlobWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/goo-blob/constants.d.ts

@@ -42,7 +42,12 @@ export declare const PULSE_OMEGA = 18;
 export declare const PULSE_ZETA = 0.35;
 /** The at-rest epsilon — velocity/position below this is "settled" (the park gate). */
 export declare const REST_EPS = 0.001;
-/** Base satellite opacity. */
+export declare const ORBIT_RANDOM_BASE = 0.85;
+export declare const ORBIT_RANDOM_SPAN = 0.2;
+export declare const SAT_WOBBLE1_BASE = 0.015;
+export declare const SAT_WOBBLE1_SPAN = 0.02;
+export declare const SAT_WOBBLE2_BASE = 0.01;
+export declare const SAT_WOBBLE2_SPAN = 0.015;
 export declare const BASE_OPACITY = 0.75;
 /** Duration (ms) to blend from emerge endpoint into live orbit — eliminates snap. */
 export declare const ORBIT_BLEND_MS = 2000;

package/dist/components/custom/goo-blob/shaders/metaball.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_WGSL = "\nconst MAX_SATS: i32 = 4;\nconst TRAIL_N: i32 = 15;\nconst MAX_BLOB_STOPS: i32 = 4;\nconst PI: f32 = 3.141592653589793;\nconst FBM_LACUNARITY: f32 = 1.8;\nconst FBM_GAIN: f32 = 0.42;\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\n// Scalars packed into vec4 lanes; per-satellite / per-trail / per-palette rows packed\n// into a vec4 so the array stride is the natural 16 bytes (no std140 stride trap \u2014 the\n// parity-blowout suspect the wave's \u00A7Triumvirate names).\nstruct Uniforms {\n  // s0: (uTime, uBodyRadius, uPulsePhase, uPulseAmp)\n  s0: vec4<f32>,\n  // s1: (uNoiseAmp, uNoiseFreq, uNoiseSpeed, uWarpAmp)\n  s1: vec4<f32>,\n  // s2: (uSmoothK, uMerge, uMaxReach, uLit)\n  s2: vec4<f32>,\n  // s3: (uSpecStrength, uSpecShininess, uRimPower, uRimStrength)\n  s3: vec4<f32>,\n  // s4: (uIridescence, uIridHue, uIridSpeed, uSssScale)\n  s4: vec4<f32>,\n  // s5: (uSssPower, uCoreGlow, uHueRange, uSatShift)\n  s5: vec4<f32>,\n  // s6: (uBrightnessShift, uColorNoiseFreq, uColorNoiseSpeed, uStretch)\n  s6: vec4<f32>,\n  // s7: (uPointerActive, uPointerAttraction, uPointerStrength, _pad)\n  s7: vec4<f32>,\n  // ptr: (uPointer.x, uPointer.y, uVelocity.x, uVelocity.y)\n  ptr: vec4<f32>,\n  // base: (uBaseColor.rgb, _pad)\n  base: vec4<f32>,\n  // rim: (uRimColor.rgb, _pad)\n  rim: vec4<f32>,\n  // light: (uLightDir.xyz, _pad)\n  light: vec4<f32>,\n  // res: (uResolution.x, uResolution.y, _pad, _pad)\n  res: vec4<f32>,\n  // ints: (uStopCount, uSatCount, uTrailCount, _pad)\n  ints: vec4<i32>,\n  palette: array<vec4<f32>, 4>,\n  satPos: array<vec4<f32>, 4>,   // (pos.x, pos.y, radius, opacity)\n  trailPos: array<vec4<f32>, 15>, // (pos.x, pos.y, radius, _pad)\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n\n// \u2500\u2500 Noise (blob-LOCAL 3D-p3 hash + IQ analytic-derivative gradient noise) \u2500\u2500\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\n// IQ analytic-derivative gradient noise \u2014 value in .x, ANALYTIC gradient (d/dx, d/dy) in\n// .yz, from one eval. The quintic fade has a continuous 2nd derivative.\nfn noised(p: vec2<f32>) -> vec3<f32> {\n  let i = floor(p);\n  let f = fract(p);\n  let uu = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n  let ga = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 0.0)), hash21(i + vec2<f32>(7.3, 0.0)));\n  let gb = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 0.0)), hash21(i + vec2<f32>(8.3, 0.0)));\n  let gc = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 1.0)), hash21(i + vec2<f32>(7.3, 1.0)));\n  let gd = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 1.0)), hash21(i + vec2<f32>(8.3, 1.0)));\n\n  let va = dot(ga, f - vec2<f32>(0.0, 0.0));\n  let vb = dot(gb, f - vec2<f32>(1.0, 0.0));\n  let vc = dot(gc, f - vec2<f32>(0.0, 1.0));\n  let vd = dot(gd, f - vec2<f32>(1.0, 1.0));\n\n  let n = va + uu.x * (vb - va) + uu.y * (vc - va) + uu.x * uu.y * (va - vb - vc + vd);\n  let value = 0.5 + 0.5 * n;\n\n  let grad =\n    ga + uu.x * (gb - ga) + uu.y * (gc - ga) + uu.x * uu.y * (ga - gb - gc + gd) +\n    du * (vec2<f32>(uu.y, uu.x) * (va - vb - vc + vd) + vec2<f32>(vb, vc) - va);\n  return vec3<f32>(value, 0.5 * grad);\n}\n\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nfn fbm(p0: vec2<f32>, octaves: i32) -> f32 {\n  var value = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 4; i = i + 1) {\n    if (i >= octaves) { break; }\n    value = value + amp * noised(p * freq).x;\n    p = FBM_ROT * p;\n    freq = freq * FBM_LACUNARITY;\n    amp = amp * FBM_GAIN;\n  }\n  return value;\n}\n\n// FBM with ANALYTIC GRADIENT \u2014 value in .x, \u2202/\u2202x, \u2202/\u2202y in .yz. The gradient accumulates\n// noised()'s analytic gradient per octave, chain-ruled through the per-octave frequency\n// scale AND the FBM_ROT rotation (the keystone feed for the analytic surface normal).\nfn fbmG(p: vec2<f32>, octaves: i32) -> vec3<f32> {\n  var value = 0.0;\n  var grad = vec2<f32>(0.0, 0.0);\n  var amp = 0.5;\n  var freq = 1.0;\n  var rotAccum = mat2x2<f32>(1.0, 0.0, 0.0, 1.0);\n  var pp = p;\n  for (var i = 0; i < 4; i = i + 1) {\n    if (i >= octaves) { break; }\n    let n = noised(pp * freq);\n    value = value + amp * n.x;\n    grad = grad + amp * freq * (transpose(rotAccum) * n.yz);\n    pp = FBM_ROT * pp;\n    freq = freq * FBM_LACUNARITY;\n    amp = amp * FBM_GAIN;\n    rotAccum = FBM_ROT * rotAccum;\n  }\n  return vec3<f32>(value, grad);\n}\n\n// One domain-warp pass with the ANALYTIC GRADIENT carried (warp-Jacobian approximation).\nfn fbmWarpedG(p: vec2<f32>, octaves: i32, warpAmp: f32) -> vec3<f32> {\n  if (warpAmp <= 0.0) { return fbmG(p, octaves); }\n  let q = vec2<f32>(fbm(p + vec2<f32>(0.0, 0.0), octaves),\n                    fbm(p + vec2<f32>(5.2, 1.3), octaves));\n  return fbmG(p + warpAmp * (q - 0.5), octaves);\n}\n\n// \u2500\u2500 SDF body (value+gradient circle + the IQ normalized smin, value+gradient form) \u2500\u2500\nfn sdgCircle(p: vec2<f32>, center: vec2<f32>, radius: f32) -> vec3<f32> {\n  let d = p - center;\n  let len = length(d);\n  var grad = vec2<f32>(0.0, 1.0);\n  if (len > 1e-6) { grad = d / len; }\n  return vec3<f32>(len - radius, grad);\n}\n\nfn sminQuadraticG(a: vec3<f32>, b: vec3<f32>, k0: f32) -> vec3<f32> {\n  let k = k0 * 4.0;\n  let h = max(k - abs(a.x - b.x), 0.0) / k;\n  let m = h * h * k * 0.25;\n  var w = 1.0 - 0.5 * h * h;\n  if (a.x < b.x) { w = 0.5 * h * h; }\n  let dist = min(a.x, b.x) - m;\n  let grad = mix(a.yz, b.yz, w);\n  return vec3<f32>(dist, grad);\n}\n\nfn sminCircularG(a: vec3<f32>, b: vec3<f32>, k0: f32) -> vec3<f32> {\n  let k = k0 * (1.0 / (1.0 - sqrt(0.5)));\n  let h = max(k - abs(a.x - b.x), 0.0) / k;\n  let m = k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n  var w = 1.0 - 0.5 * h;\n  if (a.x < b.x) { w = 0.5 * h; }\n  let dist = min(a.x, b.x) - m;\n  let grad = mix(a.yz, b.yz, w);\n  return vec3<f32>(dist, grad);\n}\n\nfn sminG(a: vec3<f32>, b: vec3<f32>, k: f32) -> vec3<f32> {\n  if (u.s2.y > 0.5) { return sminCircularG(a, b, k); }\n  return sminQuadraticG(a, b, k);\n}\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// \u2500\u2500 OKLCh gamut clamp (hue-preserving inward chroma clamp \u2014 blob-local) \u2500\u2500\nfn inGamut(lin: vec3<f32>) -> bool {\n  return all(lin >= vec3<f32>(0.0)) && all(lin <= vec3<f32>(1.0));\n}\nfn gamutClampOklch(lch: vec3<f32>) -> vec3<f32> {\n  let lin = oklabToLinearSrgb(oklchToOklab(lch));\n  if (inGamut(lin)) { return lch; }\n  var lo = 0.0;\n  var hi = lch.y;\n  for (var i = 0; i < 16; i = i + 1) {\n    let mid = 0.5 * (lo + hi);\n    let test = vec3<f32>(lch.x, mid, lch.z);\n    if (inGamut(oklabToLinearSrgb(oklchToOklab(test)))) { lo = mid; } else { hi = mid; }\n  }\n  return vec3<f32>(lch.x, lo, lch.z);\n}\n\n// AX.W15 \u2014 de-synced breath (three DETUNED sines at irrational ratios).\nfn breath(phase: f32) -> f32 {\n  return (sin(phase) + 0.5 * sin(phase * 1.4444 + 1.7) + 0.28 * sin(phase * 0.31 + 4.1)) / 1.78;\n}\n\n// AX.W15 \u2014 the composite SDF field WITH its ANALYTIC GRADIENT vec3(dist, \u2202/\u2202x, \u2202/\u2202y).\nfn sceneDistG(uv: vec2<f32>) -> vec3<f32> {\n  let uBodyRadius = u.s0.y;\n  let uPulsePhase = u.s0.z;\n  let uPulseAmp = u.s0.w;\n  let uNoiseAmp = u.s1.x;\n  let uNoiseFreq = u.s1.y;\n  let uNoiseSpeed = u.s1.z;\n  let uWarpAmp = u.s1.w;\n  let uSmoothK = u.s2.x;\n  let uTime = u.s0.x;\n  let uVelocity = u.ptr.zw;\n  let uStretch = u.s6.w;\n  let uSatCount = u.ints.y;\n  let uTrailCount = u.ints.z;\n\n  let bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;\n\n  // Velocity-driven VOLUME-PRESERVING squash-and-stretch (tanh-saturated).\n  var bodyUv = uv;\n  var ax = vec2<f32>(1.0, 0.0);\n  var perp = vec2<f32>(0.0, 1.0);\n  var sa = 1.0;\n  let speed = length(uVelocity);\n  let squashed = uStretch > 0.0 && speed > 1e-4;\n  if (squashed) {\n    ax = uVelocity / speed;\n    perp = vec2<f32>(-ax.y, ax.x);\n    sa = 1.0 + tanh(speed * 1.6) * uStretch;\n    bodyUv = vec2<f32>(dot(uv, ax) / sa, dot(uv, perp) * sa);\n  }\n\n  // Domain-warped FBM displacement WITH its analytic gradient.\n  let fbmv = fbmWarpedG(bodyUv * uNoiseFreq + uTime * uNoiseSpeed, 3, uWarpAmp);\n  let bodyDisplacement = (fbmv.x - 0.5) * uNoiseAmp;\n  let dispGradBody = uNoiseAmp * uNoiseFreq * fbmv.yz;\n\n  let bodyG = sdgCircle(bodyUv, vec2<f32>(0.0), bodyR + bodyDisplacement);\n  let bodyGradBody = bodyG.yz - dispGradBody;\n\n  var bodyGradUv: vec2<f32>;\n  if (squashed) {\n    let scaled = vec2<f32>(bodyGradBody.x / sa, bodyGradBody.y * sa);\n    bodyGradUv = scaled.x * ax + scaled.y * perp;\n  } else {\n    bodyGradUv = bodyGradBody;\n  }\n  var d = vec3<f32>(bodyG.x, bodyGradUv);\n\n  // Satellites \u2014 smin-merged into the body.\n  for (var i = 0; i < MAX_SATS; i = i + 1) {\n    if (i >= uSatCount) { break; }\n    let s = u.satPos[i];\n    var satG = sdgCircle(uv, s.xy, s.z);\n    satG.x = satG.x + (1.0 - s.w) * 0.3;\n    d = sminG(d, satG, uSmoothK);\n  }\n\n  // Pointer trail \u2014 a decaying-radius pseudopod.\n  for (var i = 0; i < TRAIL_N; i = i + 1) {\n    if (i >= uTrailCount) { break; }\n    let tp = u.trailPos[i];\n    let trailG = sdgCircle(uv, tp.xy, tp.z);\n    d = sminG(d, trailG, uSmoothK);\n  }\n  return d;\n}\n\n// AX.W15 \u2014 the analytic surface normal from the field gradient.\nfn surfaceNormalFromGrad(grad2d: vec2<f32>, d: f32, bodyR: f32) -> vec3<f32> {\n  let g = normalize(grad2d + vec2<f32>(1e-6));\n  let interior = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0);\n  let z = sqrt(max(0.0, 1.0 - (1.0 - interior) * (1.0 - interior)));\n  return normalize(vec3<f32>(g * (1.0 - z), z) + vec3<f32>(0.0, 0.0, 1e-6));\n}\n\n// W11.b \u2014 sample the multi-stop palette at t, OKLab mix + midpoint chroma-bump. Returns\n// an OKLCh stop [L, C, h(rad)]. Falls back to uBaseColor when uStopCount <= 1.\nfn samplePaletteOklch(t: f32) -> vec3<f32> {\n  let uStopCount = u.ints.x;\n  if (uStopCount <= 1) { return oklabToOklch(srgbToOklab(u.base.rgb)); }\n  let n = f32(uStopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, uStopCount - 1);\n  let f = ft - f32(i0);\n  let labA = srgbToOklab(u.palette[i0].rgb);\n  let labB = srgbToOklab(u.palette[i1].rgb);\n  let lab = mix(labA, labB, f);\n  var lch = oklabToOklch(lab);\n  lch.y = lch.y + 0.03 * sin(PI * f);\n  return lch;\n}\n\n// \u2500\u2500 Full-screen triangle vertex stage (the pilot idiom \u2014 no vertex buffer) \u2500\u2500\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var p = vec2<f32>(-1.0, -1.0);\n  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }\n  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }\n  var out: VSOut;\n  out.pos = vec4<f32>(p, 0.0, 1.0);\n  // vUv = aPos * 0.5 + 0.5 (the metaball.vert convention).\n  out.uv = p * 0.5 + 0.5;\n  return out;\n}\n\n// \u2500\u2500 Fragment stage (the main() transcription) \u2500\u2500\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let uTime = u.s0.x;\n  let uBodyRadius = u.s0.y;\n  let uPulsePhase = u.s0.z;\n  let uPulseAmp = u.s0.w;\n  let uMaxReach = u.s2.z;\n  let uLit = u.s2.w;\n  let uPointerActive = u.s7.x;\n  let uPointerAttraction = u.s7.y;\n  let uPointerStrength = u.s7.z;\n  let uPointer = u.ptr.xy;\n  let uHueRange = u.s5.z;\n  let uSatShift = u.s5.w;\n  let uBrightnessShift = u.s6.x;\n  let uColorNoiseFreq = u.s6.y;\n  let uColorNoiseSpeed = u.s6.z;\n  let uIridescence = u.s4.x;\n  let uIridHue = u.s4.y;\n  let uIridSpeed = u.s4.z;\n  let uSssScale = u.s4.w;\n  let uSssPower = u.s5.x;\n  let uCoreGlow = u.s5.y;\n  let uSpecStrength = u.s3.x;\n  let uSpecShininess = u.s3.y;\n  let uRimPower = u.s3.z;\n  let uRimStrength = u.s3.w;\n  let uLightDir = u.light.xyz;\n  let uRimColor = u.rim.rgb;\n\n  var uv = in.uv - 0.5;\n\n  // PRE-FBM bounding early-out \u2014 transparent WRITE (not a discard).\n  if (dot(uv, uv) > uMaxReach * uMaxReach) {\n    return vec4<f32>(0.0);\n  }\n\n  // Pointer deformation \u2014 sign per AY.W-BLOB-CONFIG D2.\n  if (uPointerActive > 0.5) {\n    let pointerDir = uPointer - uv;\n    let pointerDist = length(pointerDir);\n    let influence = smoothstep(0.5, 0.0, pointerDist) * uPointerAttraction * uPointerStrength;\n    uv = uv + normalize(pointerDir + vec2<f32>(1e-6)) * influence;\n  }\n\n  let bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;\n\n  // Composite domain-warped membrane field WITH its analytic gradient.\n  let scene = sceneDistG(uv);\n  let d = scene.x;\n  let fieldGrad = scene.yz;\n\n  // \u2500\u2500 fwidth SITE #1 (metaball.frag.ts line 266) \u2014 AA-edge half-width from the SDF\n  //    screen-space gradient. The WGSL fragment-stage fwidth() transcription. \u2500\u2500\n  let aa = max(fwidth(d), 1e-6);\n  let alpha = 1.0 - smoothstep(-aa, aa, d);\n\n  if (alpha < 0.001) {\n    return vec4<f32>(0.0);\n  }\n\n  // Edit #4 \u2014 perceptually-uniform OKLCh variation.\n  let colorNoise = fbm(uv * uColorNoiseFreq + uTime * uColorNoiseSpeed, 3);\n  var oklch = samplePaletteOklch(colorNoise);\n\n  oklch.z = oklch.z + (colorNoise - 0.5) * uHueRange * (PI / 180.0);\n  oklch.y = max(oklch.y + (colorNoise - 0.5) * uSatShift, 0.0);\n  oklch.x = clamp(oklch.x + uBrightnessShift, 0.0, 1.0);\n\n  let N = surfaceNormalFromGrad(fieldGrad, d, bodyR);\n  let V = vec3<f32>(0.0, 0.0, 1.0);\n  let thickness = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0);\n  let fres = pow(1.0 - max(dot(N, V), 0.0), 2.5);\n\n  // \u2500\u2500 W11.a iridescence \u2014 warm-biased IQ cosine palette driving OKLCh HUE \u2500\u2500\n  if (uIridescence > 0.0) {\n    let t = fres + 0.3 * colorNoise + uTime * uIridSpeed;\n    let iridHue = uIridHue + 0.18 * PI * cos(2.0 * PI * t);\n    let w = fres * uIridescence;\n    oklch.z = mix(oklch.z, iridHue, w);\n    oklch.y = min(oklch.y + 0.04 * w, oklch.y + 0.08);\n    oklch.x = min(oklch.x + 0.05 * w, 1.0);\n  }\n\n  // \u2500\u2500 W11.a fake subsurface translucency \u2014 thickness inner-glow + back-light \u2500\u2500\n  if (uCoreGlow > 0.0 || uSssScale > 0.0) {\n    oklch.x = min(oklch.x + uCoreGlow * (1.0 - exp(-3.0 * thickness)), 1.0);\n    let L = normalize(uLightDir + vec3<f32>(1e-6));\n    let back = pow(clamp(dot(V, -(L + N * thickness)), 0.0, 1.0), uSssPower);\n    let sss = back * uSssScale * (1.0 - thickness);\n    oklch.x = min(oklch.x + sss, 1.0);\n    oklch.z = oklch.z + sss * 0.1 * (1.0 - thickness);\n  }\n\n  oklch = gamutClampOklch(oklch);\n\n  var lin = oklabToLinearSrgb(oklchToOklab(oklch));\n\n  // \u2500\u2500 W9.b lit glass surface \u2014 Blinn-Phong glint + Fresnel rim, in LINEAR \u2500\u2500\n  if (uLit > 0.5) {\n    let L = normalize(uLightDir + vec3<f32>(1e-6));\n    let H = normalize(L + V);\n\n    let warmCream = oklabToLinearSrgb(oklchToOklab(vec3<f32>(0.97, 0.03, radians(85.0))));\n\n    // \u2500\u2500 fwidth SITE #2 (metaball.frag.ts line 364) \u2014 Toksvig normal-variance\n    //    specular clamp. The WGSL fragment-stage fwidth() of the surface normal. \u2500\u2500\n    let nVar = length(fwidth(N));\n    let shininess = uSpecShininess / (1.0 + 24.0 * nVar);\n    let energyNorm = (shininess + 2.0) / 8.0;\n    let spec = pow(max(dot(N, H), 0.0), shininess) * uSpecStrength * energyNorm;\n\n    var rimOkl = oklabToOklch(srgbToOklab(uRimColor));\n    let bodyL = oklch.x;\n    let dL = abs(rimOkl.x - bodyL);\n    let lack = clamp((0.22 - dL) / 0.22, 0.0, 1.0);\n    var target = 0.18;\n    if (bodyL < 0.5) { target = 0.92; }\n    rimOkl.x = clamp(mix(rimOkl.x, target, lack), 0.0, 1.0);\n    rimOkl.y = rimOkl.y * mix(1.0, 0.5, lack);\n    let rimLin = oklabToLinearSrgb(oklchToOklab(rimOkl));\n\n    let rimFres = pow(1.0 - max(dot(N, V), 0.0), uRimPower);\n    let rim = rimFres * uRimStrength * (1.0 - 0.6 * thickness);\n\n    var highlight = max(warmCream * spec, rimLin * rim);\n    highlight = min(highlight, vec3<f32>(0.85));\n    lin = lin + highlight;\n  }\n\n  var rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // IGN dither \u2014 1-LSB triangular dither in DISPLAY space, AFTER linearToSrgb.\n  let fragCoord = in.pos.xy;\n  let ign = fract(52.9829189 * fract(dot(fragCoord, vec2<f32>(0.06711056, 0.00583715))));\n  rgb = clamp(rgb + (ign - 0.5) / 255.0, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // premultiply AFTER the OETF: straight-alpha gamma \u2192 premultiplied.\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/handmark/HandMark.vue.d.ts

@@ -0,0 +1,29 @@
+import type { HandMarkProps } from "./types";
+declare function play(): void;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<HandMarkProps, {
+    play: typeof play;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HandMarkProps> & Readonly<{}>, {
+    color: string;
+    animation: import("./types").HandAnimation;
+    seed: number;
+    shape: import("./types").HandShape;
+    appear: "mount" | "visible" | "manual";
+    jagged: boolean;
+    brush: import("./brush").BrushName | Partial<import("./brush").Brush>;
+    drawMs: number;
+    drawDelayMs: number;
+    boilFps: number;
+    boilFrames: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};