@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/avatar/index.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Avatar } from './Avatar.vue';
+export { default as AvatarImage } from './AvatarImage.vue';
+export { default as AvatarFallback } from './AvatarFallback.vue';
+export declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type AvatarVariants = VariantProps<typeof avatarVariants>;

package/dist/components/badge/Badge.vue.d.ts

@@ -0,0 +1,41 @@
+import type { HTMLAttributes } from 'vue';
+import { type BadgeVariants } from './';
+type __VLS_Props = {
+    variant?: BadgeVariants['variant'];
+    /**
+     * BI.W-SYNONYM-RENAMES — the semantic status register (the shared `tone` axis:
+     * neutral/destructive/success/warning/info). Orthogonal to the `variant` STYLE
+     * plate; a set tone overrides the plate colour. Replaces the former
+     * `variant="destructive|success|warning|info"` (a tone is not a style).
+     */
+    tone?: BadgeVariants['tone'];
+    size?: BadgeVariants['size'];
+    /**
+     * BD.W-GLASS-ATOM-REGISTER — the register split. `loud` (default) is the opaque
+     * saturated identity pill; `glass` is the quiet transmissive `.glass-atom`
+     * capsule tinted via `--glass-fill-tint`. A status badge stays loud (information,
+     * not a sticker); `secondary`/`outline` placements may route quiet.
+     */
+    surface?: BadgeVariants['surface'];
+    /**
+     * The LOUD cel cast opt-in (BD.W-CARTOON-CASTER). Every badge carries the
+     * family floor (the press-squish + a hairline rim-cast); `cast` INTENSIFIES the
+     * loud layered-offset stamp + mounts the inert `.cartoon-cast` child. A status
+     * pill is information, so the loud stamp is opt-in (not the default).
+     */
+    cast?: boolean;
+    class?: HTMLAttributes['class'];
+};
+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<{}>, {}, {}, {}, {}, 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/badge/index.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Badge } from './Badge.vue';
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | null | undefined;
+    tone?: "neutral" | "success" | "warning" | "info" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    surface?: "glass" | "loud" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/components/blob/Blob.vue.d.ts

@@ -0,0 +1,72 @@
+import type { BlobMood, BlobConfig, BlobVariant } from "./types";
+/**
+ * Blob — a gooey metaball creature on a WebGL2 canvas.
+ *
+ * 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 `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
+ * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly; a `var(--token)` is
+ * un-wrapped to a concrete string by the SFC's `resolveTokenColor` leaf BEFORE the
+ * renderer sees it (the DOM-free renderer contract).
+ *
+ * Config is resolved with a loud discipline: either
+ * `provide(BLOB_CONFIG_KEY, cfg)` from an ancestor OR pass an explicit `config`
+ * prop. A mount with NEITHER throws — there is no silent reactive-defaults
+ * synthesis. A consumer that genuinely wants the stock tuning passes
+ * `BLOB_CONFIG_DEFAULTS` explicitly.
+ */
+type __VLS_Props = {
+    /** Base CSS color string (a `var()`/`oklch()`/`lab()`/`hsl()`/hex form; resolved
+     *  internally through the `/color` leaf to a gamma-sRGB triple). */
+    color: string;
+    /**
+     * REQUIRED unless an ancestor `provide(BLOB_CONFIG_KEY, …)` supplies it.
+     * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.
+     */
+    config?: BlobConfig;
+    /**
+     * BC.W-GOOBLOB-PLAIN — the render-variant axis. `"blob"` is the STAGE-1
+     * shadowless lightless fill-only floor; `"meatball"` (default) is the full lit
+     * register. When set it WINS the resolved config's `variant` (the per-instance
+     * override); unset, the config's own `variant` rules. STAGE 1's `uStage` gate
+     * strips the lit/shadow blocks for the `"blob"` register.
+     */
+    variant?: BlobVariant;
+    /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
+    seed?: string;
+    /**
+     * AX.W16 — the declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the
+     * render loop (the substrate's `manual` suspend) when `true` and restarts it when
+     * `false`. This is the EXACT shape `<DockBackgroundToggle>` wears — wire its
+     * `@update:paused` to this `v-model` and the blob's animation stops/starts for ALL
+     * users. The imperative `pause()`/`resume()` defineExpose handles bind the SAME
+     * renderer seam (no parallel pause path); the prop owns the default.
+     */
+    paused?: boolean;
+};
+declare function nudge(): void;
+declare function setMood(m: BlobMood): void;
+declare function pulse(): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    nudge: typeof nudge;
+    setMood: typeof setMood;
+    pulse: typeof pulse;
+    currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
+    pause: () => void;
+    resume: () => void;
+    settled: Readonly<import("vue").Ref<boolean, boolean>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+    "update:paused": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/blob/composables/satelliteKinematics.d.ts

