@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -1,62 +0,0 @@
-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.
- */
-export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
-    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>>;
-    /** 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;
-};
-export type BlobPointer = ReturnType<typeof useBlobPointer>;

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

@@ -1,69 +0,0 @@
-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[]>;
-    mood: BlobMoodSystem;
-    pointer: BlobPointer;
-    satellites: BlobSatelliteSystem;
-    config: BlobConfig;
-}
-/** 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 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/custom/goo-blob/composables/wgpuSetup.d.ts

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

@@ -1,82 +0,0 @@
-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", "uTrailCount", "uVelocity", "uStretch"];
-export type UniformName = (typeof UNIFORM_NAMES)[number];

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

@@ -1,7 +0,0 @@
-export { default as GooBlob } from "./GooBlob.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 { 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/custom/goo-blob/shaders/metaball-uniforms.glsl.d.ts

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

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

@@ -1,244 +0,0 @@
-import type { InjectionKey } from "vue";
-export type BlobMood = "idle" | "happy" | "curious" | "sleepy" | "excited";
-/** Smin merge variant — `quadratic` (cheap, creased) | `circular` (rounder menisci). */
-export type BlobMerge = "quadratic" | "circular";
-/**
- * The render-variant axis (BC.W-GOOBLOB-PLAIN — STAGE 1 owns the first two members).
- *
- * - `"blob"` — the STAGE-1 first-principles floor: a plain shadowless lightless
- *   fill-only droplet (SDF + smin satellites + fwidth-AA + warm-cream fill). The
- *   minimal verifiable "it renders, it meatballs, it works on Safari" register the
- *   `uStage` gate strips the lit/shadow blocks for. NO specular, NO iridescence, NO
- *   SSS, NO shadow — deliberately minimal.
- * - `"meatball"` — the full lit register (the default): STAGE 2 builds the lit-glass
- *   surface / Fresnel rim / iridescence / SSS / shadow ON the same field via the
- *   `uLit`/`uShadow` flags. Byte-identical to the pre-STAGE-1 default pipeline.
- *
- * `"dot-matrix"` / `"dot-sphere"` are the later-sub-wave siblings (not STAGE 1).
- */
-export type BlobVariant = "blob" | "meatball";
-/**
- * Render-quality axis (AX.W16) — `full` (default) renders the metaball pass at the
- * clamped DPR; `half` renders the backing store at HALF resolution and lets the
- * browser bilinear-upsample on composite (~4× fragment savings for weak GPUs — the
- * blob is the ideal candidate: the soft FBM/AA edge hides the interpolation).
- */
-export type BlobQuality = "full" | "half";
-export interface MoodParams {
-    orbitSpeedScale: number;
-    wobbleScale: number;
-    pulseFreq: number;
-    pulseAmp: number;
-    noiseAmp: number;
-    hueRange: number;
-    satShift: number;
-    brightnessShift: number;
-    smoothK: number;
-    pointerAttraction: number;
-    mergeRate: number;
-    /** Mood-driven iridescence/SSS intensity multiplier (excited > 1, sleepy < 1). */
-    iridScale: number;
-}
-export interface MetaballSource {
-    x: number;
-    y: number;
-    radius: number;
-    opacity: number;
-    /**
-     * BD.W-GOOBLOB-MERCURY-COLONY — the per-source SPLIT token (default `false`). When a
-     * satellite is mid-`fissioning`, this is `true` and the uniform packers DROP the
-     * `orbitWiden` bridge to nominal for it ALONE, so its neck thins past the smin reach
-     * and SNAPS into a free bead. Every non-fissioning source keeps the full bridge (the
-     * R8-07 "instant fully-detached disc" cure). Trail sources never fission (`false`).
-     */
-    fissioning?: boolean;
-}
-export type SatellitePhase = "orbiting" | "merging" | "absorbed" | "emerging" | "fissioning";
-export interface SatelliteInternal {
-    phase: SatellitePhase;
-    phaseStart: number;
-    phaseDuration: number;
-    timeOrigin: number;
-    angularSpeed: number;
-    phaseOffset: number;
-    baseRadiusX: number;
-    baseRadiusY: number;
-    wobbleAmp1: number;
-    wobbleFreq1: number;
-    wobbleAmp2: number;
-    wobbleFreq2: number;
-    pertXAmp: number;
-    pertXFreq: number;
-    pertXPhase: number;
-    pertYAmp: number;
-    pertYFreq: number;
-    pertYPhase: number;
-    startX: number;
-    startY: number;
-    endX: number;
-    endY: number;
-    /**
-     * The live phase token the uniform packers READ to phase-scope `orbitWiden`. Mirrors
-     * `phase`, but exposed on the published `MetaballSource` (below) so the GL leaves can
-     * gate the bridge widen per-satellite WITHOUT importing the satellite internals. A
-     * fissioning satellite drops to nominal bridge (its neck snaps); every other
-     * satellite keeps the full+capped widen (R8-07 cured).
-     */
-    fissioning: boolean;
-    /**
-     * BD.W-GOOBLOB-MERCURY-COLONY — the phase-local SNAP latch: false at the fission
-     * beat start, set true once the neck crosses the snap band (so the body-pulse recoil
-     * kick fires EXACTLY ONCE per pinch, not every frame across the snap window).
-     */
-    snapFired: boolean;
-}
-/** Body / orbit / satellite geometry — the contained-droplet length cohort (W15). */
-export interface BlobGeometry {
-    canvasSize: number;
-    bodyRadius: number;
-    satelliteCount: number;
-    satelliteRadius: number;
-    orbitRadius: number;
-    eccentricity: number;
-}
-/** Satellite merge/absorb/emerge/orbit lifecycle DURATIONS (ms). */
-export interface BlobSatelliteTiming {
-    mergeDuration: number;
-    absorbedDuration: [number, number];
-    emergeDuration: number;
-    orbitDuration: [number, number];
-}
-/** The living membrane — smin merge + surface noise/warp + pulsation. */
-export interface BlobMembrane {
-    smoothK: number;
-    /** Smin merge variant — `quadratic` (default) | `circular` (rounder menisci). */
-    merge: BlobMerge;
-    noiseAmp: number;
-    noiseFreq: number;
-    noiseSpeed: number;
-    /**
-     * Domain-warp strength on the FBM edge displacement (0 = plain fbm, the
-     * pre-warp look; ~0.6 = a marbled organic membrane). Taste-first low default.
-     */
-    warpAmp: number;
-    pulseFreq: number;
-    pulseAmp: number;
-}
-/** Palette + OKLCh color-perturbation atom. */
-export interface BlobColor {
-    paletteStops: string[];
-    hueRange: number;
-    satShift: number;
-    brightnessShift: number;
-    colorNoiseFreq: number;
-    colorNoiseSpeed: number;
-}
-/** The lit-glass surface — Blinn-Phong glint + Fresnel rim + iridescence/SSS/core-glow. */
-export interface BlobSurface {
-    lit: boolean;
-    /**
-     * The procedural 2D SDF soft-shadow march (BC.W-GOOBLOB-MEATBALL T2). A soft contact
-     * shadow FOLLOWING the irregular silhouette (NOT a hard disc/box shadow), gated behind
-     * the shader `uShadow` flag. Default ON (the `meatball` register); the `blob` STAGE-1
-     * floor ships shadowless via the `uStage` gate.
-     */
-    shadow: boolean;
-    /**
-     * Soft-shadow penumbra hardness (BC.W-GOOBLOB-MEATBALL T2) — the inverse light-source
-     * size fed to the IQ rmshadows march `w` term (a higher value = a harder penumbra).
-     * Range 4–48, default 16.
-     */
-    shadowSoftness: number;
-    /** CSS color for the Fresnel rim tint (resolved through the `/color` leaf). */
-    rimColor: string;
-    /** Light direction [x, y, z] (normalized in-shader). */
-    lightDir: [number, number, number];
-    specStrength: number;
-    /** Specular exponent (16-64 — a tight glint). */
-    specShininess: number;
-    /** Fresnel/Schlick exponent (~2-3). */
-    rimPower: number;
-    rimStrength: number;
-    /** Warm-pearl rim sheen weight (0 = off). */
-    iridescence: number;
-    /** Base hue (degrees) the warm-biased cosine palette centres on. */
-    iridHue: number;
-    /** Animated-thickness scroll speed for the iridescent shimmer. */
-    iridSpeed: number;
-    /** Fast-SSS back-light weight. */
-    sssScale: number;
-    /** Fast-SSS exponent. */
-    sssPower: number;
-    /** Thickness-driven inner-luminosity (core glow) lift. */
-    coreGlow: number;
-    /**
-     * BD.W-GOOBLOB-MERCURY-COLONY — the MERCURY-COLONY split register (the OPT-IN scalar,
-     * 0..1, default the calm floor `0`). At `0` the shipped `variant:"blob"` default stays
-     * calm + gate-faithful: a permanently-bonded merge/un-merge breath, NO pinch (so
-     * `proof:blob-render`/`-studio`/`-page` are UNMOVED — `orbitRadius 0.17` is NOT
-     * re-based). Lifting it toward `1` arms the `fissioning` beat: the colony breathes a
-     * satellite OUT through a thinning neck whose gap exceeds the smin reach so it SNAPS
-     * into a free orbiting bead (the mercury pinch), then re-merges next cycle. This is a
-     * DERIVED bundling over the EXISTING `surface` atom (the variant IS the bundle) — NOT
-     * a 9th geometry atom; the split rides MOTION (the satellite moves) on the EXISTING
-     * phase machine, NOT a global smin-band re-base (which would lean-regress per
-     * AZ.W-BLOB-STUDIO D2). Mood-coupled: `excited` splits more, `sleepy` barely. The
-     * `colony`/`mercury` register a consumer/studio opts into.
-     */
-    fissionAmp: number;
-}
-/** Pointer interaction — lean / squash-stretch / click-impulse. */
-export interface BlobInteraction {
-    pointerAttraction: number;
-    pointerStrength: number;
-    /**
-     * Velocity-driven volume-preserving squash-and-stretch magnitude (0 = off).
-     *
-     * AY.W-BLOB-CONFIG D3 — a SWAMPED fine-detail axis. The squash rides the smoothed
-     * spring velocity (`useBlobPointer`'s critically-damped `response: 0.18` follow),
-     * which is heavily damped and down-scaled into body space — so the tanh-saturated
-     * elongation reads at the noise floor (a live readback measured 0% body-aspect change
-     * between `stretch=0` and `stretch=1.5`). It is NOT a primary axis: it adds a subtle
-     * elongation on a FAST flick over the much louder lean/follow/pseudopod channel that
-     * dominates the deformation. Kept (the volume-preserving map is correct and lands a
-     * whisper on the fastest flicks) but DEMOTED — the demo no longer surfaces it as a
-     * top-level slider (the flick blurb is honest-down to match). A consumer that wants a
-     * pronounced taffy-pull raises this AND uncouples the velocity from the spring smooth.
-     */
-    stretch: number;
-    /** Click spring-impulse amplitude (a one-shot bouncy pulse on the body radius). */
-    clickImpulse: number;
-}
-/** Externally tunable blob configuration — EIGHT cohesive atoms, defaults via `BLOB_CONFIG_DEFAULTS`. */
-export interface BlobConfig {
-    geometry: BlobGeometry;
-    satellites: BlobSatelliteTiming;
-    membrane: BlobMembrane;
-    color: BlobColor;
-    surface: BlobSurface;
-    interaction: BlobInteraction;
-    /**
-     * The render variant (BC.W-GOOBLOB-PLAIN) — `"meatball"` (default, the full lit
-     * pipeline) | `"blob"` (the STAGE-1 plain shadowless fill-only floor). `"blob"`
-     * sets the shader `uStage` gate so the lit/shadow/iridescence/SSS blocks are NOT
-     * reached — the minimal verifiable floor. `"meatball"` is byte-identical to the
-     * pre-STAGE-1 default (the `surface.lit` flag still owns the lit-on/off within it).
-     */
-    variant: BlobVariant;
-    /**
-     * BD.W-GOO-CAROUSEL-DECK — the blob↔meatball SHADING-MORPH scalar (0..1). The user's
-     * "MORPH BLOB and MEATBALL from one to another" — a CONTINUOUS in-between, not a hard
-     * `variant` cut. `0` = the flat warm-cream blob (byte-identical to `variant: "blob"`);
-     * `1` = the fully-dressed lit meatball (byte-identical to `variant: "meatball"`);
-     * `0 < morphT < 1` lerps the SURFACE shading (the smin GEOMETRY is shared, so only the
-     * fill→lit/shadow/iridescence dressing interpolates). UNSET (the default) → the value
-     * is resolved from `variant` (blob → 0, meatball → 1), so the existing `variant` prop
-     * is byte-back-compat. A consumer ANIMATING this (a `useSpring`/registered-scalar) gets
-     * the live morph.
-     */
-    morphT?: number;
-    quality: BlobQuality;
-    tempo: number;
-}
-export declare const BLOB_CONFIG_DEFAULTS: BlobConfig;
-export declare const BLOB_CONFIG_KEY: InjectionKey<BlobConfig>;

