@firetable/project-xiaochun 0.1.13 → 0.1.15

package/dist/chunks/chunk-KQSKHPVF.js

@@ -0,0 +1,957 @@
+/*! @firetable/project-xiaochun v0.1.15 | MIT | https://github.com/FireTable/project-xiaochun */
+import {
+  XC_DEFAULT_SRC,
+  XC_UI_PARTS,
+  XC_WINDOW_CORNER_RADIUS,
+  isXcEnvelope,
+  isXcId,
+  normalizeOrigin,
+  normalizeXcUiOption,
+  xcMessage
+} from "./chunk-KKRZ3SUD.js";
+
+// src/gesture-box.ts
+var DEFAULT_RESIZE_LIMITS = Object.freeze({
+  minWidth: 120,
+  minHeight: 180,
+  maxWidth: Infinity,
+  maxHeight: Infinity
+});
+var finitePositive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+function normalizeResizable(v) {
+  if (!v) return null;
+  const o = v === true ? {} : v;
+  const minWidth = finitePositive(o.minWidth) ? o.minWidth : DEFAULT_RESIZE_LIMITS.minWidth;
+  const minHeight = finitePositive(o.minHeight) ? o.minHeight : DEFAULT_RESIZE_LIMITS.minHeight;
+  const maxWidth = finitePositive(o.maxWidth) ? Math.max(o.maxWidth, minWidth) : Infinity;
+  const maxHeight = finitePositive(o.maxHeight) ? Math.max(o.maxHeight, minHeight) : Infinity;
+  return { minWidth, minHeight, maxWidth, maxHeight };
+}
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), Math.max(lo, hi));
+function moveBox(start, totalDx, totalDy, vp) {
+  return {
+    left: clamp(start.left + totalDx, 0, vp.width - start.width),
+    top: clamp(start.top + totalDy, 0, vp.height - start.height),
+    width: start.width,
+    height: start.height
+  };
+}
+function resizeBox(start, corner, totalDx, totalDy, limits, vp) {
+  const west = corner === "NW" || corner === "SW";
+  const north = corner === "NW" || corner === "NE";
+  const right = start.left + start.width, bottom = start.top + start.height;
+  const wantW = west ? start.width - totalDx : start.width + totalDx;
+  const wantH = north ? start.height - totalDy : start.height + totalDy;
+  const roomW = west ? right : vp.width - start.left;
+  const roomH = north ? bottom : vp.height - start.top;
+  const width = clamp(wantW, limits.minWidth, Math.min(limits.maxWidth, roomW));
+  const height = clamp(wantH, limits.minHeight, Math.min(limits.maxHeight, roomH));
+  return { left: west ? right - width : start.left, top: north ? bottom - height : start.top, width, height };
+}
+function fitBox(b, vp) {
+  const width = Math.min(b.width, Math.max(1, vp.width)), height = Math.min(b.height, Math.max(1, vp.height));
+  return { left: clamp(b.left, 0, vp.width - width), top: clamp(b.top, 0, vp.height - height), width, height };
+}
+var CORNERS = /* @__PURE__ */ new Set(["NW", "NE", "SW", "SE"]);
+var PHASES = /* @__PURE__ */ new Set(["start", "move", "end"]);
+var REASONS = /* @__PURE__ */ new Set(["up", "cancel", "blur"]);
+var MAX_GESTURE_DELTA = 2e4;
+var delta = (v) => typeof v === "number" && Number.isFinite(v) && Math.abs(v) <= MAX_GESTURE_DELTA;
+var counter = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+function parseGesturePayload(kind, raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const p = raw;
+  if (!counter(p.gesture) || !counter(p.seq) || typeof p.phase !== "string" || !PHASES.has(p.phase)) return null;
+  if (!delta(p.dx) || !delta(p.dy) || !delta(p.totalDx) || !delta(p.totalDy)) return null;
+  if (p.reason !== void 0 && (typeof p.reason !== "string" || !REASONS.has(p.reason))) return null;
+  const out = { gesture: p.gesture, seq: p.seq, phase: p.phase, totalDx: p.totalDx, totalDy: p.totalDy };
+  if (kind === "resize") {
+    if (typeof p.corner !== "string" || !CORNERS.has(p.corner)) return null;
+    out.corner = p.corner;
+  }
+  return out;
+}
+var GestureGate = class {
+  constructor() {
+    this.lastGesture = 0;
+    this.lastSeq = -1;
+    this.open = false;
+  }
+  get active() {
+    return this.open;
+  }
+  accept(p) {
+    if (p.phase === "start") {
+      if (p.gesture <= this.lastGesture || p.seq !== 0) return false;
+      this.lastGesture = p.gesture;
+      this.lastSeq = 0;
+      this.open = true;
+      return true;
+    }
+    if (!this.open || p.gesture !== this.lastGesture || p.seq <= this.lastSeq) return false;
+    this.lastSeq = p.seq;
+    if (p.phase === "end") this.open = false;
+    return true;
+  }
+  /** 宿主主动结束 (关闭手势 / 销毁): 之后同一手势的迟到消息被拒绝。 */
+  close() {
+    this.open = false;
+  }
+};
+
+// 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 prefsKey = options.persist === "host" ? "xiaochun:prefs" : typeof options.persist === "string" && options.persist ? options.persist : null;
+  const readPrefs = () => {
+    if (!prefsKey) return {};
+    try {
+      const raw = JSON.parse(window.localStorage.getItem(prefsKey) ?? "null");
+      const out = {};
+      if (raw && typeof raw === "object") {
+        if (isXcId(raw.outfit)) out.outfit = raw.outfit;
+        if (isXcId(raw.scene)) out.scene = raw.scene;
+      }
+      return out;
+    } catch {
+      return {};
+    }
+  };
+  const writePrefs = (patch) => {
+    if (!prefsKey) return;
+    try {
+      const next = { ...readPrefs() };
+      for (const [k, v] of Object.entries(patch)) {
+        if (v) next[k] = v;
+        else delete next[k];
+      }
+      window.localStorage.setItem(prefsKey, JSON.stringify(next));
+    } catch {
+    }
+  };
+  const prefs = readPrefs();
+  if (options.model !== void 0 && options.outfit === void 0) {
+    console.warn('[project-xiaochun] option "model" is deprecated, use "outfit" (built-in outfit id).');
+  }
+  const uiParse = normalizeXcUiOption(options.ui);
+  const uiParts = uiParse.parts;
+  if (uiParse.legacy) console.warn(`[project-xiaochun] option "ui: true" is deprecated, use an array of parts, e.g. ui: ['chat', 'bubble', 'outfit', 'scene'].`);
+  if (uiParse.unknown.length) console.warn(`[project-xiaochun] ignoring unknown ui part(s): ${uiParse.unknown.join(", ")} (known: ${XC_UI_PARTS.join(", ")})`);
+  const outfitOpt = options.outfit ?? (isXcId(options.model) ? options.model : void 0);
+  const initialOutfit = outfitOpt ?? prefs.outfit;
+  const initialScene = options.scene ?? prefs.scene ?? (options.transparent ? "transparent" : void 0);
+  let transparent = initialScene === "transparent" || initialScene !== "light" && initialScene !== "dark" && (options.transparent ?? false);
+  let 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.boxShadow = "var(--xc-shadow, none)";
+  const applyWrapperBg = () => {
+    ws.background = transparent ? "" : "var(--xc-bg, transparent)";
+  };
+  applyWrapperBg();
+  let radiusOpt = options.borderRadius;
+  const radiusValue = () => radiusOpt !== void 0 ? css(radiusOpt, "0px") : transparent ? "0px" : `${XC_WINDOW_CORNER_RADIUS}px`;
+  const applyRadius = () => {
+    const v = `var(--xc-radius, ${radiusValue()})`;
+    ws.borderRadius = v;
+    if (placeholderEl) placeholderEl.style.borderRadius = v;
+    if (iframe) iframe.style.borderRadius = v;
+  };
+  ws.borderRadius = `var(--xc-radius, ${radiusValue()})`;
+  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, ${radiusValue()})`;
+    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;
+  let caps = null;
+  let currentOutfit = null;
+  let currentScene = null;
+  const queue = [];
+  const pending = /* @__PURE__ */ new Map();
+  let idSeq = 0;
+  let handshakeTimer = null;
+  let io = null;
+  let idleHandle = null;
+  let resolveHandshake;
+  const handshaked = new Promise((res) => {
+    resolveHandshake = res;
+  });
+  const failLocal = (type, id, code, message) => {
+    emit("error", { code, message, command: type });
+    const p = id ? pending.get(id) : void 0;
+    if (p && id) {
+      pending.delete(id);
+      p.reject(new Error(`[${code}] ${message}`));
+    }
+  };
+  const unsupportedByFrame = (type, id) => failLocal(type, id, "unsupported", `${type} is not supported by this /embed deployment (older version; its xc.ready has no capabilities for it)`);
+  const postToFrame = (type, payload, id, transfer, requires) => {
+    if (!port) {
+      queue.push({ type, payload, id, transfer, requires });
+      return;
+    }
+    if (requires && !caps?.[requires]) {
+      unsupportedByFrame(type, id);
+      return;
+    }
+    port.postMessage(xcMessage(type, payload, id), transfer ?? []);
+  };
+  const send = (type, payload, wait = false, transfer, fixedId, requires) => {
+    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, requires);
+    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 handle = {
+      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 handle;
+  };
+  function buildUrl() {
+    const u = new URL(srcUrl.href);
+    u.searchParams.set("host", window.location.origin);
+    if (transparent) u.searchParams.set("transparent", "1");
+    if (uiParts.length) u.searchParams.set("ui", uiParts.join(","));
+    if (options.lang) u.searchParams.set("lang", options.lang);
+    if (options.heavy) u.searchParams.set("heavy", options.heavy);
+    if (options.controls === false) u.searchParams.set("controls", "0");
+    if (initialScene && isXcId(initialScene)) u.searchParams.set("scene", initialScene);
+    if (initialOutfit) u.searchParams.set("outfit", initialOutfit);
+    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 = options.crossOriginIsolated === true ? "microphone; autoplay; cross-origin-isolated" : "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, ${radiusValue()})`;
+    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();
+    if (passthrough) enablePassthrough();
+  }
+  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;
+    caps = data.payload?.capabilities ?? null;
+    const gWant = wantGestures();
+    sentGestures = gWant;
+    const initConfig = {
+      ...options.allowCustomModel ? { allowCustomModel: true } : {},
+      ...gWant.move || gWant.resize ? { gestures: gWant } : {}
+    };
+    iframe.contentWindow.postMessage(
+      xcMessage("xc.init", { hostOrigin: window.location.origin, ...Object.keys(initConfig).length ? { config: initConfig } : {} }),
+      ev.origin,
+      [ch.port2]
+    );
+    warnGestureUnsupported();
+    if (handshakeTimer) {
+      clearTimeout(handshakeTimer);
+      handshakeTimer = null;
+    }
+    emit("handshake", data.payload);
+    resolveHandshake();
+    for (const m of queue.splice(0)) {
+      if (m.requires && !caps?.[m.requires]) unsupportedByFrame(m.type, m.id);
+      else port.postMessage(xcMessage(m.type, m.payload, m.id), m.transfer ?? []);
+    }
+    syncPause();
+  };
+  window.addEventListener("message", onWindowMessage);
+  function ack(id, value) {
+    const p = id ? pending.get(id) : void 0;
+    if (p && id) {
+      pending.delete(id);
+      p.resolve(value);
+    }
+  }
+  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 (options.prefetch && options.heavy === "eager" && caps?.prefetch) {
+            const ids = Array.isArray(options.prefetch) ? options.prefetch : void 0;
+            void api.prefetch(ids).catch(() => {
+            });
+          }
+          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.outfit-changed": {
+        const pl = data.payload;
+        if (!pl.noop) {
+          currentOutfit = pl.id;
+          emit("outfit-changed", pl);
+          if (!pl.initial && pl.id) writePrefs({ outfit: pl.id });
+        }
+        ack(data.id);
+        break;
+      }
+      case "xc.scene-changed": {
+        const pl = data.payload;
+        currentScene = pl.id;
+        if (pl.transparent !== transparent) applyTransparency(pl.transparent);
+        if (!pl.noop) {
+          emit("scene-changed", pl);
+          if (!pl.initial) writePrefs({ scene: pl.id });
+        }
+        ack(data.id);
+        break;
+      }
+      case "xc.prefetched":
+        ack(data.id, 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.gesture-move":
+        onGesture("move", data.payload);
+        break;
+      case "xc.gesture-resize":
+        onGesture("resize", data.payload);
+        break;
+      case "xc.error": {
+        const { code, message, command } = data.payload;
+        emit("error", { code, message, command });
+        if (code === "unknown_id" && (command === "outfit" || command === "scene")) writePrefs({ [command]: null });
+        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;
+    }
+  }
+  const POINTER_MIN_INTERVAL_MS = 32;
+  const POINTER_MIN_MOVE_PX = 2;
+  let pointerRaf = 0;
+  let lastPtr = null;
+  let lastPosted = null;
+  let rectCache = null;
+  let rectRo = null;
+  let rectAt = 0;
+  const invalidateRect = () => {
+    rectCache = null;
+  };
+  const getRect = () => {
+    if (!iframe) return null;
+    const now = performance.now();
+    if (!rectCache || now - rectAt > 400) {
+      rectCache = iframe.getBoundingClientRect();
+      rectAt = now;
+    }
+    return rectCache;
+  };
+  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 = getRect();
+      if (!r) return;
+      const x = lastPtr.x - r.left, y = lastPtr.y - r.top;
+      if (x < 0 || y < 0 || x > r.width || y > r.height) {
+        lastPosted = null;
+        if (lastHit) {
+          lastHit = false;
+          iframe.style.pointerEvents = "none";
+        }
+        return;
+      }
+      const now = performance.now();
+      if (lastPosted && now - lastPosted.t < POINTER_MIN_INTERVAL_MS) return;
+      if (lastPosted && Math.abs(x - lastPosted.x) < POINTER_MIN_MOVE_PX && Math.abs(y - lastPosted.y) < POINTER_MIN_MOVE_PX) return;
+      lastPosted = { x, y, t: now };
+      port.postMessage(xcMessage("xc.pointer", { x, y }));
+    });
+  };
+  let passthroughActive = false;
+  function enablePassthrough() {
+    if (passthroughActive || !iframe) return;
+    passthroughActive = true;
+    window.addEventListener("pointermove", onHostPointer, { passive: true });
+    window.addEventListener("pointerdown", onHostPointer, { passive: true });
+    window.addEventListener("scroll", invalidateRect, { passive: true, capture: true });
+    window.addEventListener("resize", invalidateRect, { passive: true });
+    if (typeof ResizeObserver !== "undefined") {
+      rectRo = new ResizeObserver(invalidateRect);
+      rectRo.observe(iframe);
+    }
+  }
+  function disablePassthrough() {
+    if (!passthroughActive) return;
+    passthroughActive = false;
+    window.removeEventListener("pointermove", onHostPointer);
+    window.removeEventListener("pointerdown", onHostPointer);
+    window.removeEventListener("scroll", invalidateRect, true);
+    window.removeEventListener("resize", invalidateRect);
+    rectRo?.disconnect();
+    rectRo = null;
+    if (pointerRaf) {
+      cancelAnimationFrame(pointerRaf);
+      pointerRaf = 0;
+    }
+    lastPtr = null;
+  }
+  function applyTransparency(next) {
+    transparent = next;
+    applyWrapperBg();
+    applyRadius();
+    passthrough = next ? options.passthrough ?? true : false;
+    lastHit = false;
+    lastPosted = null;
+    rectCache = null;
+    if (passthrough) enablePassthrough();
+    else disablePassthrough();
+    if (iframe) iframe.style.pointerEvents = passthrough ? "none" : "auto";
+  }
+  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 draggableOn = options.draggable === true;
+  let resizeLimits = normalizeResizable(options.resizable);
+  const gates = { move: new GestureGate(), resize: new GestureGate() };
+  let activeGesture = null;
+  let inlineShift = { x: 0, y: 0 };
+  let userMoved = false;
+  let sentGestures = null;
+  let warnedGesture = false;
+  const viewport = () => ({
+    width: document.documentElement.clientWidth || window.innerWidth,
+    height: document.documentElement.clientHeight || window.innerHeight
+  });
+  const readBox = () => {
+    const r = wrapper.getBoundingClientRect();
+    return { left: r.left, top: r.top, width: r.width, height: r.height };
+  };
+  const wantGestures = () => ({ move: draggableOn && caps?.gestures?.move === true, resize: resizeLimits !== null && caps?.gestures?.resize === true });
+  function applyBox(b, inlineBase, withSize) {
+    if (withSize) {
+      ws.width = `${b.width}px`;
+      ws.height = `${b.height}px`;
+      ws.maxWidth = "none";
+    }
+    if (position === "inline") {
+      const base = inlineBase ?? { left: b.left - inlineShift.x, top: b.top - inlineShift.y };
+      inlineShift = { x: b.left - base.left, y: b.top - base.top };
+      ws.setProperty("translate", `${inlineShift.x}px ${inlineShift.y}px`);
+    } else {
+      ws.left = `${b.left}px`;
+      ws.top = `${b.top}px`;
+      ws.right = "auto";
+      ws.bottom = "auto";
+    }
+    userMoved = true;
+    invalidateRect();
+  }
+  let selectionLock = null;
+  function lockSelection(on) {
+    const de = document.documentElement;
+    if (on && !selectionLock) {
+      selectionLock = { us: de.style.getPropertyValue("user-select"), wus: de.style.getPropertyValue("-webkit-user-select") };
+      de.style.setProperty("user-select", "none");
+      de.style.setProperty("-webkit-user-select", "none");
+      try {
+        window.getSelection()?.removeAllRanges();
+      } catch {
+      }
+    } else if (!on && selectionLock) {
+      de.style.setProperty("user-select", selectionLock.us);
+      de.style.setProperty("-webkit-user-select", selectionLock.wus);
+      selectionLock = null;
+    }
+  }
+  function endActiveGesture(kind) {
+    if (!activeGesture || kind && activeGesture.kind !== kind) return;
+    gates[activeGesture.kind].close();
+    const b = readBox();
+    emit(activeGesture.kind, { phase: "end", ...b });
+    activeGesture = null;
+    lockSelection(false);
+  }
+  function onGesture(kind, raw) {
+    if (destroyed || !caps?.gestures) return;
+    if (kind === "move" ? !draggableOn : resizeLimits === null) return;
+    const p = parseGesturePayload(kind, raw);
+    if (!p) return;
+    if (p.phase === "start" ? activeGesture !== null : activeGesture?.kind !== kind) return;
+    if (!gates[kind].accept(p)) return;
+    if (p.phase === "start") {
+      const start = readBox();
+      activeGesture = {
+        kind,
+        start,
+        corner: p.corner,
+        inlineBase: position === "inline" ? { left: start.left - inlineShift.x, top: start.top - inlineShift.y } : null
+      };
+      lockSelection(true);
+      emit(kind, { phase: "start", ...start });
+      return;
+    }
+    const a = activeGesture;
+    const vp = viewport();
+    const next = kind === "move" ? moveBox(a.start, p.totalDx, p.totalDy, vp) : resizeBox(a.start, a.corner, p.totalDx, p.totalDy, resizeLimits, vp);
+    applyBox(next, a.inlineBase, kind === "resize");
+    emit(kind, { phase: p.phase, ...next });
+    if (p.phase === "end") {
+      activeGesture = null;
+      lockSelection(false);
+    }
+  }
+  function syncGestures() {
+    if (destroyed) return;
+    const want = wantGestures();
+    if (!want.move) endActiveGesture("move");
+    if (!want.resize) endActiveGesture("resize");
+    if (!port || !caps) return;
+    warnGestureUnsupported();
+    if (sentGestures && sentGestures.move === want.move && sentGestures.resize === want.resize) return;
+    sentGestures = want;
+    if (caps.gestures) port.postMessage(xcMessage("xc.setConfig", { gestures: want }));
+  }
+  function warnGestureUnsupported() {
+    if (warnedGesture || !caps || caps.gestures) return;
+    const needMove = draggableOn;
+    if (!needMove && resizeLimits === null) return;
+    warnedGesture = true;
+    const what = [needMove ? "draggable" : "", resizeLimits !== null ? "resizable" : ""].filter(Boolean).join(" / ");
+    emit("error", { code: "unsupported", message: `${what} needs gesture support (capabilities.gestures), which this /embed deployment does not advertise (older version)`, command: "gestures" });
+  }
+  const onWindowResize = () => {
+    if (!userMoved || activeGesture || destroyed) return;
+    const cur = readBox();
+    const fit = fitBox(cur, viewport());
+    if (fit.left === cur.left && fit.top === cur.top && fit.width === cur.width && fit.height === cur.height) return;
+    applyBox(fit, position === "inline" ? { left: cur.left - inlineShift.x, top: cur.top - inlineShift.y } : null, fit.width !== cur.width || fit.height !== cur.height);
+  };
+  window.addEventListener("resize", onWindowResize, { passive: true });
+  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 }),
+    setOutfit: (id) => {
+      if (!isXcId(id)) return Promise.reject(new Error("[bad_request] invalid outfit id"));
+      return send("xc.setOutfit", { id }, true, void 0, void 0, "outfits");
+    },
+    setScene: (id) => {
+      if (!isXcId(id)) return Promise.reject(new Error("[bad_request] invalid scene id"));
+      return send("xc.setScene", { id }, true, void 0, void 0, "scenes");
+    },
+    prefetch: (ids) => {
+      if (ids !== void 0 && (!Array.isArray(ids) || ids.some((x) => !isXcId(x)))) {
+        return Promise.reject(new Error("[bad_request] prefetch ids must be an array of outfit ids"));
+      }
+      return send("xc.prefetch", ids ? { ids } : {}, true, void 0, void 0, "prefetch");
+    },
+    getOutfits: async () => {
+      if (!iframe) activate();
+      await handshaked;
+      return caps?.outfits ? caps.outfits.slice() : [];
+    },
+    getScenes: async () => {
+      if (!iframe) activate();
+      await handshaked;
+      return caps?.scenes ? caps.scenes.slice() : [];
+    },
+    get outfit() {
+      return currentOutfit;
+    },
+    get scene() {
+      return currentScene;
+    },
+    setModel: (m) => {
+      const msg = typeof m === "string" ? /^(https?:)?\/|\.vrm/i.test(m) ? { url: m } : { outfit: m } : m;
+      if (msg.url !== void 0 && msg.outfit === void 0 && !options.allowCustomModel) {
+        const message = "custom model URLs are disabled; pass allowCustomModel: true to createXiaochun() (only for URLs you trust) or use setOutfit() with a built-in id";
+        emit("error", { code: "unsupported", message, command: "xc.setModel" });
+        return Promise.reject(new Error(`[unsupported] ${message}`));
+      }
+      return send("xc.setModel", msg);
+    },
+    setConfig: (cfg) => send("xc.setConfig", cfg),
+    setSize(width, height) {
+      if (destroyed) return;
+      ws.width = css(width, "320px");
+      ws.height = css(height, "480px");
+      invalidateRect();
+    },
+    getBox: () => readBox(),
+    setBorderRadius(radius) {
+      radiusOpt = radius;
+      applyRadius();
+    },
+    setDraggable(on) {
+      draggableOn = on === true;
+      syncGestures();
+    },
+    setResizable(on) {
+      resizeLimits = normalizeResizable(on);
+      syncGestures();
+    },
+    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("resize", onWindowResize);
+      lockSelection(false);
+      disablePassthrough();
+      resolveHandshake();
+      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;
+}
+
+export {
+  createXiaochun
+};
+//# sourceMappingURL=chunk-KQSKHPVF.js.map