@@ -0,0 +1,20 @@
+import type { SatelliteInternal } from "../types";
+/**
+ * The stateless satellite KINEMATICS leaf (BG.W-BLOB-KINEMATICS-LEAF) — the
+ * orbit / eccentricity / wobble math carved out of `useBlobSatellites.ts`.
+ *
+ * Every function here is PURE: it takes the PRNG, the geometry, and the tempo
+ * clock as EXPLICIT parameters and owns NO closure state, NO `SpringProgress`,
+ * NO Vue reactivity, and NO module-level mutable state. The satellite pool +
+ * the phase state-machine live in the driver (`useBlobSatellites.ts`), which
+ * COMPOSES these — one writer of the satellite state (the driver), and the
+ * kinematics math beside it (this leaf). The `rng` is passed IN, never owned:
+ * the seed / reseed discipline stays with the stateful driver.
+ */
+declare function createSatellite(rng: () => number, index: number, orbitRadius: number, eccentricity: number, now: number): SatelliteInternal;
+declare function orbitPos(s: SatelliteInternal, now: number, orbitSpeedScale: number, wobbleScale: number): {
+    x: number;
+    y: number;
+};
+declare function randomizeOrbit(s: SatelliteInternal, rng: () => number, orbitRadius: number, eccentricity: number, now: number): void;
+export { createSatellite, orbitPos, randomizeOrbit };

package/dist/components/blob/composables/uploadBlobUniforms.d.ts

@@ -0,0 +1,51 @@
+import type { BlobConfig, MoodParams } from "../types";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+import { MAX_SATS, TRAIL_N, MAX_BLOB_STOPS, POS_SCALE, UNIFORM_NAMES } from "../constants";
+import type { UniformName } from "../constants";
+export { MAX_SATS, TRAIL_N, MAX_BLOB_STOPS, POS_SCALE, UNIFORM_NAMES };
+export type { UniformName };
+/** The cached uniform-location set the GL setup builds once per context. */
+export interface MetaballUniformLocations {
+    U: Record<UniformName, WebGLUniformLocation | null>;
+    satPosLocs: (WebGLUniformLocation | null)[];
+    satRadLocs: (WebGLUniformLocation | null)[];
+    satOpLocs: (WebGLUniformLocation | null)[];
+    satColorLocs: (WebGLUniformLocation | null)[];
+    satColorAmtLocs: (WebGLUniformLocation | null)[];
+    trailPosLocs: (WebGLUniformLocation | null)[];
+    trailRadLocs: (WebGLUniformLocation | null)[];
+    paletteLocs: (WebGLUniformLocation | null)[];
+}
+/** The per-frame state the renderer resolves and hands to the upload leaf. */
+export interface BlobFrameState {
+    /** The mood params for this frame (`mood.params.value`). */
+    params: MoodParams;
+    /** The resolved base-color gamma-sRGB triple. */
+    rgb: [number, number, number];
+    /** The tempo-integrated motion clock (ms). */
+    simTimeMs: number;
+    /** The substrate's seconds clock for this frame (the pulse-phase axis). */
+    timeSec: number;
+    /** A CONCRETE → gamma-sRGB triple resolver (the renderer's memoised `/color` leaf). */
+    resolveColor: (css: string) => [number, number, number];
+    /** The Fresnel rim color (CONCRETE — the SFC un-wrapped any var()-token). */
+    rimColor: string;
+    /** The multi-stop palette (CONCRETE strings; EMPTY → falls back to base). */
+    paletteStops: string[];
+    /**
+     * F9.R1 (BG.W-BLOB-SATELLITE-SHADE) — the per-satellite explicit shades (CONCRETE
+     * strings, index-aligned to the satellite array; EMPTY/undefined → the derived
+     * palette shade, byte-identical to HEAD). A set entry tints that satellite's
+     * smin-field neighbourhood toward the shade; an unset/empty entry leaves it on the
+     * derived base. The GL color-seam value.js's hero blob derives satellite shades into.
+     */
+    satColors?: string[];
+}
+/**
+ * Write the resolved frame state into the metaball program's uniforms and issue
+ * the draw call. Pure: it mutates GL state only (the bound program/VAO + the
+ * uniform values) and never reads the renderer's closure. The body is the
+ * byte-identical lift of the prior inline `drawFrame` uniform-upload section.
+ */
+export declare function uploadBlobUniforms(gl: WebGL2RenderingContext, prog: WebGLProgram, vao: WebGLVertexArrayObject, locs: MetaballUniformLocations, canvas: HTMLCanvasElement, config: BlobConfig, pointer: BlobPointer, satellites: BlobSatelliteSystem, frame: BlobFrameState): void;

