@backbay/glia 0.2.0-alpha.1

package/dist/emotion/controller.js

@@ -0,0 +1,203 @@
+// packages/bb-ui/src/emotion/controller.ts
+import { ANCHOR_STATES, DEFAULT_AVO, DEFAULT_MICRO_CONFIG, clampAVO } from './constants.js';
+import { blendAVO, computeVisualState } from './mapping.js';
+import { ease, getTransitionConfig } from './transitions.js';
+import { applyMicroExpression } from './micro-expressions.js';
+/**
+ * EmotionController manages the emotional state lifecycle for the Glyph character.
+ *
+ * It handles:
+ * - AVO dimension state (Arousal, Valence, Openness)
+ * - Smooth transitions between states with configurable easing
+ * - Micro-expression overlays for natural movement
+ * - Event-driven state changes from agent behaviors
+ * - Visual state computation for rendering
+ */
+export class EmotionController {
+    _dimensions;
+    _transition = null;
+    _microConfig;
+    _time = 0;
+    _listeners = new Map();
+    _disposed = false;
+    constructor(options = {}) {
+        // Initialize dimensions from anchor, custom values, or default
+        if (options.initialAnchor) {
+            this._dimensions = { ...ANCHOR_STATES[options.initialAnchor] };
+        }
+        else if (options.initial) {
+            this._dimensions = clampAVO(options.initial);
+        }
+        else {
+            this._dimensions = { ...DEFAULT_AVO };
+        }
+        // Initialize micro-expression config
+        if (options.microExpressions === false) {
+            this._microConfig = { ...DEFAULT_MICRO_CONFIG, enabled: false };
+        }
+        else if (typeof options.microExpressions === 'object') {
+            this._microConfig = { ...DEFAULT_MICRO_CONFIG, ...options.microExpressions };
+        }
+        else {
+            this._microConfig = { ...DEFAULT_MICRO_CONFIG };
+        }
+    }
+    /**
+     * Get current base dimensions (without micro-expressions)
+     */
+    getDimensions() {
+        return { ...this._dimensions };
+    }
+    /**
+     * Get current dimensions with micro-expressions applied
+     */
+    getAnimatedDimensions() {
+        return applyMicroExpression(this._dimensions, this._microConfig, this._time);
+    }
+    /**
+     * Get computed visual state for rendering
+     */
+    getVisualState() {
+        return computeVisualState(this.getAnimatedDimensions());
+    }
+    /**
+     * Set dimensions immediately (no transition)
+     * Values are clamped to valid 0-1 range
+     */
+    setDimensions(dims) {
+        this._dimensions = clampAVO({ ...this._dimensions, ...dims });
+        this._transition = null;
+        this._emit('change', this._dimensions);
+    }
+    /**
+     * Transition to target dimensions over time
+     * Auto-calculates duration and easing if not specified
+     */
+    transitionTo(target, options = {}) {
+        const from = { ...this._dimensions };
+        const to = clampAVO({ ...this._dimensions, ...target });
+        const autoConfig = getTransitionConfig(from, to);
+        this._transition = {
+            from,
+            to,
+            duration: options.duration ?? autoConfig.duration,
+            easing: options.easing ?? autoConfig.easing,
+            elapsed: 0,
+            onComplete: options.onComplete,
+        };
+        this._emit('transitionStart', { from, to });
+    }
+    /**
+     * Transition to a named anchor state
+     * Emits anchorReached when transition completes
+     */
+    transitionToAnchor(anchor, options = {}) {
+        this.transitionTo(ANCHOR_STATES[anchor], {
+            ...options,
+            onComplete: () => {
+                this._emit('anchorReached', anchor);
+                options.onComplete?.();
+            },
+        });
+    }
+    /**
+     * Handle emotion events from agent behaviors
+     * Maps event types to appropriate anchor transitions
+     */
+    handleEvent(event) {
+        const intensity = event.intensity ?? 0.5;
+        switch (event.type) {
+            case 'input_received':
+                this.transitionToAnchor('listening');
+                break;
+            case 'processing_start':
+                this.transitionToAnchor('thinking');
+                break;
+            case 'processing_complete':
+                this.transitionToAnchor('responding');
+                break;
+            case 'error_occurred':
+                this.transitionToAnchor(intensity > 0.7 ? 'error' : 'concerned');
+                break;
+            case 'success':
+                this.transitionToAnchor(intensity > 0.7 ? 'proud' : 'satisfied');
+                break;
+            case 'user_idle':
+                this.transitionToAnchor('idle', { duration: 2000 });
+                break;
+            case 'interrupt':
+                this.setDimensions({ arousal: Math.min(this._dimensions.arousal + 0.2, 1) });
+                break;
+        }
+    }
+    /**
+     * Blend toward target dimensions by a factor (0-1)
+     * Useful for continuous input-driven changes
+     */
+    blendToward(target, factor) {
+        const to = clampAVO({ ...this._dimensions, ...target });
+        this._dimensions = blendAVO(this._dimensions, to, factor);
+        this._emit('change', this._dimensions);
+    }
+    /**
+     * Check if currently transitioning
+     */
+    isTransitioning() {
+        return this._transition !== null;
+    }
+    /**
+     * Cancel current transition, keeping current position
+     */
+    cancelTransition() {
+        this._transition = null;
+    }
+    /**
+     * Subscribe to controller events
+     * Returns unsubscribe function
+     */
+    on(event, handler) {
+        if (!this._listeners.has(event)) {
+            this._listeners.set(event, new Set());
+        }
+        this._listeners.get(event).add(handler);
+        return () => {
+            this._listeners.get(event)?.delete(handler);
+        };
+    }
+    /**
+     * Update tick - call each frame with delta time in milliseconds
+     * Advances transitions and micro-expression time
+     */
+    tick(deltaMs) {
+        if (this._disposed)
+            return;
+        this._time += deltaMs / 1000;
+        if (this._transition) {
+            this._transition.elapsed += deltaMs;
+            // Handle duration 0 as immediate transition
+            const progress = this._transition.duration <= 0
+                ? 1
+                : Math.min(this._transition.elapsed / this._transition.duration, 1);
+            const easedProgress = ease(this._transition.easing, progress);
+            this._dimensions = blendAVO(this._transition.from, this._transition.to, easedProgress);
+            this._emit('change', this._dimensions);
+            if (progress >= 1) {
+                const onComplete = this._transition.onComplete;
+                this._transition = null;
+                this._emit('transitionEnd', this._dimensions);
+                onComplete?.();
+            }
+        }
+    }
+    /**
+     * Dispose controller and clean up resources
+     */
+    dispose() {
+        this._disposed = true;
+        this._listeners.clear();
+        this._transition = null;
+    }
+    _emit(event, data) {
+        this._listeners.get(event)?.forEach((handler) => handler(data));
+    }
+}

