@backbay/glia-agent 0.1.0

package/dist/cognition.js

@@ -0,0 +1,25 @@
+import {
+  CognitionController,
+  CognitionSnapshotSchema,
+  CognitionStateSchema,
+  MODE_TRANSITION_MAP,
+  clamp01,
+  createInitialCognitionState,
+  reduceDecay,
+  reduceEvent,
+  useCognition,
+  validateCognitionSnapshot
+} from "./chunk-LLOGBVQT.js";
+export {
+  CognitionController,
+  CognitionSnapshotSchema,
+  CognitionStateSchema,
+  MODE_TRANSITION_MAP,
+  clamp01,
+  createInitialCognitionState,
+  reduceDecay,
+  reduceEvent,
+  useCognition,
+  validateCognitionSnapshot
+};
+//# sourceMappingURL=cognition.js.map

package/dist/cognition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/emotion.d.ts

@@ -0,0 +1,288 @@
+import { b as AnchorState, A as AVO, M as MicroExpressionConfig, L as LegacyGlyphState, V as VisualState, E as EasingFunction, T as TransitionOptions, c as EmotionEvent } from './types-B0jyNVTH.js';
+export { a as AVODimensions } from './types-B0jyNVTH.js';
+
+/**
+ * Validate AVO dimensions are in valid range
+ */
+declare function isValidAVO(avo: AVO): boolean;
+/**
+ * Clamp AVO dimensions to valid range
+ */
+declare function clampAVO(avo: Partial<AVO>): AVO;
+/**
+ * Named anchor states with AVO coordinates
+ */
+declare const ANCHOR_STATES: Record<AnchorState, AVO>;
+/**
+ * Map legacy GlyphState to anchor states
+ */
+declare const LEGACY_STATE_MAP: Record<LegacyGlyphState, AnchorState>;
+/**
+ * Default micro-expression configuration
+ */
+declare const DEFAULT_MICRO_CONFIG: MicroExpressionConfig;
+/**
+ * Default transition durations by type (ms)
+ */
+declare const DEFAULT_TRANSITION_DURATIONS: {
+    readonly micro: 150;
+    readonly standard: 400;
+    readonly mood: 800;
+    readonly major: 1200;
+};
+/**
+ * Default AVO state (idle equivalent)
+ */
+declare const DEFAULT_AVO: AVO;
+
+/**
+ * Linear interpolation
+ */
+declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Map Arousal (0-1) to temporal visual properties
+ */
+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
+ */
+declare function mapValence(v: number): {
+    coreHue: number;
+    coreSaturation: number;
+    motionNoise: number;
+    scaleFactor: number;
+    emissiveIntensity: number;
+};
+/**
+ * Map Openness (0-1) to spatial visual properties
+ */
+declare function mapOpenness(o: number): {
+    particleFlowDirection: number;
+    particleSpreadAngle: number;
+    breathingPhaseBias: number;
+    ringTilt: number;
+    auraExpansion: number;
+};
+/**
+ * Compute complete visual state from AVO dimensions
+ */
+declare function computeVisualState(avo: AVO): VisualState;
+/**
+ * Compute Euclidean distance between two AVO states
+ */
+declare function avoDistance(a: AVO, b: AVO): number;
+/**
+ * Blend between two AVO states
+ */
+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).
+ */
+declare function getAnimationWeights(currentAVO: AVO): Record<LegacyGlyphState, number>;
+
+/**
+ * Apply easing function to progress value (clamped 0-1)
+ */
+declare function ease(fn: EasingFunction, t: number): number;
+/**
+ * Calculate appropriate transition duration based on AVO change
+ * Returns duration in milliseconds
+ * - Urgent (200ms) for sudden negative changes (e.g., error states)
+ * - Recovery uses longer duration with distance factor
+ * - Default: proportional to AVO distance
+ */
+declare function getTransitionDuration(from: AVO, to: AVO): number;
+/**
+ * Get recommended easing for a transition based on emotional context
+ * - Urgent negative: fast out (easeOut)
+ * - Recovery: springy for natural bounce-back
+ * - Default: smooth in-out
+ */
+declare function getTransitionEasing(from: AVO, to: AVO): EasingFunction;
+/**
+ * Get complete transition config with duration, easing, and onComplete callback
+ */
+declare function getTransitionConfig(from: AVO, to: AVO): Required<TransitionOptions>;
+
+/**
+ * Create a smooth noise generator (Perlin-like)
+ * Returns values between -1 and 1
+ */
+declare function createNoiseGenerator(seed?: number): (t: number) => number;
+/**
+ * Apply micro-expression variations to base AVO state
+ */
+declare function applyMicroExpression(base: AVO, config: MicroExpressionConfig, time: number): AVO;
+/**
+ * Create a micro-expression animator that tracks time internally
+ */
+declare function createMicroExpressionAnimator(config: MicroExpressionConfig): {
+    tick(deltaMs: number): void;
+    apply(base: AVO): AVO;
+    reset(): void;
+};
+
+type EventHandler<T> = (data: T) => void;
+interface EmotionControllerEvents {
+    change: AVO;
+    transitionStart: {
+        from: AVO;
+        to: AVO;
+    };
+    transitionEnd: AVO;
+    anchorReached: AnchorState;
+}
+interface EmotionControllerOptions {
+    initial?: Partial<AVO>;
+    initialAnchor?: AnchorState;
+    microExpressions?: boolean | MicroExpressionConfig;
+}
+/**
+ * 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
+ */
+declare class EmotionController {
+    private _dimensions;
+    private _transition;
+    private _microConfig;
+    private _time;
+    private _listeners;
+    private _disposed;
+    constructor(options?: EmotionControllerOptions);
+    /**
+     * Get current base dimensions (without micro-expressions)
+     */
+    getDimensions(): AVO;
+    /**
+     * Get current dimensions with micro-expressions applied
+     */
+    getAnimatedDimensions(): AVO;
+    /**
+     * Get computed visual state for rendering
+     */
+    getVisualState(): VisualState;
+    /**
+     * Set dimensions immediately (no transition)
+     * Values are clamped to valid 0-1 range
+     */
+    setDimensions(dims: Partial<AVO>): void;
+    /**
+     * Transition to target dimensions over time
+     * Auto-calculates duration and easing if not specified
+     */
+    transitionTo(target: Partial<AVO>, options?: TransitionOptions): void;
+    /**
+     * Transition to a named anchor state
+     * Emits anchorReached when transition completes
+     */
+    transitionToAnchor(anchor: AnchorState, options?: TransitionOptions): void;
+    /**
+     * Handle emotion events from agent behaviors
+     * Maps event types to appropriate anchor transitions
+     */
+    handleEvent(event: EmotionEvent): void;
+    /**
+     * Blend toward target dimensions by a factor (0-1)
+     * Useful for continuous input-driven changes
+     */
+    blendToward(target: Partial<AVO>, factor: number): void;
+    /**
+     * Check if currently transitioning
+     */
+    isTransitioning(): boolean;
+    /**
+     * Cancel current transition, keeping current position
+     */
+    cancelTransition(): void;
+    /**
+     * Subscribe to controller events
+     * Returns unsubscribe function
+     */
+    on<K extends keyof EmotionControllerEvents>(event: K, handler: EventHandler<EmotionControllerEvents[K]>): () => void;
+    /**
+     * Update tick - call each frame with delta time in milliseconds
+     * Advances transitions and micro-expression time
+     */
+    tick(deltaMs: number): void;
+    /**
+     * Dispose controller and clean up resources
+     */
+    dispose(): void;
+    private _emit;
+}
+
+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;
+}
+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>
+ * ```
+ */
+declare function useEmotion(options?: UseEmotionOptions): UseEmotionResult;
+
+export { ANCHOR_STATES, AVO, AnchorState, DEFAULT_AVO, DEFAULT_MICRO_CONFIG, DEFAULT_TRANSITION_DURATIONS, EasingFunction, EmotionController, type EmotionControllerOptions, EmotionEvent, LEGACY_STATE_MAP, LegacyGlyphState, MicroExpressionConfig, TransitionOptions, type UseEmotionOptions, type UseEmotionResult, VisualState, applyMicroExpression, avoDistance, blendAVO, clampAVO, computeVisualState, createMicroExpressionAnimator, createNoiseGenerator, ease, getAnimationWeights, getTransitionConfig, getTransitionDuration, getTransitionEasing, isValidAVO, lerp, mapArousal, mapOpenness, mapValence, useEmotion };

package/dist/emotion.js

@@ -0,0 +1,53 @@
+import {
+  ANCHOR_STATES,
+  DEFAULT_AVO,
+  DEFAULT_MICRO_CONFIG,
+  DEFAULT_TRANSITION_DURATIONS,
+  EmotionController,
+  LEGACY_STATE_MAP,
+  applyMicroExpression,
+  avoDistance,
+  blendAVO,
+  clampAVO,
+  computeVisualState,
+  createMicroExpressionAnimator,
+  createNoiseGenerator,
+  ease,
+  getAnimationWeights,
+  getTransitionConfig,
+  getTransitionDuration,
+  getTransitionEasing,
+  isValidAVO,
+  lerp,
+  mapArousal,
+  mapOpenness,
+  mapValence,
+  useEmotion
+} from "./chunk-VU2XK2NI.js";
+export {
+  ANCHOR_STATES,
+  DEFAULT_AVO,
+  DEFAULT_MICRO_CONFIG,
+  DEFAULT_TRANSITION_DURATIONS,
+  EmotionController,
+  LEGACY_STATE_MAP,
+  applyMicroExpression,
+  avoDistance,
+  blendAVO,
+  clampAVO,
+  computeVisualState,
+  createMicroExpressionAnimator,
+  createNoiseGenerator,
+  ease,
+  getAnimationWeights,
+  getTransitionConfig,
+  getTransitionDuration,
+  getTransitionEasing,
+  isValidAVO,
+  lerp,
+  mapArousal,
+  mapOpenness,
+  mapValence,
+  useEmotion
+};
+//# sourceMappingURL=emotion.js.map

package/dist/emotion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}