package/dist/components/blob/composables/useBlobPointer.d.ts

@@ -0,0 +1,88 @@
+import { type Ref } from "vue";
+import { TRAIL_N } from "../constants";
+/** Compile-time trail length — re-exported from the co-located shape budget (`../constants`). */
+export { TRAIL_N };
+/** A single trail sample — a decaying-radius metaball source the shader smin-merges. */
+export interface TrailSample {
+    x: number;
+    y: number;
+    radius: number;
+}
+/**
+ * The blob pointer/interaction machine (W10). Tracks the pointer over a host
+ * element (normalised to [-1, 1] about the element centre) and resolves it with a
+ * FRAME-RATE-INDEPENDENT critically-damped spring fed the renderer's per-frame
+ * `dtMs` (NOT a fixed-α lerp — the prior `SMOOTH_FACTOR = 0.12` was framerate
+ * dependent). The spring is `@mkbabb/keyframes.js` `SpringProgress` driven through
+ * its `tickDt(dtMs)` seam by the SUBSTRATE's single rAF — it does NOT call
+ * `SpringProgress.play()` (that would start a parallel rAF, the
+ * single-substrate-loop violation `proof:blob-interaction-prm` forbids).
+ *
+ * Exposes the smoothed `pointer` position AND its `velocity` (the spring's own
+ * per-frame velocity, units/s in normalized space), plus a decaying-radius `trail`
+ * buffer (the elastic pseudopod reaching toward the cursor and snapping back).
+ *
+ * Under `prefers-reduced-motion` the substrate freezes the rAF, so `tick` is not
+ * called and every axis holds its rest value — there is NO parallel matchMedia
+ * here (the substrate owns PRM). The deterministic rest pose: the spring at the
+ * pointer target (or centre when inactive), zero velocity, the trail collapsed
+ * onto the body.
+ *
+ * F9.R8 (BG.W-BLOB-AFFECT-INTERACT — pointer truth) — the SDF-SHAPED HIT-TEST. The
+ * listener box is a SQUARE, but the blob silhouette is the body DISC (the satellites
+ * orbit OUTSIDE the box). `options.hitRadius()` returns the silhouette radius in the
+ * normalized [-1, 1] space; `hitTest(clientX, clientY)` is the authoritative predicate
+ * the engage + click gates read, and `onPointerMove` engages the attract ONLY inside
+ * it — so hovering the empty box margin never lunges the blob, and the caller lets a
+ * corner click FALL THROUGH to a sibling card (the `.goo-blob-hit` clip-path is the
+ * compositor-level twin). With `hitRadius` UNSET the whole box engages (byte-identical
+ * to the prior always-on `active`) — the tight silhouette is the opt-in a shaped
+ * consumer (GooBlob) passes; the UNSET-whole-box default stays byte-preserved.
+ */
+export declare function useBlobPointer(el: Ref<HTMLElement | null>, options?: {
+    hitRadius?: () => number;
+}): {
+    pointer: Readonly<Ref<{
+        readonly x: number;
+        readonly y: number;
+    }, {
+        readonly x: number;
+        readonly y: number;
+    }>>;
+    velocity: Readonly<Ref<{
+        readonly x: number;
+        readonly y: number;
+    }, {
+        readonly x: number;
+        readonly y: number;
+    }>>;
+    active: Readonly<Ref<boolean, boolean>>;
+    /**
+     * BI.W-FIELD-CORE — the RAW pointer target (pre-spring, [-1,1] body space). The
+     * shared `usePointerVelocityField` reads THIS (not the smoothed `pointer`) so the
+     * field is the ONE smoothing stage — the double-smooth (feeding the spring output
+     * into the field, which smooths it AGAIN) is dead. The blob's own body spring reads
+     * `rawX`/`rawY` too (parallel, not serial), so no lag compounds.
+     */
+    rawPointer: () => {
+        x: number;
+        y: number;
+    };
+    /** The live click-impulse pulse value (folds into uPulseAmp). */
+    pulse: Readonly<Ref<number, number>>;
+    /** ms since the last pointer activity (W11.c mood idle drift). */
+    idleMs: () => number;
+    tick: (dtMs?: number) => void;
+    trailSources: (baseRadius: number) => {
+        sources: TrailSample[];
+        count: number;
+    };
+    click: (amp: number) => void;
+    consumeClick: () => boolean;
+    rest: () => void;
+    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    isAtRest: () => boolean;
+    /** F9.R8 — the SDF-shaped hit-test (is a client point inside the blob silhouette?). */
+    hitTest: (clientX: number, clientY: number) => boolean;
+};
+export type BlobPointer = ReturnType<typeof useBlobPointer>;