package/dist/components/custom/goo-dot-matrix/GooDotMatrix.vue.d.ts

@@ -1,49 +0,0 @@
-import type { GooDotConfig } from "./constants";
-/**
- * GooDotMatrix — the metaball SDF FIELD rendered as a DOT MATRIX (BC.W-VIZ-HYBRID — the
- * hybrid of the goo blob and the dot matrix).
- *
- * The merging metaball reads as a FIELD OF DOTS that flow and merge: a regular grid of small
- * warm-cream dots fills the card, and where the gooey blob is — its core, its satellites, the
- * liquid neck stretching between them — the dots are DENSE, BIG, and BRIGHT; out at the rim
- * and beyond they thin to small and dim, then vanish. As a satellite orbits in and meatballs
- * into the body, the band of dots between them THICKENS into a connected bridge, then snaps
- * back when it absorbs — the gooey form drawn entirely in dots.
- *
- * It re-uses two SOTA primitives the codebase already owns — the goo-blob SDF FIELD
- * (byte-untouched `sceneDistG`) + the dot-matrix RENDER — joined by ONE new idea: the
- * dot-grid OUTPUT stage (`v = thickness(sceneDistG(cellCenter))` drives the dot size +
- * brightness, tixy.land applied to an SDF). Four registers, ONE field: `dot-field` (the
- * §T4 default — the smooth field-driven dot), `dot-dither` (the Bayer8 halftone),
- * `dot-lattice` / `dot-sphere` (the opt-in instanced flow/depth look).
- *
- * WebGPU-FIRST: the dot-stamp fragment over the spliced field; a WebGL2 dot-stamp fallback
- * runs the SAME field + dot grid where WebGPU is absent (born-GPU — no Canvas2D). It composes
- * `useGooDotMatrix` → the `createGpuSubstrate` picker over the ONE canvas lifecycle leaf
- * (offscreen-pause, live-PRM freeze, the shared pointer field) — it never bootstraps its own
- * context. The DEFAULT palette is the warm-cream library identity over a transparent ground;
- * the near-dark + reference reproductions are DEMO presets (presets-in-consumers). The
- * teal-on-navy is GONE entirely.
- */
-type __VLS_Props = {
-    /** The full author schema (the studio's `useConfiguratorState` model). */
-    config?: GooDotConfig;
-    /**
-     * 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/goo-dot-matrix/composables/gooDotLattice.d.ts

@@ -1,24 +0,0 @@
-import { fibonacciDot, type Vec3 } from "../../dot-matrix";
-export { fibonacciDot, type Vec3 };
-/** A 2-vector — the NDC lattice anchor. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * The §T3 deterministic SCREEN lattice anchor for instance `index` of a `cols`-wide row-major
- * grid at `pitch` NDC spacing, centred on the origin. `rows` is derived so the grid is roughly
- * square (the instance fan-out `cols × rows ≥ count`); the WGSL `gridOrigin(ii, uCols, uPitch)`
- * transcribes this EXACTLY (the round-trip parity anchor):
- *
- *   col    = index % cols
- *   row    = floor(index / cols)
- *   x      = (col - (cols-1)/2) · pitch
- *   y      = (row - (cols-1)/2) · pitch   // a square grid centred on origin
- *
- * The anchors fill a centred `cols × cols` lattice in NDC; the field is sampled AT each anchor
- * for the dot size+brightness, with an opt-in `-grad` flow displacement toward the merging core.
- */
-export declare function gridOrigin(index: number, cols: number, pitch: number): Vec2;
-/** The Register-B instance count for a `cols`-wide square lattice. */
-export declare function latticeInstanceCount(cols: number): number;

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

@@ -1,79 +0,0 @@
-import { type BlobWGPUUniformScratch } from "../../goo-blob/composables/uniformBridgeWGPU";
-import { type MetaballUniformLocations } from "../../goo-blob/composables/uploadBlobUniforms";
-import { type GooDotUniformScratch } from "./uniformBridgeWGPU";
-export declare const GOO_DOT_LABEL = "[GooDotMatrix]";
-/** The ground uniform buffer byte size — ONE vec4 (uGroundTime, aspect, pad, pad). */
-export declare const GOO_DOT_GROUND_BYTES = 16;
-/** The one-time WGPU resources the per-frame closure reads (the dot pipeline + the ground
- * pipeline (Move 4a, pass-1) + the buffers + scratch). */
-export interface GooDotWGPUResources {
-    pipeline: GPURenderPipeline;
-    bindGroup: GPUBindGroup;
-    /** Move 4a — the warm-ground pass-1 pipeline (its own minimal shader, NOT Aurora). */
-    groundPipeline: GPURenderPipeline;
-    groundBindGroup: GPUBindGroup;
-    groundBuffer: GPUBuffer;
-    groundScratch: Float32Array;
-    fieldBuffer: GPUBuffer;
-    dotBuffer: GPUBuffer;
-    fieldScratch: BlobWGPUUniformScratch;
-    dotScratch: GooDotUniformScratch;
-}
-/**
- * Build the WGPU dot-stamp pipeline + the field (binding0) / dot-grid (binding1) uniform
- * buffers + bind group + the two scratch buffers — ONCE on `setupWGPU`. The composable's
- * per-frame closure writes the scratch via the pack helpers then submits the draw.
- */
-export declare function createGooDotWGPUResources(device: GPUDevice, format: GPUTextureFormat): GooDotWGPUResources;
-/** The dot-grid uniform locations (the dot extend, beside the field locations). The N named
- * scalars are the GLSL twin of the WGSL s8–s13 lane-fields; a unit asserts count parity. */
-export interface GooDotGLUniforms {
-    mode: WebGLUniformLocation | null;
-    pix: WebGLUniformLocation | null;
-    floor: WebGLUniformLocation | null;
-    bright: WebGLUniformLocation | null;
-    min: WebGLUniformLocation | null;
-    max: WebGLUniformLocation | null;
-    pr: WebGLUniformLocation | null;
-    pm: WebGLUniformLocation | null;
-    pa: WebGLUniformLocation | null;
-    cursor: WebGLUniformLocation | null;
-    bloom: WebGLUniformLocation | null;
-    shadowGate: WebGLUniformLocation | null;
-    presenceFloor: WebGLUniformLocation | null;
-    weldLo: WebGLUniformLocation | null;
-    weldHi: WebGLUniformLocation | null;
-    time: WebGLUniformLocation | null;
-    weldSwell: WebGLUniformLocation | null;
-    weldSpecular: WebGLUniformLocation | null;
-    flowAmt: WebGLUniformLocation | null;
-    latticeSquash: WebGLUniformLocation | null;
-}
-/** The Move 4a warm-ground GL program (the WebGL2/Safari tail of pass-1). */
-export interface GooDotGroundGLResources {
-    prog: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    vao: WebGLVertexArrayObject;
-    buf: WebGLBuffer;
-    uTime: WebGLUniformLocation | null;
-}
-/** The one-time GL resources the per-frame closure reads (program + VAO + the field + dot
- * locations + the Move 4a ground program). */
-export interface GooDotGLResources {
-    prog: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    buf: WebGLBuffer;
-    vao: WebGLVertexArrayObject;
-    locs: MetaballUniformLocations;
-    dU: GooDotGLUniforms;
-    ground: GooDotGroundGLResources;
-}
-/**
- * Build the WebGL2 dot-stamp program + the full-quad VAO + the field uniform-location cache
- * (the SAME UNIFORM_NAMES the field GLSL declares) + the dot-grid uniform locations — ONCE on
- * `setupGL`. The composable's per-frame closure sets the dot uniforms then calls the REUSED
- * goo-blob `uploadBlobUniforms` (which writes the field + issues the draw).
- */
-export declare function createGooDotGLResources(gl: WebGL2RenderingContext): GooDotGLResources;