package/dist/emotion/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useEmotion } from './useEmotion.js';
+export type { UseEmotionOptions, UseEmotionResult } from './useEmotion.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/emotion/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/emotion/hooks/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/emotion/hooks/index.js

@@ -0,0 +1,2 @@
+// packages/bb-ui/src/emotion/hooks/index.ts
+export { useEmotion } from './useEmotion.js';

package/dist/emotion/hooks/useEmotion.d.ts

@@ -0,0 +1,60 @@
+import type { AVO, AnchorState, TransitionOptions, EmotionEvent, VisualState, MicroExpressionConfig } from '../types.js';
+export interface UseEmotionOptions {
+    /** Initial dimensions */
+    initial?: Partial<AVO>;
+    /** Initial anchor state (overrides initial) */
+    initialAnchor?: AnchorState;
+    /** Enable micro-expressions (boolean or config object) */
+    microExpressions?: boolean | MicroExpressionConfig;
+    /** Callback on dimension change */
+    onChange?: (dimensions: AVO) => void;
+    /** Auto-tick with requestAnimationFrame (default: true) */
+    autoTick?: boolean;
+}
+export interface UseEmotionResult {
+    /** Current dimensions (with micro-expressions if enabled) */
+    dimensions: AVO;
+    /** Base dimensions (without micro-expressions) */
+    baseDimensions: AVO;
+    /** Computed visual properties */
+    visualState: VisualState;
+    /** Set dimensions instantly */
+    set: (dimensions: Partial<AVO>) => void;
+    /** Transition to dimensions */
+    transition: (dimensions: Partial<AVO>, options?: TransitionOptions) => void;
+    /** Transition to anchor state */
+    goTo: (anchor: AnchorState, options?: TransitionOptions) => void;
+    /** Handle emotion event */
+    emit: (event: EmotionEvent) => void;
+    /** Currently transitioning */
+    isTransitioning: boolean;
+    /** Manual tick (if autoTick disabled) */
+    tick: (deltaMs: number) => void;
+}
+/**
+ * React hook for managing Glyph emotion state.
+ *
+ * Creates an EmotionController and provides reactive state updates.
+ * Automatically handles RAF-based animation when autoTick is true (default).
+ *
+ * @example
+ * ```tsx
+ * const { dimensions, visualState, goTo, emit } = useEmotion({
+ *   initialAnchor: 'idle',
+ *   onChange: (dims) => console.log('Emotion changed:', dims),
+ * });
+ *
+ * // Transition to a named state
+ * goTo('thinking');
+ *
+ * // Handle agent events
+ * emit({ type: 'processing_complete' });
+ *
+ * // Apply visual state to rendering
+ * <mesh scale={visualState.scaleFactor}>
+ *   <meshStandardMaterial color={`hsl(${visualState.coreHue}, 80%, 50%)`} />
+ * </mesh>
+ * ```
+ */
+export declare function useEmotion(options?: UseEmotionOptions): UseEmotionResult;
+//# sourceMappingURL=useEmotion.d.ts.map