package/dist/components/blob/composables/useMetaballRenderer.d.ts

@@ -0,0 +1,100 @@
+import { type Ref } from "vue";
+import type { BlobConfig } from "../types";
+import type { BlobMoodSystem } from "./useBlobMood";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+export interface UseMetaballRendererOptions {
+    canvasRef: Ref<HTMLCanvasElement | null>;
+    /** The base color, ALREADY un-wrapped to a CONCRETE string by the SFC (DOM-free). */
+    color: Ref<string>;
+    /**
+     * The Fresnel rim color, ALREADY un-wrapped to a CONCRETE string by the SFC
+     * (AX.W16 — the renderer no longer reaches the DOM for the `var()`-cascade read;
+     * the SFC's `resolveTokenColor` leaf does ALL un-wrapping before the renderer sees
+     * it). A `var(--token)` rim arrives here already resolved to `rgb(...)`.
+     */
+    rimColor: Ref<string>;
+    /**
+     * The multi-stop palette, ALREADY un-wrapped to CONCRETE strings by the SFC
+     * (AX.W16). EMPTY falls back to the base color (uStopCount <= 1).
+     */
+    paletteStops: Ref<string[]>;
+    /**
+     * F9.R1 (BG.W-BLOB-SATELLITE-SHADE) — the OPTIONAL per-satellite explicit shades,
+     * ALREADY un-wrapped to CONCRETE strings by the SFC (mirroring `paletteStops`).
+     * Absent/EMPTY → the derived palette shade (the GL seam stays OFF, byte-identical).
+     */
+    satelliteColors?: Ref<string[]>;
+    mood: BlobMoodSystem;
+    pointer: BlobPointer;
+    satellites: BlobSatelliteSystem;
+    config: BlobConfig;
+    /**
+     * BI.W-E10-AURORA-ENTRANCE (value.js T-60) — the reveal-bloom CONSUMER DOOR
+     * (the twin of `AuroraRuntimeOptions.revealBloom`; the door lands on BOTH
+     * chromatic runtimes). The one-shot cold-first-VISIBLE `filter`-bloom
+     * (`data-substrate-reveal` → `@keyframes substrate-reveal-bloom`). Defaults
+     * `true` — the blob keeps a materialize entrance, but the keyframe is now
+     * PALETTE-HONEST (brightness/saturate never dip below 1, viz-reveal.css), so it
+     * never transits the `brightness<1`/`saturate<1` gray veil T-60 condemned over
+     * the chromatic field. A consumer (BI.W-BLOB-SEAMS, or an arrival-sync host)
+     * opts out with `false`.
+     */
+    revealBloom?: boolean;
+}
+/** 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;
+    /**
+     * BI.W-BLOB-SEAMS (GAP-L5 / value.js T-49) — the public QUIESCENCE seam. `true`
+     * IFF the engine is at rest: the mood is settled, the pointer is at rest, AND no
+     * satellite is mid-transition (merging / absorbed / emerging / FISSIONING) —
+     * i.e. zero in-flight fission beat. Derived from the SAME predicate the demand
+     * gate (`shouldContinue`) reads to decide whether to park — NO parallel busy-flag
+     * (the U3 single-signal discipline; the seam READS what the engine already knows,
+     * no second physics). A consumer parks ITS OWN idle/arming logic only while
+     * `settled` is true, so an armed-but-idle hero never freezes mid-split (the
+     * value.js 2.7s-idle-vs-5.2s-fission-beat mismatch this closes). READ-ONLY — a
+     * consumer observes it, never writes it.
+     */
+    settled: Readonly<Ref<boolean>>;
+}
+/**
+ * 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 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
+ * (the faithful AU.W7 lift paints gamma). The renderer is DOM-FREE: it never un-wraps
+ * a `var(--token)` — the SFC's `resolveTokenColor` leaf does that BEFORE handing
+ * concrete strings here (inv-K-3 seam); the value.js 1×1-canvas DOM probe is gone.
+ */
+export declare function useMetaballRenderer(options: UseMetaballRendererOptions): UseMetaballRendererReturn;

