@firetable/project-xiaochun 0.1.12

package/dist/index.cjs

@@ -0,0 +1,838 @@
+/*! @firetable/project-xiaochun v0.1.12 | MIT | https://github.com/FireTable/project-xiaochun */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  XC_DEFAULT_ORIGIN: () => XC_DEFAULT_ORIGIN,
+  XC_DEFAULT_SRC: () => XC_DEFAULT_SRC,
+  XC_FRAME_TO_HOST: () => XC_FRAME_TO_HOST,
+  XC_HOST_TO_FRAME: () => XC_HOST_TO_FRAME,
+  XC_IMPLEMENTED_COMMANDS: () => XC_IMPLEMENTED_COMMANDS,
+  XC_PROTOCOL_MAPPING: () => XC_PROTOCOL_MAPPING,
+  XC_PROTOCOL_VERSION: () => XC_PROTOCOL_VERSION,
+  XC_UNSUPPORTED_COMMANDS: () => XC_UNSUPPORTED_COMMANDS,
+  XIAOCHUN_ELEMENT_TAG: () => XIAOCHUN_ELEMENT_TAG,
+  XIAOCHUN_PROTOCOL_SCHEME: () => XIAOCHUN_PROTOCOL_SCHEME,
+  createXiaochun: () => createXiaochun,
+  defineXiaochunElement: () => defineXiaochunElement,
+  isXcEnvelope: () => isXcEnvelope,
+  normalizeOrigin: () => normalizeOrigin,
+  parseProtocolUrl: () => parseProtocolUrl,
+  toProtocolUrl: () => toProtocolUrl,
+  xcMessage: () => xcMessage
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/protocol.ts
+var XC_PROTOCOL_VERSION = 1;
+var XC_DEFAULT_ORIGIN = "https://xiaochun.firetable.tech";
+var XC_DEFAULT_SRC = `${XC_DEFAULT_ORIGIN}/embed`;
+var XC_HOST_TO_FRAME = [
+  "xc.init",
+  "xc.say",
+  "xc.audio",
+  "xc.audio.chunk",
+  "xc.audio.end",
+  "xc.motion",
+  "xc.expression",
+  "xc.lookAt",
+  "xc.pointer",
+  "xc.setModel",
+  "xc.setConfig",
+  "xc.mic",
+  "xc.pause",
+  "xc.resume",
+  "xc.destroy"
+];
+var XC_FRAME_TO_HOST = [
+  "xc.ready",
+  "xc.load.progress",
+  "xc.loaded",
+  "xc.state",
+  "xc.stt",
+  "xc.utterance",
+  "xc.hit-region",
+  "xc.error"
+];
+var XC_IMPLEMENTED_COMMANDS = [
+  "xc.say",
+  "xc.audio",
+  "xc.audio.chunk",
+  "xc.audio.end",
+  "xc.motion",
+  "xc.expression",
+  "xc.pointer",
+  "xc.setModel",
+  "xc.setConfig",
+  "xc.mic",
+  "xc.pause",
+  "xc.resume",
+  "xc.destroy"
+];
+var XC_UNSUPPORTED_COMMANDS = ["xc.lookAt"];
+var XC_PROTOCOL_MAPPING = [
+  { xc: "xc.say", note: 'mode:"speak" (\u9ED8\u8BA4)', action: "speak", url: "xiaochun://speak?text=\u2026" },
+  { xc: "xc.say", note: 'mode:"chat" (\u8D70 LLM)', action: null, url: null },
+  { xc: "xc.audio", note: "source \u4E3A URL \u5B57\u7B26\u4E32", action: "speak", url: "xiaochun://speak?audioUrl=\u2026[&text=\u2026]" },
+  { xc: "xc.audio", note: "source \u4E3A ArrayBuffer / Blob", action: "audio", url: null },
+  { xc: "xc.audio.chunk / xc.audio.end", note: "\u6D41\u5F0F PCM", action: "audio", url: null }
+];
+function xcMessage(type, payload, id) {
+  const m = { type, v: XC_PROTOCOL_VERSION, payload };
+  if (id !== void 0) m.id = id;
+  return m;
+}
+function isXcEnvelope(data) {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.type === "string" && d.type.startsWith("xc.") && d.v === XC_PROTOCOL_VERSION;
+}
+function normalizeOrigin(input) {
+  if (!input || input === "*" || input === "null") return null;
+  try {
+    const u = new URL(input);
+    if (u.protocol !== "https:" && u.protocol !== "http:") return null;
+    return u.origin;
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+var FALLBACK_PLACEHOLDER = "data:image/svg+xml;utf8," + encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 120 180"><defs><linearGradient id="g" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#f6b8ae"/><stop offset="1" stop-color="#ea8377"/></linearGradient></defs><ellipse cx="60" cy="170" rx="34" ry="6" fill="#000" opacity=".12"/><circle cx="60" cy="48" r="26" fill="url(#g)" opacity=".75"/><path d="M26 160c2-40 18-62 34-62s32 22 34 62z" fill="url(#g)" opacity=".6"/></svg>'
+);
+var css = (v, d) => v === void 0 ? d : typeof v === "number" ? `${v}px` : v;
+function createXiaochun(options) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("[project-xiaochun] createXiaochun must run in a browser");
+  }
+  const container = typeof options.container === "string" ? document.querySelector(options.container) : options.container;
+  if (!container) throw new Error(`[project-xiaochun] container not found: ${String(options.container)}`);
+  const src = options.src ?? XC_DEFAULT_SRC;
+  let srcUrl;
+  try {
+    srcUrl = new URL(src, window.location.href);
+  } catch {
+    throw new Error(`[project-xiaochun] invalid src: ${src}`);
+  }
+  const frameOrigin = normalizeOrigin(options.origin ?? srcUrl.origin);
+  if (!frameOrigin) throw new Error("[project-xiaochun] invalid origin (wildcards are not allowed)");
+  const trusted = /* @__PURE__ */ new Set([frameOrigin]);
+  for (const o of options.allowedOrigins ?? []) {
+    const n = normalizeOrigin(o);
+    if (!n) throw new Error(`[project-xiaochun] invalid allowedOrigins entry: ${o} (wildcards are not allowed)`);
+    trusted.add(n);
+  }
+  const transparent = options.transparent ?? false;
+  const passthrough = options.passthrough ?? transparent;
+  const lazy = options.lazy ?? true;
+  const position = options.position ?? "inline";
+  const handshakeTimeout = options.handshakeTimeout ?? 2e4;
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-xiaochun", "");
+  const ws = wrapper.style;
+  ws.position = position === "inline" ? "relative" : "fixed";
+  ws.width = css(options.width, "320px");
+  ws.height = css(options.height, "480px");
+  ws.maxWidth = "100%";
+  ws.overflow = "visible";
+  ws.contain = "layout style";
+  ws.borderRadius = "var(--xc-radius, 0)";
+  ws.boxShadow = "var(--xc-shadow, none)";
+  if (!transparent) ws.background = "var(--xc-bg, transparent)";
+  if (position === "bottom-right") {
+    ws.right = "var(--xc-offset-x, 16px)";
+    ws.bottom = "var(--xc-offset-y, 16px)";
+  }
+  if (position === "bottom-left") {
+    ws.left = "var(--xc-offset-x, 16px)";
+    ws.bottom = "var(--xc-offset-y, 16px)";
+  }
+  if (position !== "inline") ws.zIndex = `var(--xc-z-index, ${options.zIndex ?? 2147483e3})`;
+  ws.pointerEvents = "none";
+  wrapper.setAttribute("part", "wrapper");
+  container.appendChild(wrapper);
+  let placeholderEl = null;
+  if (options.placeholder !== false) {
+    if (options.placeholder instanceof HTMLElement) placeholderEl = options.placeholder;
+    else {
+      const img = document.createElement("img");
+      img.src = options.placeholder || FALLBACK_PLACEHOLDER;
+      img.alt = "Project XiaoChun";
+      img.decoding = "async";
+      img.width = 320;
+      img.height = 480;
+      placeholderEl = img;
+    }
+    const ps = placeholderEl.style;
+    placeholderEl.setAttribute("part", "placeholder");
+    ps.borderRadius = "var(--xc-radius, 0)";
+    ps.position = "absolute";
+    ps.inset = "0";
+    ps.width = "100%";
+    ps.height = "100%";
+    ps.objectFit = "contain";
+    ps.transition = "opacity .25s ease";
+    ps.pointerEvents = "auto";
+    ps.cursor = lazy === false ? "default" : "pointer";
+    placeholderEl.addEventListener("click", () => activate());
+    wrapper.appendChild(placeholderEl);
+  }
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (ev, payload) => {
+    listeners.get(ev)?.forEach((cb) => {
+      try {
+        cb(payload);
+      } catch (e) {
+        console.error("[project-xiaochun] listener error", e);
+      }
+    });
+  };
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((res, rej) => {
+    resolveReady = res;
+    rejectReady = rej;
+  });
+  ready.catch(() => {
+  });
+  let iframe = null;
+  let port = null;
+  let destroyed = false;
+  let userPaused = false;
+  let autoPaused = false;
+  let loaded = false;
+  let lastHit = false;
+  const queue = [];
+  const pending = /* @__PURE__ */ new Map();
+  let idSeq = 0;
+  let handshakeTimer = null;
+  let io = null;
+  let idleHandle = null;
+  const postToFrame = (type, payload, id, transfer) => {
+    if (!port) {
+      queue.push({ type, payload, id, transfer });
+      return;
+    }
+    port.postMessage(xcMessage(type, payload, id), transfer ?? []);
+  };
+  const send = (type, payload, wait = false, transfer, fixedId) => {
+    if (destroyed) return Promise.reject(new Error("[project-xiaochun] instance destroyed"));
+    if (!iframe) activate();
+    const id = fixedId ?? `c${++idSeq}`;
+    const p = wait ? new Promise((resolve, reject) => pending.set(id, { resolve, reject, sawEnd: false })) : Promise.resolve();
+    postToFrame(type, payload, id, transfer);
+    return p;
+  };
+  const toBuffer = (d) => d instanceof ArrayBuffer ? d : d.buffer.slice(d.byteOffset, d.byteOffset + d.byteLength);
+  const bindAbort = (signal, id) => {
+    if (!signal) return;
+    const abort = () => {
+      if (!destroyed) postToFrame("xc.audio.end", { abort: true }, id);
+    };
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+  };
+  const speakAudio = async (source, opts = {}) => {
+    if (destroyed) throw new Error("[project-xiaochun] instance destroyed");
+    if (!iframe) activate();
+    const { signal, transfer, fetch: fetchWhere, ...rest } = opts;
+    const payload = { ...rest };
+    const list = [];
+    if (typeof source === "string") {
+      if (fetchWhere === "frame") payload.source = source;
+      else {
+        const res = await fetch(source);
+        if (!res.ok) throw new Error(`[project-xiaochun] audio fetch failed: HTTP ${res.status}`);
+        const buf = await res.arrayBuffer();
+        payload.source = buf;
+        list.push(buf);
+        payload.mimeType ?? (payload.mimeType = res.headers.get("content-type") ?? void 0);
+      }
+    } else if (typeof Blob !== "undefined" && source instanceof Blob) {
+      payload.source = source;
+      payload.mimeType ?? (payload.mimeType = source.type || void 0);
+    } else {
+      const buf = toBuffer(source);
+      payload.source = buf;
+      if (!(source instanceof ArrayBuffer) || transfer !== false) list.push(buf);
+    }
+    if (destroyed) throw new Error("[project-xiaochun] instance destroyed");
+    const id = `c${++idSeq}`;
+    const done = send("xc.audio", payload, true, list, id);
+    bindAbort(signal, id);
+    return done;
+  };
+  const speakAudioStream = (opts) => {
+    if (destroyed) throw new Error("[project-xiaochun] instance destroyed");
+    const { signal, transfer, fetch: _f, mimeType: _m, ...rest } = opts;
+    const id = `c${++idSeq}`;
+    let started = false;
+    let ended = false;
+    let fmt = rest.format === "pcm16" || rest.format === "float32" ? rest.format : null;
+    let done = Promise.resolve();
+    const handle2 = {
+      write(data) {
+        if (ended) throw new Error("[project-xiaochun] audio stream already ended");
+        if (destroyed) throw new Error("[project-xiaochun] instance destroyed");
+        if (data instanceof Int16Array) fmt ?? (fmt = "pcm16");
+        else if (data instanceof Float32Array) fmt ?? (fmt = "float32");
+        if (!fmt) throw new Error("[project-xiaochun] speakAudioStream: set opts.format when writing raw ArrayBuffers");
+        const buf = toBuffer(data);
+        const body = { data: buf, format: fmt, sampleRate: rest.sampleRate, channels: rest.channels };
+        if (!started) {
+          started = true;
+          body.text = rest.text;
+          body.motion = rest.motion;
+          body.lipsync = rest.lipsync;
+          done = send("xc.audio.chunk", body, true, [buf], id);
+          bindAbort(signal, id);
+        } else {
+          postToFrame("xc.audio.chunk", body, id, !(data instanceof ArrayBuffer) || transfer !== false ? [buf] : []);
+        }
+      },
+      end() {
+        if (ended) return;
+        ended = true;
+        if (started) postToFrame("xc.audio.end", {}, id);
+      },
+      abort() {
+        if (ended && !started) return;
+        ended = true;
+        if (started) postToFrame("xc.audio.end", { abort: true }, id);
+      },
+      get done() {
+        return done;
+      }
+    };
+    return handle2;
+  };
+  function buildUrl() {
+    const u = new URL(srcUrl.href);
+    u.searchParams.set("host", window.location.origin);
+    if (transparent) u.searchParams.set("transparent", "1");
+    if (options.ui) u.searchParams.set("ui", "1");
+    if (options.lang) u.searchParams.set("lang", options.lang);
+    if (options.heavy) u.searchParams.set("heavy", options.heavy);
+    if (options.controls) u.searchParams.set("controls", "1");
+    if (options.model) u.searchParams.set("outfit", options.model);
+    return u.href;
+  }
+  function activate() {
+    if (destroyed || iframe) return;
+    cancelIdle();
+    io?.disconnect();
+    io = null;
+    const f = document.createElement("iframe");
+    f.title = "Project XiaoChun";
+    f.loading = "lazy";
+    f.allow = "microphone; autoplay";
+    f.referrerPolicy = "strict-origin-when-cross-origin";
+    if (options.sandbox !== false) {
+      f.setAttribute("sandbox", options.sandbox ?? "allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox");
+    }
+    f.setAttribute("allowtransparency", "true");
+    f.setAttribute("scrolling", "no");
+    const s = f.style;
+    s.position = "absolute";
+    s.inset = "0";
+    s.width = "100%";
+    s.height = "100%";
+    s.border = "0";
+    s.background = "transparent";
+    s.colorScheme = "normal";
+    s.borderRadius = "var(--xc-radius, 0)";
+    f.setAttribute("part", "iframe");
+    s.opacity = "0";
+    s.transition = "opacity .25s ease";
+    s.pointerEvents = passthrough ? "none" : "auto";
+    f.src = buildUrl();
+    iframe = f;
+    wrapper.appendChild(f);
+    if (placeholderEl) placeholderEl.style.cursor = "default";
+    handshakeTimer = setTimeout(() => {
+      if (!port) emit("error", { code: "timeout", message: `no xc.ready from ${frameOrigin} within ${handshakeTimeout}ms` });
+    }, handshakeTimeout);
+    setupAutoPause();
+    setupPassthrough();
+  }
+  const onWindowMessage = (ev) => {
+    if (destroyed || !iframe || ev.source !== iframe.contentWindow) return;
+    if (!trusted.has(ev.origin)) {
+      emit("error", { code: "origin_denied", message: `ignored message from untrusted origin ${ev.origin}` });
+      return;
+    }
+    const data = ev.data;
+    if (!isXcEnvelope(data) || data.type !== "xc.ready" || port) return;
+    const ch = new MessageChannel();
+    port = ch.port1;
+    port.onmessage = onPortMessage;
+    iframe.contentWindow.postMessage(
+      xcMessage("xc.init", { hostOrigin: window.location.origin }),
+      ev.origin,
+      [ch.port2]
+    );
+    if (handshakeTimer) {
+      clearTimeout(handshakeTimer);
+      handshakeTimer = null;
+    }
+    emit("handshake", data.payload);
+    for (const m of queue.splice(0)) port.postMessage(xcMessage(m.type, m.payload, m.id), m.transfer ?? []);
+    syncPause();
+  };
+  window.addEventListener("message", onWindowMessage);
+  function onPortMessage(ev) {
+    const data = ev.data;
+    if (!isXcEnvelope(data)) return;
+    switch (data.type) {
+      case "xc.load.progress":
+        emit("progress", data.payload);
+        break;
+      case "xc.loaded":
+        if (!loaded) {
+          loaded = true;
+          if (iframe) iframe.style.opacity = "1";
+          if (placeholderEl) {
+            const el = placeholderEl;
+            el.style.opacity = "0";
+            el.style.pointerEvents = "none";
+            setTimeout(() => el.remove(), 300);
+            placeholderEl = null;
+          }
+          resolveReady();
+        }
+        emit("ready", data.payload);
+        break;
+      case "xc.state":
+        emit("state", data.payload);
+        break;
+      case "xc.stt":
+        emit("stt", data.payload);
+        break;
+      case "xc.utterance": {
+        emit("utterance", data.payload);
+        const p = data.id ? pending.get(data.id) : void 0;
+        if (p && data.payload.phase === "end") {
+          pending.delete(data.id);
+          p.resolve();
+        }
+        break;
+      }
+      case "xc.hit-region": {
+        const { hit } = data.payload;
+        emit("hit-region", data.payload);
+        if (passthrough && iframe && hit !== lastHit) {
+          lastHit = hit;
+          iframe.style.pointerEvents = hit ? "auto" : "none";
+        }
+        break;
+      }
+      case "xc.error": {
+        const { code, message, command } = data.payload;
+        emit("error", { code, message, command });
+        const p = data.id ? pending.get(data.id) : void 0;
+        if (p && data.id) {
+          pending.delete(data.id);
+          p.reject(new Error(`[${code}] ${message}`));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  let pointerRaf = 0;
+  let lastPtr = null;
+  const onHostPointer = (e) => {
+    if (!iframe || !port || iframe.style.pointerEvents === "auto") return;
+    lastPtr = { x: e.clientX, y: e.clientY };
+    if (pointerRaf) return;
+    pointerRaf = requestAnimationFrame(() => {
+      pointerRaf = 0;
+      if (!iframe || !port || !lastPtr) return;
+      const r = iframe.getBoundingClientRect();
+      const x = lastPtr.x - r.left, y = lastPtr.y - r.top;
+      if (x < 0 || y < 0 || x > r.width || y > r.height) {
+        if (lastHit) {
+          lastHit = false;
+          iframe.style.pointerEvents = "none";
+        }
+        return;
+      }
+      port.postMessage(xcMessage("xc.pointer", { x, y }));
+    });
+  };
+  function setupPassthrough() {
+    if (passthrough) window.addEventListener("pointermove", onHostPointer, { passive: true });
+  }
+  let pauseIo = null;
+  function setupAutoPause() {
+    if (options.autoPause === false || typeof IntersectionObserver === "undefined") return;
+    pauseIo = new IntersectionObserver((entries) => {
+      const visible = entries[entries.length - 1]?.isIntersecting ?? true;
+      autoPaused = !visible;
+      syncPause();
+    });
+    pauseIo.observe(wrapper);
+  }
+  let sentPaused = false;
+  function syncPause() {
+    if (!port) return;
+    const want = userPaused || autoPaused;
+    if (want === sentPaused) return;
+    sentPaused = want;
+    port.postMessage(xcMessage(want ? "xc.pause" : "xc.resume"));
+  }
+  function cancelIdle() {
+    if (idleHandle === null) return;
+    const w = window;
+    if (w.cancelIdleCallback) w.cancelIdleCallback(idleHandle);
+    else clearTimeout(idleHandle);
+    idleHandle = null;
+  }
+  function scheduleLazy() {
+    if (lazy === false) {
+      activate();
+      return;
+    }
+    if (lazy === "click") return;
+    const go = () => {
+      const w = window;
+      idleHandle = w.requestIdleCallback ? w.requestIdleCallback(() => {
+        idleHandle = null;
+        activate();
+      }, { timeout: 3e3 }) : setTimeout(activate, 1200);
+    };
+    if (typeof IntersectionObserver === "undefined") {
+      go();
+      return;
+    }
+    io = new IntersectionObserver((entries) => {
+      if (entries.some((e) => e.isIntersecting)) {
+        io?.disconnect();
+        io = null;
+        go();
+      }
+    }, { rootMargin: `${options.lazyMargin ?? 200}px` });
+    io.observe(wrapper);
+  }
+  let handle = null;
+  if (options.draggable && position !== "inline") {
+    handle = document.createElement("div");
+    handle.setAttribute("aria-label", "drag");
+    Object.assign(handle.style, {
+      position: "absolute",
+      left: "0",
+      top: "0",
+      width: "28px",
+      height: "28px",
+      cursor: "grab",
+      pointerEvents: "auto",
+      borderRadius: "8px",
+      background: "rgba(0,0,0,.25)",
+      color: "#fff",
+      font: "14px/28px system-ui",
+      textAlign: "center",
+      userSelect: "none",
+      touchAction: "none",
+      zIndex: "2",
+      opacity: "0.5"
+    });
+    handle.textContent = "\u283F";
+    let drag = null;
+    handle.addEventListener("pointerdown", (e) => {
+      const r = wrapper.getBoundingClientRect();
+      drag = { dx: e.clientX - r.left, dy: e.clientY - r.top };
+      handle.setPointerCapture(e.pointerId);
+    });
+    handle.addEventListener("pointermove", (e) => {
+      if (!drag) return;
+      ws.left = `${Math.min(Math.max(0, e.clientX - drag.dx), window.innerWidth - 40)}px`;
+      ws.top = `${Math.min(Math.max(0, e.clientY - drag.dy), window.innerHeight - 40)}px`;
+      ws.right = "auto";
+      ws.bottom = "auto";
+    });
+    const end = () => {
+      drag = null;
+    };
+    handle.addEventListener("pointerup", end);
+    handle.addEventListener("pointercancel", end);
+    wrapper.appendChild(handle);
+  }
+  scheduleLazy();
+  const api = {
+    element: wrapper,
+    get iframe() {
+      return iframe;
+    },
+    ready,
+    activate,
+    say: (text, opts) => send("xc.say", { text, mode: opts?.mode }, true),
+    speakAudio,
+    speakAudioStream,
+    motion: (m) => send("xc.motion", typeof m === "string" ? m.startsWith("http") || m.startsWith("/") ? { url: m } : { name: m } : m),
+    expression: (name) => send("xc.expression", { name }),
+    lookAt: (x, y) => send("xc.lookAt", { x, y }),
+    setModel: (m) => send("xc.setModel", typeof m === "string" ? /^(https?:)?\/|\.vrm/i.test(m) ? { url: m } : { outfit: m } : m),
+    setConfig: (cfg) => send("xc.setConfig", cfg),
+    startListening: () => send("xc.mic", { enabled: true }),
+    stopListening: () => send("xc.mic", { enabled: false }),
+    mic: (enabled) => send("xc.mic", { enabled }),
+    pause() {
+      userPaused = true;
+      syncPause();
+    },
+    resume() {
+      userPaused = false;
+      syncPause();
+    },
+    destroy() {
+      if (destroyed) return;
+      try {
+        port?.postMessage(xcMessage("xc.destroy"));
+      } catch {
+      }
+      destroyed = true;
+      cancelIdle();
+      io?.disconnect();
+      pauseIo?.disconnect();
+      if (handshakeTimer) clearTimeout(handshakeTimer);
+      if (pointerRaf) cancelAnimationFrame(pointerRaf);
+      window.removeEventListener("message", onWindowMessage);
+      window.removeEventListener("pointermove", onHostPointer);
+      try {
+        port?.close();
+      } catch {
+      }
+      port = null;
+      for (const p of pending.values()) p.reject(new Error("[project-xiaochun] instance destroyed"));
+      pending.clear();
+      queue.length = 0;
+      if (!loaded) rejectReady(new Error("[project-xiaochun] destroyed before ready"));
+      wrapper.remove();
+      iframe = null;
+      emit("destroy", void 0);
+      listeners.clear();
+    },
+    on(event, cb) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(cb);
+      return () => {
+        set.delete(cb);
+      };
+    }
+  };
+  return api;
+}
+
+// src/avatar-element.ts
+var OBSERVED = [
+  "src",
+  "model",
+  "lang",
+  "mic",
+  "transparent",
+  "draggable",
+  "position",
+  "size",
+  "lazy",
+  "paused",
+  "placeholder",
+  "heavy",
+  "ui",
+  "controls",
+  "allowed-origins"
+];
+var REBUILD = /* @__PURE__ */ new Set(["src", "draggable", "position", "size", "lazy", "placeholder", "heavy", "ui", "controls", "allowed-origins", "transparent"]);
+function boolAttr(el, name, dflt) {
+  const v = el.getAttribute(name);
+  if (v === null) return dflt;
+  return v !== "false";
+}
+function parseSize(v) {
+  if (!v) return { width: "320px", height: "480px" };
+  const m = v.trim().split(/x/i);
+  const px = (s) => /^\d+(\.\d+)?$/.test(s) ? `${s}px` : s;
+  if (m.length >= 2) return { width: px(m[0]), height: px(m[1]) };
+  const w = parseFloat(m[0]);
+  return Number.isFinite(w) && /^\d+(\.\d+)?$/.test(m[0]) ? { width: `${w}px`, height: `${Math.round(w * 1.5)}px` } : { width: m[0], height: "480px" };
+}
+function createElementClass() {
+  class XiaochunAvatarElementImpl extends HTMLElement {
+    constructor() {
+      super(...arguments);
+      /** 底层 SDK 实例 (连接 DOM 后可用)。 */
+      this.client = null;
+      this.mountEl = null;
+      this.rebuildScheduled = false;
+    }
+    static get observedAttributes() {
+      return [...OBSERVED];
+    }
+    connectedCallback() {
+      if (!this.shadowRoot) {
+        const root = this.attachShadow({ mode: "open" });
+        root.innerHTML = '<style>:host{display:inline-block;max-width:100%}:host([hidden]){display:none}</style><div part="mount"></div>';
+      }
+      this.mountEl = this.shadowRoot.querySelector("div");
+      this.build();
+    }
+    disconnectedCallback() {
+      this.destroy();
+    }
+    attributeChangedCallback(name, oldV, newV) {
+      if (!this.client || oldV === newV) return;
+      if (REBUILD.has(name)) {
+        if (!this.rebuildScheduled) {
+          this.rebuildScheduled = true;
+          queueMicrotask(() => {
+            this.rebuildScheduled = false;
+            if (this.isConnected) {
+              this.destroy();
+              this.build();
+            }
+          });
+        }
+        return;
+      }
+      const c = this.client;
+      if (name === "model" && newV) void c.setModel(newV).catch(() => {
+      });
+      else if (name === "lang" && newV) void c.setConfig({ lang: newV }).catch(() => {
+      });
+      else if (name === "mic") void c.mic(boolAttr(this, "mic", false)).catch(() => {
+      });
+      else if (name === "paused") {
+        if (boolAttr(this, "paused", false)) c.pause();
+        else c.resume();
+      }
+    }
+    build() {
+      if (!this.mountEl || this.client) return;
+      const { width, height } = parseSize(this.getAttribute("size"));
+      const placeholder = this.getAttribute("placeholder");
+      const allowed = this.getAttribute("allowed-origins");
+      const lazyAttr = this.getAttribute("lazy");
+      const lazy = lazyAttr === "click" ? "click" : lazyAttr === "false" ? false : true;
+      const c = createXiaochun({
+        container: this.mountEl,
+        src: this.getAttribute("src") || void 0,
+        allowedOrigins: allowed ? allowed.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+        lazy,
+        placeholder: placeholder === "none" ? false : placeholder || void 0,
+        transparent: boolAttr(this, "transparent", true),
+        // 悬浮头像默认透明
+        width,
+        height,
+        position: this.getAttribute("position") ?? "inline",
+        draggable: boolAttr(this, "draggable", false),
+        lang: this.getAttribute("lang") ?? void 0,
+        model: this.getAttribute("model") ?? void 0,
+        heavy: this.getAttribute("heavy") ?? void 0,
+        ui: boolAttr(this, "ui", false),
+        controls: boolAttr(this, "controls", false)
+      });
+      this.client = c;
+      const fwd = (ev, name) => c.on(ev, (detail) => this.dispatchEvent(new CustomEvent(name, { detail, bubbles: true, composed: true })));
+      fwd("ready", "xc-ready");
+      fwd("progress", "xc-progress");
+      fwd("state", "xc-state");
+      fwd("stt", "xc-stt");
+      fwd("utterance", "xc-utterance");
+      fwd("error", "xc-error");
+      if (boolAttr(this, "paused", false)) c.pause();
+      if (boolAttr(this, "mic", false)) void c.ready.then(() => c.mic(true)).catch(() => {
+      });
+    }
+    say(text, opts) {
+      return this.requireClient().say(text, opts);
+    }
+    speakAudio(source, opts) {
+      return this.requireClient().speakAudio(source, opts);
+    }
+    speakAudioStream(opts) {
+      return this.requireClient().speakAudioStream(opts);
+    }
+    motion(m) {
+      return this.requireClient().motion(m);
+    }
+    expression(name) {
+      return this.requireClient().expression(name);
+    }
+    destroy() {
+      this.client?.destroy();
+      this.client = null;
+    }
+    requireClient() {
+      if (!this.client) throw new Error("<xiaochun-avatar> is not connected");
+      return this.client;
+    }
+  }
+  return XiaochunAvatarElementImpl;
+}
+var XIAOCHUN_ELEMENT_TAG = "xiaochun-avatar";
+function defineXiaochunElement(tag = XIAOCHUN_ELEMENT_TAG) {
+  if (typeof customElements === "undefined" || typeof HTMLElement === "undefined") return null;
+  const existing = customElements.get(tag);
+  if (existing) return existing;
+  const ctor = createElementClass();
+  customElements.define(tag, ctor);
+  return ctor;
+}
+
+// src/protocol-url.ts
+var XIAOCHUN_PROTOCOL_SCHEME = "xiaochun";
+function toProtocolUrl(a) {
+  if (a.action !== "speak") throw new Error(`[project-xiaochun] unsupported action: ${String(a.action)}`);
+  if (!a.text && !a.audioUrl && !a.file) throw new Error("[project-xiaochun] speak needs text, audioUrl or file");
+  if (a.audioUrl && !/^https?:\/\//i.test(a.audioUrl)) throw new Error("[project-xiaochun] audioUrl must be http(s)");
+  const q = new URLSearchParams();
+  if (a.text) q.set("text", a.text);
+  if (a.audioUrl) q.set("audioUrl", a.audioUrl);
+  if (a.file) q.set("file", a.file);
+  return `${XIAOCHUN_PROTOCOL_SCHEME}://speak?${q.toString().replace(/\+/g, "%20")}`;
+}
+function parseProtocolUrl(url) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return null;
+  }
+  if (u.protocol !== `${XIAOCHUN_PROTOCOL_SCHEME}:`) return null;
+  const name = u.hostname || u.pathname.replace(/^\/+/, "");
+  const action = name === "action" ? u.searchParams.get("action") : name;
+  if (action !== "speak") return null;
+  const out = { action: "speak" };
+  const text = u.searchParams.get("text");
+  const audioUrl = u.searchParams.get("audioUrl");
+  const file = u.searchParams.get("file");
+  if (text) out.text = text;
+  if (audioUrl) out.audioUrl = audioUrl;
+  if (file) out.file = file;
+  return out.text || out.audioUrl || out.file ? out : null;
+}
+//# sourceMappingURL=index.cjs.map