package/dist/emotion/hooks/useEmotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmotion.d.ts","sourceRoot":"","sources":["../../../src/emotion/hooks/useEmotion.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,GAAG,EACH,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,iBAAiB;IAChC,yBAAyB;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACvB,+CAA+C;IAC/C,aAAa,CAAC,EAAE,WAAW,CAAC;IAC5B,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;IACnD,mCAAmC;IACnC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,KAAK,IAAI,CAAC;IACrC,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,UAAU,EAAE,GAAG,CAAC;IAChB,kDAAkD;IAClD,cAAc,EAAE,GAAG,CAAC;IACpB,iCAAiC;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,+BAA+B;IAC/B,GAAG,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC;IACxC,+BAA+B;IAC/B,UAAU,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC5E,iCAAiC;IACjC,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACjE,2BAA2B;IAC3B,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACpC,8BAA8B;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,yCAAyC;IACzC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CAuI5E"}

package/dist/emotion/hooks/useEmotion.js

@@ -0,0 +1,121 @@
+'use client';
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { EmotionController } from '../controller.js';
+/**
+ * React hook for managing Glyph emotion state.
+ *
+ * Creates an EmotionController and provides reactive state updates.
+ * Automatically handles RAF-based animation when autoTick is true (default).
+ *
+ * @example
+ * ```tsx
+ * const { dimensions, visualState, goTo, emit } = useEmotion({
+ *   initialAnchor: 'idle',
+ *   onChange: (dims) => console.log('Emotion changed:', dims),
+ * });
+ *
+ * // Transition to a named state
+ * goTo('thinking');
+ *
+ * // Handle agent events
+ * emit({ type: 'processing_complete' });
+ *
+ * // Apply visual state to rendering
+ * <mesh scale={visualState.scaleFactor}>
+ *   <meshStandardMaterial color={`hsl(${visualState.coreHue}, 80%, 50%)`} />
+ * </mesh>
+ * ```
+ */
+export function useEmotion(options = {}) {
+    const { initial, initialAnchor, microExpressions = true, onChange, autoTick = true, } = options;
+    // Create controller ref (stable across renders)
+    const controllerRef = useRef(null);
+    if (!controllerRef.current) {
+        controllerRef.current = new EmotionController({
+            initial,
+            initialAnchor,
+            microExpressions,
+        });
+    }
+    const controller = controllerRef.current;
+    // State for React reactivity
+    const [dimensions, setDimensions] = useState(controller.getAnimatedDimensions());
+    const [baseDimensions, setBaseDimensions] = useState(controller.getDimensions());
+    const [visualState, setVisualState] = useState(controller.getVisualState());
+    const [isTransitioning, setIsTransitioning] = useState(false);
+    // Store onChange in ref to avoid effect dependency changes
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    // Subscribe to controller events
+    useEffect(() => {
+        const unsub = controller.on('change', (dims) => {
+            setBaseDimensions({ ...dims });
+            setDimensions(controller.getAnimatedDimensions());
+            setVisualState(controller.getVisualState());
+            onChangeRef.current?.(dims);
+        });
+        const unsubStart = controller.on('transitionStart', () => {
+            setIsTransitioning(true);
+        });
+        const unsubEnd = controller.on('transitionEnd', () => {
+            setIsTransitioning(false);
+        });
+        return () => {
+            unsub();
+            unsubStart();
+            unsubEnd();
+        };
+    }, [controller]);
+    // Auto-tick with RAF
+    useEffect(() => {
+        if (!autoTick)
+            return;
+        let lastTime = performance.now();
+        let rafId;
+        const tick = (time) => {
+            const delta = time - lastTime;
+            lastTime = time;
+            controller.tick(delta);
+            setDimensions(controller.getAnimatedDimensions());
+            setVisualState(controller.getVisualState());
+            rafId = requestAnimationFrame(tick);
+        };
+        rafId = requestAnimationFrame(tick);
+        return () => {
+            cancelAnimationFrame(rafId);
+        };
+    }, [controller, autoTick]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            controller.dispose();
+        };
+    }, [controller]);
+    // Stable callbacks
+    const set = useCallback((dims) => {
+        controller.setDimensions(dims);
+    }, [controller]);
+    const transition = useCallback((dims, opts) => {
+        controller.transitionTo(dims, opts);
+    }, [controller]);
+    const goTo = useCallback((anchor, opts) => {
+        controller.transitionToAnchor(anchor, opts);
+    }, [controller]);
+    const emit = useCallback((event) => {
+        controller.handleEvent(event);
+    }, [controller]);
+    const tick = useCallback((deltaMs) => {
+        controller.tick(deltaMs);
+    }, [controller]);
+    return {
+        dimensions,
+        baseDimensions,
+        visualState,
+        set,
+        transition,
+        goTo,
+        emit,
+        isTransitioning,
+        tick,
+    };
+}

