@mkbabb/glass-ui 3.9.0 → 3.10.1

package/dist/components/custom/dock/composables/useDockShellProps.d.ts

@@ -0,0 +1,131 @@
+import { type ComputedRef } from "vue";
+export type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
+export interface DockCommonProps {
+    fitContent?: boolean;
+    position?: "fixed" | "inline" | "sticky";
+    alwaysExpanded?: boolean;
+    /**
+     * Corner treatment.
+     *   `"pill"`    — the stadium silhouette (default).
+     *   `"rounded"` — a finite rounded radius (`--radius-xl`).
+     *   `"card"`    — the AW.W3b big-dock card shell: a finite concentric
+     *                 radius (`--dock-card-radius`, default `--radius-3xl`)
+     *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
+     *                 Collapsed it returns to a pill; the pill↔card swap
+     *                 morphs on the `--dock-motion-resize` spring. AX.W56's
+     *                 squircle policy applies `corner-shape:
+     *                 var(--corner-shape-bigdock)` here under `@supports
+     *                 (corner-shape: superellipse(2))` — the big-dock is the ONE
+     *                 surface where the superellipse reads (cards/pills stay
+     *                 round); the border-radius arc is the cross-engine contract.
+     *
+     * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
+     * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
+     * the horizontal-root shape rules (closing that documented-but-dead prop),
+     * so `shape` now paints on a horizontal dock too.
+     */
+    shape?: "pill" | "rounded" | "card";
+    /**
+     * Layout axis of the dock. `"horizontal"` (default) lays items out
+     * left-to-right and animates `width`; `"vertical"` lays items out
+     * top-to-bottom and animates `height`. IGNORED under `variant="rail"` /
+     * `"instrument-strip"` (those force vertical by construction).
+     */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * Density controls dock padding, gaps, layer height, and inherited
+     * dock control sizing. Root CSS variables can override each density.
+     */
+    density?: DockDensity;
+    /**
+     * Overflow strategy when the expanded content exceeds the dock's
+     * axis cap (`--dock-max-inline-size` horizontally,
+     * `--dock-max-block-size` vertically). The ONE knob governing every
+     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
+     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
+     * which all touched overflow divergently).
+     *   `"grow"`   — content grows to fit then overflows visibly past
+     *                the cap (the default; nothing clips or scrolls).
+     *   `"wrap"`   — expanded content wraps to multiple rows via CONTENT-DRIVEN
+     *                intrinsic flex-wrap (the `.dock-overflow-wrap` recipe). The
+     *                dock shrink-wraps to content and caps that intrinsic width
+     *                at `max-inline-size: var(--dock-max-inline-size)`, so the row
+     *                reflows to N rows EXACTLY when its intrinsic width exceeds
+     *                the cap — at ANY viewport width — and collapses to one row
+     *                when it fits (no viewport breakpoint). The wrapped multi-row silhouette lifts
+     *                onto the card/floating shadow tier as the dock expands.
+     *                HORIZONTAL-ONLY: a vertical rail grows-to-fit + clamps via
+     *                `--dock-max-block-size` (its own overflow story), so the
+     *                `.dock-overflow-wrap` class is not emitted for a vertical
+     *                orientation.
+     *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
+     *                scroll the active layer on the inline axis
+     *                (`.dock-scroll-x`); vertical rails scroll on the
+     *                block axis (`.dock-scroll-y`), keeping the
+     *                `max-block-size` cap. The rounded pill masks the
+     *                scroll edge; the scrollbar is hidden. The axis is
+     *                chosen automatically from `orientation`.
+     */
+    overflow?: "grow" | "wrap" | "scroll";
+    /**
+     * When set, the dock root establishes an inline-size container query
+     * subject (`container-type: inline-size; container-name: <value>`) so
+     * descendants can query the named container via `@container <value>
+     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
+     * container subject does NOT silently change the dock's clip shell
+     * (AT.W7-dock-a — the prior clip-lift was folded out; use
+     * `overflow="wrap"` to allow multi-line content).
+     *
+     * T.B audit §1.3 cornerstone: the cluster's container subject must
+     * live on the dock primitive, never on a descendant whose intrinsic
+     * size the dock relies on.
+     */
+    containerName?: string;
+}
+export interface DockVariantProps extends DockCommonProps {
+    variant?: "dock";
+    /** Idle-collapse delay in ms (default 2000). DOCK-ONLY — a rail never collapses. */
+    collapseDelay?: number;
+    /** Start in the collapsed state (default true). DOCK-ONLY — a rail is always expanded. */
+    startCollapsed?: boolean;
+    /**
+     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
+     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
+     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
+     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
+     * `layout` is the IN-cap arrangement.
+     *
+     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
+     * does not read as a collapsible pill, and no width morph means no
+     * per-frame grid reflow). The canonical pairing is
+     * `shape="card" layout="grid"` (the props stay independent — no
+     * auto-implication of `shape`). DOCK-ONLY — the grid is a horizontal big-dock
+     * arrangement, never a rail's.
+     */
+    layout?: "linear" | "grid";
+}
+export interface DockRailProps extends DockCommonProps {
+    variant: "rail" | "instrument-strip";
+}
+export type DockProps = DockVariantProps | DockRailProps;
+export declare function dockBranch(p: DockProps): p is DockVariantProps;
+/** The resolved shell-prop computeds the GlassDock SFC binds. */
+export interface DockShellProps {
+    containerStyle: ComputedRef<Record<string, string> | undefined>;
+    collapseDelay: ComputedRef<number>;
+    startCollapsed: ComputedRef<boolean>;
+    layoutValue: ComputedRef<"linear" | "grid">;
+    variant: ComputedRef<"dock" | "rail" | "instrument-strip">;
+    shape: ComputedRef<"pill" | "rounded" | "card">;
+    orientation: ComputedRef<"horizontal" | "vertical">;
+    density: ComputedRef<DockDensity>;
+    scrollClass: ComputedRef<string | null>;
+    alwaysExpanded: ComputedRef<boolean>;
+    fitContent: ComputedRef<boolean>;
+}
+/**
+ * Derive the dock's resolved shell props off the raw `props`. The defaults the
+ * prior `withDefaults` object held are applied at each read site via `?? default`
+ * (every shared default has exactly one resolution point — the one-path precept).
+ */
+export declare function useDockShellProps(props: DockProps): DockShellProps;