package/dist/components/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/blob/config.d.ts

@@ -0,0 +1,3 @@
+export type { BlobMood, BlobMerge, BlobVariant, BlobQuality, MoodParams, MetaballSource, BlobConfig, BlobGeometry, BlobSatelliteTiming, BlobMembrane, BlobColor, BlobSurface, BlobInteraction, SatellitePhase, SatelliteInternal, } from "./types";
+export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
+export { BLOB_HERO, LIGHTNESS_FLOOR_BRACKET, LIGHTNESS_FLOOR_DEFAULT, clampLightnessFloor, } from "./presets";

package/dist/components/blob/constants.d.ts

@@ -0,0 +1,82 @@
+import type { BlobMood, MoodParams } from "./types";
+/** Compile-time satellite cap — mirrors `uSat*[N]` in metaball.frag.ts. */
+export declare const MAX_SATS = 4;
+/** Compile-time trail length — mirrors the `uTrail*[N]` arrays in metaball.frag.ts. */
+export declare const TRAIL_N = 15;
+/** Compile-time palette cap — mirrors `#define MAX_BLOB_STOPS` in metaball-uniforms.glsl.ts. */
+export declare const MAX_BLOB_STOPS = 4;
+/**
+ * Canvas is CSS-sized 1.6x its layout wrapper (see GooBlob.vue). Positions are in
+ * [-0.5, 0.5] normalized space mapped to canvas UVs. To make the layout footprint
+ * represent the "visible blob region" and have the extra 60% of canvas serve as
+ * overflow margin for satellite orbits, scale all length-like uniforms by
+ * 1/1.6 = 0.625.
+ */
+export declare const POS_SCALE: number;
+/** The full ordered scalar/vector uniform-name list the program builder caches a location per. */
+/** A point in the 2-axis circumplex affect space. */
+export interface AffectPoint {
+    /** Pleasantness, -1 (unpleasant) .. +1 (pleasant). */
+    valence: number;
+    /** Activation, 0 (calm/sleepy) .. 1 (energized/excited). */
+    arousal: number;
+}
+/** The five named moods as POINTS in the {valence, arousal} circumplex. */
+export declare const MOOD_AVA: Record<BlobMood, AffectPoint>;
+/**
+ * Derive the full MoodParams from a {valence, arousal} point. Arousal drives the
+ * motion energy (orbit speed, wobble, pulse rate/amp, noise, the iridescence/SSS
+ * sheen); valence warms the palette (hue range, chroma, brightness) and the
+ * pointer lean. ONE principled surface — the five named moods are samples of it.
+ */
+export declare function paramsFor({ valence, arousal }: AffectPoint): MoodParams;
+/** The resolved per-mood target params (samples of the `paramsFor` surface). */
+export declare const MOOD_TARGETS: Record<BlobMood, MoodParams>;
+/** The per-mood cross-fade duration (ms). */
+export declare const TRANSITION_MS: Record<BlobMood, number>;
+/** Idle timeout (ms of no pointer) after which the blob drifts to `sleepy`. */
+export declare const IDLE_SLEEP_MS = 6000;
+/** Click-impulse spring ring frequency (rad/s). */
+export declare const PULSE_OMEGA = 18;
+/** Click-impulse spring damping (< 1 = underdamped, overshoot-then-settle). */
+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;
+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;
+/** Minimum spacing (ms) between satellite merge events. */
+export declare const MERGE_STAGGER_MS = 3000;
+/**
+ * The bounded fission APEX (config-UV) — the orbit radius the fissioning satellite
+ * breathes OUT to at its excursion peak. Beyond the body skin (0.22) by a clean gap that
+ * exceeds the smin reach so the neck SNAPS; bounded so the single fissioner + apex rule
+ * re-prevents the "two unrelated discs" failure WITHOUT the blanket never-leaves-reach
+ * clamp. Paints at `FISSION_REACH_MAX · POS_SCALE` uv.
+ */
+export declare const FISSION_REACH_MAX = 0.4;
+/** The fission PERIAPSIS (config-UV) — the merged-in radius the satellite gathers to before the snap (well inside the body skin, fully bonded). */
+export declare const FISSION_REACH_MIN = 0.18;
+/**
+ * The full fission BEAT duration (ms) — the SLOW gather + FAST snap + re-merge window the
+ * `fissioning` phase runs for. Long enough that the colony reads as a steady-state
+ * merge↔split breath (perpetually mid-merge on one satellite while mid-split on another),
+ * NOT a rare twitch. The `fissionSnap` curve maps the beat's `t in [0,1]` to the reach.
+ */
+export declare const FISSION_BEAT_MS = 5200;
+/**
+ * The fission INTENSITY → cadence map. `fissionAmp` (0..1, config × mood) scales how
+ * OFTEN a satellite enters the fissioning beat vs the calm bonded breath: at amp 0 the
+ * fission probability is 0 (the calm default never splits); at amp 1 a satellite reaching
+ * its orbit-phase boundary enters `fissioning` with this probability instead of a plain
+ * merge. Mood-coupled (excited raises the effective amp, sleepy lowers it).
+ */
+export declare const FISSION_PROB_AT_FULL = 0.75;
+export declare const UNIFORM_NAMES: readonly ["uResolution", "uTime", "uBaseColor", "uPointer", "uPointerActive", "uPointerAttraction", "uPointerStrength", "uBodyRadius", "uPulsePhase", "uPulseAmp", "uNoiseAmp", "uNoiseFreq", "uNoiseSpeed", "uWarpAmp", "uSmoothK", "uMerge", "uStage", "uMorphT", "uMaxReach", "uLit", "uRimColor", "uLightDir", "uSpecStrength", "uSpecShininess", "uRimPower", "uRimStrength", "uShadow", "uShadowSoftness", "uIridescence", "uIridHue", "uIridSpeed", "uSssScale", "uSssPower", "uCoreGlow", "uHueRange", "uSatShift", "uBrightnessShift", "uColorNoiseFreq", "uColorNoiseSpeed", "uStopCount", "uSatCount", "uSatColorActive", "uTrailCount", "uVelocity", "uStretch"];
+export type UniformName = (typeof UNIFORM_NAMES)[number];