package/dist/emotion/index.d.ts

@@ -0,0 +1,10 @@
+export type { AVO, AVODimensions, AnchorState, EasingFunction, TransitionOptions, VisualState, EmotionEvent, MicroExpressionConfig, LegacyGlyphState, } from './types.js';
+export { ANCHOR_STATES, LEGACY_STATE_MAP, DEFAULT_AVO, DEFAULT_MICRO_CONFIG, DEFAULT_TRANSITION_DURATIONS, isValidAVO, clampAVO, } from './constants.js';
+export { lerp, mapArousal, mapValence, mapOpenness, computeVisualState, avoDistance, blendAVO, getAnimationWeights, } from './mapping.js';
+export { ease, getTransitionDuration, getTransitionEasing, getTransitionConfig, } from './transitions.js';
+export { createNoiseGenerator, applyMicroExpression, createMicroExpressionAnimator, } from './micro-expressions.js';
+export { EmotionController } from './controller.js';
+export type { EmotionControllerOptions } from './controller.js';
+export { useEmotion } from './hooks/index.js';
+export type { UseEmotionOptions, UseEmotionResult } from './hooks/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/emotion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/emotion/index.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,GAAG,EACH,aAAa,EACb,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,4BAA4B,EAC5B,UAAU,EACV,QAAQ,GACT,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,IAAI,EACJ,UAAU,EACV,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,IAAI,EACJ,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAGhE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/emotion/index.js

@@ -0,0 +1,13 @@
+// packages/bb-ui/src/emotion/index.ts
+// Constants
+export { ANCHOR_STATES, LEGACY_STATE_MAP, DEFAULT_AVO, DEFAULT_MICRO_CONFIG, DEFAULT_TRANSITION_DURATIONS, isValidAVO, clampAVO, } from './constants.js';
+// Mapping
+export { lerp, mapArousal, mapValence, mapOpenness, computeVisualState, avoDistance, blendAVO, getAnimationWeights, } from './mapping.js';
+// Transitions
+export { ease, getTransitionDuration, getTransitionEasing, getTransitionConfig, } from './transitions.js';
+// Micro-expressions
+export { createNoiseGenerator, applyMicroExpression, createMicroExpressionAnimator, } from './micro-expressions.js';
+// Controller
+export { EmotionController } from './controller.js';
+// Hooks
+export { useEmotion } from './hooks/index.js';