package/dist/components/custom/dock/composables/useLayerTransition.d.ts

@@ -1,4 +1,48 @@
 import type { Ref } from "vue";
+/**
+ * AX.W01 — the dock single-scalar morph: ONE spring, ONE clock, the whole box.
+ *
+ * Re-derived from first principles (the e8380d7 single-clock high-water; the
+ * 479-line VT-fork accretion is gone). The collapse↔expand (and inner pane-swap)
+ * morph runs off ONE normalized analytic spring whose progress scalar (0→1) is
+ * written once per frame to `--dock-morph-t` on the `.glass-dock` root. EVERY
+ * animated axis — inline-size, padding, border-radius, scale, background / border
+ * color, AND the child stagger — is a pure `calc()` read off that one scalar in
+ * `dock.css`. NO CSS `transition` on the root morph props; NO View-Transitions
+ * fork: the live `SpringProgress` ODE is the single authority on every engine, so
+ * iOS interruptible-physics + velocity-continuity retarget are universal, not
+ * capability-gated.
+ *
+ * The morph is a FLIP — the from→to size is measured ONCE per swap (the allowed
+ * one-time measurement primitive, never a co-driver), written as `--dock-morph-from`
+ * / `--dock-morph-to` px vars on the morphing element, and the live scalar
+ * interpolates between them in CSS. Content lays out once at natural size;
+ * `overflow:clip` on the morph axis (dock.css, gated on `data-morphing`) makes the
+ * box the reveal aperture; the spring-keyed stagger fades the children in-step.
+ *
+ * Velocity-continuity (the ONE load-bearing iOS piece): a re-toggle mid-flight
+ * re-bases the live solver onto the new span from its current velocity (the
+ * analytic re-seat keyframes.js owns) — inertia carries, no snap-from-rest. The
+ * spring constant is the published `--spring-dock` (response 0.32, ζ 0.7, ~+4.6%
+ * overshoot), the SAME analytic ODE the build-time linear() token samples.
+ *
+ * LIGHT-surface only: `SpringProgress` owns its own rAF via `.play(onFrame)` and
+ * carries no static value.js edge. NEVER import `AnimationGroup` / the `./engine`
+ * boundary — that pulls value.js into the dock bundle.
+ *
+ * BOOKED: AY.W-GOD1 — the FLIP-engine FOLD. This standalone engine is a
+ * near-duplicate of the orchestrator's FLIP-pin-measure-arm dance
+ * (`dockMorphContext.ts:onSwap`), which is the SUPERSET (it carries sibling-rebase
+ * this copy lacks). W-DOCK2 found the duplication (H-dock §D3) and BOOKED the fold
+ * to W-GOD1 (the GlassDock.vue carve touches the same FLIP code, so the carve is
+ * cleaner over ONE engine; folding now would also break the `/dock` `useLayerTransition`
+ * public re-export an external consumer reads). Until W-GOD1 lands, `proof:dock-orchestrator-single`'s
+ * FLIP DRIFT-GUARD asserts this engine and the orchestrator stay byte-faithful on
+ * the load-bearing pin-measure-arm markers, so a divergence in the shared dance REDs.
+ * The CANONICAL `DOCK_SPRING` authority is `dock/constants.ts` (the colocation home
+ * BOTH this engine and the orchestrator import); `proof:spring-tokens-synced` reads
+ * it there, NOT a per-composable copy (W-COLOCATE — the dead-witness fix, continued).
+ */
 export interface UseLayerTransitionOptions {
     /** The container element that owns the stacked layer panes. */
     containerEl: Ref<HTMLElement | null>;

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

@@ -0,0 +1,23 @@
+/**
+ * The ONE dock-morph spring authority — the iOS-26 interruptible-physics tuning the
+ * dock's single `SpringProgress` orchestrator (`dockMorphContext.ts`) AND the
+ * `useLayerTransition` engine both read. Co-located here so the `response`/`damping`
+ * pair is defined ONCE rather than duplicated at the top of each composable (the two
+ * prior copies were a DRY hazard — a re-tune had to touch both).
+ */
+export declare const DOCK_SPRING: {
+    readonly response: 0.32;
+    readonly dampingFraction: 0.7;
+};
+/**
+ * The CSS properties whose `transitionend` the dock-morph window watches to know a
+ * resize-morph has settled (`useDockMorphWindow.ts`). A `transitionend` on any other
+ * property is ignored.
+ */
+export declare const RESIZE_MORPH_PROPS: Set<string>;
+/** `Symbol()` label for the `DockContext` injection key (`dockContext.ts`). */
+export declare const DOCK_CONTEXT_LABEL = "glass-ui:dock-context";
+/** `Symbol()` label for the `DockLayerGroupContext` injection key (`dockLayerContext.ts`). */
+export declare const DOCK_LAYER_GROUP_LABEL = "glass-ui:dock-layer-group";
+/** `Symbol()` label for the `DockMorphContext` injection key (`dockMorphContext.ts`). */
+export declare const DOCK_MORPH_LABEL = "glass-ui:dock-morph-context";

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

@@ -32,6 +32,12 @@ type __VLS_Props = {
     seed?: string;
     /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). Default false. */
     freeze?: boolean;
+    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
+     *  resolved `peakAlpha`/`headGlowAlpha` at the PAINT layer (a per-LAYER
+     *  multiply, not a uniform CSS opacity). Default 1 (the bundle's resting
+     *  loudness); clamped [0, 2] — the field's ~2 upper bound lets a hero push
+     *  brighter than the recessed default without runaway. */
+    intensity?: 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 _default: typeof __VLS_export;

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

@@ -1,2 +1,26 @@
+import type { ColorResolver } from "../../../composables/color";
 export { default as FourierField } from "./FourierField.vue";
-export { comp, evalFourier, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
+export { comp, positionsAt, 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. */
+export type FourierFieldVariant = "hero" | "final";
+/** The props a consumer forwards when wrapping `<FourierField>` (the seeded
+ *  inverse-DFT epicycle background; ships via `/fourier-field`). Mirrors the
+ *  component's inline `defineProps` shape (an SFC cannot export its inline
+ *  props type). */
+export interface FourierFieldProps {
+    /** Configuration bundle. Default `hero`. */
+    variant?: FourierFieldVariant;
+    /** Base CSS color (a `var()`/`light-dark()` token resolves against the host). */
+    color: string;
+    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
+    colorResolver: ColorResolver;
+    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    seed?: string;
+    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
+    freeze?: boolean;
+    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
+     *  resolved `peakAlpha`/`headGlowAlpha` at the paint layer. Default 1; clamped [0, 2]. */
+    intensity?: number;
+}

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

@@ -15,19 +15,31 @@ export interface BasisComponent {
  * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
  */
 export declare function comp(index: number, re: number, im: number): BasisComponent;
-/**
- * Sum `c_k * exp(2*pi*i*k*t)` — the curve point at parameter `t`. `maxTerms`
- * truncates the series (the partial-sum read). Returns the complex value as
- * `[re, im]` (the curve's `[x, y]` before view-fit).
- */
-export declare function evalFourier(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
 /**
  * The epicycle chain at parameter `t`: the running tip of each phasor stacked on
  * the last, starting at the origin. `positions[0]` is `[0, 0]`; the final entry
- * is the curve point ({@link evalFourier} at the same `t`). `maxCircles`
- * truncates the chain (draw fewer arms than the spectrum carries).
+ * is the curve point — the inverse-DFT sum `Σ c_k * exp(2*pi*i*k*t)` at the same
+ * `t`. `maxCircles` truncates the chain (draw fewer arms than the spectrum
+ * carries).
  */
 export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: 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`,
+ * uniformly spaced in the parameter `t ∈ [0, 1)`) and returns the
+ * {@link BasisComponent} spectrum that {@link positionsAt} reconstructs.
+ *
+ * Frequencies run symmetrically around 0 — `0, +1, -1, +2, -2, …` up to the
+ * Nyquist limit — which is the index ordering the epicycle chain wants (the big
+ * low-order phasors first). The DC term (`index 0`) is the curve's centroid; the
+ * caller can subtract it (draw the chain centered) or keep it (draw at the
+ * sampled position).
+ *
+ * General: any point set drives it (a glyph outline, a hand-traced path, a
+ * digitized signature). It is NOT a special case — it is the literal forward
+ * transform whose inverse already ships as `positionsAt`.
+ */
+export declare function dftFromPoints(points: [number, number][]): BasisComponent[];
 /** Tuning for {@link makeEllipticSpectrum}. */
 export interface EllipticSpectrumOptions {
     /**

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

@@ -0,0 +1,54 @@
+export interface VariantPreset {
+    /** Higher-order harmonics layered over the dominant counter-rotating pair. */
+    harmonics: number;
+    /** Peak magnitude of those harmonics relative to the dominant phasor. */
+    harmonicScale: number;
+    /** Draw the nested epicycle circles + arms underneath the curve. */
+    epicycles: boolean;
+    /** Comet-trail capacity (frames of head history). ~1/3 of the period so the
+     *  comet reads as a substantial arc, not a stub (the fourier-analysis bar). */
+    trailLength: number;
+    /** Hue offset (degrees) of the epicycle second hue away from the outline hue. */
+    epicycleHueShift: number;
+    /** Forward-clock period for one full curve traversal, in ms. */
+    durationMs: number;
+    /** A constant per-variant seed used under `freeze` so a capture is deterministic. */
+    frozenSeed: string;
+    /** The parameter `t` of the static best-frame painted under `freeze`. */
+    frozenT: number;
+    /** Comet-trail PEAK alpha (the head segment). The reference trail rides ~0.9
+     *  near-opaque — present, not the prior 0.45 hairline whisper. */
+    peakAlpha: number;
+    /** Trail stroke weight in CSS px (the reference is a BOLD 3.5px stroke, not
+     *  the prior 1.6 hairline). The single biggest faintness lever. */
+    trailWidth: number;
+    /** Head-glow alpha — the STRONGEST layer (head-forward: > peakAlpha). */
+    headGlowAlpha: number;
+    /** Head-glow `shadowBlur` bloom radius, in px. */
+    headGlowBlur: number;
+    /** The comet HEAD DOT radius in CSS px (the reference's glowing tip — a
+     *  saturated core + white highlight + soft halo). 0 disables it. */
+    headDotRadius: number;
+    /** Epicycle scaffolding alphas ÷ peak (hero only; {0,0} disables the scaffold).
+     *  The reference circles/arms are PRESENT (≈0.5/0.75), not the prior 0.18 ghost. */
+    epicycleRatios: {
+        circle: number;
+        arm: number;
+    };
+    /** Epicycle circle / arm stroke weights in CSS px (the reference uses a bold
+     *  ≈2.5/2 chain, the joints carry filled dots). */
+    epicycleWidths: {
+        circle: number;
+        arm: number;
+    };
+    /** Paint the epicycle chain as a rainbow across the spectrum (the
+     *  fourier-analysis signature) vs one analogous second hue. Hero only. */
+    epicycleRainbow: boolean;
+    /** Trail persistence exponent — SOFT (1..2), never the quadratic that kills the body. */
+    trailFadeExp: number;
+    /** Min trail alpha ÷ peak — the body survives, never decays to 0. The
+     *  reference body reads near-uniform; the floor sits HIGH (≈0.35) so the
+     *  comet body has real presence on cream too (the light-mode floor fork). */
+    trailFloor: number;
+}
+export declare const PRESETS: Record<"hero" | "final", VariantPreset>;

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

@@ -1,4 +1,3 @@
-import type { ColorResolver } from "../../../composables/color";
 import type { BlobMood, BlobConfig } from "./types";
 /**
  * GooBlob — a gooey metaball creature on a WebGL2 canvas.
@@ -8,23 +7,22 @@ import type { BlobMood, BlobConfig } from "./types";
  * satellite system drive the motion. The renderer composes the `useWebGLCanvas`
  * substrate — it never bootstraps its own context.
  *
- * Color is resolved through an INJECTED `colorResolver` seam (DEC-AT-2): the blob
- * paints the GAMMA-sRGB triple it returns. The prop is REQUIRED — pass
- * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or your own) so a
- * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly. A missing resolver
- * throws (the loud failure, not a silent gray).
+ * 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 the SAME loud discipline as the resolver: either
+ * 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 (any form the `colorResolver` understands). */
+    /** 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 color seam — resolves `color` to a gamma-sRGB [r,g,b] triple in [0,1]. */
-    colorResolver: ColorResolver;
     /**
      * REQUIRED unless an ancestor `provide(BLOB_CONFIG_KEY, …)` supplies it.
      * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.

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

@@ -0,0 +1,18 @@
+import { type MetaballUniformLocations } from "./uploadBlobUniforms";
+/** The compiled-program handles the renderer closes over + tears down. */
+export interface MetaballProgram {
+    prog: WebGLProgram;
+    vs: WebGLShader;
+    fs: WebGLShader;
+    vao: WebGLVertexArrayObject;
+    buf: WebGLBuffer;
+    locs: MetaballUniformLocations;
+}
+/**
+ * Compile the metaball shader, build the full-quad VAO, and resolve the uniform
+ * location cache on a fresh context. Leaves `BLEND` enabled with the
+ * premultiplied-alpha `(ONE, ONE_MINUS_SRC_ALPHA)` blend func (the source's
+ * setup), `prog` in use, and the VAO bound — the caller's `resize`/`drawFrame`
+ * re-bind as needed.
+ */
+export declare function buildMetaballProgram(gl: WebGL2RenderingContext): MetaballProgram;

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

@@ -0,0 +1,41 @@
+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)[];
+    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[];
+}
+/**
+ * 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/custom/goo-blob/composables/useBlobPointer.d.ts

@@ -1,6 +1,7 @@
 import { type Ref } from "vue";
-/** Compile-time trail length — mirrors `TRAIL_N` in metaball.frag.ts. */
-export declare const TRAIL_N = 15;
+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;
@@ -13,7 +14,7 @@ export interface TrailSample {
  * 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 `tick(dt)` seam by the SUBSTRATE's single rAF — it does NOT call
+ * 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).
  *

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

@@ -1,5 +1,4 @@
 import { type Ref } from "vue";
-import type { ColorResolver } from "../../../../composables/color";
 import type { BlobConfig } from "../types";
 import type { BlobMoodSystem } from "./useBlobMood";
 import type { BlobPointer } from "./useBlobPointer";
@@ -24,34 +23,30 @@ export interface UseMetaballRendererOptions {
     pointer: BlobPointer;
     satellites: BlobSatelliteSystem;
     config: BlobConfig;
-    /**
-     * The injected color seam (DEC-AT-2). Resolves a CONCRETE CSS color string to a
-     * GAMMA-sRGB triple in [0,1] fed straight into the shader's base-color uniform —
-     * the faithful AU.W7 lift paints gamma. REQUIRED: a no-resolver mount throws (the
-     * loud failure, not a silent gray) instructing the consumer to pass
-     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own). The
-     * renderer is DOM-FREE: it never un-wraps a `var(--token)` — the SFC's
-     * `resolveTokenColor` leaf does that BEFORE handing strings here (inv-K-3 seam).
-     */
-    colorResolver: ColorResolver;
+}
+/** The renderer's public control surface — pause/resume the demand loop. */
+export interface UseMetaballRendererReturn {
+    pause: () => void;
+    resume: () => void;
 }
 /**
  * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
  *
  * This module owns ONLY the metaball-specific concerns: compiling the shader,
- * building the quad + uniform cache, and uploading the per-frame uniforms derived
- * from the mood / pointer / satellite systems and the injected color resolver. The
- * generic WebGL2 lifecycle — context creation, the suspend/resume model, the
- * demand-driven rAF loop, the tab-visibility owner, the ResizeObserver, and the
+ * 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).
  *
- * Colors arrive ALREADY resolved to a gamma-sRGB triple via the injected
- * `colorResolver`; the value.js 1×1-canvas DOM probe is gone (the seam replaces it).
+ * 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): {
-    pause: () => void;
-    resume: () => void;
-};
+export declare function useMetaballRenderer(options: UseMetaballRendererOptions): UseMetaballRendererReturn;

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

@@ -0,0 +1,52 @@
+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;
+/** Base satellite opacity. */
+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;
+export declare const UNIFORM_NAMES: readonly ["uResolution", "uTime", "uBaseColor", "uPointer", "uPointerActive", "uPointerAttraction", "uPointerStrength", "uBodyRadius", "uPulsePhase", "uPulseAmp", "uNoiseAmp", "uNoiseFreq", "uNoiseSpeed", "uWarpAmp", "uSmoothK", "uMerge", "uMaxReach", "uLit", "uRimColor", "uLightDir", "uSpecStrength", "uSpecShininess", "uRimPower", "uRimStrength", "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,5 +1,5 @@
 export { default as GooBlob } from "./GooBlob.vue";
-export type { BlobMood, BlobMerge, BlobQuality, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
+export type { BlobMood, BlobMerge, 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";

package/dist/components/custom/goo-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// 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// 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";