package/dist/components/blob/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Blob } from "./Blob.vue";
+export type { BlobMood, BlobMerge, BlobVariant, BlobQuality, MoodParams, MetaballSource, BlobConfig, BlobGeometry, BlobSatelliteTiming, BlobMembrane, BlobColor, BlobSurface, BlobInteraction, SatellitePhase, SatelliteInternal, } from "./types";
+export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
+export { BLOB_HERO, LIGHTNESS_FLOOR_BRACKET, LIGHTNESS_FLOOR_DEFAULT, clampLightnessFloor, } from "./presets";
+export { useBlobMood, type BlobMoodSystem } from "./composables/useBlobMood";
+export { useBlobPointer, type BlobPointer } from "./composables/useBlobPointer";
+export { useBlobSatellites, type BlobSatelliteSystem, } from "./composables/useBlobSatellites";
+export { useMetaballRenderer, type UseMetaballRendererOptions, } from "./composables/useMetaballRenderer";

package/dist/components/blob/presets.d.ts

@@ -0,0 +1,14 @@
+import type { BlobConfig } from "./types";
+/** The D8 OKLab-L ink-floor bracket — `[min, max]` (BI.W-BLOB-SEAMS / value.js GAP-L5). */
+export declare const LIGHTNESS_FLOOR_BRACKET: readonly [number, number];
+/** The default derived-palette OKLab-L floor (mid-bracket). */
+export declare const LIGHTNESS_FLOOR_DEFAULT = 0.15;
+/**
+ * Clamp a lightness-floor value into the {@link LIGHTNESS_FLOOR_BRACKET} `[0.12, 0.20]`.
+ * A non-finite / omitted value resolves to {@link LIGHTNESS_FLOOR_DEFAULT} (0.15). Pass
+ * the result to `deriveBlobPalette`'s `lightnessFloor` so a consumer/HERO body never
+ * derives below the ink floor NOR above the deep-body ceiling — the bracket is the
+ * contract, the atom is the knob.
+ */
+export declare function clampLightnessFloor(v?: number): number;
+export declare const BLOB_HERO: BlobConfig;

