@mkbabb/glass-ui 4.0.0 → 4.0.1

package/dist/components/custom/easing/composables/useEasingPicker.d.ts

@@ -0,0 +1,75 @@
+import { type ComputedRef, type Ref } from "vue";
+import { jumpTerms } from "@mkbabb/value.js";
+/** The two curve-authoring modes — the two donor arms unified. */
+export type EasingPickerMode = "bezier" | "steps";
+/** A `(t: number) => number` easing callable — the value.js family shape. */
+export type EasingFn = (t: number) => number;
+/** The bezier control-point quad `[x1, y1, x2, y2]`. */
+export type BezierPoints = [number, number, number, number];
+/** A value.js step jump-term (`jump-start`/`end`/`both`/`none` + aliases). */
+export type JumpTerm = (typeof jumpTerms)[number];
+/** The picker's v-model payload — the live curve callable + its re-parseable
+ *  CSS literal + the mode, so a consumer can read back the authored curve. */
+export interface EasingPickerValue {
+    readonly mode: EasingPickerMode;
+    /** The complete re-parseable CSS literal (`cubic-bezier(…)` / `steps(…)`). */
+    readonly css: string;
+    /** The live value.js easing callable the literal evaluates to. */
+    readonly fn: EasingFn;
+    /** The bezier control points (bezier mode). */
+    readonly points: BezierPoints;
+    /** The step jump count (steps mode). */
+    readonly steps: number;
+    /** The step jump term (steps mode). */
+    readonly term: JumpTerm;
+}
+export interface UseEasingPickerOptions {
+    /** The initial mode (default `"bezier"`). */
+    initialMode?: EasingPickerMode;
+    /** The initial bezier preset key (default `"ease-out-back"`). */
+    initialPreset?: string;
+    /** The initial step count (default 4). */
+    initialSteps?: number;
+    /** The initial step term (default `"end"`). */
+    initialTerm?: JumpTerm;
+}
+export interface UseEasingPickerReturn {
+    mode: Ref<EasingPickerMode>;
+    preset: Ref<string>;
+    points: Ref<BezierPoints>;
+    presetNames: readonly string[];
+    selectPreset: (name: string) => void;
+    setHandle: (index: 0 | 1, x: number, y: number) => void;
+    steps: Ref<number>;
+    term: Ref<JumpTerm>;
+    terms: readonly JumpTerm[];
+    /** The live easing callable for the active mode — re-derived on every edit. */
+    easingFn: ComputedRef<EasingFn>;
+    /** The complete re-parseable readout literal for the active mode. */
+    readout: ComputedRef<string>;
+    /** The full v-model payload (mode + css + fn + raw params). */
+    value: ComputedRef<EasingPickerValue>;
+    /** Two SVG-space handle coords `[{x,y},{x,y}]` (bezier mode). */
+    handlesSvg: ComputedRef<{
+        x: number;
+        y: number;
+    }[]>;
+    /** The bezier path `d` (`M 0 1 C …`). */
+    bezierPathD: ComputedRef<string>;
+    /** The sampled staircase path `d` (steps mode). */
+    stepPathD: ComputedRef<string>;
+    /** The bezier-canvas viewBox `{ minY, height }` clamping overshoot. */
+    viewBox: ComputedRef<{
+        minY: number;
+        height: number;
+    }>;
+    progress: Ref<number>;
+    playTravel: () => void;
+    stopTravel: () => void;
+}
+/**
+ * The <EasingPicker> shared editor state. Composes the value.js math; owns the
+ * chassis (control points, the literal, the rAF travel). Used by the EasingPicker
+ * SFC + (composed through it) the EasingConfigurator register — ONE source.
+ */
+export declare function useEasingPicker(options?: UseEasingPickerOptions): UseEasingPickerReturn;

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

