avatarlayer 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2165 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnthropicAdapter: () => AnthropicAdapter,
+  AtlasRenderer: () => AtlasRenderer,
+  AvatarSession: () => AvatarSession,
+  ElevenLabsAdapter: () => ElevenLabsAdapter,
+  ElevenLabsSTTAdapter: () => ElevenLabsSTTAdapter,
+  GeminiAdapter: () => GeminiAdapter,
+  HeyGenRenderer: () => HeyGenRenderer,
+  LemonSliceRenderer: () => LemonSliceRenderer,
+  LipSyncEngine: () => LipSyncEngine,
+  Live2DRenderer: () => Live2DRenderer,
+  MicCapture: () => MicCapture,
+  OpenAIAdapter: () => OpenAIAdapter,
+  TypedEmitter: () => TypedEmitter,
+  VRMLocalRenderer: () => VRMLocalRenderer,
+  VideoRenderer: () => VideoRenderer,
+  decodeToPcm: () => decodeToPcm,
+  playAudioBlob: () => playAudioBlob
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/events.ts
+var TypedEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return this;
+  }
+  off(event, fn) {
+    this.listeners.get(event)?.delete(fn);
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn(...args);
+      } catch {
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/core/session.ts
+var SENTENCE_DELIMITERS = /(?<=[.!?。！？\n])\s+/;
+function splitSentences(buffer) {
+  const parts = buffer.split(SENTENCE_DELIMITERS);
+  if (parts.length <= 1) return [[], buffer];
+  const remaining = parts.pop();
+  return [parts.filter((s) => s.trim().length > 0), remaining];
+}
+var AvatarSession = class extends TypedEmitter {
+  config;
+  _state = "idle";
+  history = [];
+  abortController = null;
+  transactionId = 0;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get state() {
+    return this._state;
+  }
+  get messages() {
+    return this.history;
+  }
+  /** Mount the renderer and transition to ready. */
+  async start(container) {
+    if (this._state !== "idle" && this._state !== "destroyed") return;
+    this.setState("connecting");
+    try {
+      await this.config.renderer.mount(container);
+      this.setState("ready");
+    } catch (err) {
+      this.setState("error");
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /** Send a user message and run the LLM → TTS → speak pipeline. */
+  async sendMessage(text) {
+    if (this._state !== "ready" && this._state !== "speaking") return;
+    this.interrupt();
+    const userMsg = {
+      role: "user",
+      content: text,
+      id: crypto.randomUUID(),
+      timestamp: Date.now()
+    };
+    this.history.push(userMsg);
+    this.emit("message", userMsg);
+    const txId = ++this.transactionId;
+    const ac = new AbortController();
+    this.abortController = ac;
+    this.setState("thinking");
+    const messagesForLLM = [];
+    if (this.config.systemPrompt) {
+      messagesForLLM.push({ role: "system", content: this.config.systemPrompt });
+    }
+    messagesForLLM.push(...this.history);
+    let fullText = "";
+    let buffer = "";
+    const assistantMsg = {
+      role: "assistant",
+      content: "",
+      id: crypto.randomUUID(),
+      timestamp: Date.now()
+    };
+    try {
+      const stream = this.config.llm.chat(messagesForLLM, {
+        signal: ac.signal,
+        ...this.config.reasoningEffort ? { reasoningEffort: this.config.reasoningEffort } : {}
+      });
+      for await (const chunk of stream) {
+        if (ac.signal.aborted || txId !== this.transactionId) return;
+        fullText += chunk.text;
+        buffer += chunk.text;
+        this.emit("chunk", chunk.text, fullText);
+        const [sentences, rest] = splitSentences(buffer);
+        buffer = rest;
+        for (const sentence of sentences) {
+          if (ac.signal.aborted || txId !== this.transactionId) return;
+          await this.synthesizeAndSpeak(sentence, ac.signal, txId);
+        }
+      }
+      if (buffer.trim() && !ac.signal.aborted && txId === this.transactionId) {
+        await this.synthesizeAndSpeak(buffer.trim(), ac.signal, txId);
+      }
+      if (!ac.signal.aborted && txId === this.transactionId) {
+        assistantMsg.content = fullText;
+        this.history.push(assistantMsg);
+        this.emit("message", assistantMsg);
+        this.setState("ready");
+      }
+    } catch (err) {
+      if (ac.signal.aborted) return;
+      this.setState("error");
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /** Cancel the current LLM/TTS/speak pipeline. */
+  interrupt() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.config.renderer.interrupt();
+    if (this._state === "thinking" || this._state === "speaking") {
+      this.setState("ready");
+    }
+  }
+  /** Update the renderer with new avatar control state. */
+  updateControl(control) {
+    this.config.renderer.update(control);
+  }
+  /** Replace the LLM provider at runtime. */
+  setLLM(llm) {
+    this.config = { ...this.config, llm };
+  }
+  /** Replace the TTS provider at runtime. */
+  setTTS(tts) {
+    this.config = { ...this.config, tts };
+  }
+  /** Replace the renderer at runtime. Unmounts the old one. */
+  async setRenderer(renderer, container) {
+    this.interrupt();
+    this.config.renderer.unmount();
+    this.config = { ...this.config, renderer };
+    await renderer.mount(container);
+  }
+  /** Tear down everything. */
+  destroy() {
+    this.interrupt();
+    this.config.renderer.unmount();
+    this.removeAllListeners();
+    this.setState("destroyed");
+  }
+  // -- internals --
+  async synthesizeAndSpeak(text, signal, txId) {
+    if (signal.aborted || txId !== this.transactionId) return;
+    if (this.config.renderer.speakText) {
+      this.setState("speaking");
+      this.emit("speech-start");
+      try {
+        await this.config.renderer.speakText(text, signal);
+      } finally {
+        if (!signal.aborted && txId === this.transactionId) {
+          this.emit("speech-end");
+        }
+      }
+      return;
+    }
+    if (!this.config.tts) {
+      throw new Error("TTSProvider is required when the renderer does not implement speakText");
+    }
+    const blob = await this.config.tts.synthesize(text, { signal });
+    if (signal.aborted || txId !== this.transactionId) return;
+    this.setState("speaking");
+    this.emit("speech-start");
+    try {
+      await this.config.renderer.speak(blob);
+    } finally {
+      if (!signal.aborted && txId === this.transactionId) {
+        this.emit("speech-end");
+      }
+    }
+  }
+  setState(next) {
+    if (this._state === next) return;
+    this._state = next;
+    this.emit("state-change", next);
+  }
+};
+
+// src/core/audio-utils.ts
+var PCM_SAMPLE_RATE = 16e3;
+var PCM_BYTES_PER_SAMPLE = 2;
+async function decodeToPcm(audioBlob) {
+  const arrayBuffer = await audioBlob.arrayBuffer();
+  const ctx = new AudioContext();
+  let decoded;
+  try {
+    decoded = await ctx.decodeAudioData(arrayBuffer.slice(0));
+  } finally {
+    await ctx.close();
+  }
+  let resampled = decoded;
+  if (decoded.sampleRate !== PCM_SAMPLE_RATE) {
+    const length = Math.ceil(decoded.duration * PCM_SAMPLE_RATE);
+    const offline = new OfflineAudioContext(
+      decoded.numberOfChannels,
+      length,
+      PCM_SAMPLE_RATE
+    );
+    const src = offline.createBufferSource();
+    src.buffer = decoded;
+    src.connect(offline.destination);
+    src.start(0);
+    resampled = await offline.startRendering();
+  }
+  const numChannels = resampled.numberOfChannels;
+  const frameCount = resampled.length;
+  const buf = new ArrayBuffer(frameCount * numChannels * PCM_BYTES_PER_SAMPLE);
+  const view = new DataView(buf);
+  for (let i = 0; i < frameCount; i++) {
+    for (let ch = 0; ch < numChannels; ch++) {
+      const sample = resampled.getChannelData(ch)[i] ?? 0;
+      const clamped = Math.max(-1, Math.min(1, sample));
+      const int16 = clamped < 0 ? clamped * 32768 : clamped * 32767;
+      view.setInt16((i * numChannels + ch) * PCM_BYTES_PER_SAMPLE, int16, true);
+    }
+  }
+  let pcmBytes = new Uint8Array(buf);
+  if (pcmBytes.byteLength % PCM_BYTES_PER_SAMPLE !== 0) {
+    pcmBytes = pcmBytes.subarray(
+      0,
+      pcmBytes.byteLength - pcmBytes.byteLength % PCM_BYTES_PER_SAMPLE
+    );
+  }
+  return { pcmBytes, sampleRate: PCM_SAMPLE_RATE, numChannels };
+}
+function playAudioBlob(blob, signal) {
+  return new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(blob);
+    const audio = new Audio(url);
+    const cleanup = () => {
+      audio.pause();
+      audio.removeAttribute("src");
+      URL.revokeObjectURL(url);
+    };
+    audio.addEventListener("ended", () => {
+      cleanup();
+      resolve();
+    });
+    audio.addEventListener("error", () => {
+      cleanup();
+      reject(new Error("Audio playback error"));
+    });
+    if (signal) {
+      if (signal.aborted) {
+        cleanup();
+        resolve();
+        return;
+      }
+      signal.addEventListener("abort", () => {
+        cleanup();
+        resolve();
+      });
+    }
+    audio.play().catch((err) => {
+      cleanup();
+      reject(err);
+    });
+  });
+}
+
+// src/adapters/llm/openai.ts
+var import_openai = __toESM(require("openai"), 1);
+var OpenAIAdapter = class {
+  id = "openai";
+  client;
+  defaultModel;
+  constructor(opts) {
+    this.client = new import_openai.default({
+      apiKey: opts.apiKey,
+      baseURL: opts.baseURL,
+      dangerouslyAllowBrowser: true
+    });
+    this.defaultModel = opts.model ?? "gpt-5.4-mini";
+  }
+  async *chat(messages, opts) {
+    const reasoningEffort = opts?.reasoningEffort && opts.reasoningEffort !== "none" ? opts.reasoningEffort : void 0;
+    const stream = await this.client.chat.completions.create(
+      {
+        model: opts?.model ?? this.defaultModel,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        stream: true,
+        ...opts?.temperature != null ? { temperature: opts.temperature } : {},
+        ...opts?.maxTokens != null ? { max_tokens: opts.maxTokens } : {},
+        ...reasoningEffort ? { reasoning_effort: reasoningEffort } : {}
+      },
+      { signal: opts?.signal }
+    );
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta?.content;
+      if (delta) {
+        yield { text: delta, done: false };
+      }
+    }
+    yield { text: "", done: true };
+  }
+};
+
+// src/adapters/llm/anthropic.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+var AnthropicAdapter = class {
+  id = "anthropic";
+  client;
+  defaultModel;
+  constructor(opts) {
+    this.client = new import_sdk.default({
+      apiKey: opts.apiKey,
+      ...opts.baseURL ? { baseURL: opts.baseURL } : {}
+    });
+    this.defaultModel = opts.model ?? "claude-sonnet-4.6";
+  }
+  async *chat(messages, opts) {
+    const systemPrompt = opts?.systemPrompt ?? messages.find((m) => m.role === "system")?.content;
+    const filtered = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const thinkingParam = (() => {
+      const effort = opts?.reasoningEffort;
+      if (!effort || effort === "none") return {};
+      const budgetMap = {
+        low: 4096,
+        medium: 1e4,
+        high: 32e3
+      };
+      return {
+        thinking: {
+          type: "enabled",
+          budget_tokens: budgetMap[effort] ?? 1e4
+        }
+      };
+    })();
+    const stream = this.client.messages.stream(
+      {
+        model: opts?.model ?? this.defaultModel,
+        max_tokens: opts?.maxTokens ?? (thinkingParam.thinking ? 16384 : 4096),
+        messages: filtered,
+        ...systemPrompt ? { system: systemPrompt } : {},
+        ...opts?.temperature != null && !thinkingParam.thinking ? { temperature: opts.temperature } : {},
+        ...thinkingParam
+      },
+      { signal: opts?.signal ?? void 0 }
+    );
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield { text: event.delta.text, done: false };
+      }
+    }
+    yield { text: "", done: true };
+  }
+};
+
+// src/adapters/llm/gemini.ts
+var import_generative_ai = require("@google/generative-ai");
+var GeminiAdapter = class {
+  id = "gemini";
+  genAI;
+  defaultModel;
+  constructor(opts) {
+    this.genAI = new import_generative_ai.GoogleGenerativeAI(opts.apiKey);
+    this.defaultModel = opts.model ?? "gemini-3-flash-preview";
+  }
+  async *chat(messages, opts) {
+    const model = this.genAI.getGenerativeModel({
+      model: opts?.model ?? this.defaultModel,
+      generationConfig: {
+        ...opts?.temperature != null ? { temperature: opts.temperature } : {},
+        ...opts?.maxTokens != null ? { maxOutputTokens: opts.maxTokens } : {}
+      }
+    });
+    const systemInstruction = opts?.systemPrompt ?? messages.find((m) => m.role === "system")?.content;
+    const history = messages.filter((m) => m.role !== "system").slice(0, -1).map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const lastMsg = messages.filter((m) => m.role !== "system").at(-1);
+    if (!lastMsg) {
+      yield { text: "", done: true };
+      return;
+    }
+    const chat = model.startChat({
+      history,
+      ...systemInstruction ? { systemInstruction: { role: "system", parts: [{ text: systemInstruction }] } } : {}
+    });
+    const result = await chat.sendMessageStream(lastMsg.content);
+    for await (const chunk of result.stream) {
+      const text = chunk.text();
+      if (text) {
+        yield { text, done: false };
+      }
+    }
+    yield { text: "", done: true };
+  }
+};
+
+// src/adapters/tts/elevenlabs.ts
+var ELEVENLABS_BASE = "https://api.elevenlabs.io/v1";
+var ElevenLabsAdapter = class {
+  id = "elevenlabs";
+  apiKey;
+  defaultVoiceId;
+  defaultModelId;
+  baseURL;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.defaultVoiceId = opts.voiceId ?? "21m00Tcm4TlvDq8ikWAM";
+    this.defaultModelId = opts.modelId ?? "eleven_multilingual_v2";
+    this.baseURL = opts.baseURL ?? ELEVENLABS_BASE;
+  }
+  async synthesize(text, opts) {
+    const voiceId = opts?.voiceId ?? this.defaultVoiceId;
+    const url = `${this.baseURL}/text-to-speech/${encodeURIComponent(voiceId)}/stream`;
+    const body = {
+      text,
+      model_id: opts?.modelId ?? this.defaultModelId,
+      output_format: opts?.outputFormat ?? "mp3_44100_128"
+    };
+    const voiceSettings = {};
+    if (opts?.stability != null) voiceSettings.stability = opts.stability;
+    if (opts?.similarityBoost != null)
+      voiceSettings.similarity_boost = opts.similarityBoost;
+    if (opts?.speed != null) voiceSettings.speed = opts.speed;
+    if (Object.keys(voiceSettings).length > 0)
+      body.voice_settings = voiceSettings;
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "xi-api-key": this.apiKey
+      },
+      body: JSON.stringify(body),
+      signal: opts?.signal
+    });
+    if (!resp.ok) {
+      const detail = await resp.text().catch(() => resp.statusText);
+      throw new Error(`ElevenLabs TTS failed (${resp.status}): ${detail}`);
+    }
+    return resp.blob();
+  }
+};
+
+// src/adapters/stt/elevenlabs.ts
+var isTranscriptOk = (transcript) => /\p{L}|\p{N}/u.test(transcript);
+var ElevenLabsSTTAdapter = class extends TypedEmitter {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+  }
+  opts;
+  ws = null;
+  abortController = null;
+  committedText = "";
+  pendingPartial = "";
+  getFullText() {
+    if (!this.pendingPartial) return this.committedText;
+    if (!this.committedText) return this.pendingPartial;
+    return this.committedText + " " + this.pendingPartial;
+  }
+  /**
+   * Connect to ElevenLabs Scribe v2 realtime WebSocket.
+   * Resolves once the WebSocket is open and ready to receive audio.
+   */
+  async connect(signal) {
+    this.disconnect();
+    const ac = new AbortController();
+    this.abortController = ac;
+    signal?.addEventListener("abort", () => ac.abort());
+    const token = await this.fetchToken(ac.signal);
+    if (ac.signal.aborted) return;
+    const modelId = this.opts.modelId ?? "scribe_v2_realtime";
+    const vadSilence = this.opts.vadSilenceThresholdSecs ?? 1;
+    const wsParams = new URLSearchParams({
+      model_id: modelId,
+      token,
+      commit_strategy: "vad",
+      vad_silence_threshold_secs: String(vadSilence),
+      audio_format: "pcm_16000"
+    });
+    const ws = new WebSocket(
+      `wss://api.elevenlabs.io/v1/speech-to-text/realtime?${wsParams.toString()}`
+    );
+    this.ws = ws;
+    ac.signal.addEventListener("abort", () => {
+      ws.close();
+    });
+    let sessionStarted = false;
+    ws.addEventListener("message", (e) => {
+      try {
+        const msg = JSON.parse(e.data);
+        if (msg.message_type === "session_started") {
+          if (!sessionStarted) {
+            sessionStarted = true;
+            this.emit("session-started");
+          }
+        } else if (msg.message_type === "partial_transcript") {
+          const newPartial = msg.text ?? "";
+          if (newPartial.length > this.pendingPartial.length) {
+            const delta = newPartial.slice(this.pendingPartial.length);
+            this.pendingPartial = newPartial;
+            this.emit("transcript", delta, { fullText: this.getFullText() });
+          } else {
+            this.pendingPartial = newPartial;
+            this.emit("transcript", "", { fullText: this.getFullText() });
+          }
+        } else if (msg.message_type === "committed_transcript") {
+          const transcript = msg.text ?? "";
+          if (transcript && isTranscriptOk(transcript)) {
+            this.committedText = this.committedText ? this.committedText + " " + transcript : transcript;
+            this.pendingPartial = "";
+            this.emit("transcript", transcript, {
+              final: true,
+              fullText: this.getFullText()
+            });
+          } else {
+            this.pendingPartial = "";
+          }
+        }
+      } catch {
+      }
+    });
+    ws.addEventListener("error", () => {
+      this.emit("error", new Error("ElevenLabs STT WebSocket error"));
+    });
+    ws.addEventListener("close", () => {
+      this.emit("close");
+    });
+    if (ws.readyState !== WebSocket.OPEN) {
+      await new Promise((resolve, reject) => {
+        const onOpen = () => {
+          cleanup();
+          resolve();
+        };
+        const onError = (ev) => {
+          cleanup();
+          reject(ev);
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(new DOMException("Aborted", "AbortError"));
+        };
+        const cleanup = () => {
+          ws.removeEventListener("open", onOpen);
+          ws.removeEventListener("error", onError);
+          ac.signal.removeEventListener("abort", onAbort);
+        };
+        ws.addEventListener("open", onOpen);
+        ws.addEventListener("error", onError);
+        ac.signal.addEventListener("abort", onAbort);
+      });
+    }
+  }
+  /**
+   * Send a PCM audio buffer (Float32Array, 16 kHz mono) to the WebSocket.
+   * Converts to int16 PCM then base64 before sending.
+   */
+  sendAudio(pcm) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const int16 = new Int16Array(pcm.length);
+    for (let i = 0; i < pcm.length; i++) {
+      const s = Math.max(-1, Math.min(1, pcm[i]));
+      int16[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    const bytes = new Uint8Array(int16.buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    const audioBase64 = btoa(binary);
+    this.ws.send(
+      JSON.stringify({
+        message_type: "input_audio_chunk",
+        audio_base_64: audioBase64
+      })
+    );
+  }
+  /** Disconnect and clean up. */
+  disconnect() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.committedText = "";
+    this.pendingPartial = "";
+  }
+  /** Whether a committed_transcript has been received since the last drain check. */
+  get hasCommitted() {
+    return this.committedText.length > 0;
+  }
+  async fetchToken(signal) {
+    if (this.opts.tokenUrl) {
+      const resp = await fetch(this.opts.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ apiKey: this.opts.apiKey }),
+        signal
+      });
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => resp.statusText);
+        throw new Error(`STT token request failed: ${resp.status} ${body}`);
+      }
+      const json = await resp.json();
+      return json.token;
+    }
+    if (this.opts.apiKey) {
+      const resp = await fetch(
+        "https://api.elevenlabs.io/v1/speech-to-text/single-use-token/realtime_scribe",
+        {
+          method: "POST",
+          headers: { "xi-api-key": this.opts.apiKey },
+          signal
+        }
+      );
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => resp.statusText);
+        throw new Error(`STT token request failed: ${resp.status} ${body}`);
+      }
+      const json = await resp.json();
+      return json.token;
+    }
+    throw new Error(
+      "ElevenLabsSTTAdapter requires either tokenUrl or apiKey"
+    );
+  }
+};
+
+// src/core/mic-capture.ts
+var MicCapture = class {
+  audioContext = null;
+  source = null;
+  workletNode = null;
+  stream = null;
+  abortController = null;
+  /**
+   * Request mic access, load the AudioWorklet, and start streaming.
+   * Resolves once the worklet is connected and producing buffers.
+   */
+  async start(opts = {}) {
+    const {
+      workletUrl = "/audio/microphone-worklet.js",
+      sampleRate = 16e3,
+      bufferSize = 4096,
+      onBuffer,
+      onVolume
+    } = opts;
+    this.stop();
+    const ac = new AbortController();
+    this.abortController = ac;
+    const micStream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        autoGainControl: true,
+        noiseSuppression: true,
+        echoCancellation: true
+      }
+    });
+    if (ac.signal.aborted) {
+      micStream.getTracks().forEach((t) => t.stop());
+      throw new DOMException("Aborted", "AbortError");
+    }
+    this.stream = micStream;
+    const audioContext = new AudioContext();
+    this.audioContext = audioContext;
+    await audioContext.audioWorklet.addModule(workletUrl);
+    if (ac.signal.aborted) {
+      audioContext.close().catch(() => {
+      });
+      micStream.getTracks().forEach((t) => t.stop());
+      throw new DOMException("Aborted", "AbortError");
+    }
+    const source = audioContext.createMediaStreamSource(micStream);
+    this.source = source;
+    const workletNode = new AudioWorkletNode(audioContext, "volume-processor");
+    this.workletNode = workletNode;
+    workletNode.port.postMessage(
+      JSON.stringify({
+        method: "options",
+        args: {
+          sampleRate,
+          bufferSize,
+          muted: true,
+          emitVolume: !!onVolume,
+          emitBuffer: !!onBuffer
+        }
+      })
+    );
+    workletNode.port.onmessage = (e) => {
+      if (ac.signal.aborted) return;
+      if (e.data.method === "volume") {
+        onVolume?.(e.data.data);
+      } else if (e.data.method === "buffer") {
+        onBuffer?.(e.data.data);
+      }
+    };
+    source.connect(workletNode);
+    workletNode.connect(audioContext.destination);
+    return micStream;
+  }
+  /** Stop mic capture and release all resources. */
+  stop() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.workletNode) {
+      this.workletNode.port.onmessage = null;
+      this.workletNode.disconnect();
+      this.workletNode = null;
+    }
+    if (this.source) {
+      this.source.disconnect();
+      this.source = null;
+    }
+    if (this.stream) {
+      this.stream.getTracks().forEach((t) => t.stop());
+      this.stream = null;
+    }
+    if (this.audioContext) {
+      this.audioContext.close().catch(() => {
+      });
+      this.audioContext = null;
+    }
+  }
+  /** Stop just the mic tracks (audio input) while keeping the worklet alive for drain. */
+  stopMicTracks() {
+    if (this.stream) {
+      this.stream.getTracks().forEach((t) => t.stop());
+    }
+  }
+};
+
+// src/adapters/avatar/lemonslice.ts
+var AUDIO_STREAM_TOPIC = "lk.audio_stream";
+var RPC_CLEAR_BUFFER = "lk.clear_buffer";
+var RPC_PLAYBACK_FINISHED = "lk.playback_finished";
+var PCM_FRAME_MS = 100;
+var PCM_BYTES_PER_SAMPLE2 = 2;
+var CONNECT_TIMEOUT_MS = 45e3;
+var LemonSliceRenderer = class {
+  id = "lemonslice";
+  type = "remote";
+  opts;
+  room = null;
+  avatarIdentity = null;
+  audioStreamWriter = null;
+  clearBufferSupported = true;
+  playbackFinishedRegistered = false;
+  connected = false;
+  awaitingVideo = false;
+  connectTimer = null;
+  writeQueue = Promise.resolve();
+  container = null;
+  videoEl = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async mount(container) {
+    this.container = container;
+    const lk = await import("livekit-client");
+    const session = await this.opts.createSession();
+    this.avatarIdentity = session.avatarIdentity;
+    this.awaitingVideo = true;
+    const room = new lk.Room({ adaptiveStream: true, dynacast: true });
+    room.on(lk.RoomEvent.TrackSubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video) {
+        const mt = track.mediaStreamTrack;
+        if (mt) {
+          if (this.awaitingVideo) {
+            this.awaitingVideo = false;
+            this.connected = true;
+            this.clearConnectTimeout();
+            this.opts.onStateChange?.("connected");
+          }
+          const stream = new MediaStream([mt]);
+          this.opts.onVideoStream?.(stream);
+          this.attachVideo(stream);
+        }
+      }
+      if (track.kind === lk.Track.Kind.Audio) {
+        const mt = track.mediaStreamTrack;
+        if (mt) this.opts.onAudioStream?.(new MediaStream([mt]));
+      }
+    });
+    room.on(lk.RoomEvent.TrackUnsubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video)
+        this.opts.onVideoStream?.(null);
+      if (track.kind === lk.Track.Kind.Audio)
+        this.opts.onAudioStream?.(null);
+      track.detach();
+    });
+    room.on(lk.RoomEvent.ParticipantConnected, (p) => {
+      if (p.identity.startsWith("avatar-") || p.identity.startsWith("lemonslice-")) {
+        this.avatarIdentity = p.identity;
+      }
+    });
+    room.on(lk.RoomEvent.Disconnected, () => {
+      this.connected = false;
+      this.opts.onStateChange?.("disconnected");
+      this.opts.onVideoStream?.(null);
+      this.opts.onAudioStream?.(null);
+    });
+    this.opts.onStateChange?.("connecting");
+    await room.connect(session.livekitUrl, session.livekitToken);
+    this.room = room;
+    try {
+      room.registerRpcMethod(RPC_PLAYBACK_FINISHED, async () => "ok");
+      this.playbackFinishedRegistered = true;
+    } catch {
+    }
+    this.startConnectTimeout();
+  }
+  update(_control) {
+  }
+  async speak(audio) {
+    const next = this.writeQueue.then(() => this.writeSpeechBlob(audio));
+    this.writeQueue = next.catch(() => {
+    });
+    return next;
+  }
+  interrupt() {
+    void this.closeAudioStream();
+    void this.clearAvatarBuffer();
+  }
+  unmount() {
+    this.clearConnectTimeout();
+    void this.closeAudioStream();
+    if (this.room) {
+      if (this.playbackFinishedRegistered) {
+        this.room.unregisterRpcMethod(RPC_PLAYBACK_FINISHED);
+        this.playbackFinishedRegistered = false;
+      }
+      this.room.disconnect();
+      this.room = null;
+    }
+    this.connected = false;
+    this.awaitingVideo = false;
+    this.avatarIdentity = null;
+    if (this.videoEl) {
+      this.videoEl.remove();
+      this.videoEl = null;
+    }
+    this.opts.onVideoStream?.(null);
+    this.opts.onAudioStream?.(null);
+    this.opts.onStateChange?.("disconnected");
+  }
+  // -- private ---
+  attachVideo(stream) {
+    if (!this.container) return;
+    if (!this.videoEl) {
+      this.videoEl = document.createElement("video");
+      this.videoEl.autoplay = true;
+      this.videoEl.playsInline = true;
+      this.videoEl.muted = false;
+      this.videoEl.style.width = "100%";
+      this.videoEl.style.height = "100%";
+      this.videoEl.style.objectFit = "contain";
+      this.container.appendChild(this.videoEl);
+    }
+    this.videoEl.srcObject = stream;
+  }
+  clearConnectTimeout() {
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+  }
+  startConnectTimeout() {
+    this.clearConnectTimeout();
+    this.connectTimer = setTimeout(() => {
+      if (this.awaitingVideo) {
+        this.opts.onStateChange?.(
+          "error",
+          "Timed out waiting for avatar video"
+        );
+      }
+    }, CONNECT_TIMEOUT_MS);
+  }
+  async clearAvatarBuffer() {
+    if (!this.room || !this.clearBufferSupported || !this.avatarIdentity) return;
+    try {
+      await this.room.localParticipant.performRpc({
+        destinationIdentity: this.avatarIdentity,
+        method: RPC_CLEAR_BUFFER,
+        payload: ""
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("Method not supported")) this.clearBufferSupported = false;
+    }
+  }
+  async closeAudioStream() {
+    const writer = this.audioStreamWriter;
+    this.audioStreamWriter = null;
+    if (writer) {
+      try {
+        await writer.close();
+      } catch {
+      }
+    }
+  }
+  async writeSpeechBlob(audioBlob) {
+    if (!this.room || !this.connected) throw new Error("Room not connected");
+    if (!this.avatarIdentity) throw new Error("Avatar participant not ready");
+    await this.closeAudioStream();
+    await this.clearAvatarBuffer();
+    const { pcmBytes, sampleRate, numChannels } = await decodeToPcm(audioBlob);
+    await this.streamPcm(pcmBytes, sampleRate, numChannels);
+    await this.closeAudioStream();
+  }
+  async streamPcm(pcmBytes, sampleRate, numChannels) {
+    if (!this.room || !this.avatarIdentity) return;
+    const segmentId = crypto.randomUUID().slice(0, 8);
+    const writer = this.audioStreamWriter ?? await this.room.localParticipant.streamBytes({
+      name: `AUDIO_${segmentId}`,
+      topic: AUDIO_STREAM_TOPIC,
+      destinationIdentities: [this.avatarIdentity],
+      attributes: {
+        sample_rate: String(sampleRate),
+        num_channels: String(numChannels)
+      }
+    });
+    this.audioStreamWriter = writer;
+    const bytesPerSecond = sampleRate * numChannels * PCM_BYTES_PER_SAMPLE2;
+    const chunkBytes = Math.max(1024, Math.floor(bytesPerSecond * PCM_FRAME_MS / 1e3));
+    let offset = 0;
+    while (offset < pcmBytes.byteLength) {
+      const next = Math.min(offset + chunkBytes, pcmBytes.byteLength);
+      const chunk = pcmBytes.subarray(offset, next);
+      await writer.write(chunk);
+      offset = next;
+      const durationMs = Math.max(0, Math.round(chunk.byteLength / bytesPerSecond * 1e3));
+      if (durationMs > 0) {
+        await new Promise((r) => setTimeout(r, durationMs));
+      }
+    }
+  }
+};
+
+// src/adapters/avatar/atlas.ts
+var CONNECT_TIMEOUT_MS2 = 45e3;
+var AtlasRenderer = class {
+  id = "atlas";
+  type = "remote";
+  opts;
+  room = null;
+  sessionId = null;
+  connected = false;
+  awaitingVideo = false;
+  connectTimer = null;
+  container = null;
+  videoEl = null;
+  audioCtx = null;
+  audioDest = null;
+  currentSource = null;
+  speakQueue = Promise.resolve();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async mount(container) {
+    this.container = container;
+    const lk = await import("livekit-client");
+    const session = await this.opts.createSession();
+    this.sessionId = session.sessionId;
+    this.awaitingVideo = true;
+    this.audioCtx = new AudioContext();
+    this.audioDest = this.audioCtx.createMediaStreamDestination();
+    const room = new lk.Room({ adaptiveStream: true, dynacast: true });
+    room.on(lk.RoomEvent.TrackSubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video) {
+        const mt = track.mediaStreamTrack;
+        if (mt) {
+          if (this.awaitingVideo) {
+            this.awaitingVideo = false;
+            this.connected = true;
+            this.clearConnectTimeout();
+            this.opts.onStateChange?.("connected");
+          }
+          const stream = new MediaStream([mt]);
+          this.opts.onVideoStream?.(stream);
+          this.attachVideo(stream);
+        }
+      }
+      if (track.kind === lk.Track.Kind.Audio) {
+        const mt = track.mediaStreamTrack;
+        if (mt) this.opts.onAudioStream?.(new MediaStream([mt]));
+      }
+    });
+    room.on(lk.RoomEvent.TrackUnsubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video)
+        this.opts.onVideoStream?.(null);
+      if (track.kind === lk.Track.Kind.Audio)
+        this.opts.onAudioStream?.(null);
+      track.detach();
+    });
+    room.on(lk.RoomEvent.Disconnected, () => {
+      this.connected = false;
+      this.opts.onStateChange?.("disconnected");
+      this.opts.onVideoStream?.(null);
+      this.opts.onAudioStream?.(null);
+    });
+    this.opts.onStateChange?.("connecting");
+    await room.connect(session.livekitUrl, session.token);
+    this.room = room;
+    const audioTrack = this.audioDest.stream.getAudioTracks()[0];
+    if (audioTrack) {
+      await room.localParticipant.publishTrack(audioTrack, {
+        source: lk.Track.Source.Microphone
+      });
+    }
+    this.startConnectTimeout();
+  }
+  update(_control) {
+  }
+  async speak(audio) {
+    const next = this.speakQueue.then(() => this.playSpeechBlob(audio));
+    this.speakQueue = next.catch(() => {
+    });
+    return next;
+  }
+  interrupt() {
+    if (this.currentSource) {
+      try {
+        this.currentSource.stop();
+      } catch {
+      }
+      this.currentSource = null;
+    }
+  }
+  unmount() {
+    this.clearConnectTimeout();
+    this.interrupt();
+    if (this.room) {
+      this.room.disconnect();
+      this.room = null;
+    }
+    if (this.audioCtx) {
+      void this.audioCtx.close().catch(() => {
+      });
+      this.audioCtx = null;
+      this.audioDest = null;
+    }
+    this.connected = false;
+    this.awaitingVideo = false;
+    if (this.videoEl) {
+      this.videoEl.remove();
+      this.videoEl = null;
+    }
+    this.opts.onVideoStream?.(null);
+    this.opts.onAudioStream?.(null);
+    this.opts.onStateChange?.("disconnected");
+    const id = this.sessionId;
+    this.sessionId = null;
+    if (id && this.opts.deleteSession) {
+      void this.opts.deleteSession(id).catch(() => {
+      });
+    }
+  }
+  // -- private ---
+  attachVideo(stream) {
+    if (!this.container) return;
+    if (!this.videoEl) {
+      this.videoEl = document.createElement("video");
+      this.videoEl.autoplay = true;
+      this.videoEl.playsInline = true;
+      this.videoEl.muted = false;
+      this.videoEl.style.width = "100%";
+      this.videoEl.style.height = "100%";
+      this.videoEl.style.objectFit = "contain";
+      this.container.appendChild(this.videoEl);
+    }
+    this.videoEl.srcObject = stream;
+  }
+  clearConnectTimeout() {
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+  }
+  startConnectTimeout() {
+    this.clearConnectTimeout();
+    this.connectTimer = setTimeout(() => {
+      if (this.awaitingVideo) {
+        this.opts.onStateChange?.(
+          "error",
+          "Timed out waiting for avatar video"
+        );
+      }
+    }, CONNECT_TIMEOUT_MS2);
+  }
+  async playSpeechBlob(audioBlob) {
+    if (!this.audioCtx || !this.audioDest || !this.connected) {
+      throw new Error("Atlas session not connected");
+    }
+    if (this.audioCtx.state === "suspended") {
+      await this.audioCtx.resume();
+    }
+    const arrayBuffer = await audioBlob.arrayBuffer();
+    const audioBuffer = await this.audioCtx.decodeAudioData(arrayBuffer);
+    const source = this.audioCtx.createBufferSource();
+    source.buffer = audioBuffer;
+    source.connect(this.audioDest);
+    this.currentSource = source;
+    return new Promise((resolve) => {
+      source.onended = () => {
+        if (this.currentSource === source) {
+          this.currentSource = null;
+        }
+        resolve();
+      };
+      source.start();
+    });
+  }
+};
+
+// src/adapters/avatar/heygen.ts
+var CONNECT_TIMEOUT_MS3 = 45e3;
+var WORDS_PER_MS = 150 / 6e4;
+var MIN_SPEAK_MS = 800;
+var HeyGenRenderer = class {
+  id = "heygen";
+  type = "remote";
+  opts;
+  room = null;
+  sessionId = null;
+  connected = false;
+  awaitingVideo = false;
+  connectTimer = null;
+  container = null;
+  videoEl = null;
+  speakQueue = Promise.resolve();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async mount(container) {
+    this.container = container;
+    const lk = await import("livekit-client");
+    const session = await this.opts.createSession();
+    this.sessionId = session.sessionId;
+    this.awaitingVideo = true;
+    const room = new lk.Room({ adaptiveStream: true, dynacast: true });
+    room.on(lk.RoomEvent.TrackSubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video) {
+        const mt = track.mediaStreamTrack;
+        if (mt) {
+          if (this.awaitingVideo) {
+            this.awaitingVideo = false;
+            this.connected = true;
+            this.clearConnectTimeout();
+            this.opts.onStateChange?.("connected");
+          }
+          const stream = new MediaStream([mt]);
+          this.opts.onVideoStream?.(stream);
+          this.attachVideo(stream);
+        }
+      }
+      if (track.kind === lk.Track.Kind.Audio) {
+        const mt = track.mediaStreamTrack;
+        if (mt) {
+          const stream = new MediaStream([mt]);
+          this.opts.onAudioStream?.(stream);
+          this.attachAudio(stream);
+        }
+      }
+    });
+    room.on(lk.RoomEvent.TrackUnsubscribed, (track) => {
+      if (track.kind === lk.Track.Kind.Video)
+        this.opts.onVideoStream?.(null);
+      if (track.kind === lk.Track.Kind.Audio)
+        this.opts.onAudioStream?.(null);
+      track.detach();
+    });
+    room.on(lk.RoomEvent.Disconnected, () => {
+      this.connected = false;
+      this.opts.onStateChange?.("disconnected");
+      this.opts.onVideoStream?.(null);
+      this.opts.onAudioStream?.(null);
+    });
+    this.opts.onStateChange?.("connecting");
+    await room.connect(session.livekitUrl, session.livekitToken);
+    this.room = room;
+    this.startConnectTimeout();
+  }
+  update(_control) {
+  }
+  /**
+   * Text-driven speech: sends text to HeyGen's streaming.task endpoint.
+   * Resolves when the estimated speech duration elapses.
+   */
+  async speakText(text, signal) {
+    const next = this.speakQueue.then(
+      () => this.doSpeakText(text, signal)
+    );
+    this.speakQueue = next.catch(() => {
+    });
+    return next;
+  }
+  /** Audio-based speak — no-op for HeyGen (TTS is handled internally). */
+  async speak(_audio) {
+  }
+  interrupt() {
+    this.speakQueue = Promise.resolve();
+    const id = this.sessionId;
+    if (id && this.opts.interruptSession) {
+      void this.opts.interruptSession(id).catch(() => {
+      });
+    }
+  }
+  unmount() {
+    this.clearConnectTimeout();
+    this.interrupt();
+    if (this.room) {
+      this.room.disconnect();
+      this.room = null;
+    }
+    this.connected = false;
+    this.awaitingVideo = false;
+    if (this.videoEl) {
+      this.videoEl.remove();
+      this.videoEl = null;
+    }
+    this.opts.onVideoStream?.(null);
+    this.opts.onAudioStream?.(null);
+    this.opts.onStateChange?.("disconnected");
+    const id = this.sessionId;
+    this.sessionId = null;
+    if (id && this.opts.closeSession) {
+      void this.opts.closeSession(id).catch(() => {
+      });
+    }
+  }
+  // -- private ---
+  async doSpeakText(text, signal) {
+    if (!this.sessionId || !this.connected) {
+      throw new Error("HeyGen session not connected");
+    }
+    if (signal?.aborted) return;
+    const result = await this.opts.sendTask(this.sessionId, text);
+    if (signal?.aborted) return;
+    const waitMs = result.durationMs ?? Math.max(text.split(/\s+/).length / WORDS_PER_MS, MIN_SPEAK_MS);
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, waitMs);
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+  attachVideo(stream) {
+    if (!this.container) return;
+    if (!this.videoEl) {
+      this.videoEl = document.createElement("video");
+      this.videoEl.autoplay = true;
+      this.videoEl.playsInline = true;
+      this.videoEl.muted = false;
+      this.videoEl.style.width = "100%";
+      this.videoEl.style.height = "100%";
+      this.videoEl.style.objectFit = "contain";
+      this.container.appendChild(this.videoEl);
+    }
+    this.videoEl.srcObject = stream;
+  }
+  attachAudio(stream) {
+    if (!this.container) return;
+    let audioEl = this.container.querySelector(
+      "audio[data-heygen-audio]"
+    );
+    if (!audioEl) {
+      audioEl = document.createElement("audio");
+      audioEl.setAttribute("data-heygen-audio", "");
+      audioEl.autoplay = true;
+      audioEl.style.display = "none";
+      this.container.appendChild(audioEl);
+    }
+    audioEl.srcObject = stream;
+  }
+  clearConnectTimeout() {
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+  }
+  startConnectTimeout() {
+    this.clearConnectTimeout();
+    this.connectTimer = setTimeout(() => {
+      if (this.awaitingVideo) {
+        this.opts.onStateChange?.(
+          "error",
+          "Timed out waiting for HeyGen avatar video"
+        );
+      }
+    }, CONNECT_TIMEOUT_MS3);
+  }
+};
+
+// src/renderers/lip-sync.ts
+var SMOOTHING = 0.35;
+var LipSyncEngine = class {
+  analyser = null;
+  ctx = null;
+  source = null;
+  dataArray = null;
+  currentValue = 0;
+  /** Attach to an <audio> element and start analysing. */
+  attach(audio, audioContext) {
+    this.detach();
+    this.ctx = audioContext;
+    this.analyser = audioContext.createAnalyser();
+    this.analyser.fftSize = 256;
+    this.analyser.smoothingTimeConstant = SMOOTHING;
+    this.source = audioContext.createMediaElementSource(audio);
+    this.source.connect(this.analyser);
+    this.analyser.connect(audioContext.destination);
+    this.dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+  }
+  /** Detach and free resources. */
+  detach() {
+    if (this.source) {
+      try {
+        this.source.disconnect();
+      } catch {
+      }
+      this.source = null;
+    }
+    if (this.analyser) {
+      try {
+        this.analyser.disconnect();
+      } catch {
+      }
+      this.analyser = null;
+    }
+    this.dataArray = null;
+    this.currentValue = 0;
+  }
+  /** Call on every animation frame to get the current mouth-open value 0..1 */
+  sample() {
+    if (!this.analyser || !this.dataArray) return 0;
+    this.analyser.getByteTimeDomainData(this.dataArray);
+    let sumSq = 0;
+    for (let i = 0; i < this.dataArray.length; i++) {
+      const v = (this.dataArray[i] - 128) / 128;
+      sumSq += v * v;
+    }
+    const rms = Math.sqrt(sumSq / this.dataArray.length);
+    const target = Math.min(1, rms * 4);
+    this.currentValue += (target - this.currentValue) * 0.4;
+    return this.currentValue;
+  }
+};
+
+// src/renderers/vrm-renderer.ts
+var VRMLocalRenderer = class {
+  id = "vrm-local";
+  type = "local";
+  opts;
+  container = null;
+  threeRenderer = null;
+  scene = null;
+  camera = null;
+  clock = null;
+  vrm = null;
+  VRMModule = null;
+  mixer = null;
+  rafId = null;
+  blinkTimer = null;
+  lipSync = new LipSyncEngine();
+  audioContext = null;
+  currentAudio = null;
+  speakResolve = null;
+  resizeObserver = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async mount(container) {
+    this.container = container;
+    const THREE = await import("three");
+    const VRMModule = await import("@pixiv/three-vrm");
+    this.VRMModule = VRMModule;
+    this.scene = new THREE.Scene();
+    this.camera = new THREE.PerspectiveCamera(
+      30,
+      container.clientWidth / container.clientHeight,
+      0.1,
+      20
+    );
+    this.camera.position.set(0, 1.35, 1.5);
+    this.camera.lookAt(0, 1.2, 0);
+    this.threeRenderer = new THREE.WebGLRenderer({
+      alpha: true,
+      antialias: true
+    });
+    this.threeRenderer.setPixelRatio(window.devicePixelRatio);
+    this.threeRenderer.setSize(container.clientWidth, container.clientHeight);
+    this.threeRenderer.outputColorSpace = THREE.SRGBColorSpace;
+    container.appendChild(this.threeRenderer.domElement);
+    const ambient = new THREE.AmbientLight(16777215, 0.6);
+    this.scene.add(ambient);
+    const dir = new THREE.DirectionalLight(16777215, 1);
+    dir.position.set(1, 2, 1);
+    this.scene.add(dir);
+    this.clock = new THREE.Clock();
+    const { GLTFLoader } = await import("three/addons/loaders/GLTFLoader.js");
+    const loader = new GLTFLoader();
+    loader.register((parser) => new VRMModule.VRMLoaderPlugin(parser));
+    await this.loadVRM(this.opts.modelUrl, loader, THREE, VRMModule);
+    this.startBlink();
+    this.startRenderLoop();
+    this.resizeObserver = new ResizeObserver(() => this.handleResize());
+    this.resizeObserver.observe(container);
+  }
+  update(control) {
+    if (!this.vrm || !this.VRMModule) return;
+    const face = control.avatar?.face;
+    if (face?.mouth) {
+      this.vrm.expressionManager?.setValue(
+        this.VRMModule.VRMExpressionPresetName.Aa,
+        face.mouth.jawOpen
+      );
+    }
+    if (face?.eyes) {
+      this.vrm.expressionManager?.setValue(
+        this.VRMModule.VRMExpressionPresetName.Blink,
+        1 - Math.min(face.eyes.blinkL, face.eyes.blinkR)
+      );
+    }
+    const emotion = control.avatar?.emotion;
+    if (emotion?.label) {
+      this.applyExpression(emotion.label, emotion.intensity ?? 0.8);
+    }
+  }
+  async speak(audio) {
+    return new Promise((resolve) => {
+      this.speakResolve = resolve;
+      const url = URL.createObjectURL(audio);
+      const el = new Audio(url);
+      this.currentAudio = el;
+      if (!this.audioContext || this.audioContext.state === "closed") {
+        this.audioContext = new AudioContext();
+      }
+      this.lipSync.attach(el, this.audioContext);
+      el.addEventListener("ended", () => {
+        this.lipSync.detach();
+        URL.revokeObjectURL(url);
+        this.currentAudio = null;
+        this.speakResolve = null;
+        resolve();
+      });
+      el.addEventListener("error", () => {
+        this.lipSync.detach();
+        URL.revokeObjectURL(url);
+        this.currentAudio = null;
+        this.speakResolve = null;
+        resolve();
+      });
+      el.play().catch(() => {
+        this.lipSync.detach();
+        URL.revokeObjectURL(url);
+        this.currentAudio = null;
+        this.speakResolve = null;
+        resolve();
+      });
+    });
+  }
+  interrupt() {
+    if (this.currentAudio) {
+      this.currentAudio.pause();
+      this.currentAudio.removeAttribute("src");
+      this.currentAudio = null;
+    }
+    this.lipSync.detach();
+    if (this.speakResolve) {
+      this.speakResolve();
+      this.speakResolve = null;
+    }
+  }
+  unmount() {
+    this.interrupt();
+    if (this.rafId != null) cancelAnimationFrame(this.rafId);
+    if (this.blinkTimer != null) clearInterval(this.blinkTimer);
+    this.resizeObserver?.disconnect();
+    this.threeRenderer?.dispose();
+    if (this.threeRenderer?.domElement?.parentElement) {
+      this.threeRenderer.domElement.parentElement.removeChild(
+        this.threeRenderer.domElement
+      );
+    }
+    if (this.audioContext && this.audioContext.state !== "closed") {
+      this.audioContext.close().catch(() => {
+      });
+    }
+    this.vrm = null;
+    this.scene = null;
+    this.camera = null;
+    this.threeRenderer = null;
+    this.container = null;
+  }
+  // -- internals --
+  async loadVRM(url, loader, THREE, VRM) {
+    const gltf = await new Promise((resolve, reject) => {
+      loader.load(url, resolve, void 0, reject);
+    });
+    const vrm = gltf.userData.vrm;
+    if (!vrm) throw new Error("No VRM data found in model");
+    VRM.VRMUtils.removeUnnecessaryJoints(gltf.scene);
+    this.scene.add(gltf.scene);
+    this.vrm = vrm;
+    this.mixer = new THREE.AnimationMixer(gltf.scene);
+  }
+  startBlink() {
+    this.blinkTimer = setInterval(() => {
+      if (!this.vrm || !this.VRMModule) return;
+      const blink = this.VRMModule.VRMExpressionPresetName.Blink;
+      this.vrm.expressionManager?.setValue(blink, 1);
+      setTimeout(() => {
+        this.vrm?.expressionManager?.setValue(blink, 0);
+      }, 120);
+    }, 3e3 + Math.random() * 3e3);
+  }
+  startRenderLoop() {
+    const animate = () => {
+      this.rafId = requestAnimationFrame(animate);
+      const delta = this.clock.getDelta();
+      if (this.vrm) {
+        const mouthOpen = this.lipSync.sample();
+        if (mouthOpen > 0.01 && this.VRMModule) {
+          this.vrm.expressionManager?.setValue(
+            this.VRMModule.VRMExpressionPresetName.Aa,
+            mouthOpen
+          );
+        }
+        this.vrm.update(delta);
+      }
+      this.mixer?.update(delta);
+      this.threeRenderer.render(this.scene, this.camera);
+    };
+    animate();
+  }
+  applyExpression(label, intensity) {
+    if (!this.vrm || !this.VRMModule) return;
+    const presetMap = {
+      happy: this.VRMModule.VRMExpressionPresetName.Happy,
+      sad: this.VRMModule.VRMExpressionPresetName.Sad,
+      angry: this.VRMModule.VRMExpressionPresetName.Angry,
+      surprised: this.VRMModule.VRMExpressionPresetName.Surprised,
+      relaxed: this.VRMModule.VRMExpressionPresetName.Relaxed,
+      neutral: this.VRMModule.VRMExpressionPresetName.Neutral
+    };
+    const preset = presetMap[label.toLowerCase()];
+    if (!preset) return;
+    for (const v of Object.values(presetMap)) {
+      this.vrm.expressionManager?.setValue(v, 0);
+    }
+    this.vrm.expressionManager?.setValue(preset, intensity);
+  }
+  handleResize() {
+    if (!this.container || !this.camera || !this.threeRenderer) return;
+    const w = this.container.clientWidth;
+    const h = this.container.clientHeight;
+    this.camera.aspect = w / h;
+    this.camera.updateProjectionMatrix();
+    this.threeRenderer.setSize(w, h);
+  }
+};
+
+// src/renderers/live2d-renderer.ts
+var CDN_LIVE2D = "https://cdn.jsdelivr.net/gh/nicx-next/live2d-cubism2@1.0.0/live2d.min.js";
+var CDN_PIXI = "https://cdn.jsdelivr.net/npm/pixi.js@6.5.10/dist/browser/pixi.min.js";
+var CDN_CUBISM2 = "https://cdn.jsdelivr.net/npm/pixi-live2d-display@0.4.0/dist/cubism2.min.js";
+var PARAM = {
+  ANGLE_X: "PARAM_ANGLE_X",
+  ANGLE_Y: "PARAM_ANGLE_Y",
+  ANGLE_Z: "PARAM_ANGLE_Z",
+  EYE_L_OPEN: "PARAM_EYE_L_OPEN",
+  EYE_R_OPEN: "PARAM_EYE_R_OPEN",
+  EYE_BALL_X: "PARAM_EYE_BALL_X",
+  EYE_BALL_Y: "PARAM_EYE_BALL_Y",
+  MOUTH_OPEN_Y: "PARAM_MOUTH_OPEN_Y",
+  MOUTH_FORM: "PARAM_MOUTH_FORM"
+};
+var EMOTION_CANDIDATES = {
+  happy: ["happy", "joy", "f_happy", "exp_happy"],
+  joy: ["happy", "joy", "f_happy", "exp_happy"],
+  sad: ["sad", "sorrow", "f_sad", "exp_sad"],
+  sorrow: ["sad", "sorrow", "f_sad"],
+  angry: ["angry", "anger", "f_angry", "exp_angry"],
+  anger: ["angry", "anger", "f_angry"],
+  surprised: ["surprised", "surprise", "f_surprised"],
+  surprise: ["surprised", "surprise", "f_surprised"],
+  relaxed: ["relaxed", "calm", "f_relaxed", "f_calm"],
+  calm: ["relaxed", "calm", "f_relaxed"]
+};
+var libsPromise = null;
+function loadScript(src) {
+  return new Promise((resolve, reject) => {
+    const attr = "data-avatarlayer-src";
+    const existing = document.querySelector(
+      `script[${attr}="${CSS.escape(src)}"]`
+    );
+    if (existing) {
+      if (existing.dataset.alLoaded) return resolve();
+      if (existing.dataset.alError)
+        return reject(new Error(`Script load failed: ${src}`));
+      existing.addEventListener("load", () => resolve());
+      existing.addEventListener(
+        "error",
+        () => reject(new Error(`Script load failed: ${src}`))
+      );
+      return;
+    }
+    const s = document.createElement("script");
+    s.src = src;
+    s.setAttribute(attr, src);
+    s.onload = () => {
+      s.dataset.alLoaded = "1";
+      resolve();
+    };
+    s.onerror = () => {
+      s.dataset.alError = "1";
+      reject(new Error(`Script load failed: ${src}`));
+    };
+    document.head.appendChild(s);
+  });
+}
+function ensureLibs(vendorBase) {
+  if (libsPromise) return libsPromise;
+  const live2dUrl = vendorBase ? `${vendorBase}/live2d.min.js` : CDN_LIVE2D;
+  const pixiUrl = vendorBase ? `${vendorBase}/pixi.min.js` : CDN_PIXI;
+  const cubism2Url = vendorBase ? `${vendorBase}/cubism2.min.js` : CDN_CUBISM2;
+  libsPromise = loadScript(live2dUrl).then(() => loadScript(pixiUrl)).then(() => loadScript(cubism2Url)).then(() => {
+    const P = window.PIXI;
+    if (!P?.Application)
+      throw new Error("PIXI runtime missing after script load");
+    if (!P.live2d?.Live2DModel)
+      throw new Error(
+        "pixi-live2d-display cubism2 missing after script load"
+      );
+    return P;
+  }).catch((err) => {
+    libsPromise = null;
+    throw err;
+  });
+  return libsPromise;
+}
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v || 0));
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function deadzone(v, zone) {
+  const n = v || 0;
+  if (Math.abs(n) <= zone) return 0;
+  return n > 0 ? n - zone : n + zone;
+}
+function neutralFace() {
+  return {
+    yaw: 0,
+    pitch: 0,
+    roll: 0,
+    gazeX: 0,
+    gazeY: 0,
+    blinkL: 1,
+    blinkR: 1,
+    jawOpen: 0,
+    smile: 0
+  };
+}
+var Live2DRenderer = class {
+  id = "live2d-local";
+  type = "local";
+  opts;
+  container = null;
+  app = null;
+  model = null;
+  PIXI = null;
+  destroyed = false;
+  faceCurrent = neutralFace();
+  faceTarget = neutralFace();
+  lastEmotionLabel = null;
+  lipSync = new LipSyncEngine();
+  audioContext = null;
+  currentAudio = null;
+  speakResolve = null;
+  blinkTimer = null;
+  footSnapTimer = null;
+  resizeObserver = null;
+  pointerHandler = null;
+  constructor(opts) {
+    this.opts = {
+      modelUrl: opts.modelUrl,
+      vendorBase: opts.vendorBase,
+      frameMode: opts.frameMode ?? "upperBodyFocus",
+      autoBlink: opts.autoBlink ?? true,
+      autoTrackPointer: opts.autoTrackPointer ?? false
+    };
+  }
+  // ── AvatarRenderer interface ──────────────────────────────────────────────
+  async mount(container) {
+    this.container = container;
+    this.destroyed = false;
+    const PIXI = await ensureLibs(this.opts.vendorBase);
+    if (this.destroyed) throw new Error("Renderer destroyed before mount");
+    this.PIXI = PIXI;
+    const dpr = Math.max(1, window.devicePixelRatio || 1);
+    const viewW = Math.max(1, container.clientWidth);
+    const viewH = Math.max(1, container.clientHeight);
+    this.app = new PIXI.Application({
+      width: Math.round(viewW * dpr),
+      height: Math.round(viewH * dpr),
+      backgroundAlpha: 0,
+      antialias: true,
+      resolution: 1,
+      autoDensity: false
+    });
+    const canvas = this.app.view;
+    canvas.style.width = "100%";
+    canvas.style.height = "100%";
+    canvas.style.display = "block";
+    container.appendChild(canvas);
+    this.model = await PIXI.live2d.Live2DModel.from(this.opts.modelUrl, {
+      autoUpdate: false
+    });
+    if (this.destroyed) throw new Error("Renderer destroyed during model load");
+    this.app.stage.addChild(this.model);
+    this.applyLayout();
+    this.scheduleFootSnap();
+    try {
+      const priority = PIXI.live2d.MotionPriority?.IDLE ?? 1;
+      this.model.motion("idle", 0, priority);
+    } catch {
+    }
+    this.startTicker();
+    if (this.opts.autoBlink) this.startBlink();
+    if (this.opts.autoTrackPointer) this.startPointerTracking();
+    this.resizeObserver = new ResizeObserver(() => this.handleResize());
+    this.resizeObserver.observe(container);
+  }
+  update(control) {
+    const face = control.avatar?.face;
+    if (face) {
+      const pose = face.pose ?? {};
+      const eyes = face.eyes ?? {};
+      const mouth = face.mouth ?? {};
+      this.faceTarget.yaw = deadzone(clamp(pose.yaw ?? 0, -1, 1), 0.02);
+      this.faceTarget.pitch = deadzone(clamp(pose.pitch ?? 0, -1, 1), 0.02);
+      this.faceTarget.roll = deadzone(clamp(pose.roll ?? 0, -1, 1), 0.02);
+      this.faceTarget.gazeX = deadzone(clamp(eyes.gazeX ?? 0, -1, 1), 0.02);
+      this.faceTarget.gazeY = deadzone(clamp(eyes.gazeY ?? 0, -1, 1), 0.02);
+      this.faceTarget.blinkL = 1 - clamp(eyes.blinkL ?? 0, 0, 1);
+      this.faceTarget.blinkR = 1 - clamp(eyes.blinkR ?? 0, 0, 1);
+      this.faceTarget.jawOpen = clamp(mouth.jawOpen ?? 0, 0, 1);
+      this.faceTarget.smile = clamp(mouth.smile ?? 0, -1, 1);
+    }
+    const emotion = control.avatar?.emotion;
+    if (emotion) this.applyEmotion(emotion.label);
+  }
+  async speak(audio) {
+    return new Promise((resolve) => {
+      this.speakResolve = resolve;
+      const url = URL.createObjectURL(audio);
+      const el = new Audio(url);
+      this.currentAudio = el;
+      if (!this.audioContext || this.audioContext.state === "closed") {
+        this.audioContext = new AudioContext();
+      }
+      this.lipSync.attach(el, this.audioContext);
+      const cleanup = () => {
+        this.lipSync.detach();
+        URL.revokeObjectURL(url);
+        this.currentAudio = null;
+        this.speakResolve = null;
+        resolve();
+      };
+      el.addEventListener("ended", cleanup);
+      el.addEventListener("error", cleanup);
+      el.play().catch(cleanup);
+    });
+  }
+  interrupt() {
+    if (this.currentAudio) {
+      this.currentAudio.pause();
+      this.currentAudio.removeAttribute("src");
+      this.currentAudio = null;
+    }
+    this.lipSync.detach();
+    if (this.speakResolve) {
+      this.speakResolve();
+      this.speakResolve = null;
+    }
+  }
+  unmount() {
+    this.destroyed = true;
+    this.interrupt();
+    if (this.blinkTimer != null) {
+      clearInterval(this.blinkTimer);
+      this.blinkTimer = null;
+    }
+    if (this.footSnapTimer != null) {
+      clearTimeout(this.footSnapTimer);
+      this.footSnapTimer = null;
+    }
+    this.resizeObserver?.disconnect();
+    this.resizeObserver = null;
+    if (this.pointerHandler && this.container) {
+      this.container.removeEventListener("pointermove", this.pointerHandler);
+      this.pointerHandler = null;
+    }
+    try {
+      if (this.model && this.app) {
+        this.app.stage.removeChild(this.model);
+        this.model.destroy();
+      }
+      this.app?.destroy(true, { children: true });
+    } catch {
+    }
+    this.app = null;
+    this.model = null;
+    this.PIXI = null;
+    if (this.container) {
+      while (this.container.firstChild)
+        this.container.removeChild(this.container.firstChild);
+    }
+    this.container = null;
+    if (this.audioContext && this.audioContext.state !== "closed") {
+      this.audioContext.close().catch(() => {
+      });
+    }
+  }
+  // ── Layout ──────────────────────────────────────────────────────────────────
+  applyLayout() {
+    if (!this.app || !this.model || !this.container) return;
+    const dpr = Math.max(1, window.devicePixelRatio || 1);
+    const viewW = Math.max(1, this.container.clientWidth);
+    const viewH = Math.max(1, this.container.clientHeight);
+    this.app.renderer.resize(Math.round(viewW * dpr), Math.round(viewH * dpr));
+    this.app.stage.scale.set(dpr, dpr);
+    const mW = this.model.internalModel?.originalWidth || this.model.width || viewW;
+    const mH = this.model.internalModel?.originalHeight || this.model.height || viewH;
+    let scale;
+    if (this.opts.frameMode === "upperBodyFocus") {
+      const visibleH = mH * 0.72;
+      scale = Math.min(viewW / mW, viewH / visibleH) * 0.97;
+      this.model.anchor.set(0.5, 0);
+      this.model.scale.set(scale);
+      this.model.x = viewW / 2;
+      this.model.y = -mH * scale * 0.03;
+    } else {
+      scale = Math.min(viewW / mW, viewH / mH) * 0.98;
+      this.model.anchor.set(0.5, 1);
+      this.model.scale.set(scale);
+      this.model.x = viewW / 2;
+      this.model.y = viewH - Math.round(viewH * 5e-3);
+    }
+  }
+  // ── Per-frame ticker ────────────────────────────────────────────────────────
+  startTicker() {
+    this.app.ticker.add(() => {
+      if (!this.model || this.destroyed) return;
+      const lipSyncValue = this.lipSync.sample();
+      if (lipSyncValue > 0.01) {
+        this.faceTarget.jawOpen = lipSyncValue;
+      }
+      const k = 0.18;
+      const kb = 0.35;
+      this.faceCurrent.yaw = lerp(this.faceCurrent.yaw, this.faceTarget.yaw, k);
+      this.faceCurrent.pitch = lerp(this.faceCurrent.pitch, this.faceTarget.pitch, k);
+      this.faceCurrent.roll = lerp(this.faceCurrent.roll, this.faceTarget.roll, k);
+      this.faceCurrent.gazeX = lerp(this.faceCurrent.gazeX, this.faceTarget.gazeX, k);
+      this.faceCurrent.gazeY = lerp(this.faceCurrent.gazeY, this.faceTarget.gazeY, k);
+      this.faceCurrent.blinkL = lerp(this.faceCurrent.blinkL, this.faceTarget.blinkL, kb);
+      this.faceCurrent.blinkR = lerp(this.faceCurrent.blinkR, this.faceTarget.blinkR, kb);
+      this.faceCurrent.jawOpen = lerp(this.faceCurrent.jawOpen, this.faceTarget.jawOpen, k);
+      this.faceCurrent.smile = lerp(this.faceCurrent.smile, this.faceTarget.smile, k);
+      try {
+        this.model.update(this.app.ticker.deltaMS);
+      } catch {
+      }
+      this.setParam(PARAM.ANGLE_X, this.faceCurrent.yaw * 30);
+      this.setParam(PARAM.ANGLE_Y, this.faceCurrent.pitch * 30);
+      this.setParam(PARAM.ANGLE_Z, this.faceCurrent.roll * 30);
+      this.setParam(PARAM.EYE_BALL_X, this.faceCurrent.gazeX);
+      this.setParam(PARAM.EYE_BALL_Y, this.faceCurrent.gazeY);
+      this.setParam(PARAM.EYE_L_OPEN, this.faceCurrent.blinkL);
+      this.setParam(PARAM.EYE_R_OPEN, this.faceCurrent.blinkR);
+      this.setParam(PARAM.MOUTH_OPEN_Y, this.faceCurrent.jawOpen);
+      this.setParam(PARAM.MOUTH_FORM, this.faceCurrent.smile);
+      try {
+        const core = this.model.internalModel?.coreModel;
+        if (core && typeof core.update === "function") core.update();
+      } catch {
+      }
+    });
+  }
+  setParam(name, value) {
+    try {
+      const core = this.model?.internalModel?.coreModel;
+      if (core && typeof core.setParamFloat === "function") {
+        core.setParamFloat(name, value);
+      }
+    } catch {
+    }
+  }
+  // ── Auto-blink ──────────────────────────────────────────────────────────────
+  startBlink() {
+    const nextBlink = () => 2500 + Math.random() * 3500;
+    this.blinkTimer = setInterval(() => {
+      this.faceTarget.blinkL = 0;
+      this.faceTarget.blinkR = 0;
+      setTimeout(() => {
+        this.faceTarget.blinkL = 1;
+        this.faceTarget.blinkR = 1;
+      }, 100);
+    }, nextBlink());
+  }
+  // ── Pointer tracking ────────────────────────────────────────────────────────
+  startPointerTracking() {
+    if (!this.container) return;
+    this.pointerHandler = (e) => {
+      if (!this.container) return;
+      const rect = this.container.getBoundingClientRect();
+      const nx = (e.clientX - rect.left) / rect.width * 2 - 1;
+      const ny = (e.clientY - rect.top) / rect.height * 2 - 1;
+      this.faceTarget.gazeX = clamp(nx, -1, 1);
+      this.faceTarget.gazeY = clamp(-ny, -1, 1);
+    };
+    this.container.addEventListener("pointermove", this.pointerHandler);
+  }
+  // ── Expressions / emotions ──────────────────────────────────────────────────
+  applyEmotion(label) {
+    if (!this.model) return;
+    const normalized = (label || "neutral").toLowerCase();
+    if (normalized === this.lastEmotionLabel) return;
+    this.lastEmotionLabel = normalized;
+    if (normalized === "neutral") {
+      try {
+        this.model.expression();
+      } catch {
+      }
+      return;
+    }
+    const candidates = EMOTION_CANDIDATES[normalized] ?? [normalized];
+    let available = [];
+    try {
+      if (Array.isArray(this.model.expressions)) {
+        available = this.model.expressions.map(
+          (e) => (typeof e === "string" ? e : e?.name ?? "").toLowerCase()
+        );
+      }
+    } catch {
+    }
+    for (const c of candidates) {
+      if (available.length > 0 && !available.includes(c.toLowerCase()))
+        continue;
+      try {
+        this.model.expression(c);
+      } catch {
+      }
+      break;
+    }
+  }
+  // ── Foot-snap (full-body mode) ──────────────────────────────────────────────
+  scheduleFootSnap() {
+    if (this.opts.frameMode !== "fullBody") return;
+    if (this.footSnapTimer) clearTimeout(this.footSnapTimer);
+    this.footSnapTimer = setTimeout(() => {
+      this.footSnapTimer = null;
+      this.snapFeet();
+      this.footSnapTimer = setTimeout(() => {
+        this.footSnapTimer = null;
+        this.snapFeet();
+      }, 200);
+    }, 120);
+  }
+  snapFeet() {
+    if (this.destroyed || !this.model || !this.app || !this.container) return;
+    if (this.opts.frameMode !== "fullBody") return;
+    const bottomCSS = this.detectBottomCSS();
+    if (bottomCSS === null) return;
+    const viewH = Math.max(1, this.container.clientHeight);
+    const targetBottom = viewH - Math.round(viewH * 8e-3);
+    const delta = targetBottom - bottomCSS;
+    if (Math.abs(delta) > 1) this.model.y += delta;
+  }
+  detectBottomCSS() {
+    if (!this.app?.renderer) return null;
+    try {
+      const gl = this.app.renderer.gl;
+      if (!gl) return null;
+      const canvas = this.app.view;
+      const cW = canvas.width;
+      const cH = canvas.height;
+      const dpr = Math.max(1, window.devicePixelRatio || 1);
+      const strip = Math.min(cW, 512);
+      const offX = Math.floor((cW - strip) / 2);
+      const buf = new Uint8Array(strip * 4);
+      for (let gy = 0; gy < cH; gy++) {
+        gl.readPixels(offX, gy, strip, 1, gl.RGBA, gl.UNSIGNED_BYTE, buf);
+        for (let xi = 3; xi < buf.length; xi += 4) {
+          if (buf[xi] > 12) return (cH - 1 - gy) / dpr;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // ── Resize ──────────────────────────────────────────────────────────────────
+  handleResize() {
+    this.applyLayout();
+    this.scheduleFootSnap();
+  }
+};
+
+// src/renderers/video-renderer.ts
+var VideoRenderer = class {
+  id = "video-remote";
+  type = "remote";
+  container = null;
+  videoEl = null;
+  stream = null;
+  abortController = null;
+  /** Optional: supply an existing MediaStream to display. */
+  setStream(stream) {
+    this.stream = stream;
+    if (this.videoEl) {
+      this.videoEl.srcObject = stream;
+    }
+  }
+  async mount(container) {
+    this.container = container;
+    this.videoEl = document.createElement("video");
+    this.videoEl.autoplay = true;
+    this.videoEl.playsInline = true;
+    this.videoEl.muted = false;
+    this.videoEl.style.width = "100%";
+    this.videoEl.style.height = "100%";
+    this.videoEl.style.objectFit = "contain";
+    this.videoEl.style.background = "#000";
+    this.videoEl.style.borderRadius = "12px";
+    container.appendChild(this.videoEl);
+    if (this.stream) {
+      this.videoEl.srcObject = this.stream;
+    }
+  }
+  update(_control) {
+  }
+  async speak(audio) {
+    this.abortController = new AbortController();
+    await playAudioBlob(audio, this.abortController.signal);
+  }
+  interrupt() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  unmount() {
+    this.interrupt();
+    if (this.videoEl) {
+      this.videoEl.srcObject = null;
+      this.videoEl.remove();
+      this.videoEl = null;
+    }
+    this.container = null;
+    this.stream = null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicAdapter,
+  AtlasRenderer,
+  AvatarSession,
+  ElevenLabsAdapter,
+  ElevenLabsSTTAdapter,
+  GeminiAdapter,
+  HeyGenRenderer,
+  LemonSliceRenderer,
+  LipSyncEngine,
+  Live2DRenderer,
+  MicCapture,
+  OpenAIAdapter,
+  TypedEmitter,
+  VRMLocalRenderer,
+  VideoRenderer,
+  decodeToPcm,
+  playAudioBlob
+});
+//# sourceMappingURL=index.cjs.map