package/dist/emotion/mapping.d.ts

@@ -0,0 +1,55 @@
+import type { AVO, LegacyGlyphState, VisualState } from './types.js';
+/**
+ * Linear interpolation
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Map Arousal (0-1) to temporal visual properties
+ */
+export declare function mapArousal(a: number): {
+    breathingRate: number;
+    breathingAmplitude: number;
+    ringRotationSpeed: number;
+    particleVelocity: number;
+    particleCount: number;
+    glowPulseRate: number;
+};
+/**
+ * Map Valence (0-1) to qualitative visual properties
+ */
+export declare function mapValence(v: number): {
+    coreHue: number;
+    coreSaturation: number;
+    motionNoise: number;
+    scaleFactor: number;
+    emissiveIntensity: number;
+};
+/**
+ * Map Openness (0-1) to spatial visual properties
+ */
+export declare function mapOpenness(o: number): {
+    particleFlowDirection: number;
+    particleSpreadAngle: number;
+    breathingPhaseBias: number;
+    ringTilt: number;
+    auraExpansion: number;
+};
+/**
+ * Compute complete visual state from AVO dimensions
+ */
+export declare function computeVisualState(avo: AVO): VisualState;
+/**
+ * Compute Euclidean distance between two AVO states
+ */
+export declare function avoDistance(a: AVO, b: AVO): number;
+/**
+ * Blend between two AVO states
+ */
+export declare function blendAVO(from: AVO, to: AVO, t: number): AVO;
+/**
+ * Calculate animation weights for all legacy states based on distance to current AVO.
+ * Uses inverse distance weighting with falloff - states closer in AVO space get higher weights.
+ * Weights are normalized to sum to 1.0 (or all zero if no state is close enough).
+ */
+export declare function getAnimationWeights(currentAVO: AVO): Record<LegacyGlyphState, number>;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/emotion/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../src/emotion/mapping.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGrE;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM;;;;;;;EASnC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM;;;;;;EAWnC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM;;;;;;EAQpC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW,CAcxD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAMlD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,GAAG,GACd,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAiClC"}

package/dist/emotion/mapping.js

