@mkbabb/glass-ui 6.0.0 → 7.0.0

package/dist/components/avatar/Avatar.vue.d.ts

@@ -1,18 +1,79 @@
-import type { HTMLAttributes } from 'vue';
-import { type AvatarVariants } from './';
-type __VLS_Props = {
-    class?: HTMLAttributes['class'];
-    size?: AvatarVariants['size'];
-    shape?: AvatarVariants['shape'];
+import { type HTMLAttributes } from "vue";
+export type AvatarSize = "sm" | "md" | "lg";
+export type AvatarShape = "circle" | "square";
+export type AvatarIdentityProps = {
+    label: string;
+    labelledBy?: never;
+    decorative?: false;
+} | {
+    label?: never;
+    labelledBy: string;
+    decorative?: false;
+} | {
+    label?: never;
+    labelledBy?: never;
+    decorative: true;
 };
-declare var __VLS_8: {};
+export type AvatarProps = AvatarIdentityProps & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_8: {}, __VLS_10: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
+} & {
+    status?: (props: typeof __VLS_10) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    size: "sm" | "md" | "lg" | null;
-    shape: "circle" | "square" | null;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<({
+    label: string;
+    labelledBy?: never;
+    decorative?: false;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+}) | ({
+    label?: never;
+    labelledBy: string;
+    decorative?: false;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+}) | ({
+    label?: never;
+    labelledBy?: never;
+    decorative: true;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+}), {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<({
+    label: string;
+    labelledBy?: never;
+    decorative?: false;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+}) | ({
+    label?: never;
+    labelledBy: string;
+    decorative?: false;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+}) | ({
+    label?: never;
+    labelledBy?: never;
+    decorative: true;
+} & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    class?: HTMLAttributes["class"];
+})> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/avatar/AvatarFallback.vue.d.ts

@@ -1,9 +1,8 @@
-import { type AvatarFallbackProps } from 'reka-ui';
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<AvatarFallbackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/avatar/AvatarImage.vue.d.ts

@@ -1,10 +1,14 @@
-import type { ImgHTMLAttributes } from 'vue';
-import { type AvatarImageProps } from 'reka-ui';
-type __VLS_Props = AvatarImageProps & {
-    alt?: ImgHTMLAttributes['alt'];
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    alt: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import { type ImgHTMLAttributes } from "vue";
+interface AvatarImageProps {
+    src: string;
+    referrerPolicy?: ImgHTMLAttributes["referrerpolicy"];
+    crossOrigin?: ImgHTMLAttributes["crossorigin"];
+}
+type AvatarImageStatus = "idle" | "loading" | "loaded" | "error";
+declare const __VLS_export: import("vue").DefineComponent<AvatarImageProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    loadingStatusChange: (status: AvatarImageStatus) => any;
+}, string, import("vue").PublicProps, Readonly<AvatarImageProps> & Readonly<{
+    onLoadingStatusChange?: ((status: AvatarImageStatus) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

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

package/dist/components/avatar/styles.css

@@ -0,0 +1 @@
+@layer components { .glass-avatar { --avatar-size: var(--control-h-md); position: relative; display: inline-grid; flex: none; inline-size: var(--avatar-size); block-size: var(--avatar-size); vertical-align: middle; isolation: isolate; } .glass-avatar[data-size="md"] { --avatar-size: 4rem; } .glass-avatar[data-size="lg"] { --avatar-size: 8rem; } .glass-avatar__identity, .glass-avatar__image, .glass-avatar__fallback { inline-size: 100%; block-size: 100%; } .glass-avatar__identity { display: grid; overflow: hidden; place-items: center; border: 1px solid var(--glass-border-wash); background: var(--glass-bg-wash); color: var(--foreground); box-shadow: var(--glass-specular), var(--shadow-sm); } .glass-avatar[data-shape="circle"] .glass-avatar__identity { border-radius: var(--radius-pill); } .glass-avatar[data-shape="square"] .glass-avatar__identity { border-radius: var(--radius-input); } .glass-avatar__image, .glass-avatar__fallback { grid-area: 1 / 1; } .glass-avatar__image { object-fit: cover; } .glass-avatar__fallback { display: grid; place-items: center; background: color-mix(in srgb, var(--secondary) 82%, transparent); font-size: var(--type-caption); font-weight: var(--font-weight-semibold); letter-spacing: var(--tracking-tight); line-height: 1; user-select: none; } .glass-avatar[data-size="md"] .glass-avatar__fallback { font-size: var(--type-subheading); } .glass-avatar[data-size="lg"] .glass-avatar__fallback { font-size: var(--type-display-2); } .glass-avatar__status { position: absolute; inset-inline-end: -0.125rem; inset-block-end: -0.125rem; z-index: 1; display: grid; min-inline-size: 0.875rem; min-block-size: 0.875rem; place-items: center; padding: 0.125rem; border-radius: var(--radius-pill); background: var(--background); box-shadow: 0 0 0 1px var(--glass-border-wash); } }

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

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

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

@@ -1,9 +1,32 @@
-import { type VariantProps } from 'class-variance-authority';
-export { default as Badge } from './Badge.vue';
-export declare const badgeVariants: (props?: ({
-    variant?: "default" | "secondary" | "outline" | null | undefined;
-    tone?: "neutral" | "destructive" | "success" | "warning" | "info" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-    surface?: "glass" | "loud" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type BadgeVariants = VariantProps<typeof badgeVariants>;
+import { type ClassValue } from "../_shared/class-names";
+export { default as Badge } from "./Badge.vue";
+declare const VARIANT: {
+    readonly default: "bg-primary text-primary-foreground";
+    readonly secondary: "bg-secondary text-secondary-foreground";
+    readonly outline: "badge-atom--outline text-foreground";
+};
+declare const TONE: {
+    readonly neutral: "";
+    readonly destructive: "bg-destructive text-destructive-foreground dark:bg-[hsl(0_70%_45%)]";
+    readonly success: "bg-success text-success-foreground";
+    readonly warning: "bg-warning text-warning-foreground";
+    readonly info: "bg-info text-info-foreground";
+};
+declare const SIZE: {
+    readonly sm: "text-[length:var(--control-text-sm)] leading-[1.1] px-2 py-0.5";
+    readonly md: "text-[length:var(--control-text)] leading-[1.1] px-2.5 py-1";
+    readonly lg: "text-[length:calc(var(--type-body)*var(--ui-scale))] leading-[1.1] px-3 py-1.5";
+};
+declare const SURFACE: {
+    readonly loud: "";
+    readonly glass: "badge-atom--glass glass-capsule glass-atom";
+};
+export interface BadgeVariants {
+    variant?: keyof typeof VARIANT | null;
+    tone?: keyof typeof TONE | null;
+    size?: keyof typeof SIZE | null;
+    surface?: keyof typeof SURFACE | null;
+    class?: ClassValue;
+    className?: ClassValue;
+}
+export declare function badgeVariants(options?: BadgeVariants): string;

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

@@ -1,12 +1,12 @@
-import type { BlobMood, BlobConfig, BlobVariant } from "./types";
+import type { BlobMood, BlobConfig } from "./types";
 /**
- * Blob — a gooey metaball creature on a WebGL2 canvas.
+ * Blob — a gooey metaball creature on a WebGPU/WebGL2 canvas.
  *
  * Renders a pulsing SDF body with orbiting satellites that periodically merge in,
  * get absorbed, then re-emerge. Mood, pointer-attraction and a deterministic
  * satellite system drive the motion. The renderer composes the `createGpuSubstrate`
  * picker — the WebGPU-first `metaball.wgsl` primary OR the WebGL2 `metaball.frag`
- * fallback (BB.W-VIZ-SUITE / W-GOOBLOB-WGPU), selected once by `navigator.gpu`
+ * fallback, selected once by `navigator.gpu`
  * feature-detect; it never bootstraps its own context.
  *
  * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
@@ -30,18 +30,10 @@ type __VLS_Props = {
      * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.
      */
     config?: BlobConfig;
-    /**
-     * BC.W-GOOBLOB-PLAIN — the render-variant axis. `"blob"` is the STAGE-1
-     * shadowless lightless fill-only floor; `"meatball"` (default) is the full lit
-     * register. When set it WINS the resolved config's `variant` (the per-instance
-     * override); unset, the config's own `variant` rules. STAGE 1's `uStage` gate
-     * strips the lit/shadow blocks for the `"blob"` register.
-     */
-    variant?: BlobVariant;
     /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
     seed?: string;
     /**
-     * AX.W16 — the declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the
+     * Declarative WCAG 2.2.2 pause seam. `v-model:paused` parks the
      * render loop (the substrate's `manual` suspend) when `true` and restarts it when
      * `false`. This is the EXACT shape `<DockBackgroundToggle>` wears — wire its
      * `@update:paused` to this `v-model` and the blob's animation stops/starts for ALL
@@ -69,6 +61,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     pause: () => void;
     resume: () => void;
     settled: Readonly<import("vue").Ref<boolean, boolean>>;
+    settledFrame: Readonly<import("vue").Ref<import(".").BlobSettledFrame | null, import(".").BlobSettledFrame | null>>;
     rendererStatus: Readonly<import("vue").Ref<import("../../composables/glass/webgpu/rendererStatus").RendererStatus, import("../../composables/glass/webgpu/rendererStatus").RendererStatus>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: () => any;

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

@@ -0,0 +1,80 @@
+import { type Ref } from "vue";
+import type { BackingSize } from "../../../composables/glass/webgpu/useGpuSubstrate";
+import type { BlobConfig, MoodParams } from "../types";
+import type { BlobMoodSystem } from "./useBlobMood";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+/** Per-frame state shared by the WebGPU and WebGL2 upload legs. */
+export interface BlobFrameState {
+    params: MoodParams;
+    rgb: [number, number, number];
+    simTimeMs: number;
+    timeSec: number;
+    resolveColor: (css: string) => [number, number, number];
+    rimColor: string;
+    paletteStops: string[];
+    satColors?: string[];
+}
+/** The exact terminal frame last drawn while the Blob engine was quiescent. */
+export interface BlobSettledFrame {
+    readonly timeSec: number;
+    readonly simulationTimeMs: number;
+    readonly buffer: {
+        readonly width: number;
+        readonly height: number;
+        readonly dpr: number;
+    };
+    readonly simulationOrigin: {
+        readonly x: 0.5;
+        readonly y: 0.5;
+    };
+}
+export declare function resolveBlobSettledFrame(frame: BlobFrameState | null, size: BackingSize | null): BlobSettledFrame | null;
+interface BlobSimulationDeps {
+    color: Ref<string>;
+    rimColor: Ref<string>;
+    paletteStops: Ref<string[]>;
+    satelliteColors?: Ref<string[]>;
+    mood: BlobMoodSystem;
+    pointer: BlobPointer;
+    satellites: BlobSatelliteSystem;
+    config: BlobConfig;
+    getReducedMotion: () => boolean;
+    wake: () => void;
+}
+export declare function createBlobSimulation(deps: BlobSimulationDeps): {
+    resolveFrame: (timeSec: number) => BlobFrameState;
+    shouldContinue: () => boolean;
+    recordBackingSize: (size: BackingSize) => void;
+    recordDraw: (frame: BlobFrameState) => void;
+    pause: () => void;
+    resume: () => void;
+    dispose: () => void;
+    settled: Readonly<Ref<boolean, boolean>>;
+    settledFrame: Readonly<Ref<{
+        readonly timeSec: number;
+        readonly simulationTimeMs: number;
+        readonly buffer: {
+            readonly width: number;
+            readonly height: number;
+            readonly dpr: number;
+        };
+        readonly simulationOrigin: {
+            readonly x: 0.5;
+            readonly y: 0.5;
+        };
+    } | null, {
+        readonly timeSec: number;
+        readonly simulationTimeMs: number;
+        readonly buffer: {
+            readonly width: number;
+            readonly height: number;
+            readonly dpr: number;
+        };
+        readonly simulationOrigin: {
+            readonly x: 0.5;
+            readonly y: 0.5;
+        };
+    } | null>>;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { type MetaballUniformLocations } from "./uploadBlobUniforms";
+import type { MetaballUniformLocations } from "./uploadBlobUniforms";
 /** The compiled-program handles the renderer closes over + tears down. */
 export interface MetaballProgram {
     prog: WebGLProgram;

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

@@ -0,0 +1,6 @@
+import type { BlobConfig } from "../types";
+/** One bounded surface decision shared by both renderer backends. */
+export declare function resolveBlobSurface(config: BlobConfig): {
+    morphT: number;
+    dressed: boolean;
+};

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

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

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

@@ -1,7 +1,7 @@
 import type { BlobConfig } from "../types";
 import type { BlobPointer } from "./useBlobPointer";
 import type { BlobSatelliteSystem } from "./useBlobSatellites";
-import type { BlobFrameState } from "./uploadBlobUniforms";
+import type { BlobFrameState } from "./blobSimulation";
 /** The total uniform-buffer byte size (16-aligned). */
 export declare const BLOB_WGPU_UNIFORM_BYTES: number;
 /**

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

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

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

@@ -10,7 +10,7 @@ export interface MoodInteraction {
     idleMs: number;
 }
 /**
- * Who is driving a `setMood` retarget (AX.W46 D7). `"auto"` — the autonomic arc
+ * Who is driving a `setMood` retarget. `"auto"` — the autonomic arc
  * (`update` from the pointer/idle state); `"manual"` — the public expose (an imperative
  * `setMood` from a consumer / the demo mood pills). A manual retarget arms the
  * `manualOverride` latch the auto-arc respects.
@@ -24,8 +24,8 @@ export interface SetMoodOptions {
 /**
  * Animates the blob's mood parameters — a cross-fade between named mood targets
  * driven per frame by `tick(dt)`. `setMood(mood, { source })` retargets (a `"manual"`
- * source — the default — pins the mood above the auto-arc, AX.W46 D7);
- * `update(interaction)` drives the AUTONOMIC arc from the AW.W10 pointer/idle state
+ * source — the default — pins the mood above the auto arc;
+ * `update(interaction)` drives the autonomic arc from pointer and idle state
  * (curious on approach, excited on click, sleepy after inactivity), always
  * `source: "auto"`, and early-returns while a manual mood is pinned; `params` is the
  * eased current value the renderer reads.
@@ -36,9 +36,9 @@ export declare function useBlobMood(): {
     setMood: (mood: BlobMood, options?: SetMoodOptions) => void;
     update: (interaction: MoodInteraction) => void;
     tick: (dt: number) => void;
-    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    /** Quiescence predicate read by the renderer's demand gate. */
     isSettled: () => boolean;
-    /** AX.W16 — wall-ms to the next auto-mood retarget (the wake horizon). */
+    /** Milliseconds to the next automatic mood retarget. */
     nextAutoMoodMs: () => number;
 };
 export type BlobMoodSystem = ReturnType<typeof useBlobMood>;

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

@@ -9,14 +9,14 @@ export interface TrailSample {
     radius: number;
 }
 /**
- * The blob pointer/interaction machine (W10). Tracks the pointer over a host
+ * The blob pointer/interaction machine 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
+ * `dtMs`, rather than a frame-rate-dependent fixed-α lerp. 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).
+ * single-substrate-loop contract 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`
@@ -28,16 +28,15 @@ export interface TrailSample {
  * pointer target (or centre when inactive), zero velocity, the trail collapsed
  * onto the body.
  *
- * F9.R8 (BG.W-BLOB-AFFECT-INTERACT — pointer truth) — the SDF-SHAPED HIT-TEST. The
+ * The SDF-shaped hit test. The
  * listener box is a SQUARE, but the blob silhouette is the body DISC (the satellites
  * orbit OUTSIDE the box). `options.hitRadius()` returns the silhouette radius in the
  * normalized [-1, 1] space; `hitTest(clientX, clientY)` is the authoritative predicate
  * the engage + click gates read, and `onPointerMove` engages the attract ONLY inside
  * it — so hovering the empty box margin never lunges the blob, and the caller lets a
  * corner click FALL THROUGH to a sibling card (the `.goo-blob-hit` clip-path is the
- * compositor-level twin). With `hitRadius` UNSET the whole box engages (byte-identical
- * to the prior always-on `active`) — the tight silhouette is the opt-in a shaped
- * consumer (GooBlob) passes; the UNSET-whole-box default stays byte-preserved.
+ * compositor-level twin). With `hitRadius` unset, the whole box engages; a shaped
+ * consumer passes a tighter silhouette radius.
  */
 export declare function useBlobPointer(el: Ref<HTMLElement | null>, options?: {
     hitRadius?: () => number;
@@ -58,7 +57,7 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>, options?: {
     }>>;
     active: Readonly<Ref<boolean, boolean>>;
     /**
-     * BI.W-FIELD-CORE — the RAW pointer target (pre-spring, [-1,1] body space). The
+     * the RAW pointer target (pre-spring, [-1,1] body space). The
      * shared `usePointerVelocityField` reads THIS (not the smoothed `pointer`) so the
      * field is the ONE smoothing stage — the double-smooth (feeding the spring output
      * into the field, which smooths it AGAIN) is dead. The blob's own body spring reads
@@ -70,7 +69,7 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>, options?: {
     };
     /** 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). */
+    /** Milliseconds since the last pointer activity, used by mood idle drift. */
     idleMs: () => number;
     tick: (dtMs?: number) => void;
     trailSources: (baseRadius: number) => {
@@ -80,9 +79,9 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>, options?: {
     click: (amp: number) => void;
     consumeClick: () => boolean;
     rest: () => void;
-    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    /** Quiescence predicate read by the renderer's demand gate. */
     isAtRest: () => boolean;
-    /** F9.R8 — the SDF-shaped hit-test (is a client point inside the blob silhouette?). */
+    /** the SDF-shaped hit-test (is a client point inside the blob silhouette?). */
     hitTest: (clientX: number, clientY: number) => boolean;
 };
 export type BlobPointer = ReturnType<typeof useBlobPointer>;