@@ -0,0 +1,28 @@
+/** The bezier-mode catalogue key used for the live-edited custom curve. */
+export declare const CUSTOM_PRESET: "custom";
+/** The default bezier-mode preset (a back-overshoot curve reads expressive). */
+export declare const DEFAULT_BEZIER_PRESET: "ease-out-back";
+/** The default steps-mode jump count + term. */
+export declare const DEFAULT_STEP_COUNT = 4;
+export declare const DEFAULT_STEP_TERM: "end";
+/** The steps-mode slider bounds. */
+export declare const STEP_COUNT_MIN = 1;
+export declare const STEP_COUNT_MAX = 12;
+/** Dense staircase sampling so the riser/tread reads crisp (a sampled staircase,
+ *  not a smoothed curve). */
+export declare const STEP_PLOT_SAMPLES = 240;
+/** bezier-Y (0 bottom, 1 top) → SVG-Y (0 top, grows down). */
+export declare const SVG_FLIP: (y: number) => number;
+/** The bezier-canvas viewBox overshoot clamp + pad (a back-curve must not blow up
+ *  the canvas). */
+export declare const VIEW_PAD = 0.1;
+export declare const MAX_OVERSHOOT = 0.6;
+/** The pointer hit-radius for grabbing a handle (touch is forgiving). */
+export declare const HANDLE_HIT_RADIUS = 0.1;
+export declare const HANDLE_HIT_RADIUS_TOUCH = 0.15;
+/** The number of curve samples the viewBox bounds-fit walks. */
+export declare const VIEWBOX_FIT_SAMPLES = 16;
+/** The one-shot rAF travel clock (ms) for the playback dot. */
+export declare const TRAVEL_DURATION_MS = 1200;
+/** The copy-feedback dwell (ms). */
+export declare const COPY_FEEDBACK_MS = 1400;

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

@@ -0,0 +1,3 @@
+export { default as EasingPicker } from "./EasingPicker.vue";
+export { default as EasingConfigurator } from "./EasingConfigurator.vue";
+export { useEasingPicker, type EasingPickerMode, type EasingPickerValue, type EasingFn, type BezierPoints, type JumpTerm, type UseEasingPickerOptions, type UseEasingPickerReturn, } from "./composables/useEasingPicker";

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