@@ -0,0 +1,118 @@
+// packages/bb-ui/src/emotion/mapping.ts
+import { ANCHOR_STATES, LEGACY_STATE_MAP } from './constants.js';
+/**
+ * Linear interpolation
+ */
+export function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+/**
+ * Map Arousal (0-1) to temporal visual properties
+ */
+export function mapArousal(a) {
+    return {
+        breathingRate: 0.3 + Math.pow(a, 1.5) * 1.7, // 0.3 - 2.0 Hz
+        breathingAmplitude: 0.01 + a * 0.05, // 1% - 6%
+        ringRotationSpeed: 0.1 + Math.pow(a, 1.3) * 1.9, // 0.1 - 2.0 rad/s
+        particleVelocity: 0.02 + a * 0.18, // 0.02 - 0.20
+        particleCount: Math.floor(20 + a * 80), // 20 - 100
+        glowPulseRate: 0.2 + Math.pow(a, 1.4) * 1.3, // 0.2 - 1.5 Hz
+    };
+}
+/**
+ * Map Valence (0-1) to qualitative visual properties
+ */
+export function mapValence(v) {
+    // Sigmoid for sharper color transition in middle range
+    const colorT = 1 / (1 + Math.exp(-8 * (v - 0.4)));
+    return {
+        coreHue: lerp(220, 35, colorT), // Blue(220) → Gold(35)
+        coreSaturation: 0.4 + v * 0.45, // 40% - 85%
+        motionNoise: 0.15 * Math.pow(1 - v, 2), // High noise when low
+        scaleFactor: 0.92 + v * 0.16, // 0.92x - 1.08x
+        emissiveIntensity: 0.2 + Math.pow(v, 1.5) * 0.7, // 0.2 - 0.9
+    };
+}
+/**
+ * Map Openness (0-1) to spatial visual properties
+ */
+export function mapOpenness(o) {
+    return {
+        particleFlowDirection: lerp(-1, 1, o), // -1 (in) to +1 (out)
+        particleSpreadAngle: lerp(30, 120, o), // 30° - 120°
+        breathingPhaseBias: lerp(-0.3, 0.3, o), // Inhale vs exhale bias
+        ringTilt: lerp(-15, 15, o), // -15° to +15°
+        auraExpansion: lerp(0.95, 1.1, o), // 0.95x - 1.1x
+    };
+}
+/**
+ * Compute complete visual state from AVO dimensions
+ */
+export function computeVisualState(avo) {
+    const arousalMap = mapArousal(avo.arousal);
+    const valenceMap = mapValence(avo.valence);
+    const opennessMap = mapOpenness(avo.openness);
+    // Cross-dimensional: overall intensity combines A and V
+    const overallIntensity = 0.3 + (avo.arousal * 0.4) + (avo.valence * 0.3);
+    return {
+        ...arousalMap,
+        ...valenceMap,
+        ...opennessMap,
+        overallIntensity,
+    };
+}
+/**
+ * Compute Euclidean distance between two AVO states
+ */
+export function avoDistance(a, b) {
+    return Math.sqrt(Math.pow(a.arousal - b.arousal, 2) +
+        Math.pow(a.valence - b.valence, 2) +
+        Math.pow(a.openness - b.openness, 2));
+}
+/**
+ * Blend between two AVO states
+ */
+export function blendAVO(from, to, t) {
+    return {
+        arousal: lerp(from.arousal, to.arousal, t),
+        valence: lerp(from.valence, to.valence, t),
+        openness: lerp(from.openness, to.openness, t),
+    };
+}
+/**
+ * Calculate animation weights for all legacy states based on distance to current AVO.
+ * Uses inverse distance weighting with falloff - states closer in AVO space get higher weights.
+ * Weights are normalized to sum to 1.0 (or all zero if no state is close enough).
+ */
+export function getAnimationWeights(currentAVO) {
+    const weights = {
+        idle: 0,
+        listening: 0,
+        thinking: 0,
+        responding: 0,
+        success: 0,
+        error: 0,
+        sleep: 0,
+    };
+    // Calculate distance to each legacy state's AVO coordinates
+    for (const [state, anchor] of Object.entries(LEGACY_STATE_MAP)) {
+        const targetAVO = ANCHOR_STATES[anchor];
+        const distance = avoDistance(currentAVO, targetAVO);
+        // Inverse distance weighting with falloff
+        // Distance of 0 -> weight 1, distance >= 0.5 -> weight 0
+        weights[state] = Math.max(0, 1 - distance * 2);
+    }
+    // Normalize weights to sum to 1.0
+    const total = Object.values(weights).reduce((a, b) => a + b, 0);
+    if (total > 0) {
+        for (const key of Object.keys(weights)) {
+            weights[key] /= total;
+        }
+    }
+    else {
+        // Fallback: if all weights are zero (current AVO is far from all states),
+        // default to idle with full weight
+        weights.idle = 1;
+    }
+    return weights;
+}

package/dist/emotion/micro-expressions.d.ts

@@ -0,0 +1,19 @@
+import type { AVO, MicroExpressionConfig } from './types.js';
+/**
+ * Create a smooth noise generator (Perlin-like)
+ * Returns values between -1 and 1
+ */
+export declare function createNoiseGenerator(seed?: number): (t: number) => number;
+/**
+ * Apply micro-expression variations to base AVO state
+ */
+export declare function applyMicroExpression(base: AVO, config: MicroExpressionConfig, time: number): AVO;
+/**
+ * Create a micro-expression animator that tracks time internally
+ */
+export declare function createMicroExpressionAnimator(config: MicroExpressionConfig): {
+    tick(deltaMs: number): void;
+    apply(base: AVO): AVO;
+    reset(): void;
+};
+//# sourceMappingURL=micro-expressions.d.ts.map

package/dist/emotion/micro-expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"micro-expressions.d.ts","sourceRoot":"","sources":["../../src/emotion/micro-expressions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAa7D;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,MAAW,IAY5C,GAAG,MAAM,KAAG,MAAM,CAa3B;AAOD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,GACX,GAAG,CAkBL;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,qBAAqB;kBAIzD,MAAM;gBAGR,GAAG,GAAG,GAAG;;EAOxB"}