@prometheusavatar/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Shared types for the Prometheus Avatar SDK
+ */
+/** Supported emotion types */
+type Emotion = 'neutral' | 'happy' | 'sad' | 'angry' | 'surprised' | 'thinking';
+/** Result from emotion analysis */
+interface EmotionResult {
+    emotion: Emotion;
+    confidence: number;
+    triggers: string[];
+}
+/** TTS engine interface — implement this to plug in custom TTS providers */
+interface ITTSEngine {
+    /** Speak the given text, return audio context for lip sync */
+    speak(text: string, options?: TTSOptions): Promise<void>;
+    /** Stop current speech */
+    stop(): void;
+    /** Whether the engine is currently speaking */
+    readonly isSpeaking: boolean;
+    /** Register callback for audio data (for lip sync) */
+    onAudioData?: (data: Float32Array) => void;
+    /** Register callback when speech ends */
+    onEnd?: () => void;
+}
+/** TTS configuration options */
+interface TTSOptions {
+    voice?: string;
+    rate?: number;
+    pitch?: number;
+    volume?: number;
+    lang?: string;
+}
+/** A single frame of lip sync data */
+interface LipSyncFrame {
+    mouthOpenY: number;
+    mouthForm: number;
+    timestamp: number;
+}
+/** Configuration for creating a Prometheus Avatar */
+interface PrometheusConfig {
+    /** DOM element to mount the avatar canvas into */
+    container: HTMLElement;
+    /** URL to the Live2D model file (.model3.json) */
+    modelUrl: string;
+    /** Optional TTS engine (defaults to Web Speech API) */
+    ttsEngine?: ITTSEngine;
+    /** Canvas width (default: 800) */
+    width?: number;
+    /** Canvas height (default: 600) */
+    height?: number;
+    /** Background color (default: transparent) */
+    backgroundColor?: number;
+    /** TTS options */
+    ttsOptions?: TTSOptions;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Avatar creation options (subset of config with defaults) */
+interface AvatarOptions extends Partial<PrometheusConfig> {
+    container: HTMLElement;
+    modelUrl: string;
+}
+/** Events emitted by PrometheusAvatar */
+interface AvatarEventMap {
+    'model:loaded': {
+        modelUrl: string;
+    };
+    'model:error': {
+        error: Error;
+        modelUrl: string;
+    };
+    'speech:start': {
+        text: string;
+    };
+    'speech:end': {
+        text: string;
+    };
+    'emotion:change': {
+        result: EmotionResult;
+        previous: Emotion;
+    };
+    'lipsync:frame': {
+        frame: LipSyncFrame;
+    };
+    'destroy': void;
+}
+
+/**
+ * PrometheusAvatar — Main orchestrator class
+ *
+ * Ties together renderer, TTS, lip sync, and emotion analysis into a
+ * unified API for driving a Live2D avatar from LLM output.
+ *
+ * Usage:
+ *   const avatar = await createAvatar({
+ *     container: document.getElementById('avatar'),
+ *     modelUrl: '/models/haru/haru.model3.json',
+ *   });
+ *   await avatar.speak('Hello! How are you today? 😊');
+ */
+
+type EventCallback<T> = (data: T) => void;
+declare class PrometheusAvatar {
+    private renderer;
+    private tts;
+    private lipSync;
+    private emotion;
+    private currentEmotion;
+    private config;
+    private listeners;
+    private destroyed;
+    constructor(config: PrometheusConfig);
+    /**
+     * Initialize the avatar — must be called before speak/setEmotion
+     */
+    init(): Promise<void>;
+    /**
+     * Speak text through the avatar:
+     * 1. Analyze emotion from text
+     * 2. Set expression
+     * 3. Start TTS
+     * 4. Lip sync follows audio
+     */
+    speak(text: string): Promise<void>;
+    /**
+     * Process text from an LLM stream — updates emotion and lip sync
+     * without TTS (useful when TTS is handled externally)
+     */
+    processText(text: string): EmotionResult;
+    /**
+     * Directly set the avatar's emotion
+     */
+    setEmotion(emotion: Emotion): void;
+    /**
+     * Load a different avatar model
+     */
+    loadModel(modelUrl: string): Promise<void>;
+    /**
+     * Stop current speech and lip sync
+     */
+    stop(): void;
+    /**
+     * Resize the avatar canvas
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Get current emotion
+     */
+    getEmotion(): Emotion;
+    /**
+     * Subscribe to events
+     */
+    on<K extends keyof AvatarEventMap>(event: K, callback: EventCallback<AvatarEventMap[K]>): () => void;
+    /**
+     * Destroy the avatar and release all resources
+     */
+    destroy(): void;
+    /**
+     * Emit an event to all listeners
+     */
+    private emit;
+}
+/**
+ * Factory function — convenient way to create and initialize a PrometheusAvatar
+ *
+ * @example
+ * ```ts
+ * const avatar = await createAvatar({
+ *   container: document.getElementById('avatar')!,
+ *   modelUrl: '/models/haru/haru.model3.json',
+ * });
+ * await avatar.speak('Hello world! 😊');
+ * ```
+ */
+declare function createAvatar(options: AvatarOptions): Promise<PrometheusAvatar>;
+
+/**
+ * Live2D Renderer
+ *
+ * Wraps pixi-live2d-display to load and control Live2D models.
+ * Handles model loading, expression parameters, motions, and layout.
+ */
+
+type Live2DModel = any;
+interface RendererOptions {
+    container: HTMLElement;
+    width?: number;
+    height?: number;
+    backgroundColor?: number;
+    debug?: boolean;
+}
+declare class Live2DRenderer {
+    private app;
+    private model;
+    private container;
+    private width;
+    private height;
+    private backgroundColor;
+    private initialized;
+    private debug;
+    constructor(options: RendererOptions);
+    /**
+     * Initialize the PixiJS application
+     */
+    init(): Promise<void>;
+    /**
+     * Load a Live2D model from URL
+     */
+    loadModel(modelUrl: string): Promise<void>;
+    /**
+     * Set mouth open parameter (for lip sync)
+     */
+    setMouthOpen(value: number): void;
+    /**
+     * Set emotion expression parameters
+     */
+    setEmotion(emotion: Emotion, transition?: boolean): void;
+    /**
+     * Set a single model parameter
+     */
+    setParam(paramId: string, value: number): void;
+    /**
+     * Get the current model instance
+     */
+    getModel(): Live2DModel | null;
+    /**
+     * Resize the renderer
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Destroy the renderer and clean up resources
+     */
+    destroy(): void;
+    /**
+     * Fit model to canvas with proper scaling
+     */
+    private fitModel;
+    /**
+     * Smoothly transition parameters over time
+     */
+    private transitionParams;
+    /**
+     * Get current value of a parameter
+     */
+    private getParamValue;
+}
+
+/**
+ * TTS (Text-to-Speech) Engine
+ *
+ * Pluggable interface with Web Speech API as default implementation.
+ * Users can swap in ElevenLabs, Azure, or any custom TTS provider.
+ */
+
+/**
+ * Default TTS engine using the Web Speech Synthesis API.
+ * Zero-config, works in all modern browsers.
+ */
+declare class WebSpeechTTS implements ITTSEngine {
+    private synth;
+    private currentUtterance;
+    private _isSpeaking;
+    private defaultOptions;
+    /** Called with audio amplitude data for lip sync */
+    onAudioData?: (data: Float32Array) => void;
+    /** Called when speech ends */
+    onEnd?: () => void;
+    constructor(options?: TTSOptions);
+    get isSpeaking(): boolean;
+    /**
+     * Speak the given text using Web Speech API
+     */
+    speak(text: string, options?: TTSOptions): Promise<void>;
+    /**
+     * Stop current speech
+     */
+    stop(): void;
+    /**
+     * Get available voices
+     */
+    getVoices(): SpeechSynthesisVoice[];
+    /**
+     * Simulate lip sync data since Web Speech API doesn't expose raw audio.
+     * Uses text analysis to generate approximate mouth movements.
+     */
+    private simulateLipSyncData;
+    /**
+     * Map character to approximate mouth amplitude
+     */
+    private charToAmplitude;
+}
+
+/**
+ * Lip Sync Engine
+ *
+ * Drives Live2D mouth parameters from audio data or text analysis.
+ * Two modes:
+ * 1. Audio-driven: analyzes audio amplitude → mouth open/close
+ * 2. Text fallback: generates syllable-based mouth animation
+ */
+
+declare class LipSyncEngine {
+    private animationFrame;
+    private currentMouthOpen;
+    private targetMouthOpen;
+    private smoothing;
+    private isActive;
+    /** Called each frame with updated lip sync data */
+    onFrame?: (frame: LipSyncFrame) => void;
+    constructor(options?: {
+        smoothing?: number;
+    });
+    /**
+     * Process audio amplitude data (called by TTS engine)
+     */
+    processAudioData(data: Float32Array): void;
+    /**
+     * Start text-based lip sync animation (fallback when no audio data)
+     */
+    startTextSync(text: string, durationMs?: number): void;
+    /**
+     * Stop lip sync animation
+     */
+    stop(): void;
+    /**
+     * Start the smooth animation loop
+     */
+    private startAnimation;
+    /**
+     * Convert text to syllable amplitude array
+     */
+    private textToSyllables;
+}
+
+/**
+ * Rule-based Emotion Analyzer
+ *
+ * Analyzes text for emotional cues using punctuation, emojis, and keywords.
+ * MVP approach — v2 will use LLM-based analysis.
+ */
+
+declare class EmotionAnalyzer {
+    /**
+     * Analyze text and return the detected emotion
+     */
+    analyze(text: string): EmotionResult;
+}
+
+export { type AvatarEventMap, type AvatarOptions, type Emotion, EmotionAnalyzer, type EmotionResult, type ITTSEngine, LipSyncEngine, type LipSyncFrame, Live2DRenderer, PrometheusAvatar, type PrometheusConfig, type TTSOptions, WebSpeechTTS, createAvatar };

package/dist/index.js

@@ -0,0 +1,825 @@
+// src/renderer.ts
+import { Application } from "pixi.js";
+var EMOTION_PARAMS = {
+  neutral: {
+    "ParamEyeLOpen": 1,
+    "ParamEyeROpen": 1,
+    "ParamBrowLY": 0,
+    "ParamBrowRY": 0,
+    "ParamMouthForm": 0
+  },
+  happy: {
+    "ParamEyeLOpen": 0.8,
+    "ParamEyeROpen": 0.8,
+    "ParamBrowLY": 0.3,
+    "ParamBrowRY": 0.3,
+    "ParamMouthForm": 1,
+    // smile
+    "ParamEyeLSmile": 1,
+    "ParamEyeRSmile": 1
+  },
+  sad: {
+    "ParamEyeLOpen": 0.6,
+    "ParamEyeROpen": 0.6,
+    "ParamBrowLY": -0.5,
+    "ParamBrowRY": -0.5,
+    "ParamMouthForm": -0.3
+  },
+  angry: {
+    "ParamEyeLOpen": 1.2,
+    "ParamEyeROpen": 1.2,
+    "ParamBrowLY": -1,
+    "ParamBrowRY": -1,
+    "ParamBrowLAngle": -1,
+    "ParamBrowRAngle": -1,
+    "ParamMouthForm": -0.5
+  },
+  surprised: {
+    "ParamEyeLOpen": 1.3,
+    "ParamEyeROpen": 1.3,
+    "ParamBrowLY": 1,
+    "ParamBrowRY": 1,
+    "ParamMouthOpenY": 0.8,
+    "ParamMouthForm": 0
+  },
+  thinking: {
+    "ParamEyeLOpen": 0.7,
+    "ParamEyeROpen": 0.9,
+    "ParamBrowLY": 0.3,
+    "ParamBrowRY": -0.2,
+    "ParamAngleX": 15,
+    "ParamMouthForm": 0
+  }
+};
+var Live2DRenderer = class {
+  constructor(options) {
+    this.app = null;
+    this.model = null;
+    this.initialized = false;
+    this.container = options.container;
+    this.width = options.width ?? 800;
+    this.height = options.height ?? 600;
+    this.backgroundColor = options.backgroundColor ?? 0;
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Initialize the PixiJS application
+   */
+  async init() {
+    if (this.initialized) return;
+    await import("pixi.js");
+    this.app = new Application({
+      width: this.width,
+      height: this.height,
+      backgroundAlpha: this.backgroundColor === 0 ? 0 : 1,
+      backgroundColor: this.backgroundColor,
+      antialias: true,
+      resolution: window.devicePixelRatio || 1,
+      autoDensity: true
+    });
+    this.container.appendChild(this.app.view);
+    this.initialized = true;
+    if (this.debug) {
+      console.log("[Prometheus] Renderer initialized", { width: this.width, height: this.height });
+    }
+  }
+  /**
+   * Load a Live2D model from URL
+   */
+  async loadModel(modelUrl) {
+    if (!this.app) {
+      await this.init();
+    }
+    try {
+      const { Live2DModel: L2DModel } = await import("pixi-live2d-display");
+      if (this.model) {
+        this.app.stage.removeChild(this.model);
+        this.model.destroy();
+      }
+      if (this.debug) {
+        console.log("[Prometheus] Loading model:", modelUrl);
+      }
+      this.model = await L2DModel.from(modelUrl);
+      this.fitModel();
+      this.app.stage.addChild(this.model);
+      this.model.motion?.("idle", 0, { loop: true });
+      if (this.debug) {
+        console.log("[Prometheus] Model loaded successfully");
+      }
+    } catch (error) {
+      console.error("[Prometheus] Failed to load model:", error);
+      throw error;
+    }
+  }
+  /**
+   * Set mouth open parameter (for lip sync)
+   */
+  setMouthOpen(value) {
+    if (!this.model) return;
+    this.setParam("ParamMouthOpenY", Math.max(0, Math.min(1, value)));
+  }
+  /**
+   * Set emotion expression parameters
+   */
+  setEmotion(emotion, transition = true) {
+    if (!this.model) return;
+    const params = EMOTION_PARAMS[emotion];
+    if (!params) return;
+    if (transition) {
+      this.transitionParams(params, 300);
+    } else {
+      for (const [param, value] of Object.entries(params)) {
+        this.setParam(param, value);
+      }
+    }
+  }
+  /**
+   * Set a single model parameter
+   */
+  setParam(paramId, value) {
+    if (!this.model?.internalModel?.coreModel) return;
+    try {
+      const coreModel = this.model.internalModel.coreModel;
+      const paramIndex = coreModel.getParameterIndex(paramId);
+      if (paramIndex >= 0) {
+        coreModel.setParameterValueById(paramId, value);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get the current model instance
+   */
+  getModel() {
+    return this.model;
+  }
+  /**
+   * Resize the renderer
+   */
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    if (this.app) {
+      this.app.renderer.resize(width, height);
+      this.fitModel();
+    }
+  }
+  /**
+   * Destroy the renderer and clean up resources
+   */
+  destroy() {
+    if (this.model) {
+      this.model.destroy();
+      this.model = null;
+    }
+    if (this.app) {
+      this.app.destroy(true, { children: true, texture: true });
+      this.app = null;
+    }
+    this.initialized = false;
+  }
+  /**
+   * Fit model to canvas with proper scaling
+   */
+  fitModel() {
+    if (!this.model || !this.app) return;
+    const scaleX = this.width / this.model.width;
+    const scaleY = this.height / this.model.height;
+    const scale = Math.min(scaleX, scaleY) * 0.8;
+    this.model.scale.set(scale);
+    this.model.x = this.width / 2;
+    this.model.y = this.height / 2;
+    this.model.anchor?.set(0.5, 0.5);
+  }
+  /**
+   * Smoothly transition parameters over time
+   */
+  transitionParams(targetParams, durationMs) {
+    const startTime = performance.now();
+    const startParams = {};
+    for (const paramId of Object.keys(targetParams)) {
+      startParams[paramId] = this.getParamValue(paramId) ?? 0;
+    }
+    const animate = () => {
+      const elapsed = performance.now() - startTime;
+      const progress = Math.min(elapsed / durationMs, 1);
+      const eased = 1 - Math.pow(1 - progress, 3);
+      for (const [paramId, targetValue] of Object.entries(targetParams)) {
+        const startValue = startParams[paramId] ?? 0;
+        const currentValue = startValue + (targetValue - startValue) * eased;
+        this.setParam(paramId, currentValue);
+      }
+      if (progress < 1) {
+        requestAnimationFrame(animate);
+      }
+    };
+    requestAnimationFrame(animate);
+  }
+  /**
+   * Get current value of a parameter
+   */
+  getParamValue(paramId) {
+    if (!this.model?.internalModel?.coreModel) return null;
+    try {
+      const coreModel = this.model.internalModel.coreModel;
+      return coreModel.getParameterValueById(paramId);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/tts.ts
+var WebSpeechTTS = class {
+  constructor(options) {
+    this.currentUtterance = null;
+    this._isSpeaking = false;
+    this.synth = window.speechSynthesis;
+    this.defaultOptions = {
+      rate: 1,
+      pitch: 1,
+      volume: 1,
+      lang: "en-US",
+      ...options
+    };
+  }
+  get isSpeaking() {
+    return this._isSpeaking;
+  }
+  /**
+   * Speak the given text using Web Speech API
+   */
+  async speak(text, options) {
+    this.stop();
+    return new Promise((resolve, reject) => {
+      const utterance = new SpeechSynthesisUtterance(text);
+      const opts = { ...this.defaultOptions, ...options };
+      utterance.rate = opts.rate ?? 1;
+      utterance.pitch = opts.pitch ?? 1;
+      utterance.volume = opts.volume ?? 1;
+      utterance.lang = opts.lang ?? "en-US";
+      if (opts.voice) {
+        const voices = this.synth.getVoices();
+        const match = voices.find(
+          (v) => v.name === opts.voice || v.voiceURI === opts.voice
+        );
+        if (match) utterance.voice = match;
+      }
+      utterance.onstart = () => {
+        this._isSpeaking = true;
+        this.simulateLipSyncData(text);
+      };
+      utterance.onend = () => {
+        this._isSpeaking = false;
+        this.currentUtterance = null;
+        this.onEnd?.();
+        resolve();
+      };
+      utterance.onerror = (event) => {
+        this._isSpeaking = false;
+        this.currentUtterance = null;
+        if (event.error !== "canceled") {
+          reject(new Error(`TTS error: ${event.error}`));
+        } else {
+          resolve();
+        }
+      };
+      this.currentUtterance = utterance;
+      this.synth.speak(utterance);
+    });
+  }
+  /**
+   * Stop current speech
+   */
+  stop() {
+    if (this.synth.speaking) {
+      this.synth.cancel();
+    }
+    this._isSpeaking = false;
+    this.currentUtterance = null;
+  }
+  /**
+   * Get available voices
+   */
+  getVoices() {
+    return this.synth.getVoices();
+  }
+  /**
+   * Simulate lip sync data since Web Speech API doesn't expose raw audio.
+   * Uses text analysis to generate approximate mouth movements.
+   */
+  simulateLipSyncData(text) {
+    if (!this.onAudioData) return;
+    const words = text.split(/\s+/);
+    const avgWordDuration = 250;
+    let offset = 0;
+    for (const word of words) {
+      for (let i = 0; i < word.length; i++) {
+        const char = word[i].toLowerCase();
+        const amplitude = this.charToAmplitude(char);
+        const delay = offset + i * 60;
+        setTimeout(() => {
+          if (this._isSpeaking && this.onAudioData) {
+            const data = new Float32Array([amplitude]);
+            this.onAudioData(data);
+          }
+        }, delay);
+      }
+      offset += avgWordDuration;
+    }
+  }
+  /**
+   * Map character to approximate mouth amplitude
+   */
+  charToAmplitude(char) {
+    if ("aeiou".includes(char)) return 0.7 + Math.random() * 0.3;
+    if ("bmp".includes(char)) return 0.05;
+    if ("lnr".includes(char)) return 0.4 + Math.random() * 0.2;
+    if ("fvsz".includes(char)) return 0.3 + Math.random() * 0.2;
+    return 0.2 + Math.random() * 0.3;
+  }
+};
+
+// src/lip-sync.ts
+var LipSyncEngine = class {
+  constructor(options) {
+    this.animationFrame = null;
+    this.currentMouthOpen = 0;
+    this.targetMouthOpen = 0;
+    this.smoothing = 0.3;
+    // lower = smoother
+    this.isActive = false;
+    if (options?.smoothing !== void 0) {
+      this.smoothing = Math.max(0.05, Math.min(1, options.smoothing));
+    }
+  }
+  /**
+   * Process audio amplitude data (called by TTS engine)
+   */
+  processAudioData(data) {
+    if (data.length === 0) return;
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) {
+      sum += data[i] * data[i];
+    }
+    const rms = Math.sqrt(sum / data.length);
+    this.targetMouthOpen = Math.min(1, rms * 2);
+    if (!this.isActive) {
+      this.startAnimation();
+    }
+  }
+  /**
+   * Start text-based lip sync animation (fallback when no audio data)
+   */
+  startTextSync(text, durationMs) {
+    const duration = durationMs ?? text.length * 80;
+    const syllables = this.textToSyllables(text);
+    const syllableDuration = duration / syllables.length;
+    let index = 0;
+    this.isActive = true;
+    const step = () => {
+      if (index >= syllables.length || !this.isActive) {
+        this.targetMouthOpen = 0;
+        return;
+      }
+      this.targetMouthOpen = syllables[index];
+      index++;
+      setTimeout(step, syllableDuration);
+    };
+    step();
+    if (!this.animationFrame) {
+      this.startAnimation();
+    }
+  }
+  /**
+   * Stop lip sync animation
+   */
+  stop() {
+    this.isActive = false;
+    this.targetMouthOpen = 0;
+    this.currentMouthOpen = 0;
+    if (this.animationFrame !== null) {
+      cancelAnimationFrame(this.animationFrame);
+      this.animationFrame = null;
+    }
+    this.onFrame?.({
+      mouthOpenY: 0,
+      mouthForm: 0,
+      timestamp: performance.now()
+    });
+  }
+  /**
+   * Start the smooth animation loop
+   */
+  startAnimation() {
+    this.isActive = true;
+    const animate = () => {
+      this.currentMouthOpen += (this.targetMouthOpen - this.currentMouthOpen) * this.smoothing;
+      if (this.currentMouthOpen < 0.02) {
+        this.currentMouthOpen = 0;
+      }
+      this.onFrame?.({
+        mouthOpenY: this.currentMouthOpen,
+        mouthForm: 0,
+        // neutral form for now
+        timestamp: performance.now()
+      });
+      if (this.isActive || this.currentMouthOpen > 0.01) {
+        this.animationFrame = requestAnimationFrame(animate);
+      } else {
+        this.animationFrame = null;
+      }
+    };
+    this.animationFrame = requestAnimationFrame(animate);
+  }
+  /**
+   * Convert text to syllable amplitude array
+   */
+  textToSyllables(text) {
+    const syllables = [];
+    for (const char of text) {
+      const lower = char.toLowerCase();
+      if ("aeiou\xE1\xE9\xED\xF3\xFA".includes(lower)) {
+        syllables.push(0.6 + Math.random() * 0.4);
+      } else if ("bmp".includes(lower)) {
+        syllables.push(0.05);
+      } else if (" 	\n".includes(char)) {
+        syllables.push(0);
+      } else if (/[\u4e00-\u9fff]/.test(char)) {
+        syllables.push(0.5 + Math.random() * 0.3);
+      } else if (/[a-z]/.test(lower)) {
+        syllables.push(0.3 + Math.random() * 0.3);
+      } else {
+        syllables.push(0.05);
+      }
+    }
+    return syllables;
+  }
+};
+
+// src/emotion.ts
+var EMOJI_MAP = {
+  "\u{1F60A}": "happy",
+  "\u{1F604}": "happy",
+  "\u{1F603}": "happy",
+  "\u{1F970}": "happy",
+  "\u2764\uFE0F": "happy",
+  "\u{1F602}": "happy",
+  "\u{1F923}": "happy",
+  "\u{1F601}": "happy",
+  "\u{1F495}": "happy",
+  "\u2728": "happy",
+  "\u{1F389}": "happy",
+  "\u{1F44D}": "happy",
+  "\u{1F60D}": "happy",
+  "\u{1F642}": "happy",
+  "\u263A\uFE0F": "happy",
+  "\u{1F622}": "sad",
+  "\u{1F62D}": "sad",
+  "\u{1F61E}": "sad",
+  "\u{1F614}": "sad",
+  "\u{1F494}": "sad",
+  "\u{1F97A}": "sad",
+  "\u{1F63F}": "sad",
+  "\u{1F61F}": "sad",
+  "\u{1F620}": "angry",
+  "\u{1F621}": "angry",
+  "\u{1F92C}": "angry",
+  "\u{1F4A2}": "angry",
+  "\u{1F44A}": "angry",
+  "\u{1F624}": "angry",
+  "\u{1F525}": "angry",
+  "\u{1F632}": "surprised",
+  "\u{1F62E}": "surprised",
+  "\u{1F92F}": "surprised",
+  "\u{1F631}": "surprised",
+  "\u2757": "surprised",
+  "\u2049\uFE0F": "surprised",
+  "\u203C\uFE0F": "surprised",
+  "\u{1F633}": "surprised",
+  "\u{1F914}": "thinking",
+  "\u{1F4AD}": "thinking",
+  "\u{1F9D0}": "thinking",
+  "\u{1F4DD}": "thinking"
+};
+var KEYWORD_MAP = {
+  // Happy
+  "happy": "happy",
+  "glad": "happy",
+  "great": "happy",
+  "awesome": "happy",
+  "wonderful": "happy",
+  "love": "happy",
+  "amazing": "happy",
+  "excellent": "happy",
+  "fantastic": "happy",
+  "beautiful": "happy",
+  "perfect": "happy",
+  "haha": "happy",
+  "lol": "happy",
+  "yay": "happy",
+  "hooray": "happy",
+  "congratulations": "happy",
+  "\u5F00\u5FC3": "happy",
+  "\u9AD8\u5174": "happy",
+  "\u592A\u597D\u4E86": "happy",
+  "\u68D2": "happy",
+  "\u54C8\u54C8": "happy",
+  // Sad
+  "sad": "sad",
+  "sorry": "sad",
+  "unfortunately": "sad",
+  "miss": "sad",
+  "disappointed": "sad",
+  "depressed": "sad",
+  "unhappy": "sad",
+  "cry": "sad",
+  "tragic": "sad",
+  "heartbroken": "sad",
+  "\u96BE\u8FC7": "sad",
+  "\u4F24\u5FC3": "sad",
+  "\u53EF\u60DC": "sad",
+  "\u9057\u61BE": "sad",
+  // Angry
+  "angry": "angry",
+  "furious": "angry",
+  "hate": "angry",
+  "terrible": "angry",
+  "awful": "angry",
+  "stupid": "angry",
+  "ridiculous": "angry",
+  "unacceptable": "angry",
+  "\u751F\u6C14": "angry",
+  "\u6124\u6012": "angry",
+  "\u8BA8\u538C": "angry",
+  // Surprised
+  "wow": "surprised",
+  "whoa": "surprised",
+  "omg": "surprised",
+  "incredible": "surprised",
+  "unbelievable": "surprised",
+  "shocking": "surprised",
+  "unexpected": "surprised",
+  "\u54C7": "surprised",
+  "\u5929\u54EA": "surprised",
+  "\u4E0D\u53EF\u601D\u8BAE": "surprised",
+  // Thinking
+  "think": "thinking",
+  "consider": "thinking",
+  "perhaps": "thinking",
+  "maybe": "thinking",
+  "hmm": "thinking",
+  "interesting": "thinking",
+  "wonder": "thinking",
+  "analyze": "thinking",
+  "\u60F3\u60F3": "thinking",
+  "\u4E5F\u8BB8": "thinking",
+  "\u6709\u610F\u601D": "thinking"
+};
+var EmotionAnalyzer = class {
+  /**
+   * Analyze text and return the detected emotion
+   */
+  analyze(text) {
+    const triggers = [];
+    const scores = {
+      neutral: 0.3,
+      // baseline — neutral wins when nothing else triggers
+      happy: 0,
+      sad: 0,
+      angry: 0,
+      surprised: 0,
+      thinking: 0
+    };
+    for (const [emoji, emotion] of Object.entries(EMOJI_MAP)) {
+      if (text.includes(emoji)) {
+        scores[emotion] += 0.5;
+        triggers.push(`emoji:${emoji}`);
+      }
+    }
+    const lowerText = text.toLowerCase();
+    for (const [keyword, emotion] of Object.entries(KEYWORD_MAP)) {
+      if (lowerText.includes(keyword)) {
+        scores[emotion] += 0.3;
+        triggers.push(`keyword:${keyword}`);
+      }
+    }
+    const exclamationCount = (text.match(/!/g) || []).length;
+    const questionCount = (text.match(/\?/g) || []).length;
+    const capsRatio = text.replace(/[^a-zA-Z]/g, "").length > 0 ? (text.match(/[A-Z]/g) || []).length / text.replace(/[^a-zA-Z]/g, "").length : 0;
+    if (exclamationCount >= 2) {
+      scores.surprised += 0.3;
+      triggers.push("punctuation:!!");
+    } else if (exclamationCount === 1) {
+      scores.happy += 0.15;
+      triggers.push("punctuation:!");
+    }
+    if (questionCount >= 1) {
+      scores.thinking += 0.2;
+      triggers.push("punctuation:?");
+    }
+    if (capsRatio > 0.6 && text.length > 5) {
+      scores.angry += 0.2;
+      scores.surprised += 0.15;
+      triggers.push("caps:high");
+    }
+    if (text.includes("...") || text.includes("\u2026")) {
+      scores.thinking += 0.15;
+      triggers.push("punctuation:...");
+    }
+    let maxEmotion = "neutral";
+    let maxScore = 0;
+    for (const [emotion, score] of Object.entries(scores)) {
+      if (score > maxScore) {
+        maxScore = score;
+        maxEmotion = emotion;
+      }
+    }
+    return {
+      emotion: maxEmotion,
+      confidence: Math.min(maxScore, 1),
+      triggers
+    };
+  }
+};
+
+// src/avatar.ts
+var PrometheusAvatar = class {
+  constructor(config) {
+    this.currentEmotion = "neutral";
+    this.listeners = /* @__PURE__ */ new Map();
+    this.destroyed = false;
+    this.config = config;
+    this.renderer = new Live2DRenderer({
+      container: config.container,
+      width: config.width,
+      height: config.height,
+      backgroundColor: config.backgroundColor,
+      debug: config.debug
+    });
+    this.tts = config.ttsEngine ?? new WebSpeechTTS(config.ttsOptions);
+    this.lipSync = new LipSyncEngine();
+    this.emotion = new EmotionAnalyzer();
+    this.tts.onAudioData = (data) => {
+      this.lipSync.processAudioData(data);
+    };
+    this.lipSync.onFrame = (frame) => {
+      this.renderer.setMouthOpen(frame.mouthOpenY);
+      this.emit("lipsync:frame", { frame });
+    };
+    this.tts.onEnd = () => {
+      this.lipSync.stop();
+    };
+  }
+  /**
+   * Initialize the avatar — must be called before speak/setEmotion
+   */
+  async init() {
+    await this.renderer.init();
+    await this.renderer.loadModel(this.config.modelUrl);
+    this.emit("model:loaded", { modelUrl: this.config.modelUrl });
+  }
+  /**
+   * Speak text through the avatar:
+   * 1. Analyze emotion from text
+   * 2. Set expression
+   * 3. Start TTS
+   * 4. Lip sync follows audio
+   */
+  async speak(text) {
+    if (this.destroyed) return;
+    const result = this.emotion.analyze(text);
+    if (result.emotion !== this.currentEmotion) {
+      const previous = this.currentEmotion;
+      this.currentEmotion = result.emotion;
+      this.renderer.setEmotion(result.emotion);
+      this.emit("emotion:change", { result, previous });
+    }
+    this.emit("speech:start", { text });
+    try {
+      await this.tts.speak(text, this.config.ttsOptions);
+    } finally {
+      this.lipSync.stop();
+      this.emit("speech:end", { text });
+    }
+  }
+  /**
+   * Process text from an LLM stream — updates emotion and lip sync
+   * without TTS (useful when TTS is handled externally)
+   */
+  processText(text) {
+    if (this.destroyed) return { emotion: "neutral", confidence: 0, triggers: [] };
+    const result = this.emotion.analyze(text);
+    if (result.emotion !== this.currentEmotion) {
+      const previous = this.currentEmotion;
+      this.currentEmotion = result.emotion;
+      this.renderer.setEmotion(result.emotion);
+      this.emit("emotion:change", { result, previous });
+    }
+    this.lipSync.startTextSync(text);
+    return result;
+  }
+  /**
+   * Directly set the avatar's emotion
+   */
+  setEmotion(emotion) {
+    if (this.destroyed) return;
+    const previous = this.currentEmotion;
+    this.currentEmotion = emotion;
+    this.renderer.setEmotion(emotion);
+    this.emit("emotion:change", {
+      result: { emotion, confidence: 1, triggers: ["manual"] },
+      previous
+    });
+  }
+  /**
+   * Load a different avatar model
+   */
+  async loadModel(modelUrl) {
+    if (this.destroyed) return;
+    try {
+      await this.renderer.loadModel(modelUrl);
+      this.config.modelUrl = modelUrl;
+      this.currentEmotion = "neutral";
+      this.emit("model:loaded", { modelUrl });
+    } catch (error) {
+      this.emit("model:error", { error, modelUrl });
+      throw error;
+    }
+  }
+  /**
+   * Stop current speech and lip sync
+   */
+  stop() {
+    this.tts.stop();
+    this.lipSync.stop();
+  }
+  /**
+   * Resize the avatar canvas
+   */
+  resize(width, height) {
+    this.renderer.resize(width, height);
+  }
+  /**
+   * Get current emotion
+   */
+  getEmotion() {
+    return this.currentEmotion;
+  }
+  /**
+   * Subscribe to events
+   */
+  on(event, callback) {
+    const key = event;
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(key).add(callback);
+    return () => {
+      this.listeners.get(key)?.delete(callback);
+    };
+  }
+  /**
+   * Destroy the avatar and release all resources
+   */
+  destroy() {
+    this.destroyed = true;
+    this.stop();
+    this.renderer.destroy();
+    this.listeners.clear();
+    this.emit("destroy", void 0);
+  }
+  /**
+   * Emit an event to all listeners
+   */
+  emit(event, data) {
+    const key = event;
+    this.listeners.get(key)?.forEach((cb) => {
+      try {
+        cb(data);
+      } catch (error) {
+        console.error(`[Prometheus] Error in event handler for '${key}':`, error);
+      }
+    });
+  }
+};
+async function createAvatar(options) {
+  const config = {
+    width: 800,
+    height: 600,
+    backgroundColor: 0,
+    debug: false,
+    ...options
+  };
+  const avatar = new PrometheusAvatar(config);
+  await avatar.init();
+  return avatar;
+}
+export {
+  EmotionAnalyzer,
+  LipSyncEngine,
+  Live2DRenderer,
+  PrometheusAvatar,
+  WebSpeechTTS,
+  createAvatar
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@prometheusavatar/core",
+    "version": "0.1.0",
+    "description": "Give your AI agent an embodied avatar — Live2D rendering, TTS, lip-sync, and emotion analysis in one SDK",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsup src/index.ts --format esm --dts --clean",
+        "dev": "tsup src/index.ts --format esm --dts --watch",
+        "clean": "rm -rf dist",
+        "lint": "tsc --noEmit"
+    },
+    "dependencies": {
+        "pixi.js": "^6.5.10",
+        "pixi-live2d-display": "^0.4.0"
+    },
+    "devDependencies": {
+        "tsup": "^8.0.0",
+        "typescript": "^5.4.0"
+    },
+    "keywords": [
+        "live2d",
+        "avatar",
+        "ai",
+        "llm",
+        "tts",
+        "lip-sync",
+        "embodied-intelligence",
+        "openclaw",
+        "vtuber"
+    ],
+    "license": "MIT",
+    "author": "Myths Labs (JC)",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/myths-labs/prometheus"
+    }
+}