@@ -1,4 +1,4 @@
-import { type ColorResolver } from "../../../composables/color";
+import type { ColorResolver } from "../../../composables/color";
 /**
  * FourierField — a Fourier epicycle field on a Canvas2D surface, a sibling
  * primitive to Aurora and GooBlob. A seeded elliptic spectrum reconstructs a
@@ -20,6 +20,11 @@ import { type ColorResolver } from "../../../composables/color";
  * draws a few big phasors with the epicycles ON and a warm trail feel; `final`
  * draws a denser elliptic spectrum with the epicycles OFF. One engine, two
  * presets. The hue itself always comes from the consumer's `color`.
+ *
+ * BB.W-CARVE3 — the ~475-line renderer lives in `composables/useFourierField.ts`
+ * (the colocation symmetry Aurora/`useAurora.ts`, GooBlob/`useMetaballRenderer.ts`
+ * and Constellation/`useConstellation.ts` already carry). The SFC stays thin: the
+ * props, the two template refs, and the single `useFourierField(props, …)` call.
  */
 type __VLS_Props = {
     /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. Default `hero`. */
@@ -46,6 +51,11 @@ type __VLS_Props = {
      *  ambient bundle is unchanged. The SOLE additive seam (BA.W-FOURIER-STUDIO). */
     clock?: () => number;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    variant: "hero" | "final";
+    seed: string;
+    freeze: boolean;
+    intensity: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/custom/fourier-field/composables/useFourierField.d.ts

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

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

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

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

@@ -33,9 +33,9 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<GlassPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassPanelProps> & Readonly<{}>, {
+    blur: number;
     variant: GlassPanelVariant;
     surface: Surface;
-    blur: number;
     refraction: number;
     chromaticAberration: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

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

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

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

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

@@ -40,18 +40,25 @@ export interface UseMetaballRendererReturn {
     wake: () => void;
 }
 /**
- * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
+ * The GooBlob renderer — composes the `createGpuSubstrate` picker (BB.W-VIZ-SUITE /
+ * W-GOOBLOB-WGPU): the WebGPU-first `metaball.wgsl` primary OR the WebGL2
+ * `metaball.frag.ts` fallback, selected ONCE by `navigator.gpu` feature-detect. Both
+ * backends compose the SAME `createCanvasLifecycle` leaf (AU.W6), so the demand-driven
+ * scheduling + offscreen-park + live-PRM-freeze are byte-identical across backends.
  *
- * This module owns ONLY the metaball-specific concerns: compiling the shader,
- * building the quad + uniform cache (the `buildMetaballProgram` leaf), and
- * uploading the per-frame uniforms (the `uploadBlobUniforms` leaf) derived from the
- * mood / pointer / satellite systems and the resolved base color. The generic
- * WebGL2 lifecycle — context creation, the suspend/resume model, the demand-driven
- * rAF loop, the tab-visibility owner, the ResizeObserver, and the
- * webglcontextlost/restored robustness — lives in the substrate; this renderer
- * threads its behaviour through the substrate's
- * `setup`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does NOT call
- * `getContext("webgl2")` itself (the single-bootstrap contract).
+ * This module owns ONLY the metaball-specific concerns: compiling the shader, building
+ * the quad + uniform cache (the WebGL2 `buildMetaballProgram` leaf) OR the WGSL pipeline
+ * + the typed-struct uniform buffer (the WGSL `createBlobWGPUSetup` leaf), and the
+ * per-frame SIMULATION advance + uniform upload derived from the mood / pointer /
+ * satellite systems and the resolved base color. The simulation advance is SHARED — the
+ * `resolveFrame(timeSec)` closure advances the systems and returns the settled
+ * `BlobFrameState`; the WebGL2 `drawFrame` and the WGSL `frame` both call it, so the
+ * physics is substrate-agnostic and only the upload+draw leg differs. The generic
+ * lifecycle (context creation, the suspend/resume model, the demand-driven rAF loop, the
+ * tab-visibility owner, the ResizeObserver, and the context-loss self-heal) lives in the
+ * substrate; this renderer threads its behaviour through the substrate's
+ * `setupGL`/`setupWGPU`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does
+ * NOT call `getContext("webgl2")`/`navigator.gpu` itself (the single-bootstrap contract).
  *
  * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
  * oklchToGammaRgb`) — the GAMMA-sRGB triple fed straight into the base-color uniform

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

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

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

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

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

@@ -8,9 +8,9 @@ declare const __VLS_base: import("vue").DefineComponent<HandMarkProps, {
     play: typeof play;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HandMarkProps> & Readonly<{}>, {
     color: string;
+    animation: import("./types").HandAnimation;
     seed: number;
     shape: import("./types").HandShape;
-    animation: import("./types").HandAnimation;
     appear: "mount" | "visible" | "manual";
     jagged: boolean;
     brush: import("./brush").BrushName | Partial<import("./brush").Brush>;

package/dist/components/custom/icon-chip/types.d.ts

@@ -57,10 +57,20 @@ export interface IconChipProps {
     duotone?: boolean;
     /**
      * The chip's own smooth-glass hover register (the backplate mix lifts, a soft
-     * glow ring appears, the stroke firms) — on the §6 easing doctrine, PRM-gated,
+     * glow ring appears, the stroke firms) — on the §6 easing doctrine (the GROW
+     * rides --spring-smooth, the color cross-fade the bezier), PRM-gated,
      * disco-FREE. Default `false`.
      */
     bloom?: boolean;
+    /**
+     * The louder focal-pop vibrancy axis (BB.W-SUFFUSE3) — re-points the
+     * backplate `color-mix` strength off the 25% reference stop to ~40% (more
+     * chroma) via `--icon-chip-plate-strength`. STILL the ONE color event per
+     * surface (the same event, louder — proof:suffuse d3 counts the event family,
+     * not the saturation); the `in srgb` space + the chip≤glyph ratio are
+     * untouched. Default `false` (byte-identical to the reference register).
+     */
+    saturated?: boolean;
     /**
      * Entrance choreography — composes the shipped `vReveal` directive. A numeric
      * value is the `--d` stagger index; `true` is index 0. PRM-gated by `vReveal`'s

package/dist/components/custom/instrument-chassis/InstrumentChassis.vue.d.ts

@@ -23,7 +23,9 @@ export type InstrumentChassisPhase = "ready" | "ping" | "download" | "upload" |
  *   the structural grooves re-point to the `--silver` quad (the gold quad's
  *   cool mirror) instead of the warm-cream `--surface-tint-*` default, so the
  *   chassis reads as an INDUSTRIAL precision-instrument housing — the cool-metal
- *   twin of the gold "complete"-phase affirmation. The phase cascade stays
+ *   twin of the warm-gold "complete"-phase affirmation the chassis ships by
+ *   DEFAULT (the `--phase-complete-color` consumer token defaults to gold;
+ *   BB.W-PHASE-PALETTE — a consumer may re-ink completion). The phase cascade stays
  *   orthogonal (a `structure` chassis still retints on `data-phase`); only the
  *   structure-metal recipe forks. The silver is the W-NO-GRAY named cool-neutral
  *   exception. Consumer #2 of the silver quad (the atlas's structure surface is

package/dist/components/custom/metric-stack/MetricStack.vue.d.ts

@@ -77,8 +77,8 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MetricStackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricStackProps> & Readonly<{}>, {
-    as: string | Component;
     containerName: string;
+    as: string | Component;
     rows: number;
     register: "audacious" | "result";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/spa-view/SpaView.vue.d.ts

@@ -0,0 +1,50 @@
+import type { Component } from "vue";
+export interface SpaViewProps {
+    /**
+     * The active view. Either a component (`<component :is>`) or a string key the
+     * default-slot resolves against. When `view`/`is` is set, SpaView renders the
+     * dynamic component directly; when unset, the default slot is the active view
+     * (the consumer drives `:is` inside the slot themselves).
+     */
+    view?: Component | string;
+    /** Alias of `view` (the `:is` ergonomics — same dynamic-component target). */
+    is?: Component | string;
+    /**
+     * The LRU cap — the max number of cached inactive view instances. Threaded
+     * straight onto `<KeepAlive :max>`; when unset, KeepAlive's default (unbounded)
+     * applies. The visual-load-bearing register: a bounded admin shell sets `:max`
+     * to its tab count so the cache never grows without bound.
+     */
+    max?: number;
+    /** KeepAlive include allowlist (component name / RegExp / array — pass-through). */
+    include?: string | RegExp | (string | RegExp)[];
+    /** KeepAlive exclude denylist (component name / RegExp / array — pass-through). */
+    exclude?: string | RegExp | (string | RegExp)[];
+    /**
+     * The Vue <Transition> recipe name driving the out-in cross-fade. Defaults to
+     * `"fade"` — the shared opacity-only compositor recipe (transitions.css). A
+     * consumer overrides it with another `mode="out-in"`-safe recipe name.
+     */
+    transition?: string;
+    /**
+     * The stable key the transition keys off (a re-render WITHOUT a key change is
+     * not a view swap). Defaults to the resolved `view`/`is` target. A consumer
+     * driving the active view from the default slot supplies its own `:view-key`.
+     */
+    viewKey?: string | number;
+}
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SpaViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaViewProps> & Readonly<{}>, {
+    transition: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/spa-view/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SpaView } from "./SpaView.vue";
+export type { SpaViewProps } from "./SpaView.vue";

package/dist/components/custom/tabs/SegmentedTabs.vue.d.ts

@@ -49,6 +49,15 @@ export interface SegmentedTabsProps {
      * accessible name.
      */
     responsive?: boolean | SegmentedTabsResponsive;
+    /**
+     * BB.W-DRAG-MORPH — the LIQUID TAB. When `true` (ADDITIVE, default `false`),
+     * the `pill` indicator becomes a physical lozenge you can GRAB and PULL: it
+     * follows the finger ~1:1, squishes on drag velocity, and flings to the nearest
+     * tab on release (`useDragMorph`). The click-selection path is byte-identical;
+     * the drag is opt-in. No-op on `underline` (the ink hairline has no indicator
+     * element to deform).
+     */
+    draggable?: boolean;
     class?: HTMLAttributes["class"];
 }
 type __VLS_Props = SegmentedTabsProps;
@@ -75,6 +84,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {
 }>, {
     orientation: SegmentedTabsOrientation;
     variant: SegmentedTabsVariant;
+    draggable: boolean;
     responsive: boolean | SegmentedTabsResponsive;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/custom/tabs/composables/useTabDragMorph.d.ts

@@ -0,0 +1,42 @@
+import type { ComputedRef, Ref } from "vue";
+import { type UseDragMorphReturn } from "../../../../composables/motion/useDragMorph";
+import type { SegmentedTabOption } from "../SegmentedTabs.vue";
+/**
+ * Package-private composable for `SegmentedTabs.vue` — BB.W-DRAG-MORPH, the LIQUID
+ * TAB (the `:draggable` axis). Carved out of the SFC at BB.W-CARVE4 to hold the
+ * no-god-module bound, mirroring the `useTabIndicator` colocation sibling; the SFC
+ * IMPORTS it and binds `drag.dragStyle`/`drag.dragging` in its template.
+ *
+ * When `:draggable`, the `pill` indicator is wired to `useDragMorph` with the snap
+ * targets resolved off the CENTER-ANCHORED button geometry (the SAME measure
+ * `useTabIndicator` runs — reused, never re-measured). Dragging the indicator follows
+ * the finger, squishes on velocity, and flings to the nearest tab center on release →
+ * `onSnap` writes the `model`. The drag is the `pill` material ONLY (the `underline`
+ * ink hairline has no `indicatorRef` element to deform). The squish reads the SAME
+ * `--tab-indicator-max-stretch` live cap the click squish does (the SOLE cap source);
+ * the drag's `--stretch` write composes the existing reciprocal CSS pairing — no
+ * second squish recipe.
+ */
+export interface UseTabDragMorphParams {
+    /** The active indicator element (the drag follow + squish target). */
+    indicatorRef: Ref<HTMLElement | null>;
+    /** True for the vertical (block-axis) orientation. */
+    isVertical: ComputedRef<boolean>;
+    /** True for the underline material (drag is a no-op there). */
+    isUnderline: ComputedRef<boolean>;
+    /** The `:draggable` prop (ADDITIVE, default false). */
+    draggable: () => boolean;
+    /** The strip's rendered options (the snap targets + the refresh trigger). */
+    stripOptions: ComputedRef<SegmentedTabOption[]>;
+    /** Per-option button refs, index-aligned to `stripOptions`. */
+    buttonRefs: Ref<HTMLElement[]>;
+    /** The single-select model — the fling-to-nearest commits the selection. */
+    model: Ref<string | undefined>;
+}
+export interface UseTabDragMorphReturn {
+    /** True when the drag is live (the `pill` material + the `:draggable` prop). */
+    dragEnabled: ComputedRef<boolean>;
+    /** The `useDragMorph` handle (the SFC binds `dragStyle`/`dragging`). */
+    drag: UseDragMorphReturn;
+}
+export declare function useTabDragMorph(params: UseTabDragMorphParams): UseTabDragMorphReturn;

package/dist/components/custom/watercolor-dot/WatercolorDot.vue.d.ts

@@ -43,9 +43,9 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     animate: boolean;
+    range: [number, number];
     variant: "solid" | "ghost";
     seed: string;
-    range: [number, number];
     tag: "div" | "button";
     cycleDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/_shared/menuItemVariants.d.ts

@@ -44,7 +44,7 @@ import { type VariantProps } from "class-variance-authority";
  *   opts in via `surface="accent"`.
  */
 export declare const menuItemVariants: (props?: ({
-    surface?: "accent" | "glass" | null | undefined;
+    surface?: "glass" | "accent" | null | undefined;
     indicator?: "start" | "none" | "start-wide" | null | undefined;
     density?: "comfortable" | "audacious" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/components/ui/badge/index.d.ts

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

package/dist/components/ui/button/Button.vue.d.ts

@@ -1,16 +1,19 @@
 import type { ButtonHTMLAttributes, HTMLAttributes } from 'vue';
 import { type PrimitiveProps } from 'reka-ui';
 import { type ButtonVariants } from '.';
+import type { Surface } from '../_shared/useSurfaceAxis';
 interface Props extends PrimitiveProps {
     variant?: ButtonVariants['variant'];
     size?: ButtonVariants['size'];
     class?: HTMLAttributes['class'];
+    surface?: Surface;
+    liquid?: boolean;
     type?: ButtonHTMLAttributes['type'];
     disabled?: ButtonHTMLAttributes['disabled'];
 }
-declare var __VLS_8: {};
+declare var __VLS_13: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     as: import("reka-ui").AsTag | import("vue").Component;

package/dist/components/ui/button/index.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 export { default as Button } from './Button.vue';
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null | undefined;
-    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
+    variant?: "link" | "default" | "glass" | "outline" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "secondary" | "accent" | "ghost" | "glass-wash" | "ai" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | "icon-sm" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ButtonVariants = VariantProps<typeof buttonVariants>;