package/dist/components/blob/shaders/metaball-uniforms.glsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_UNIFORMS_GLSL = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform vec2 uResolution;\nuniform float uTime;\nuniform vec3 uBaseColor;\n\n// Multi-stop palette (W11.b) \u2014 2-4 in-family OKLCh stops (uploaded GAMMA sRGB, like\n// uBaseColor). uStopCount <= 1 falls back to uBaseColor (the single-color default,\n// zero regression). MAX_BLOB_STOPS is a compile-time #define.\n#define MAX_BLOB_STOPS 4\nuniform int uStopCount;\nuniform vec3 uPalette[MAX_BLOB_STOPS];\n\n// Pointer\nuniform vec2 uPointer;\nuniform float uPointerActive;\nuniform float uPointerAttraction;\nuniform float uPointerStrength;\n\n// Main body\nuniform float uBodyRadius;\n\n// Pulsation\nuniform float uPulsePhase;\nuniform float uPulseAmp;\n\n// Surface noise\nuniform float uNoiseAmp;\nuniform float uNoiseFreq;\nuniform float uNoiseSpeed;\n\n// Gooey\nuniform float uSmoothK;\nuniform float uMerge;   // 0 = quadratic smin, 1 = circular smin (rounder menisci)\n\n// BC.W-GOOBLOB-PLAIN \u2014 the STAGE-1 gate. 1.0 = the plain shadowless lightless\n// fill-only floor (variant=\"blob\"); 0.0 = the full lit pipeline (variant=\"meatball\" /\n// STAGE 2). The WebGL2 fallback transcribes the SAME stripped branch the WGSL primary\n// gates (research/viz/goo-blob.md \u00A75 \u2014 the GLSL twin).\n// BD.W-GOO-CAROUSEL-DECK \u2014 uStage is now DERIVED from uMorphT (uStage = uMorphT<=0 ?\n// 1 : 0) at upload; the SHADING morph (below) reads uMorphT directly.\nuniform float uStage;\n\n// BD.W-GOO-CAROUSEL-DECK \u2014 the blob to meatball SHADING-MORPH scalar. 0.0 = the flat blob\n// fill (byte-identical to the STAGE-1 floor), 1.0 = the fully-dressed lit meatball; the\n// in-between LERPS the surface shading (NOT the geometry \u2014 the smin field is shared). The\n// renderer resolves it from config.morphT (variant to endpoint back-compat: blob to 0,\n// meatball to 1). A consumer ANIMATING morphT 0 to 1 gets the live morph.\nuniform float uMorphT;\n\n// AX.W16 (arm 5) \u2014 the PRE-FBM bounding-discard radius (UV space). main() early-outs\n// to a transparent write for any fragment OUTSIDE this radius BEFORE the two 3-octave\n// FBM calls + the OKLCh round-trip. The renderer uploads it PADDED by every\n// outward-expanding term (body + eccentric orbit + sat radius + smin band + FBM edge\n// amplitude + click-pulse + a lean/squash safety pad) so it NEVER clips the wet\n// meniscus (IQ: inflate the bound to match any outward op).\nuniform float uMaxReach;\n\n// Membrane \u2014 domain-warp strength on the FBM edge displacement (0 = plain fbm).\nuniform float uWarpAmp;\n\n// Lit glass surface (W9.b) \u2014 gated behind uLit so the flat fill stays default.\nuniform float uLit;             // 0 = flat fill (default), 1 = lit droplet\nuniform vec3 uRimColor;         // Fresnel rim tint (GAMMA sRGB, via the /color leaf)\nuniform vec3 uLightDir;         // normalized light direction (x, y, z)\nuniform float uSpecStrength;    // Blinn-Phong specular weight\nuniform float uSpecShininess;   // specular exponent (16-64, tight glint)\nuniform float uRimPower;        // Fresnel/Schlick exponent (~2-3)\nuniform float uRimStrength;     // Fresnel rim weight\n\n// BC.W-GOOBLOB-MEATBALL \u2014 the procedural 2D SDF soft-shadow march (T2, the GLSL twin of\n// the WGSL res.z/res.w lanes). uShadow gates the IQ rmshadows soft contact shadow that\n// FOLLOWS the irregular silhouette; uShadowSoftness is the penumbra hardness (4-48).\nuniform float uShadow;          // 0 = no shadow, 1 = the soft contact shadow ON\nuniform float uShadowSoftness;  // penumbra hardness (inverse light-source size, 4-48)\n\n// Iridescence + fake subsurface (W11.a) \u2014 translucent-gel read.\nuniform float uIridescence;     // warm-pearl rim sheen weight (0 = off)\nuniform float uIridHue;         // base hue (radians) the cosine palette biases toward (warm)\nuniform float uIridSpeed;       // animated-thickness scroll for the iridescent t\nuniform float uSssScale;        // fast-SSS back-light weight\nuniform float uSssPower;        // fast-SSS exponent\nuniform float uCoreGlow;        // thickness-driven inner-luminosity lift\n\n// Color perturbation (perceptually uniform \u2014 OKLCh L/C/h)\nuniform float uHueRange;        // degrees of hue swing (converted to radians)\nuniform float uSatShift;        // OKLCh chroma swing\nuniform float uBrightnessShift; // OKLCh lightness bias\nuniform float uColorNoiseFreq;\nuniform float uColorNoiseSpeed;\n\n// Satellites (max 4)\n#define MAX_SATS 4\nuniform int uSatCount;\nuniform vec2 uSatPos[MAX_SATS];\nuniform float uSatRadius[MAX_SATS];\nuniform float uSatOpacity[MAX_SATS];\n\n// F9.R1 (BG.W-BLOB-SATELLITE-SHADE) \u2014 the per-satellite EXPLICIT-SHADE seam (the GL\n// color-seam widen the value.js hero blob asked for; the BA-VJS-5 / C-1 residual, the\n// W-GOO-REDRESS arm-B book discharged). uSatColorActive == 0 is the DEFAULT (the derived\n// palette shade \u2014 byte-identical to HEAD): blendSatColor() early-returns and touches\n// nothing. When a consumer supplies explicit per-satellite shades (uSatColor[i], GAMMA\n// sRGB, at uSatColorAmt[i] weight \u2014 typically 1) the fragment blends the base palette\n// OKLCh toward each satellite's shade, weighted by that satellite's smin-field proximity\n// at this pixel. The body keeps the derived base (the ask is per-SATELLITE).\nuniform int uSatColorActive;\nuniform vec3 uSatColor[MAX_SATS];\nuniform float uSatColorAmt[MAX_SATS];\n\n// Pointer trail (W10) \u2014 a decaying-radius pseudopod toward the cursor. uTrail is a\n// COMPILE-TIME-SIZED array (GLSL ES 3.00 forbids a uniform-sized array) with a\n// DYNAMIC break on uTrailCount, mirroring the satellite loop. Later samples paint\n// smaller metaballs (r *= 1 - i/N) so the trail tapers into a tail.\n#define TRAIL_N 15\nuniform int uTrailCount;\nuniform vec2 uTrailPos[TRAIL_N];\nuniform float uTrailRadius[TRAIL_N];\n\n// Velocity-driven volume-preserving squash-and-stretch (W10).\nuniform vec2 uVelocity;   // smoothed pointer velocity (motion direction + speed)\nuniform float uStretch;   // squash-stretch magnitude (0 = off)\n\nconst float PI = 3.141592653589793;\n";