@lichen-ai/chatkit-web-component 0.4.0

package/dist/xpert-chatkit.js

@@ -0,0 +1,3088 @@
+class EventEmitter {
+  callbacks = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.callbacks.has(event)) {
+      this.callbacks.set(event, /* @__PURE__ */ new Set());
+    }
+    this.callbacks.get(event).add(callback);
+  }
+  emit(event, ...args) {
+    const data = args[0];
+    this.callbacks.get(event)?.forEach((callback) => callback(data));
+  }
+  off(event, callback) {
+    if (!callback) {
+      this.callbacks.delete(event);
+    } else {
+      this.callbacks.get(event)?.delete(callback);
+    }
+  }
+  allOff() {
+    this.callbacks.clear();
+  }
+}
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const EventStreamContentType = "text/event-stream";
+const DefaultRetryInterval = 1e3;
+const LastEventId = "last-event-id";
+function fetchEventSource(input, _a2) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a2, rest = __rest(_a2, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (!document.hidden) {
+        create();
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+      resolve();
+    });
+    const fetch2 = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a3;
+      curRequestController = new AbortController();
+      try {
+        const response = await fetch2(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a3 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a3 !== void 0 ? _a3 : retryInterval;
+            window.clearTimeout(retryTimer);
+            retryTimer = window.setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
+const FRAME_SAFE_ERROR_KEY = "__chatkit_error__";
+class HttpError extends Error {
+  status;
+  statusText;
+  metadata;
+  constructor(message, res, metadata) {
+    super(message);
+    this.name = "HttpError";
+    this.statusText = res.statusText;
+    this.status = res.status;
+    this.metadata = metadata;
+  }
+  static fromPossibleFrameSafeError(error) {
+    if (error instanceof HttpError) {
+      return error;
+    }
+    if (error && typeof error === "object" && FRAME_SAFE_ERROR_KEY in error && error[FRAME_SAFE_ERROR_KEY] === "HttpError") {
+      const safeError = error;
+      const parsedError = new HttpError(
+        safeError.message,
+        {
+          status: safeError.status,
+          statusText: safeError.statusText
+        },
+        safeError.metadata
+      );
+      parsedError.stack = safeError.stack;
+      return parsedError;
+    }
+    return null;
+  }
+}
+class FrameSafeHttpError {
+  [FRAME_SAFE_ERROR_KEY] = "HttpError";
+  message;
+  stack;
+  status;
+  statusText;
+  metadata;
+  constructor(message, res, metadata) {
+    this.message = message;
+    this.stack = new Error(message).stack;
+    this.status = res.status;
+    this.statusText = res.statusText;
+    this.metadata = metadata;
+  }
+  static fromHttpError(error) {
+    return new FrameSafeHttpError(
+      error.message,
+      {
+        status: error.status,
+        statusText: error.statusText
+      },
+      error.metadata
+    );
+  }
+}
+const BASE_RETRY_DELAY_MS = 1e3;
+const MAX_RETRY_DELAY_MS = 1e4;
+const MAX_RETRY_ATTEMPTS = 5;
+const nextDelay = (attempt, maxRetryDelay = MAX_RETRY_DELAY_MS, baseDelayMs = BASE_RETRY_DELAY_MS) => {
+  const max = Math.min(maxRetryDelay, baseDelayMs * 2 ** attempt);
+  return Math.floor(max * (0.5 + Math.random() * 0.5));
+};
+class RetryableError extends Error {
+  constructor(cause) {
+    super();
+    this.cause = cause;
+  }
+}
+const fetchEventSourceWithRetry = async (url, params) => {
+  let retryAttempt = 0;
+  const { onopen, ...restParams } = params;
+  await fetchEventSource(url, {
+    ...restParams,
+    onopen: async (res) => {
+      onopen?.(res);
+      if (res.ok && res.headers.get("content-type")?.startsWith("text/event-stream")) {
+        retryAttempt = 0;
+        return;
+      }
+      const httpError = new FrameSafeHttpError(`Streaming failed: ${res.statusText}`, res);
+      if (res.status >= 400 && res.status < 500) {
+        throw httpError;
+      } else {
+        throw new RetryableError(httpError);
+      }
+    },
+    onerror: (error) => {
+      if (error instanceof RetryableError) {
+        if (retryAttempt >= MAX_RETRY_ATTEMPTS) {
+          throw error.cause;
+        }
+        retryAttempt += 1;
+        return nextDelay(retryAttempt);
+      }
+      throw error;
+    }
+  });
+};
+function safeRandomUUID() {
+  const cryptoRef = globalThis.crypto;
+  if (typeof cryptoRef?.randomUUID === "function") {
+    return cryptoRef.randomUUID();
+  }
+  if (typeof cryptoRef?.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    cryptoRef.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("").replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+  }
+  return `ck_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+let IntegrationError$1 = class IntegrationError extends Error {
+  _name;
+  constructor(message) {
+    super(message);
+    this.name = "IntegrationError";
+    this._name = this.name;
+  }
+  static fromPossibleFrameSafeError(error) {
+    if (error && typeof error === "object" && FRAME_SAFE_ERROR_KEY in error && error[FRAME_SAFE_ERROR_KEY] === "IntegrationError") {
+      const safeError = error;
+      const parsedError = new IntegrationError(safeError.message);
+      parsedError.stack = safeError.stack;
+      return parsedError;
+    }
+    return null;
+  }
+};
+class FrameSafeIntegrationError {
+  [FRAME_SAFE_ERROR_KEY] = "IntegrationError";
+  message;
+  stack;
+  constructor(message) {
+    this.message = message;
+    this.stack = new Error(message).stack;
+  }
+}
+class BaseMessenger {
+  targetOrigin;
+  target;
+  commandHandlers;
+  _fetch;
+  constructor({
+    handlers,
+    target,
+    targetOrigin,
+    fetch: fetch2 = window.fetch
+  }) {
+    this.commandHandlers = handlers;
+    this.target = target;
+    this.targetOrigin = targetOrigin;
+    this._fetch = ((...args) => fetch2(...args));
+  }
+  emitter = new EventEmitter();
+  handlers = /* @__PURE__ */ new Map();
+  fetchEventSourceHandlers = /* @__PURE__ */ new Map();
+  setTargetOrigin(targetOrigin) {
+    this.targetOrigin = targetOrigin;
+  }
+  abortControllers = /* @__PURE__ */ new Map();
+  sendMessage(data, transfer) {
+    const message = {
+      __xpaiChatKit: true,
+      ...data
+    };
+    this.target()?.postMessage(message, this.targetOrigin, transfer);
+  }
+  connect() {
+    window.addEventListener("message", this.handleMessage);
+  }
+  disconnect() {
+    window.removeEventListener("message", this.handleMessage);
+  }
+  fetch(url, params) {
+    return new Promise((resolve, reject) => {
+      const nonce = safeRandomUUID();
+      this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+      let formData;
+      if (params.body instanceof FormData) {
+        formData = {};
+        for (const [key, value] of params.body.entries()) {
+          formData[key] = value;
+        }
+        params.body = void 0;
+      }
+      if (params.signal) {
+        params.signal.addEventListener("abort", () => {
+          this.sendMessage({
+            type: "abortSignal",
+            nonce,
+            reason: params.signal?.reason
+          });
+        });
+        params.signal = void 0;
+      }
+      this.sendMessage({ type: "fetch", nonce, params, formData, url });
+    });
+  }
+  // Supporting onopen would require a good way for us to serialize the Response object
+  // across the iframe boundary, which is not trivial and also not really necessary.
+  fetchEventSource(url, params) {
+    return new Promise((resolve, reject) => {
+      const { onmessage, signal, ...rest } = params;
+      const nonce = safeRandomUUID();
+      this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+      this.fetchEventSourceHandlers.set(nonce, {
+        onmessage
+      });
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          this.sendMessage({
+            type: "abortSignal",
+            nonce,
+            reason: signal.reason
+          });
+        });
+      }
+      this.sendMessage({ type: "fetchEventSource", nonce, params: rest, url });
+    });
+  }
+  commands = new Proxy(
+    {},
+    {
+      get: (_, command) => {
+        return (data, transfer) => {
+          return new Promise((resolve, reject) => {
+            const nonce = safeRandomUUID();
+            this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+            this.sendMessage(
+              {
+                type: "command",
+                nonce,
+                command: `on${command.charAt(0).toUpperCase()}${command.slice(1)}`,
+                data
+              },
+              transfer
+            );
+          });
+        };
+      }
+    }
+  );
+  emit(...[event, data, transfer]) {
+    this.sendMessage(
+      {
+        type: "event",
+        event,
+        data
+      },
+      transfer
+    );
+  }
+  on(...[event, callback]) {
+    this.emitter.on(event, callback);
+  }
+  destroy() {
+    window.removeEventListener("message", this.handleMessage);
+    this.emitter.allOff();
+    this.handlers.clear();
+  }
+  handleMessage = async (event) => {
+    if (!event.data || event.data.__xpaiChatKit !== true || event.origin !== this.targetOrigin || event.source !== this.target()) {
+      return;
+    }
+    const data = event.data;
+    switch (data.type) {
+      case "event": {
+        this.emitter.emit(data.event, data.data);
+        break;
+      }
+      case "fetch": {
+        try {
+          if (data.formData) {
+            const formData = new FormData();
+            for (const [key, value] of Object.entries(data.formData)) {
+              formData.append(key, value);
+            }
+            data.params.body = formData;
+          }
+          const controller = new AbortController();
+          this.abortControllers.set(data.nonce, controller);
+          data.params.signal = controller.signal;
+          const res = await this._fetch(data.url, data.params);
+          if (!res.ok) {
+            const message = await res.json().then((json2) => json2.message || res.statusText).catch(() => res.statusText);
+            throw new FrameSafeHttpError(message, res);
+          }
+          const json = await res.json().catch(() => ({}));
+          this.sendMessage({
+            type: "response",
+            response: json,
+            nonce: data.nonce
+          });
+        } catch (error) {
+          this.sendMessage({
+            type: "response",
+            error,
+            nonce: data.nonce
+          });
+        }
+        break;
+      }
+      case "fetchEventSource": {
+        try {
+          const controller = new AbortController();
+          this.abortControllers.set(data.nonce, controller);
+          await fetchEventSourceWithRetry(data.url, {
+            ...data.params,
+            signal: controller.signal,
+            fetch: this._fetch,
+            onmessage: (message) => {
+              this.sendMessage({
+                type: "fetchEventSourceMessage",
+                message,
+                nonce: data.nonce
+              });
+            }
+          });
+          this.sendMessage({
+            type: "response",
+            response: void 0,
+            nonce: data.nonce
+          });
+        } catch (error) {
+          this.sendMessage({
+            type: "response",
+            error,
+            nonce: data.nonce
+          });
+        }
+        break;
+      }
+      case "command": {
+        if (!this.canReceiveCommand(data.command)) {
+          this.sendMessage({
+            type: "response",
+            error: new FrameSafeIntegrationError(`Command ${data.command} not supported`),
+            nonce: data.nonce
+          });
+          return;
+        }
+        try {
+          const response = await this.commandHandlers[data.command]?.(data.data);
+          this.sendMessage({
+            type: "response",
+            response,
+            nonce: data.nonce
+          });
+        } catch (error) {
+          this.sendMessage({
+            type: "response",
+            error,
+            nonce: data.nonce
+          });
+        }
+        break;
+      }
+      case "response": {
+        const handler = this.handlers.get(data.nonce);
+        if (!handler) {
+          console.error("No handler found for nonce", data.nonce);
+          return;
+        }
+        if (data.error) {
+          const integrationError = IntegrationError$1.fromPossibleFrameSafeError(data.error);
+          const httpError = HttpError.fromPossibleFrameSafeError(data.error);
+          if (integrationError) {
+            integrationError.stack = handler.stack;
+            handler.reject(integrationError);
+          } else if (httpError) {
+            handler.reject(httpError);
+          } else {
+            handler.reject(data.error);
+          }
+        } else {
+          handler.resolve(data.response);
+        }
+        this.handlers.delete(data.nonce);
+        break;
+      }
+      case "fetchEventSourceMessage": {
+        const handler = this.fetchEventSourceHandlers.get(data.nonce);
+        if (!handler) {
+          console.error("No handler found for nonce", data.nonce);
+          return;
+        }
+        this.fetchEventSourceHandlers.get(data.nonce)?.onmessage?.(data.message);
+        break;
+      }
+      case "abortSignal": {
+        const controller = this.abortControllers.get(data.nonce);
+        if (controller) {
+          controller.abort(data.reason);
+          this.abortControllers.delete(data.nonce);
+        }
+        break;
+      }
+    }
+  };
+}
+const toUrlBase64 = (bin) => btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+const encodeBase64 = (value) => {
+  if (value === void 0) {
+    throw new TypeError("encodeBase64: `undefined` cannot be encoded to valid JSON. Pass null instead.");
+  }
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return toUrlBase64(bin);
+};
+class IntegrationError2 extends Error {
+}
+function fromPossibleFrameSafeError(err) {
+  return err.message;
+}
+const BASE_CAPABILITY_ALLOWLIST = [
+  // commands
+  "command.setOptions",
+  "command.sendUserMessage",
+  "command.setComposerValue",
+  "command.setThreadId",
+  "command.focusComposer",
+  "command.fetchUpdates",
+  "command.sendCustomAction",
+  "command.showHistory",
+  "command.hideHistory",
+  // events
+  "event.ready",
+  "event.error",
+  "event.log",
+  "event.response.start",
+  "event.response.end",
+  "event.response.stop",
+  "event.thread.change",
+  "event.tool.change",
+  "event.thread.load.start",
+  "event.thread.load.end",
+  "event.deeplink",
+  "event.effect",
+  // errors
+  "error.StreamError",
+  "error.StreamEventParsingError",
+  "error.WidgetItemError",
+  "error.InitialThreadLoadError",
+  "error.FileAttachmentError",
+  "error.HistoryViewError",
+  "error.FatalAppError",
+  "error.IntegrationError",
+  "error.EntitySearchError",
+  "error.DomainVerificationRequestError",
+  // backend
+  "backend.threads.get_by_id",
+  "backend.threads.list",
+  "backend.threads.update",
+  "backend.threads.delete",
+  "backend.threads.create",
+  "backend.threads.add_user_message",
+  "backend.threads.add_client_tool_output",
+  "backend.threads.retry_after_item",
+  "backend.threads.custom_action",
+  "backend.attachments.create",
+  "backend.attachments.get_preview",
+  "backend.attachments.delete",
+  "backend.items.list",
+  "backend.items.feedback",
+  // thread item types
+  "thread.item.generated_image",
+  "thread.item.user_message",
+  "thread.item.assistant_message",
+  "thread.item.client_tool_call",
+  "thread.item.widget",
+  "thread.item.task",
+  "thread.item.workflow",
+  "thread.item.end_of_turn",
+  "thread.item.image_generation",
+  // widgets
+  "widget.Basic",
+  "widget.Card",
+  "widget.ListView",
+  "widget.ListViewItem",
+  "widget.Badge",
+  "widget.Box",
+  "widget.Row",
+  "widget.Col",
+  "widget.Button",
+  "widget.Caption",
+  "widget.Chart",
+  "widget.Checkbox",
+  "widget.DatePicker",
+  "widget.Divider",
+  "widget.Form",
+  "widget.Icon",
+  "widget.Image",
+  "widget.Input",
+  "widget.Label",
+  "widget.Markdown",
+  "widget.RadioGroup",
+  "widget.Select",
+  "widget.Spacer",
+  "widget.Text",
+  "widget.Textarea",
+  "widget.Title",
+  "widget.Transition"
+];
+const BASE_CAPABILITY_DENYLIST = [
+  // --- commands
+  "command.shareThread",
+  "command.setTrainingOptOut",
+  // --- events
+  "event.thread.restore",
+  "event.message.share",
+  "event.image.download",
+  "event.history.open",
+  "event.history.close",
+  "event.log.chatgpt",
+  // --- errors
+  // These errors considered internal and are not exposed to the user by default.
+  "error.HttpError",
+  "error.NetworkError",
+  "error.UnhandledError",
+  "error.UnhandledPromiseRejectionError",
+  "error.StreamEventHandlingError",
+  "error.StreamStopError",
+  "error.ThreadRenderingError",
+  "error.IntlError",
+  "error.AppError",
+  // --- backend
+  "backend.threads.stop",
+  "backend.threads.share",
+  "backend.threads.create_from_shared",
+  "backend.threads.init",
+  "backend.attachments.process",
+  // widgets
+  "widget.CardCarousel",
+  "widget.Favicon",
+  "widget.CardLinkItem",
+  "widget.Map"
+];
+const PROFILE_TO_RULES = {
+  chatkit: {
+    allow: [...BASE_CAPABILITY_ALLOWLIST, "thread.item.image_generation"],
+    deny: BASE_CAPABILITY_DENYLIST
+  }
+};
+const getCapabilities = (profile) => {
+  const rules = PROFILE_TO_RULES[profile];
+  const effective = new Set(rules.allow);
+  for (const capability of rules.deny ?? []) {
+    effective.delete(capability);
+  }
+  const commands = /* @__PURE__ */ new Set();
+  const events = /* @__PURE__ */ new Set();
+  const backend = /* @__PURE__ */ new Set();
+  const threadItems = /* @__PURE__ */ new Set();
+  const errors = /* @__PURE__ */ new Set();
+  const widgets = /* @__PURE__ */ new Set();
+  for (const capability of effective) {
+    if (capability.startsWith("command.")) {
+      commands.add(capability.slice("command.".length));
+      continue;
+    }
+    if (capability.startsWith("event.")) {
+      events.add(capability.slice("event.".length));
+      continue;
+    }
+    if (capability.startsWith("backend.")) {
+      backend.add(capability.slice("backend.".length));
+      continue;
+    }
+    if (capability.startsWith("thread.item.")) {
+      threadItems.add(capability.slice("thread.item.".length));
+    }
+    if (capability.startsWith("error.")) {
+      errors.add(capability.slice("error.".length));
+      continue;
+    }
+    if (capability.startsWith("widget.")) {
+      widgets.add(capability.slice("widget.".length));
+      continue;
+    }
+  }
+  return { commands, events, backend, threadItems, errors, widgets };
+};
+class ChatFrameMessenger extends BaseMessenger {
+  // Messenger running in outer can always handle commands coming from inner
+  canReceiveCommand(_) {
+    return true;
+  }
+}
+const PET_ANIMATION_NAMES = [
+  "idle",
+  "running-right",
+  "running-left",
+  "waving",
+  "jumping",
+  "failed",
+  "waiting",
+  "running",
+  "review"
+];
+const petSpriteAtlas = {
+  columns: 8,
+  rows: 9,
+  cellWidth: 192,
+  cellHeight: 208,
+  animations: {
+    idle: {
+      row: 0,
+      frames: 6,
+      frameDurations: [280, 110, 110, 140, 140, 320]
+    },
+    "running-right": {
+      row: 1,
+      frames: 8,
+      frameDurations: [120, 120, 120, 120, 120, 120, 120, 220]
+    },
+    "running-left": {
+      row: 2,
+      frames: 8,
+      frameDurations: [120, 120, 120, 120, 120, 120, 120, 220]
+    },
+    waving: {
+      row: 3,
+      frames: 4,
+      frameDurations: [140, 140, 140, 280]
+    },
+    jumping: {
+      row: 4,
+      frames: 5,
+      frameDurations: [140, 140, 140, 140, 280]
+    },
+    failed: {
+      row: 5,
+      frames: 8,
+      frameDurations: [140, 140, 140, 140, 140, 140, 140, 240]
+    },
+    waiting: {
+      row: 6,
+      frames: 6,
+      frameDurations: [150, 150, 150, 150, 150, 260]
+    },
+    running: {
+      row: 7,
+      frames: 6,
+      frameDurations: [120, 120, 120, 120, 120, 220]
+    },
+    review: {
+      row: 8,
+      frames: 6,
+      frameDurations: [150, 150, 150, 150, 150, 280]
+    }
+  }
+};
+const DEFAULT_PET_BOUNDS_PADDING = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+const DEFAULT_PET_STORAGE_KEY = "chatkit:pet:position:v1";
+const DEFAULT_PET_SPRITESHEET_URL = "/pets/boba/spritesheet.webp";
+const DEFAULT_PET_CHARACTER = {
+  type: "sprite-atlas",
+  src: DEFAULT_PET_SPRITESHEET_URL
+};
+const DEFAULT_POSITION = {
+  pin: "bottom-right",
+  draggable: true,
+  scale: 0.25,
+  persist: true,
+  zIndex: 40
+};
+function mergeFrameAnimation(base, override) {
+  return {
+    row: override?.row ?? base.row,
+    frames: override?.frames ?? base.frames,
+    frameDurations: override?.frameDurations && override.frameDurations.length > 0 ? override.frameDurations : base.frameDurations
+  };
+}
+function mergePetSpriteAtlas(override) {
+  const animations = {};
+  for (const name of PET_ANIMATION_NAMES) {
+    animations[name] = mergeFrameAnimation(petSpriteAtlas.animations[name], override?.animations?.[name]);
+  }
+  return {
+    columns: override?.columns ?? petSpriteAtlas.columns,
+    rows: override?.rows ?? petSpriteAtlas.rows,
+    cellWidth: override?.cellWidth ?? petSpriteAtlas.cellWidth,
+    cellHeight: override?.cellHeight ?? petSpriteAtlas.cellHeight,
+    animations
+  };
+}
+function normalizeCharacter(character) {
+  if (!character) {
+    return DEFAULT_PET_CHARACTER;
+  }
+  if (character.src) {
+    return character;
+  }
+  return DEFAULT_PET_CHARACTER;
+}
+function normalizePetOptions(pet) {
+  if (!pet) {
+    return null;
+  }
+  if (pet === true) {
+    return {
+      character: DEFAULT_PET_CHARACTER,
+      position: DEFAULT_POSITION,
+      behavior: "auto",
+      ariaLabel: "Animated pet",
+      imageRendering: "auto"
+    };
+  }
+  if (pet.enabled === false) {
+    return null;
+  }
+  return {
+    character: normalizeCharacter(pet.character),
+    position: {
+      ...DEFAULT_POSITION,
+      ...pet.position
+    },
+    behavior: pet.behavior ?? "auto",
+    ariaLabel: pet.ariaLabel ?? "Animated pet",
+    imageRendering: pet.imageRendering ?? "auto"
+  };
+}
+function resolvePetCharacter(character) {
+  if (!character.src) {
+    return null;
+  }
+  return {
+    kind: "atlas",
+    src: character.src,
+    atlas: mergePetSpriteAtlas(character.atlas)
+  };
+}
+function normalizeBoundsPadding(value) {
+  if (typeof value === "number") {
+    return {
+      top: value,
+      right: value,
+      bottom: value,
+      left: value
+    };
+  }
+  return {
+    top: value?.top ?? DEFAULT_PET_BOUNDS_PADDING.top,
+    right: value?.right ?? DEFAULT_PET_BOUNDS_PADDING.right,
+    bottom: value?.bottom ?? DEFAULT_PET_BOUNDS_PADDING.bottom,
+    left: value?.left ?? DEFAULT_PET_BOUNDS_PADDING.left
+  };
+}
+function clampPetPosition(position, size, viewport, padding) {
+  const minX = padding.left;
+  const minY = padding.top;
+  const maxX = Math.max(minX, viewport.width - size.width - padding.right);
+  const maxY = Math.max(minY, viewport.height - size.height - padding.bottom);
+  return {
+    x: Math.min(maxX, Math.max(minX, position.x)),
+    y: Math.min(maxY, Math.max(minY, position.y))
+  };
+}
+function getPinnedPetPosition(pin, size, viewport, padding) {
+  const horizontalCenter = (viewport.width - size.width) / 2;
+  const verticalCenter = (viewport.height - size.height) / 2;
+  const right = viewport.width - size.width - padding.right;
+  const bottom = viewport.height - size.height - padding.bottom;
+  switch (pin) {
+    case "top-left":
+      return clampPetPosition({ x: padding.left, y: padding.top }, size, viewport, padding);
+    case "top":
+      return clampPetPosition({ x: horizontalCenter, y: padding.top }, size, viewport, padding);
+    case "top-right":
+      return clampPetPosition({ x: right, y: padding.top }, size, viewport, padding);
+    case "left":
+      return clampPetPosition({ x: padding.left, y: verticalCenter }, size, viewport, padding);
+    case "center":
+      return clampPetPosition({ x: horizontalCenter, y: verticalCenter }, size, viewport, padding);
+    case "right":
+      return clampPetPosition({ x: right, y: verticalCenter }, size, viewport, padding);
+    case "bottom-left":
+      return clampPetPosition({ x: padding.left, y: bottom }, size, viewport, padding);
+    case "bottom":
+      return clampPetPosition({ x: horizontalCenter, y: bottom }, size, viewport, padding);
+    case "bottom-right":
+    default:
+      return clampPetPosition({ x: right, y: bottom }, size, viewport, padding);
+  }
+}
+const removeMethods = (obj, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (typeof obj === "function") return "[ChatKitMethod]";
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (seen.has(obj)) return obj;
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return obj.map((c) => removeMethods(c, seen));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value !== "function") {
+      result[key] = removeMethods(value, seen);
+    } else {
+      result[key] = "[ChatKitMethod]";
+    }
+  }
+  return result;
+};
+const DRAG_DIRECTION_THRESHOLD_PX = 2;
+const PET_BASE_RENDER_SCALE = 0.5;
+const PET_FRAME_DURATION_MULTIPLIER = 1.5;
+const PET_RESTING_FRAME_DURATION_MULTIPLIER = 3;
+const PET_RESTING_DELAY_MS = 2e3;
+const PET_SUMMARY_GAP = 12;
+const PET_SUMMARY_WIDTH = 320;
+const PET_SUMMARY_MARGIN = 12;
+const PET_CONTEXT_MENU_MARGIN = 8;
+const PET_SUMMARY_FONT_FAMILY = 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+const PET_OVERLAY_COPY = {
+  "en-US": {
+    closePetMenuItem: "Close pet",
+    hideMessage: "Hide message",
+    expandMessage: "Expand message",
+    collapseMessage: "Collapse message",
+    restoreMessage: "Show message",
+    replyButton: "Reply",
+    replyPlaceholder: "Reply...",
+    sendButton: "Send",
+    sendingButton: "Sending...",
+    sendFailed: "Failed to send"
+  },
+  "zh-CN": {
+    closePetMenuItem: "关闭宠物",
+    hideMessage: "隐藏消息",
+    expandMessage: "展开消息",
+    collapseMessage: "收起消息",
+    restoreMessage: "显示消息",
+    replyButton: "回复",
+    replyPlaceholder: "输入回复...",
+    sendButton: "发送",
+    sendingButton: "发送中...",
+    sendFailed: "发送失败"
+  }
+};
+function stopEventPropagation(event) {
+  event.stopPropagation();
+}
+function getViewportSize() {
+  const visualViewport = window.visualViewport;
+  return {
+    width: visualViewport?.width || window.innerWidth || 320,
+    height: visualViewport?.height || window.innerHeight || 480
+  };
+}
+function readPersistedPosition(storageKey, persist) {
+  if (!persist) {
+    return null;
+  }
+  try {
+    const raw = window.localStorage.getItem(storageKey);
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || typeof parsed.x !== "number" || typeof parsed.y !== "number") {
+      return null;
+    }
+    return { x: parsed.x, y: parsed.y };
+  } catch {
+    return null;
+  }
+}
+function writePersistedPosition(storageKey, persist, position) {
+  if (!persist) {
+    return;
+  }
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(position));
+  } catch {
+  }
+}
+function escapeCssUrl(value) {
+  return value.replace(/["\\]/g, "\\$&");
+}
+function getRenderScale(scale) {
+  return Math.max(0.1, scale) * PET_BASE_RENDER_SCALE;
+}
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function getDefaultLocale() {
+  if (typeof window !== "undefined") {
+    try {
+      const stored = window.localStorage.getItem("chatkit:locale");
+      if (stored) {
+        return stored;
+      }
+    } catch {
+    }
+  }
+  return typeof navigator !== "undefined" ? navigator.language : null;
+}
+function resolveCopyLocale(locale) {
+  const normalized = (locale ?? getDefaultLocale() ?? "").trim().toLowerCase();
+  if (normalized === "zh-cn" || normalized === "zh-hans" || normalized.startsWith("zh")) {
+    return "zh-CN";
+  }
+  return "en-US";
+}
+function getSummaryDensityMetrics(density) {
+  switch (density) {
+    case "compact":
+      return {
+        padding: "8px 10px",
+        gap: 6,
+        marginTop: 3,
+        toggleSize: 30,
+        actionSize: 22
+      };
+    case "spacious":
+      return {
+        padding: "14px 16px",
+        gap: 10,
+        marginTop: 6,
+        toggleSize: 38,
+        actionSize: 28
+      };
+    case "normal":
+    default:
+      return {
+        padding: "12px 14px",
+        gap: 8,
+        marginTop: 4,
+        toggleSize: 34,
+        actionSize: 26
+      };
+  }
+}
+function getSummaryRadius(radius) {
+  switch (radius) {
+    case "pill":
+      return 24;
+    case "round":
+      return 16;
+    case "sharp":
+      return 0;
+    case "soft":
+    default:
+      return 12;
+  }
+}
+function getSummaryThemeMetrics(theme) {
+  const themeObject = typeof theme === "string" ? null : theme;
+  const baseSize = themeObject?.typography?.baseSize ?? 16;
+  const density = themeObject?.density ?? "normal";
+  const densityOffset = density === "compact" ? -1 : density === "spacious" ? 1 : 0;
+  const bodySize = clampNumber(baseSize - 2 + densityOffset, 11, 17);
+  const densityMetrics = getSummaryDensityMetrics(density);
+  return {
+    ...densityMetrics,
+    bodySize,
+    titleSize: bodySize + 1,
+    iconSize: clampNumber(bodySize + 2, 13, 19),
+    radius: getSummaryRadius(themeObject?.radius),
+    fontFamily: themeObject?.typography?.fontFamily ?? PET_SUMMARY_FONT_FAMILY
+  };
+}
+function isPetState(value) {
+  return value === "idle" || value === "running-right" || value === "running-left" || value === "waving" || value === "jumping" || value === "failed" || value === "waiting" || value === "running" || value === "review";
+}
+function parsePetStateChangePayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const payload = value;
+  return isPetState(payload.state) ? { state: payload.state } : null;
+}
+function parsePetOptionsChangePayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const payload = value;
+  if (payload.pet === null || typeof payload.pet === "boolean") {
+    return { pet: payload.pet };
+  }
+  if (payload.pet && typeof payload.pet === "object" && !Array.isArray(payload.pet)) {
+    return { pet: payload.pet };
+  }
+  return null;
+}
+function isThreadSummaryStatus(value) {
+  return value === "running" || value === "completed" || value === "failed";
+}
+function getThreadSummaryKey(summary) {
+  if (!summary) {
+    return null;
+  }
+  return [summary.threadId, summary.messageId || summary.updatedAt || summary.message].join(":");
+}
+function getThreadSummaryInteractionKey(summary) {
+  if (!summary) {
+    return null;
+  }
+  return [summary.threadId, summary.messageId ?? ""].join(":");
+}
+function parseThreadSummaryPayload(value) {
+  if (value === null) {
+    return { summary: null };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const payload = value;
+  if (typeof payload.threadId !== "string" || !payload.threadId.trim() || typeof payload.title !== "string" || !payload.title.trim() || typeof payload.message !== "string" || !payload.message.trim() || !isThreadSummaryStatus(payload.status)) {
+    return null;
+  }
+  return {
+    summary: {
+      threadId: payload.threadId,
+      title: payload.title,
+      message: payload.message,
+      status: payload.status,
+      ...typeof payload.messageId === "string" && payload.messageId.trim() ? { messageId: payload.messageId } : {},
+      ...typeof payload.updatedAt === "string" && payload.updatedAt.trim() ? { updatedAt: payload.updatedAt } : {}
+    }
+  };
+}
+function parseThreadSummaryLogPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const payload = value;
+  if (payload.name !== "thread.summary") {
+    return null;
+  }
+  return parseThreadSummaryPayload(payload.data ?? null);
+}
+class PetOverlay {
+  constructor(root, options) {
+    this.overlayElement = null;
+    this.petElement = null;
+    this.contextMenuElement = null;
+    this.summaryElement = null;
+    this.summaryToggleElement = null;
+    this.mediaElement = null;
+    this.options = null;
+    this.theme = null;
+    this.resolved = null;
+    this.summary = null;
+    this.summaryRenderKey = null;
+    this.dismissedSummaryKey = null;
+    this.isSummaryCollapsed = false;
+    this.isSummaryExpanded = false;
+    this.isSummaryHovering = false;
+    this.isReplyOpen = false;
+    this.isReplySubmitting = false;
+    this.replyError = null;
+    this.replyDraft = "";
+    this.replyInputElement = null;
+    this.copyLocale = resolveCopyLocale();
+    this.copy = PET_OVERLAY_COPY[this.copyLocale];
+    this.currentState = "waiting";
+    this.lastAutoState = "waiting";
+    this.transient = null;
+    this.position = null;
+    this.dragPosition = null;
+    this.dragOffset = { x: 0, y: 0 };
+    this.lastDragPosition = null;
+    this.lastDragClientX = null;
+    this.dragAnimation = null;
+    this.isDragging = false;
+    this.isHovering = false;
+    this.movedDuringDrag = false;
+    this.prefersReducedMotion = false;
+    this.frame = 0;
+    this.completed = false;
+    this.activeAnimationName = null;
+    this.activeAnimationMode = null;
+    this.frameTimer = null;
+    this.restingDelayTimer = null;
+    this.mediaQuery = null;
+    this.connected = false;
+    this.handleViewportChange = () => {
+      this.closeContextMenu();
+      this.render();
+    };
+    this.handleReducedMotionChange = () => {
+      this.prefersReducedMotion = Boolean(this.mediaQuery?.matches);
+      if (this.prefersReducedMotion) {
+        this.transient = null;
+      }
+      this.render();
+    };
+    this.handlePointerEnter = () => {
+      this.clearRestingDelayTimer();
+      this.isHovering = true;
+      this.rescheduleAnimation();
+    };
+    this.handlePointerLeave = () => {
+      if (!this.isDragging) {
+        this.enterRestingAfterDelay();
+      }
+    };
+    this.handleContextMenu = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      this.openContextMenu({ x: event.clientX, y: event.clientY });
+    };
+    this.handleContextMenuEvent = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+    };
+    this.handleContextMenuOutsidePointerDown = (event) => {
+      const menu = this.contextMenuElement;
+      if (menu && event.composedPath().includes(menu)) {
+        return;
+      }
+      this.closeContextMenu();
+    };
+    this.handleContextMenuKeyDown = (event) => {
+      if (event.key !== "Escape") {
+        return;
+      }
+      event.preventDefault();
+      this.closeContextMenu();
+    };
+    this.handleClosePetMenuItemClick = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      this.closeContextMenu();
+      this.onClose?.();
+    };
+    this.handleSummaryPointerEnter = () => {
+      this.isSummaryHovering = true;
+      this.render();
+    };
+    this.handleSummaryPointerLeave = () => {
+      this.isSummaryHovering = false;
+      if (!this.isReplyOpen) {
+        this.render();
+      }
+    };
+    this.handleSummaryClick = () => {
+      const threadId = this.summary?.threadId.trim();
+      if (!threadId) {
+        return;
+      }
+      this.onThreadSummaryActivate?.(threadId);
+    };
+    this.handleSummaryDelete = () => {
+      const summaryKey = getThreadSummaryKey(this.summary);
+      if (summaryKey) {
+        this.dismissedSummaryKey = summaryKey;
+      }
+      this.isSummaryCollapsed = false;
+      this.isReplyOpen = false;
+      this.replyDraft = "";
+      this.replyError = null;
+      this.removeSummaryElements();
+    };
+    this.handleSummaryCollapseToggle = () => {
+      this.isSummaryCollapsed = !this.isSummaryCollapsed;
+      this.isSummaryExpanded = false;
+      this.isReplyOpen = false;
+      this.replyError = null;
+      this.render();
+    };
+    this.handleSummaryExpandToggle = () => {
+      this.isSummaryExpanded = !this.isSummaryExpanded;
+      this.render();
+    };
+    this.handleReplyOpen = () => {
+      this.isReplyOpen = true;
+      this.replyError = null;
+      this.render();
+    };
+    this.handleReplyInput = (event) => {
+      const target = event.currentTarget;
+      if (target instanceof HTMLInputElement) {
+        this.replyDraft = target.value;
+        this.replyError = null;
+      }
+    };
+    this.handleReplySubmit = (event) => {
+      event.preventDefault();
+      void this.submitReply();
+    };
+    this.handleReplyKeyDown = (event) => {
+      if (event.key !== "Escape") {
+        return;
+      }
+      event.preventDefault();
+      this.isReplyOpen = false;
+      this.replyError = null;
+      this.render();
+    };
+    this.handlePointerDown = (event) => {
+      if (event.button !== 0 || event.ctrlKey) {
+        return;
+      }
+      this.closeContextMenu();
+      if (!this.options?.position.draggable) {
+        return;
+      }
+      event.preventDefault();
+      const rect = this.petElement?.getBoundingClientRect();
+      if (!rect) {
+        return;
+      }
+      const nextPosition = {
+        x: rect.left,
+        y: rect.top
+      };
+      this.dragOffset = {
+        x: event.clientX - rect.left,
+        y: event.clientY - rect.top
+      };
+      this.lastDragPosition = nextPosition;
+      this.lastDragClientX = event.clientX;
+      this.dragAnimation = null;
+      this.movedDuringDrag = false;
+      this.dragPosition = nextPosition;
+      this.isDragging = true;
+      this.clearRestingDelayTimer();
+      this.isHovering = true;
+      this.installDragListeners();
+      this.rescheduleAnimation();
+    };
+    this.handlePointerMove = (event) => {
+      const nextPosition = this.getNextDragPosition(event);
+      const last = this.lastDragPosition;
+      if (last && (Math.abs(last.x - nextPosition.x) > DRAG_DIRECTION_THRESHOLD_PX || Math.abs(last.y - nextPosition.y) > DRAG_DIRECTION_THRESHOLD_PX)) {
+        this.movedDuringDrag = true;
+      }
+      if (this.lastDragClientX !== null) {
+        const deltaX = event.clientX - this.lastDragClientX;
+        if (deltaX > DRAG_DIRECTION_THRESHOLD_PX) {
+          this.dragAnimation = "running-right";
+        } else if (deltaX < -DRAG_DIRECTION_THRESHOLD_PX) {
+          this.dragAnimation = "running-left";
+        }
+      }
+      this.lastDragClientX = event.clientX;
+      this.lastDragPosition = nextPosition;
+      this.dragPosition = nextPosition;
+      this.render();
+    };
+    this.handlePointerUp = (event) => {
+      const finalPosition = this.lastDragPosition ?? this.getNextDragPosition(event);
+      this.isDragging = false;
+      this.dragPosition = null;
+      this.dragAnimation = null;
+      this.lastDragClientX = null;
+      this.removeDragListeners();
+      this.persistPosition(finalPosition);
+      if (event.pointerType === "mouse" && this.isPointerOverPet(event)) {
+        this.isHovering = true;
+        this.rescheduleAnimation();
+      } else {
+        this.enterRestingAfterDelay();
+        this.rescheduleAnimation();
+      }
+    };
+    this.handleClick = () => {
+      if (this.movedDuringDrag) {
+        return;
+      }
+      this.onActivate?.();
+      if (this.prefersReducedMotion) {
+        return;
+      }
+      this.transient = { name: "waving" };
+      this.render();
+    };
+    this.root = root;
+    this.onActivate = options?.onActivate;
+    this.onClose = options?.onClose;
+    this.onReply = options?.onReply;
+    this.onThreadSummaryActivate = options?.onThreadSummaryActivate;
+    this.connect();
+  }
+  connect() {
+    if (this.connected) {
+      return;
+    }
+    this.connected = true;
+    this.installViewportListeners();
+    this.installReducedMotionListener();
+    this.render();
+  }
+  setOptions(pet, theme) {
+    this.closeContextMenu();
+    const nextOptions = normalizePetOptions(pet);
+    this.options = nextOptions;
+    this.theme = theme ?? null;
+    if (!nextOptions) {
+      this.isDragging = false;
+      this.isHovering = false;
+      this.position = null;
+      this.dragPosition = null;
+      this.dragAnimation = null;
+      this.lastDragPosition = null;
+      this.lastDragClientX = null;
+      this.transient = null;
+      this.resolved = null;
+      this.clearRestingDelayTimer();
+      this.removeDragListeners();
+      this.removeOverlay();
+      return;
+    }
+    this.position = readPersistedPosition(DEFAULT_PET_STORAGE_KEY, nextOptions.position.persist);
+    if (nextOptions.behavior === "auto" && !this.prefersReducedMotion) {
+      this.transient = { name: "waving" };
+    }
+    this.resolveCharacter();
+    this.render();
+  }
+  setState(state) {
+    const previous = this.lastAutoState;
+    this.lastAutoState = state;
+    this.currentState = state;
+    if (this.options?.behavior === "auto" && !this.prefersReducedMotion && state === "idle" && (previous === "running" || previous === "review") && !this.transient) {
+      this.transient = { name: "jumping" };
+    } else if (state !== "idle") {
+      this.transient = null;
+    }
+    this.render();
+  }
+  setLocale(locale) {
+    const nextLocale = resolveCopyLocale(locale);
+    if (nextLocale === this.copyLocale) {
+      return;
+    }
+    this.copyLocale = nextLocale;
+    this.copy = PET_OVERLAY_COPY[nextLocale];
+    this.summaryRenderKey = null;
+    this.closeContextMenu();
+    this.render();
+  }
+  setThreadSummary(summary) {
+    const previousKey = getThreadSummaryInteractionKey(this.summary);
+    const nextKey = getThreadSummaryInteractionKey(summary);
+    this.summary = summary;
+    if (!summary) {
+      this.isSummaryCollapsed = false;
+      this.isSummaryExpanded = false;
+      this.isSummaryHovering = false;
+      this.isReplyOpen = false;
+      this.isReplySubmitting = false;
+      this.replyError = null;
+      this.replyDraft = "";
+      this.summaryRenderKey = null;
+      this.removeSummaryElements();
+      return;
+    }
+    if (previousKey !== nextKey) {
+      this.isSummaryCollapsed = false;
+      this.isSummaryExpanded = false;
+      this.isSummaryHovering = false;
+      this.isReplyOpen = false;
+      this.isReplySubmitting = false;
+      this.replyError = null;
+      this.replyDraft = "";
+    }
+    this.render();
+  }
+  setThreadSummaryStatus(status) {
+    if (!this.summary || this.summary.status === status) {
+      return;
+    }
+    this.summary = { ...this.summary, status };
+    this.render();
+  }
+  destroy() {
+    if (!this.connected) {
+      return;
+    }
+    this.connected = false;
+    this.clearRestingDelayTimer();
+    this.clearTimers();
+    this.removeDragListeners();
+    this.removeOverlay();
+    window.removeEventListener("resize", this.handleViewportChange);
+    window.visualViewport?.removeEventListener("resize", this.handleViewportChange);
+    window.visualViewport?.removeEventListener("scroll", this.handleViewportChange);
+    this.mediaQuery?.removeEventListener?.("change", this.handleReducedMotionChange);
+    this.mediaQuery = null;
+  }
+  installViewportListeners() {
+    window.addEventListener("resize", this.handleViewportChange);
+    window.visualViewport?.addEventListener("resize", this.handleViewportChange);
+    window.visualViewport?.addEventListener("scroll", this.handleViewportChange);
+  }
+  installReducedMotionListener() {
+    if (!window.matchMedia) {
+      return;
+    }
+    this.mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    this.prefersReducedMotion = this.mediaQuery.matches;
+    this.mediaQuery.addEventListener?.("change", this.handleReducedMotionChange);
+  }
+  resolveCharacter() {
+    if (!this.options) {
+      this.resolved = null;
+      return;
+    }
+    const character = this.options.character;
+    this.resolved = resolvePetCharacter(character);
+  }
+  ensureOverlay() {
+    if (this.overlayElement && this.petElement) {
+      return;
+    }
+    const overlay = document.createElement("div");
+    overlay.setAttribute("data-chatkit-host-pet-layer", "");
+    overlay.style.position = "fixed";
+    overlay.style.inset = "0";
+    overlay.style.pointerEvents = "none";
+    overlay.style.overflow = "visible";
+    const style = document.createElement("style");
+    style.textContent = `
+      @keyframes chatkit-pet-summary-spin {
+        to { transform: rotate(360deg); }
+      }
+    `;
+    const pet = document.createElement("div");
+    pet.setAttribute("data-chatkit-host-pet", "");
+    pet.style.position = "absolute";
+    pet.style.top = "0";
+    pet.style.left = "0";
+    pet.style.pointerEvents = "auto";
+    pet.style.touchAction = "none";
+    pet.style.userSelect = "none";
+    pet.style.willChange = "transform";
+    pet.addEventListener("pointerenter", this.handlePointerEnter);
+    pet.addEventListener("pointerleave", this.handlePointerLeave);
+    pet.addEventListener("pointerdown", this.handlePointerDown);
+    pet.addEventListener("contextmenu", this.handleContextMenu);
+    pet.addEventListener("click", this.handleClick);
+    overlay.append(style, pet);
+    this.root.append(overlay);
+    this.overlayElement = overlay;
+    this.petElement = pet;
+  }
+  removeOverlay() {
+    this.clearRestingDelayTimer();
+    this.clearTimers();
+    this.closeContextMenu();
+    if (this.petElement) {
+      this.petElement.removeEventListener("pointerenter", this.handlePointerEnter);
+      this.petElement.removeEventListener("pointerleave", this.handlePointerLeave);
+      this.petElement.removeEventListener("pointerdown", this.handlePointerDown);
+      this.petElement.removeEventListener("contextmenu", this.handleContextMenu);
+      this.petElement.removeEventListener("click", this.handleClick);
+    }
+    this.isHovering = false;
+    this.removeSummaryElements();
+    this.overlayElement?.remove();
+    this.overlayElement = null;
+    this.petElement = null;
+    this.mediaElement = null;
+  }
+  removeSummaryElements() {
+    this.summaryElement?.remove();
+    this.summaryToggleElement?.remove();
+    this.summaryElement = null;
+    this.summaryToggleElement = null;
+    this.replyInputElement = null;
+    this.summaryRenderKey = null;
+  }
+  getSize() {
+    if (!this.options || !this.resolved) {
+      return { width: 0, height: 0 };
+    }
+    const scale = getRenderScale(this.options.position.scale);
+    const baseSize = {
+      width: this.resolved.atlas.cellWidth,
+      height: this.resolved.atlas.cellHeight
+    };
+    return {
+      width: baseSize.width * scale,
+      height: baseSize.height * scale
+    };
+  }
+  getCurrentPosition(size) {
+    const options = this.options;
+    if (!options) {
+      return { x: 0, y: 0 };
+    }
+    const viewport = getViewportSize();
+    const padding = normalizeBoundsPadding(options.position.boundsPadding);
+    const pin = options.position.pin === void 0 ? "bottom-right" : options.position.pin;
+    const pinnedPosition = pin ? getPinnedPetPosition(pin, size, viewport, padding) : null;
+    return clampPetPosition(
+      this.dragPosition ?? this.position ?? pinnedPosition ?? { x: padding.left, y: padding.top },
+      size,
+      viewport,
+      padding
+    );
+  }
+  persistPosition(nextPosition) {
+    if (!this.options) {
+      return;
+    }
+    const size = this.getSize();
+    const clamped = clampPetPosition(
+      nextPosition,
+      size,
+      getViewportSize(),
+      normalizeBoundsPadding(this.options.position.boundsPadding)
+    );
+    this.position = clamped;
+    writePersistedPosition(DEFAULT_PET_STORAGE_KEY, this.options.position.persist, clamped);
+  }
+  getActiveAnimationName() {
+    if (!this.options) {
+      return "idle";
+    }
+    if (this.isDragging) {
+      return this.dragAnimation ?? "running";
+    }
+    if (this.transient) {
+      return this.transient.name;
+    }
+    if (this.options.behavior === "manual") {
+      return "idle";
+    }
+    return this.currentState;
+  }
+  getActiveAnimationMode() {
+    if (this.isDragging) {
+      return "loop";
+    }
+    return this.transient ? "once" : "loop";
+  }
+  resetAnimationIfNeeded(name, mode) {
+    if (this.activeAnimationName === name && this.activeAnimationMode === mode) {
+      return;
+    }
+    this.clearTimers();
+    this.activeAnimationName = name;
+    this.activeAnimationMode = mode;
+    this.frame = 0;
+    this.completed = false;
+  }
+  render() {
+    if (!this.options || !this.resolved) {
+      this.clearTimers();
+      if (this.petElement) {
+        this.petElement.replaceChildren();
+      }
+      this.removeSummaryElements();
+      this.mediaElement = null;
+      this.activeAnimationName = null;
+      this.activeAnimationMode = null;
+      this.frame = 0;
+      this.completed = false;
+      return;
+    }
+    this.ensureOverlay();
+    const overlay = this.overlayElement;
+    const pet = this.petElement;
+    if (!overlay || !pet) {
+      return;
+    }
+    const size = this.getSize();
+    const position = this.getCurrentPosition(size);
+    const animationName = this.getActiveAnimationName();
+    const animationMode = this.getActiveAnimationMode();
+    this.resetAnimationIfNeeded(animationName, animationMode);
+    overlay.style.zIndex = String(this.options.position.zIndex);
+    pet.style.width = `${size.width}px`;
+    pet.style.height = `${size.height}px`;
+    pet.style.transform = `translate3d(${position.x}px, ${position.y}px, 0)`;
+    pet.style.cursor = this.options.position.draggable ? this.isDragging ? "grabbing" : "grab" : "default";
+    pet.dataset.petAnimation = animationName;
+    pet.setAttribute("aria-label", this.options.ariaLabel);
+    pet.setAttribute("role", "img");
+    this.renderAtlas(animationName, animationMode);
+    this.renderThreadSummary(position, size);
+    this.scheduleNextFrame(animationName, animationMode);
+  }
+  renderThreadSummary(position, size) {
+    const summary = this.summary;
+    const summaryKey = getThreadSummaryKey(summary);
+    if (!summary || !summaryKey || this.dismissedSummaryKey === summaryKey) {
+      this.removeSummaryElements();
+      return;
+    }
+    if (this.isSummaryCollapsed) {
+      this.renderCollapsedSummary(position, size);
+      return;
+    }
+    const nextRenderKey = [
+      this.copyLocale,
+      this.isSummaryExpanded ? "expanded" : "compact",
+      this.isSummaryHovering ? "hover" : "rest",
+      this.isReplyOpen ? "reply" : "closed",
+      this.isReplySubmitting ? "submitting" : "ready",
+      this.replyError ?? ""
+    ].join("|");
+    if (!this.summaryElement || this.summaryRenderKey !== nextRenderKey) {
+      this.summaryElement?.remove();
+      this.summaryToggleElement?.remove();
+      this.summaryElement = this.createSummaryBubble(summary);
+      this.summaryToggleElement = this.createSummaryToggleButton("v");
+      this.overlayElement?.append(this.summaryElement, this.summaryToggleElement);
+      this.summaryRenderKey = nextRenderKey;
+      if (this.isReplyOpen && !this.isReplySubmitting) {
+        window.setTimeout(() => this.replyInputElement?.focus(), 0);
+      }
+    }
+    this.updateSummaryBubbleContent(summary);
+    this.positionSummaryBubble(position, size);
+  }
+  renderCollapsedSummary(position, size) {
+    this.summaryElement?.remove();
+    this.summaryElement = null;
+    this.summaryRenderKey = null;
+    if (!this.summaryToggleElement) {
+      this.summaryToggleElement = this.createSummaryToggleButton("1");
+      this.overlayElement?.append(this.summaryToggleElement);
+    }
+    this.summaryToggleElement.textContent = "1";
+    this.positionSummaryToggleBadge(position, size);
+  }
+  positionSummaryToggleBadge(position, size) {
+    const badge = this.summaryToggleElement;
+    if (!badge) {
+      return;
+    }
+    const viewport = getViewportSize();
+    const badgeSize = getSummaryThemeMetrics(this.theme).toggleSize;
+    const x = clampNumber(
+      position.x + size.width - badgeSize * 0.35,
+      PET_SUMMARY_MARGIN,
+      viewport.width - badgeSize - PET_SUMMARY_MARGIN
+    );
+    const y = clampNumber(
+      position.y - badgeSize * 0.35,
+      PET_SUMMARY_MARGIN,
+      viewport.height - badgeSize - PET_SUMMARY_MARGIN
+    );
+    badge.style.width = `${badgeSize}px`;
+    badge.style.height = `${badgeSize}px`;
+    badge.style.transform = `translate3d(${x}px, ${y}px, 0)`;
+    badge.style.borderRadius = "999px";
+  }
+  positionSummaryBubble(position, size) {
+    const bubble = this.summaryElement;
+    const toggle = this.summaryToggleElement;
+    if (!bubble || !toggle) {
+      return;
+    }
+    const viewport = getViewportSize();
+    const width = Math.min(PET_SUMMARY_WIDTH, viewport.width - PET_SUMMARY_MARGIN * 2);
+    bubble.style.width = `${width}px`;
+    const bubbleHeight = bubble.offsetHeight || 96;
+    const aboveY = position.y - bubbleHeight - PET_SUMMARY_GAP;
+    const showAbove = aboveY >= PET_SUMMARY_MARGIN;
+    const y = showAbove ? aboveY : clampNumber(
+      position.y + size.height + PET_SUMMARY_GAP,
+      PET_SUMMARY_MARGIN,
+      viewport.height - bubbleHeight - PET_SUMMARY_MARGIN
+    );
+    const x = clampNumber(
+      position.x + size.width / 2 - width / 2,
+      PET_SUMMARY_MARGIN,
+      viewport.width - width - PET_SUMMARY_MARGIN
+    );
+    bubble.style.transform = `translate3d(${x}px, ${y}px, 0)`;
+    this.positionSummaryToggleBadge(position, size);
+  }
+  createSummaryBubble(summary) {
+    const shouldShowReplyButton = this.isSummaryHovering && !this.isReplyOpen;
+    const metrics = getSummaryThemeMetrics(this.theme);
+    const bubble = document.createElement("div");
+    bubble.setAttribute("data-chatkit-pet-summary", "");
+    bubble.addEventListener("pointerenter", this.handleSummaryPointerEnter);
+    bubble.addEventListener("pointerleave", this.handleSummaryPointerLeave);
+    bubble.addEventListener("click", this.handleSummaryClick);
+    bubble.style.position = "absolute";
+    bubble.style.top = "0";
+    bubble.style.left = "0";
+    bubble.style.boxSizing = "border-box";
+    bubble.style.pointerEvents = "auto";
+    bubble.style.padding = metrics.padding;
+    bubble.style.border = "1px solid rgba(148, 163, 184, 0.22)";
+    bubble.style.borderRadius = `${metrics.radius}px`;
+    bubble.style.background = "rgba(255, 255, 255, 0.94)";
+    bubble.style.color = "#1f2937";
+    bubble.style.boxShadow = "0 8px 24px rgba(15, 23, 42, 0.1)";
+    bubble.style.font = `500 ${metrics.bodySize}px/1.35 ${metrics.fontFamily}`;
+    bubble.style.backdropFilter = "blur(10px)";
+    const header = document.createElement("div");
+    header.style.display = "flex";
+    header.style.alignItems = "center";
+    header.style.gap = `${metrics.gap}px`;
+    if (this.isSummaryHovering || this.isReplyOpen) {
+      header.append(this.createSummaryActionButton("x", this.copy.hideMessage, this.handleSummaryDelete));
+    }
+    const title = document.createElement("div");
+    title.textContent = summary.title;
+    title.style.minWidth = "0";
+    title.style.flex = "1";
+    title.style.overflow = "hidden";
+    title.style.textOverflow = "ellipsis";
+    title.style.whiteSpace = "nowrap";
+    title.style.fontWeight = "700";
+    title.style.fontSize = `${metrics.titleSize}px`;
+    title.dataset.chatkitPetSummaryTitle = "";
+    header.append(title);
+    if (this.isSummaryHovering || this.isReplyOpen) {
+      header.append(
+        this.createSummaryActionButton(
+          this.isSummaryExpanded ? "-" : ">",
+          this.isSummaryExpanded ? this.copy.collapseMessage : this.copy.expandMessage,
+          this.handleSummaryExpandToggle
+        )
+      );
+    } else {
+      header.append(this.createStatusIcon(summary.status));
+    }
+    const message = document.createElement("div");
+    message.textContent = summary.message;
+    message.style.marginTop = `${metrics.marginTop}px`;
+    message.style.fontWeight = "400";
+    message.style.color = "#374151";
+    message.style.overflow = "hidden";
+    if (this.isSummaryExpanded) {
+      message.style.maxHeight = "7em";
+      message.style.overflowY = "auto";
+    } else {
+      message.style.display = "-webkit-box";
+      message.style.setProperty("-webkit-line-clamp", "2");
+      message.style.setProperty("-webkit-box-orient", "vertical");
+    }
+    message.dataset.chatkitPetSummaryMessage = "";
+    bubble.append(header, message);
+    if (shouldShowReplyButton) {
+      const reply = this.createTextButton(this.copy.replyButton, this.handleReplyOpen);
+      reply.style.position = "absolute";
+      reply.style.right = "14px";
+      reply.style.bottom = "10px";
+      bubble.append(reply);
+    }
+    if (this.isReplyOpen) {
+      bubble.append(this.createReplyForm());
+    }
+    return bubble;
+  }
+  updateSummaryBubbleContent(summary) {
+    const title = this.summaryElement?.querySelector("[data-chatkit-pet-summary-title]");
+    if (title && title.textContent !== summary.title) {
+      title.textContent = summary.title;
+    }
+    const message = this.summaryElement?.querySelector("[data-chatkit-pet-summary-message]");
+    if (message && message.textContent !== summary.message) {
+      message.textContent = summary.message;
+    }
+    const statusIcon = this.summaryElement?.querySelector("[data-chatkit-pet-summary-status]");
+    if (statusIcon && statusIcon.dataset.chatkitPetSummaryStatus !== summary.status) {
+      const nextIcon = this.createStatusIcon(summary.status);
+      statusIcon.replaceWith(nextIcon);
+    }
+  }
+  createSummaryToggleButton(label) {
+    const metrics = getSummaryThemeMetrics(this.theme);
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = label;
+    button.title = label === "1" ? this.copy.restoreMessage : this.copy.collapseMessage;
+    button.addEventListener("click", stopEventPropagation);
+    button.addEventListener("click", this.handleSummaryCollapseToggle);
+    button.style.position = "absolute";
+    button.style.top = "0";
+    button.style.left = "0";
+    button.style.pointerEvents = "auto";
+    button.style.border = "1px solid rgba(148, 163, 184, 0.28)";
+    button.style.background = "rgba(248, 250, 252, 0.94)";
+    button.style.color = "#475569";
+    button.style.boxShadow = "0 6px 18px rgba(15, 23, 42, 0.1)";
+    button.style.cursor = "pointer";
+    button.style.font = `600 ${metrics.titleSize}px/1 ${metrics.fontFamily}`;
+    button.style.display = "flex";
+    button.style.alignItems = "center";
+    button.style.justifyContent = "center";
+    return button;
+  }
+  createStatusIcon(status) {
+    const metrics = getSummaryThemeMetrics(this.theme);
+    const iconSize = metrics.iconSize;
+    const icon = document.createElement("span");
+    icon.setAttribute("aria-hidden", "true");
+    icon.dataset.chatkitPetSummaryStatus = status;
+    icon.style.display = "inline-flex";
+    icon.style.width = `${iconSize}px`;
+    icon.style.height = `${iconSize}px`;
+    icon.style.alignItems = "center";
+    icon.style.justifyContent = "center";
+    icon.style.flex = "0 0 auto";
+    if (status === "running") {
+      icon.style.border = "2px solid rgba(71, 85, 105, 0.32)";
+      icon.style.borderTopColor = "#64748b";
+      icon.style.borderRadius = "999px";
+      icon.style.animation = "chatkit-pet-summary-spin 900ms linear infinite";
+      return icon;
+    }
+    icon.style.borderRadius = "999px";
+    icon.style.fontSize = `${Math.max(10, iconSize - 4)}px`;
+    icon.style.fontWeight = "700";
+    if (status === "failed") {
+      icon.textContent = "!";
+      icon.style.background = "#fee2e2";
+      icon.style.color = "#b91c1c";
+      return icon;
+    }
+    icon.textContent = "";
+    icon.style.border = "2px solid #22c55e";
+    icon.style.position = "relative";
+    const check = document.createElement("span");
+    check.style.width = `${Math.round(iconSize * 0.44)}px`;
+    check.style.height = `${Math.round(iconSize * 0.25)}px`;
+    check.style.borderLeft = "2px solid #22c55e";
+    check.style.borderBottom = "2px solid #22c55e";
+    check.style.transform = "rotate(-45deg) translate(1px, -1px)";
+    icon.append(check);
+    return icon;
+  }
+  createSummaryActionButton(label, title, onClick) {
+    const metrics = getSummaryThemeMetrics(this.theme);
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = label;
+    button.title = title;
+    button.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      onClick();
+    });
+    button.style.width = `${metrics.actionSize}px`;
+    button.style.height = `${metrics.actionSize}px`;
+    button.style.border = "0";
+    button.style.borderRadius = "999px";
+    button.style.background = "rgba(241, 245, 249, 0.96)";
+    button.style.color = "#475569";
+    button.style.cursor = "pointer";
+    button.style.font = `600 ${metrics.titleSize}px/1 ${metrics.fontFamily}`;
+    return button;
+  }
+  createTextButton(label, onClick) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = label;
+    button.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      onClick();
+    });
+    button.style.border = "1px solid rgba(148, 163, 184, 0.28)";
+    button.style.borderRadius = "999px";
+    button.style.background = "rgba(248, 250, 252, 0.95)";
+    button.style.color = "#334155";
+    button.style.cursor = "pointer";
+    button.style.padding = "3px 10px";
+    button.style.font = '600 12px/1.4 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    return button;
+  }
+  createReplyForm() {
+    const form = document.createElement("form");
+    form.addEventListener("click", stopEventPropagation);
+    form.addEventListener("submit", this.handleReplySubmit);
+    form.addEventListener("keydown", this.handleReplyKeyDown);
+    form.style.display = "flex";
+    form.style.gap = "6px";
+    form.style.alignItems = "center";
+    form.style.marginTop = "8px";
+    const input = document.createElement("input");
+    input.type = "text";
+    input.value = this.replyDraft;
+    input.disabled = this.isReplySubmitting;
+    input.placeholder = this.copy.replyPlaceholder;
+    input.addEventListener("input", this.handleReplyInput);
+    input.style.minWidth = "0";
+    input.style.flex = "1";
+    input.style.border = "1px solid rgba(148, 163, 184, 0.35)";
+    input.style.borderRadius = "999px";
+    input.style.padding = "6px 10px";
+    input.style.font = '400 13px/1.2 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    this.replyInputElement = input;
+    const send = document.createElement("button");
+    send.type = "submit";
+    send.textContent = this.isReplySubmitting ? this.copy.sendingButton : this.copy.sendButton;
+    send.disabled = this.isReplySubmitting;
+    send.style.border = "0";
+    send.style.borderRadius = "999px";
+    send.style.background = "#22c55e";
+    send.style.color = "#052e16";
+    send.style.cursor = this.isReplySubmitting ? "default" : "pointer";
+    send.style.padding = "6px 10px";
+    send.style.font = '700 12px/1.2 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    form.append(input, send);
+    if (this.replyError) {
+      const error = document.createElement("div");
+      error.textContent = this.copy.sendFailed;
+      error.style.flexBasis = "100%";
+      error.style.color = "#b91c1c";
+      error.style.fontSize = "12px";
+      form.style.flexWrap = "wrap";
+      form.append(error);
+    }
+    return form;
+  }
+  createContextMenu() {
+    const menu = document.createElement("div");
+    menu.setAttribute("data-chatkit-pet-context-menu", "");
+    menu.setAttribute("role", "menu");
+    menu.addEventListener("contextmenu", this.handleContextMenuEvent);
+    menu.addEventListener("pointerdown", stopEventPropagation);
+    menu.addEventListener("click", stopEventPropagation);
+    menu.style.position = "absolute";
+    menu.style.top = "0";
+    menu.style.left = "0";
+    menu.style.boxSizing = "border-box";
+    menu.style.minWidth = "132px";
+    menu.style.padding = "4px";
+    menu.style.pointerEvents = "auto";
+    menu.style.border = "1px solid rgba(148, 163, 184, 0.28)";
+    menu.style.borderRadius = "10px";
+    menu.style.background = "rgba(255, 255, 255, 0.96)";
+    menu.style.color = "#1f2937";
+    menu.style.boxShadow = "0 12px 28px rgba(15, 23, 42, 0.16)";
+    menu.style.font = '500 13px/1.3 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    menu.style.backdropFilter = "blur(10px)";
+    const closeItem = document.createElement("button");
+    closeItem.type = "button";
+    closeItem.textContent = this.copy.closePetMenuItem;
+    closeItem.setAttribute("role", "menuitem");
+    closeItem.addEventListener("click", this.handleClosePetMenuItemClick);
+    closeItem.style.display = "block";
+    closeItem.style.width = "100%";
+    closeItem.style.border = "0";
+    closeItem.style.borderRadius = "7px";
+    closeItem.style.background = "transparent";
+    closeItem.style.color = "inherit";
+    closeItem.style.cursor = "pointer";
+    closeItem.style.padding = "7px 10px";
+    closeItem.style.textAlign = "left";
+    closeItem.style.font = "inherit";
+    menu.append(closeItem);
+    return menu;
+  }
+  openContextMenu(position) {
+    const overlay = this.overlayElement;
+    if (!overlay) {
+      return;
+    }
+    this.closeContextMenu();
+    const menu = this.createContextMenu();
+    overlay.append(menu);
+    this.contextMenuElement = menu;
+    this.positionContextMenu(position);
+    menu.querySelector("button")?.focus({ preventScroll: true });
+    window.addEventListener("pointerdown", this.handleContextMenuOutsidePointerDown, true);
+    window.addEventListener("keydown", this.handleContextMenuKeyDown);
+  }
+  closeContextMenu() {
+    this.contextMenuElement?.remove();
+    this.contextMenuElement = null;
+    window.removeEventListener("pointerdown", this.handleContextMenuOutsidePointerDown, true);
+    window.removeEventListener("keydown", this.handleContextMenuKeyDown);
+  }
+  positionContextMenu(position) {
+    const menu = this.contextMenuElement;
+    if (!menu) {
+      return;
+    }
+    const viewport = getViewportSize();
+    const width = menu.offsetWidth || 132;
+    const height = menu.offsetHeight || 40;
+    const maxX = Math.max(PET_CONTEXT_MENU_MARGIN, viewport.width - width - PET_CONTEXT_MENU_MARGIN);
+    const maxY = Math.max(PET_CONTEXT_MENU_MARGIN, viewport.height - height - PET_CONTEXT_MENU_MARGIN);
+    const x = clampNumber(position.x, PET_CONTEXT_MENU_MARGIN, maxX);
+    const y = clampNumber(position.y, PET_CONTEXT_MENU_MARGIN, maxY);
+    menu.style.transform = `translate3d(${x}px, ${y}px, 0)`;
+  }
+  renderAtlas(animationName, animationMode) {
+    if (!this.petElement || this.resolved?.kind !== "atlas" || !this.options) {
+      return;
+    }
+    if (!(this.mediaElement instanceof HTMLDivElement)) {
+      const frame = document.createElement("div");
+      frame.setAttribute("aria-hidden", "true");
+      this.petElement.replaceChildren(frame);
+      this.mediaElement = frame;
+    }
+    const frameElement = this.mediaElement;
+    const atlas = this.resolved.atlas;
+    const definition = atlas.animations[animationName] ?? atlas.animations.idle;
+    const safeFrame = animationMode === "once" && this.completed ? Math.max(0, definition.frames - 1) : Math.min(this.frame, Math.max(0, definition.frames - 1));
+    const scale = getRenderScale(this.options.position.scale);
+    const sourceWidth = atlas.cellWidth;
+    const sourceHeight = atlas.cellHeight;
+    const backgroundWidth = atlas.columns * sourceWidth;
+    const backgroundHeight = atlas.rows * sourceHeight;
+    frameElement.style.width = `${sourceWidth}px`;
+    frameElement.style.height = `${sourceHeight}px`;
+    frameElement.style.overflow = "hidden";
+    frameElement.style.transform = `scale(${scale})`;
+    frameElement.style.transformOrigin = "top left";
+    frameElement.style.pointerEvents = "none";
+    frameElement.style.backgroundImage = `url("${escapeCssUrl(this.resolved.src)}")`;
+    frameElement.style.backgroundRepeat = "no-repeat";
+    frameElement.style.backgroundSize = `${backgroundWidth}px ${backgroundHeight}px`;
+    frameElement.style.backgroundPosition = `${-safeFrame * sourceWidth}px ${-definition.row * sourceHeight}px`;
+    frameElement.style.imageRendering = this.options.imageRendering;
+    frameElement.dataset.petFrame = String(safeFrame);
+  }
+  scheduleNextFrame(animationName, animationMode) {
+    if (this.prefersReducedMotion || this.completed || !this.resolved) {
+      this.clearTimers();
+      return;
+    }
+    if (this.frameTimer !== null) {
+      return;
+    }
+    const atlas = this.resolved.atlas;
+    const definition = atlas.animations[animationName] ?? atlas.animations.idle;
+    const duration = definition.frameDurations[this.frame] ?? definition.frameDurations[definition.frameDurations.length - 1] ?? 150;
+    const baseDuration = duration * PET_FRAME_DURATION_MULTIPLIER;
+    const effectiveDuration = this.isHovering || this.isDragging ? baseDuration : baseDuration * PET_RESTING_FRAME_DURATION_MULTIPLIER;
+    this.frameTimer = window.setTimeout(() => {
+      this.frameTimer = null;
+      const nextFrame = this.frame + 1;
+      if (nextFrame >= definition.frames) {
+        if (animationMode === "once") {
+          this.completed = true;
+          this.frame = Math.max(0, definition.frames - 1);
+          this.finishTransient();
+          return;
+        }
+        this.frame = 0;
+        this.render();
+        return;
+      }
+      this.frame = nextFrame;
+      this.render();
+    }, effectiveDuration);
+  }
+  clearTimers() {
+    if (this.frameTimer !== null) {
+      window.clearTimeout(this.frameTimer);
+      this.frameTimer = null;
+    }
+  }
+  clearRestingDelayTimer() {
+    if (this.restingDelayTimer !== null) {
+      window.clearTimeout(this.restingDelayTimer);
+      this.restingDelayTimer = null;
+    }
+  }
+  finishTransient() {
+    this.transient = null;
+    this.activeAnimationName = null;
+    this.activeAnimationMode = null;
+    this.render();
+  }
+  rescheduleAnimation() {
+    this.clearTimers();
+    this.render();
+  }
+  enterRestingAfterDelay() {
+    this.clearRestingDelayTimer();
+    this.isHovering = true;
+    this.restingDelayTimer = window.setTimeout(() => {
+      this.restingDelayTimer = null;
+      if (this.isDragging) {
+        return;
+      }
+      this.isHovering = false;
+      this.rescheduleAnimation();
+    }, PET_RESTING_DELAY_MS);
+  }
+  isPointOverPet(clientX, clientY) {
+    const rect = this.petElement?.getBoundingClientRect();
+    if (!rect) {
+      return false;
+    }
+    return clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
+  }
+  isPointerOverPet(event) {
+    return this.isPointOverPet(event.clientX, event.clientY);
+  }
+  async submitReply() {
+    const text = this.replyDraft.trim();
+    if (!text || this.isReplySubmitting) {
+      return;
+    }
+    this.isReplySubmitting = true;
+    this.replyError = null;
+    this.render();
+    try {
+      await this.onReply?.(text);
+      this.replyDraft = "";
+      this.isReplyOpen = false;
+      this.isSummaryHovering = false;
+    } catch {
+      this.replyError = "Failed to send";
+    } finally {
+      this.isReplySubmitting = false;
+      this.render();
+    }
+  }
+  getNextDragPosition(event) {
+    if (!this.options) {
+      return { x: 0, y: 0 };
+    }
+    return clampPetPosition(
+      {
+        x: event.clientX - this.dragOffset.x,
+        y: event.clientY - this.dragOffset.y
+      },
+      this.getSize(),
+      getViewportSize(),
+      normalizeBoundsPadding(this.options.position.boundsPadding)
+    );
+  }
+  installDragListeners() {
+    window.addEventListener("pointermove", this.handlePointerMove);
+    window.addEventListener("pointerup", this.handlePointerUp, { once: true });
+    window.addEventListener("pointercancel", this.handlePointerUp, {
+      once: true
+    });
+  }
+  removeDragListeners() {
+    window.removeEventListener("pointermove", this.handlePointerMove);
+    window.removeEventListener("pointerup", this.handlePointerUp);
+    window.removeEventListener("pointercancel", this.handlePointerUp);
+  }
+}
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, access, k = flags & 7, s = false, p = false;
+  var j = 2, key = __decoratorStrings[k + 5];
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = (target = target.prototype, __getOwnPropDesc(target, name));
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: (x) => name in x };
+      access.get = (x) => x[name];
+    }
+    it = (0, decorators[i])(desc[key], ctx), done._ = 1;
+    __expectFn(it) && (desc[key] = it);
+  }
+  return desc && __defProp(target, name, desc), target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _setTrainingOptOut_dec, _hideHistory_dec, _showHistory_dec, _sendCustomAction_dec, _shareThread_dec, _setThreadId_dec, _setComposerValue_dec, _sendUserMessage_dec, _fetchUpdates_dec, _focusComposer_dec, _a, _opts, _frameUrl, _frame, _wrapper, _launcherCloseButton, _launcherOpen, _chatMinimizedToPet, _framePetOptionsOverride, _petClosedByContextMenu, _shadow, _petOverlay, _resolveLoaded, _loaded, _messenger, _ChatKitElementBase_instances, emitAndThrow_fn, setOptionsDataAttributes_fn, getDisplayMode_fn, getConfiguredPetOptions_fn, mergeConfiguredPetPositionDefaults_fn, getOverlayPetOptions_fn, resolvePetAssetUrl_fn, resolveOverlayPetOptions_fn, getFrameOptions_fn, setLauncherOpen_fn, setChatMinimizedToPet_fn, syncPetOverlayOptions_fn, handlePetActivate_fn, handlePetClose_fn, handlePetReply_fn, handlePetThreadSummaryActivate_fn, _handleLauncherClose, getFrameUrl_fn, setFrameUrl_fn, consumeFrameUrl_fn, _handleFrameLoad, _initialized, maybeInit_fn, _init;
+function getInnerOptions(options) {
+  return removeMethods(options);
+}
+function requireCommandCapability(value, context) {
+  const command = String(context.name);
+  return function(...args) {
+    if (!this.capabilities.commands.has(command)) {
+      throw new IntegrationError2(
+        `ChatKit command "${String(command)}" is not available for the "${this.profile}" profile.`
+      );
+    }
+    return value.apply(this, args);
+  };
+}
+class ChatKitElementBase extends (_a = HTMLElement, _focusComposer_dec = [requireCommandCapability], _fetchUpdates_dec = [requireCommandCapability], _sendUserMessage_dec = [requireCommandCapability], _setComposerValue_dec = [requireCommandCapability], _setThreadId_dec = [requireCommandCapability], _shareThread_dec = [requireCommandCapability], _sendCustomAction_dec = [requireCommandCapability], _showHistory_dec = [requireCommandCapability], _hideHistory_dec = [requireCommandCapability], _setTrainingOptOut_dec = [requireCommandCapability], _a) {
+  constructor({ profile }) {
+    super();
+    __runInitializers(_init, 5, this);
+    __privateAdd(this, _ChatKitElementBase_instances);
+    this.profile = void 0;
+    this.capabilities = void 0;
+    __privateAdd(this, _opts);
+    __privateAdd(this, _frameUrl);
+    __privateAdd(this, _frame);
+    __privateAdd(this, _wrapper);
+    __privateAdd(this, _launcherCloseButton);
+    __privateAdd(this, _launcherOpen, false);
+    __privateAdd(this, _chatMinimizedToPet, false);
+    __privateAdd(this, _framePetOptionsOverride);
+    __privateAdd(this, _petClosedByContextMenu, false);
+    __privateAdd(this, _shadow, this.attachShadow({ mode: "open" }));
+    __privateAdd(this, _petOverlay, new PetOverlay(__privateGet(this, _shadow), {
+      onActivate: () => __privateMethod(this, _ChatKitElementBase_instances, handlePetActivate_fn).call(this),
+      onClose: () => __privateMethod(this, _ChatKitElementBase_instances, handlePetClose_fn).call(this),
+      onReply: (text) => __privateMethod(this, _ChatKitElementBase_instances, handlePetReply_fn).call(this, text),
+      onThreadSummaryActivate: (threadId) => void __privateMethod(this, _ChatKitElementBase_instances, handlePetThreadSummaryActivate_fn).call(this, threadId)
+    }));
+    __privateAdd(this, _resolveLoaded);
+    __privateAdd(this, _loaded, new Promise((resolve) => {
+      __privateSet(this, _resolveLoaded, resolve);
+    }));
+    __privateAdd(this, _messenger, new ChatFrameMessenger({
+      fetch: ((...args) => {
+        const customFetch = __privateGet(this, _opts)?.api && "fetch" in __privateGet(this, _opts).api && __privateGet(this, _opts).api.fetch;
+        return customFetch ? customFetch(...args) : fetch(...args);
+      }),
+      target: () => __privateGet(this, _frame)?.contentWindow ?? null,
+      targetOrigin: window.location.origin,
+      handlers: {
+        onFileInputClick: ({ inputAttributes }) => {
+          return new Promise((resolve) => {
+            const input = document.createElement("input");
+            for (const [key, value] of Object.entries(inputAttributes)) {
+              input.setAttribute(key, String(value));
+            }
+            const respond = () => {
+              resolve(Array.from(input.files || []));
+              if (__privateGet(this, _shadow).contains(input)) {
+                __privateGet(this, _shadow).removeChild(input);
+              }
+            };
+            input.addEventListener("cancel", respond);
+            input.addEventListener("change", respond);
+            __privateGet(this, _shadow).appendChild(input);
+            input.click();
+          });
+        },
+        onClientToolCall: async ({
+          name,
+          params,
+          id,
+          tool_call_id
+        }) => {
+          const onClientTool = __privateGet(this, _opts)?.onClientTool;
+          if (!onClientTool) {
+            __privateMethod(this, _ChatKitElementBase_instances, emitAndThrow_fn).call(this, new IntegrationError2(
+              `No handler for client tool calls. You'll need to add onClientTool to your ChatKit options.`
+            ));
+          }
+          return onClientTool({ name, params, id, tool_call_id });
+        },
+        onWidgetAction: async ({
+          action,
+          widgetItem
+        }) => {
+          const onAction = __privateGet(this, _opts)?.widgets?.onAction;
+          if (!onAction) {
+            __privateMethod(this, _ChatKitElementBase_instances, emitAndThrow_fn).call(this, new IntegrationError2(
+              `No handler for widget actions. You'll need to add widgets.onAction to your ChatKit options.`
+            ));
+          }
+          return onAction(action, widgetItem);
+        },
+        onEntitySearch: async ({ query }) => __privateGet(this, _opts)?.entities?.onTagSearch?.(query) ?? [],
+        onEntityClick: async ({ entity }) => __privateGet(this, _opts)?.entities?.onClick?.(entity),
+        onEntityPreview: async ({ entity }) => __privateGet(this, _opts)?.entities?.onRequestPreview?.(entity) ?? { preview: null },
+        onGetClientSecret: async (currentClientSecret) => {
+          if (!__privateGet(this, _opts) || !("getClientSecret" in __privateGet(this, _opts).api) || !__privateGet(this, _opts).api.getClientSecret) {
+            __privateMethod(this, _ChatKitElementBase_instances, emitAndThrow_fn).call(this, new IntegrationError2(
+              "Could not refresh the session because ChatKitOptions.api.getClientSecret is not configured."
+            ));
+          }
+          return __privateGet(this, _opts).api.getClientSecret(currentClientSecret ?? null);
+        },
+        onAddMetadataToRequest: ({ op, params }) => {
+          throw new IntegrationError2("ChatKit: onAddMetadataToRequest is unimplemented.");
+        }
+      }
+    }));
+    __privateAdd(this, _handleLauncherClose, () => {
+      __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, false);
+    });
+    __privateAdd(this, _handleFrameLoad, () => {
+      var _a2;
+      this.dataset.loaded = "true";
+      this.dispatchEvent(new CustomEvent("chatkit.ready", { bubbles: true, composed: true }));
+      (_a2 = __privateGet(this, _resolveLoaded)) == null ? void 0 : _a2.call(this);
+    });
+    __privateAdd(this, _initialized, false);
+    this.profile = profile;
+    this.capabilities = getCapabilities(profile);
+  }
+  setProfile(profile) {
+    this.profile = profile;
+    this.capabilities = getCapabilities(profile);
+  }
+  connectedCallback() {
+    __privateGet(this, _petOverlay).connect();
+    const style = document.createElement("style");
+    style.textContent = `
+      :host {
+        display: block;
+        position: relative;
+        height: 100%;
+        width: 100%;
+        overflow: visible;
+      }
+      :host([data-display-mode="pet"]) {
+        display: contents;
+      }
+      :host([data-chat-minimized-to-pet="true"]) {
+        display: contents;
+      }
+      .ck-iframe {
+        border: none;
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        color-scheme: light only;
+      }
+      .ck-wrapper {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        opacity: 0;
+      }
+      .ck-launcher-close {
+        display: none;
+      }
+      :host([data-display-mode="pet"]) .ck-wrapper {
+        position: fixed;
+        inset: auto 16px 16px auto;
+        width: min(420px, calc(100vw - 32px));
+        height: min(720px, calc(100vh - 32px));
+        max-height: calc(100vh - 32px);
+        overflow: visible;
+        border: 1px solid rgba(148, 163, 184, 0.35);
+        border-radius: 18px;
+        background: Canvas;
+        box-shadow:
+          0 24px 80px rgba(15, 23, 42, 0.22),
+          0 0 0 1px rgba(15, 23, 42, 0.04);
+        opacity: 0;
+        pointer-events: none;
+        transform: translateY(12px) scale(0.98);
+        transition:
+          opacity 160ms ease,
+          transform 160ms ease;
+        z-index: 39;
+      }
+      :host([data-display-mode="pet"][data-chat-open="true"]) .ck-wrapper {
+        opacity: 1;
+        pointer-events: auto;
+        transform: translateY(0) scale(1);
+      }
+      :host([data-display-mode="pet"]) .ck-iframe {
+        border-radius: inherit;
+      }
+      :host([data-display-mode="pet"]) .ck-launcher-close {
+        display: inline-flex;
+        position: absolute;
+        top: -10px;
+        right: -10px;
+        z-index: 2;
+        width: 28px;
+        height: 28px;
+        align-items: center;
+        justify-content: center;
+        border: 1px solid rgba(148, 163, 184, 0.45);
+        border-radius: 999px;
+        background: rgba(255, 255, 255, 0.96);
+        color: #475569;
+        box-shadow: 0 8px 24px rgba(15, 23, 42, 0.18);
+        cursor: pointer;
+        font: inherit;
+        font-size: 0;
+        line-height: 1;
+      }
+      :host([data-display-mode="pet"]) .ck-launcher-close::before,
+      :host([data-display-mode="pet"]) .ck-launcher-close::after {
+        content: '';
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        width: 14px;
+        height: 2px;
+        border-radius: 999px;
+        background: currentColor;
+        transform: translate(-50%, -50%) rotate(45deg);
+      }
+      :host([data-display-mode="pet"]) .ck-launcher-close::after {
+        transform: translate(-50%, -50%) rotate(-45deg);
+      }
+      :host([data-display-mode="pet"]) .ck-launcher-close:hover {
+        background: #fff;
+        color: #0f172a;
+      }
+      :host([data-color-scheme="dark"]) .ck-iframe {
+        color-scheme: dark only;
+      }
+      :host([data-color-scheme="dark"][data-display-mode="pet"]) .ck-wrapper {
+        border-color: rgba(148, 163, 184, 0.28);
+        background: #020617;
+        box-shadow:
+          0 24px 80px rgba(0, 0, 0, 0.5),
+          0 0 0 1px rgba(255, 255, 255, 0.06);
+      }
+      :host([data-color-scheme="dark"][data-display-mode="pet"]) .ck-launcher-close {
+        background: rgba(15, 23, 42, 0.88);
+        border-color: rgba(148, 163, 184, 0.32);
+        color: #cbd5e1;
+      }
+      :host([data-color-scheme="dark"][data-display-mode="pet"]) .ck-launcher-close:hover {
+        background: #1e293b;
+        color: #f8fafc;
+      }
+      :host([data-loaded="true"]) .ck-wrapper {
+        opacity: 1;
+      }
+      :host([data-chat-minimized-to-pet="true"]) .ck-wrapper {
+        opacity: 0;
+        pointer-events: none;
+        visibility: hidden;
+      }
+      :host([data-display-mode="pet"]:not([data-chat-open="true"])) .ck-wrapper {
+        opacity: 0;
+      }
+      @media (max-width: 520px) {
+        :host([data-display-mode="pet"]) .ck-wrapper {
+          inset: auto 8px 8px 8px;
+          width: auto;
+          height: min(680px, calc(100vh - 16px));
+          max-height: calc(100vh - 16px);
+          border-radius: 16px;
+        }
+        :host([data-display-mode="pet"]) .ck-launcher-close {
+          top: -8px;
+          right: 8px;
+        }
+      }
+    `;
+    const frame = document.createElement("iframe");
+    frame.className = "ck-iframe";
+    frame.name = "chatkit";
+    frame.role = "presentation";
+    frame.tabIndex = 0;
+    frame.setAttribute("allowtransparency", "true");
+    frame.setAttribute("frameborder", "0");
+    frame.setAttribute("scrolling", "no");
+    frame.setAttribute("allow", "clipboard-read; clipboard-write");
+    __privateSet(this, _frame, frame);
+    const wrapper = document.createElement("div");
+    wrapper.className = "ck-wrapper";
+    wrapper.appendChild(frame);
+    __privateSet(this, _wrapper, wrapper);
+    const closeButton = document.createElement("button");
+    closeButton.className = "ck-launcher-close";
+    closeButton.type = "button";
+    closeButton.setAttribute("aria-label", "Close chat");
+    closeButton.addEventListener("click", __privateGet(this, _handleLauncherClose));
+    wrapper.appendChild(closeButton);
+    __privateSet(this, _launcherCloseButton, closeButton);
+    __privateGet(this, _shadow).append(style);
+    __privateGet(this, _messenger).on("left_header_icon_click", () => {
+      __privateGet(this, _opts)?.header?.leftAction?.onClick();
+    });
+    __privateGet(this, _messenger).on("right_header_icon_click", () => {
+      __privateGet(this, _opts)?.header?.rightAction?.onClick();
+    });
+    __privateGet(this, _messenger).on("public_event", ([event, data]) => {
+      if (event === "log") {
+        const payload = parseThreadSummaryLogPayload(data);
+        if (payload) {
+          __privateGet(this, _petOverlay).setThreadSummary(payload.summary);
+        }
+      } else if (event === "response.start") {
+        __privateGet(this, _petOverlay).setThreadSummaryStatus("running");
+      } else if (event === "response.end") {
+        __privateGet(this, _petOverlay).setThreadSummaryStatus("completed");
+      } else if (event === "response.stop") {
+        __privateGet(this, _petOverlay).setThreadSummaryStatus("completed");
+      }
+      if (!this.capabilities.events.has(event)) return;
+      if (event === "error" && "error" in data) {
+        const error = fromPossibleFrameSafeError(data.error);
+        this.dispatchEvent(new CustomEvent("chatkit.error", { detail: { error } }));
+        if (error instanceof IntegrationError2) {
+          throw error;
+        }
+        return;
+      }
+      this.dispatchEvent(new CustomEvent(`chatkit.${event}`, { detail: data }));
+    });
+    __privateGet(this, _messenger).on("pet_state_change", (data) => {
+      const payload = parsePetStateChangePayload(data);
+      if (payload) {
+        __privateGet(this, _petOverlay).setState(payload.state);
+      }
+    });
+    __privateGet(this, _messenger).on("pet_options_change", (data) => {
+      const payload = parsePetOptionsChangePayload(data);
+      if (payload) {
+        if (!__privateGet(this, _petClosedByContextMenu) || payload.pet === null) {
+          __privateSet(this, _petClosedByContextMenu, false);
+        }
+        __privateSet(this, _framePetOptionsOverride, payload.pet);
+        __privateMethod(this, _ChatKitElementBase_instances, syncPetOverlayOptions_fn).call(this);
+      }
+    });
+    __privateGet(this, _messenger).on("chat_minimize_change", (data) => {
+      const minimized = typeof data === "object" && data !== null && "minimized" in data && data.minimized === true;
+      if (minimized && !__privateMethod(this, _ChatKitElementBase_instances, getOverlayPetOptions_fn).call(this)) {
+        return;
+      }
+      __privateMethod(this, _ChatKitElementBase_instances, setChatMinimizedToPet_fn).call(this, minimized);
+      if (minimized) {
+        __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, false);
+      }
+    });
+    __privateGet(this, _messenger).on("unmount", () => {
+      if (__privateGet(this, _wrapper) && __privateGet(this, _shadow).contains(__privateGet(this, _wrapper))) {
+        __privateGet(this, _shadow).removeChild(__privateGet(this, _wrapper));
+        __privateSet(this, _wrapper, void 0);
+        __privateSet(this, _frame, void 0);
+      }
+    });
+    __privateGet(this, _messenger).on("capabilities_profile_change", ({ profile }) => {
+      this.setProfile(profile);
+    });
+    frame.addEventListener("load", __privateGet(this, _handleFrameLoad), { once: true });
+    try {
+      __privateMethod(this, _ChatKitElementBase_instances, maybeInit_fn).call(this);
+    } catch (error) {
+      console.error(error);
+      __privateMethod(this, _ChatKitElementBase_instances, emitAndThrow_fn).call(this, error instanceof Error ? error : new IntegrationError2("Failed to initialize ChatKit"));
+    }
+  }
+  disconnectedCallback() {
+    __privateGet(this, _frame)?.removeEventListener("load", __privateGet(this, _handleFrameLoad));
+    __privateGet(this, _launcherCloseButton)?.removeEventListener("click", __privateGet(this, _handleLauncherClose));
+    __privateGet(this, _messenger).disconnect();
+    __privateGet(this, _petOverlay).destroy();
+  }
+  applySanitizedOptions(newOptions) {
+    __privateSet(this, _opts, newOptions);
+    __privateSet(this, _petClosedByContextMenu, false);
+    __privateGet(this, _petOverlay).setLocale(newOptions.locale);
+    __privateMethod(this, _ChatKitElementBase_instances, syncPetOverlayOptions_fn).call(this);
+    if (__privateGet(this, _initialized)) {
+      __privateMethod(this, _ChatKitElementBase_instances, setOptionsDataAttributes_fn).call(this, __privateGet(this, _opts));
+      __privateGet(this, _loaded).then(() => {
+        __privateGet(this, _messenger).commands.setOptions(getInnerOptions(__privateMethod(this, _ChatKitElementBase_instances, getFrameOptions_fn).call(this, newOptions)));
+      });
+    } else {
+      __privateMethod(this, _ChatKitElementBase_instances, maybeInit_fn).call(this);
+    }
+  }
+  setOptions(newOptions) {
+    try {
+      const sanitized = this.sanitizeOptions(newOptions);
+      __privateMethod(this, _ChatKitElementBase_instances, consumeFrameUrl_fn).call(this, sanitized);
+      this.applySanitizedOptions(sanitized);
+    } catch (error) {
+      __privateMethod(this, _ChatKitElementBase_instances, emitAndThrow_fn).call(this, error instanceof Error ? error : new IntegrationError2("Failed to parse options"));
+    }
+  }
+  async focusComposer() {
+    await __privateGet(this, _loaded);
+    __privateGet(this, _frame)?.focus();
+    await __privateGet(this, _messenger)?.commands.focusComposer();
+  }
+  async fetchUpdates() {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.fetchUpdates();
+  }
+  async sendUserMessage(params) {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.sendUserMessage(params);
+  }
+  async setComposerValue(params) {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.setComposerValue(params);
+  }
+  async setThreadId(threadId) {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.setThreadId({ threadId });
+  }
+  async shareThread() {
+    await __privateGet(this, _loaded);
+    return __privateGet(this, _messenger)?.commands.shareThread();
+  }
+  async sendCustomAction(action, itemId) {
+    await __privateGet(this, _loaded);
+    return __privateGet(this, _messenger)?.commands.sendCustomAction({ action, itemId });
+  }
+  async showHistory() {
+    await __privateGet(this, _loaded);
+    return __privateGet(this, _messenger)?.commands.showHistory();
+  }
+  async hideHistory() {
+    await __privateGet(this, _loaded);
+    return __privateGet(this, _messenger)?.commands.hideHistory();
+  }
+  async setTrainingOptOut(value) {
+    await __privateGet(this, _loaded);
+    return __privateGet(this, _messenger)?.commands.setTrainingOptOut({ value });
+  }
+}
+_init = __decoratorStart(_a);
+_opts = /* @__PURE__ */ new WeakMap();
+_frameUrl = /* @__PURE__ */ new WeakMap();
+_frame = /* @__PURE__ */ new WeakMap();
+_wrapper = /* @__PURE__ */ new WeakMap();
+_launcherCloseButton = /* @__PURE__ */ new WeakMap();
+_launcherOpen = /* @__PURE__ */ new WeakMap();
+_chatMinimizedToPet = /* @__PURE__ */ new WeakMap();
+_framePetOptionsOverride = /* @__PURE__ */ new WeakMap();
+_petClosedByContextMenu = /* @__PURE__ */ new WeakMap();
+_shadow = /* @__PURE__ */ new WeakMap();
+_petOverlay = /* @__PURE__ */ new WeakMap();
+_resolveLoaded = /* @__PURE__ */ new WeakMap();
+_loaded = /* @__PURE__ */ new WeakMap();
+_messenger = /* @__PURE__ */ new WeakMap();
+_ChatKitElementBase_instances = /* @__PURE__ */ new WeakSet();
+emitAndThrow_fn = function(error) {
+  this.dispatchEvent(new CustomEvent("chatkit.error", { detail: { error } }));
+  throw error;
+};
+setOptionsDataAttributes_fn = function(options) {
+  this.dataset.colorScheme = typeof options.theme === "string" ? options.theme : options.theme?.colorScheme ?? "light";
+  this.dataset.displayMode = __privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this, options);
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this, options) !== "pet") {
+    __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, false);
+  }
+};
+getDisplayMode_fn = function(options = __privateGet(this, _opts)) {
+  return options?.displayMode === "pet" ? "pet" : "chat";
+};
+getConfiguredPetOptions_fn = function(options = __privateGet(this, _opts)) {
+  if (!options) {
+    return null;
+  }
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this, options) === "pet" && !normalizePetOptions(options.pet ?? null)) {
+    return true;
+  }
+  return options.pet ?? null;
+};
+mergeConfiguredPetPositionDefaults_fn = function(pet) {
+  if (!pet) {
+    return pet;
+  }
+  const configured = normalizePetOptions(__privateMethod(this, _ChatKitElementBase_instances, getConfiguredPetOptions_fn).call(this) ?? null);
+  if (!configured) {
+    return pet;
+  }
+  if (pet === true) {
+    return { position: configured.position };
+  }
+  if (!pet.position) {
+    return { ...pet, position: configured.position };
+  }
+  return {
+    ...pet,
+    position: {
+      ...configured.position,
+      ...pet.position,
+      boundsPadding: pet.position.boundsPadding ?? configured.position.boundsPadding,
+      pin: "pin" in pet.position ? pet.position.pin : configured.position.pin
+    }
+  };
+};
+getOverlayPetOptions_fn = function() {
+  if (__privateGet(this, _petClosedByContextMenu)) {
+    return null;
+  }
+  let pet;
+  if (__privateGet(this, _framePetOptionsOverride) !== void 0) {
+    pet = __privateMethod(this, _ChatKitElementBase_instances, mergeConfiguredPetPositionDefaults_fn).call(this, __privateGet(this, _framePetOptionsOverride));
+  } else {
+    pet = __privateMethod(this, _ChatKitElementBase_instances, getConfiguredPetOptions_fn).call(this);
+  }
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this) === "pet" && !normalizePetOptions(pet ?? null)) {
+    pet = true;
+  }
+  return __privateMethod(this, _ChatKitElementBase_instances, resolveOverlayPetOptions_fn).call(this, pet);
+};
+resolvePetAssetUrl_fn = function(src) {
+  try {
+    const base = new URL(__privateGet(this, _frameUrl) ?? window.location.href, window.location.origin);
+    return new URL(src, base).toString();
+  } catch {
+    return src;
+  }
+};
+resolveOverlayPetOptions_fn = function(pet) {
+  const normalized = normalizePetOptions(pet ?? null);
+  if (!normalized) {
+    return null;
+  }
+  return {
+    character: {
+      ...normalized.character,
+      src: __privateMethod(this, _ChatKitElementBase_instances, resolvePetAssetUrl_fn).call(this, normalized.character.src)
+    },
+    position: normalized.position,
+    behavior: normalized.behavior,
+    ariaLabel: normalized.ariaLabel,
+    imageRendering: normalized.imageRendering
+  };
+};
+getFrameOptions_fn = function(options) {
+  const pet = __privateMethod(this, _ChatKitElementBase_instances, getConfiguredPetOptions_fn).call(this, options);
+  if (pet === (options.pet ?? null)) {
+    return options;
+  }
+  const nextOptions = { ...options };
+  if (pet === null) {
+    delete nextOptions.pet;
+  } else {
+    nextOptions.pet = pet;
+  }
+  return nextOptions;
+};
+setLauncherOpen_fn = function(open) {
+  __privateSet(this, _launcherOpen, open);
+  if (open) {
+    this.dataset.chatOpen = "true";
+  } else {
+    delete this.dataset.chatOpen;
+  }
+};
+setChatMinimizedToPet_fn = function(minimized) {
+  const next = minimized && Boolean(__privateMethod(this, _ChatKitElementBase_instances, getOverlayPetOptions_fn).call(this));
+  __privateSet(this, _chatMinimizedToPet, next);
+  if (next) {
+    this.dataset.chatMinimizedToPet = "true";
+  } else {
+    delete this.dataset.chatMinimizedToPet;
+  }
+};
+syncPetOverlayOptions_fn = function() {
+  const overlayPetOptions = __privateMethod(this, _ChatKitElementBase_instances, getOverlayPetOptions_fn).call(this);
+  __privateGet(this, _petOverlay).setOptions(overlayPetOptions, __privateGet(this, _opts)?.theme);
+  if (!overlayPetOptions) {
+    __privateMethod(this, _ChatKitElementBase_instances, setChatMinimizedToPet_fn).call(this, false);
+  }
+};
+handlePetActivate_fn = function() {
+  if (__privateGet(this, _chatMinimizedToPet)) {
+    __privateMethod(this, _ChatKitElementBase_instances, setChatMinimizedToPet_fn).call(this, false);
+    if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this) === "pet") {
+      __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, true);
+    }
+    __privateGet(this, _loaded).then(() => this.focusComposer()).catch(() => void 0);
+    return;
+  }
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this) !== "pet") {
+    return;
+  }
+  __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, true);
+  __privateGet(this, _loaded).then(() => this.focusComposer()).catch(() => void 0);
+};
+handlePetClose_fn = function() {
+  __privateSet(this, _petClosedByContextMenu, true);
+  __privateSet(this, _framePetOptionsOverride, null);
+  __privateMethod(this, _ChatKitElementBase_instances, setChatMinimizedToPet_fn).call(this, false);
+  __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, false);
+  __privateGet(this, _petOverlay).setOptions(null);
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this) === "pet") {
+    return;
+  }
+  __privateGet(this, _loaded).then(() => __privateGet(this, _messenger).commands.setPetEnabled({ enabled: false })).catch(() => void 0);
+};
+handlePetReply_fn = async function(text) {
+  await this.sendUserMessage({ text });
+};
+handlePetThreadSummaryActivate_fn = async function(threadId) {
+  if (__privateMethod(this, _ChatKitElementBase_instances, getDisplayMode_fn).call(this) === "pet") {
+    __privateMethod(this, _ChatKitElementBase_instances, setLauncherOpen_fn).call(this, true);
+  }
+  await this.setThreadId(threadId);
+  await this.focusComposer();
+};
+_handleLauncherClose = /* @__PURE__ */ new WeakMap();
+getFrameUrl_fn = function() {
+  if (!__privateGet(this, _frameUrl)) {
+    throw new IntegrationError2(
+      "ChatKit frameUrl is not configured. Provide it via setOptions({ frameUrl }) before mounting."
+    );
+  }
+  return __privateGet(this, _frameUrl);
+};
+setFrameUrl_fn = function(frameUrl) {
+  if (__privateGet(this, _initialized) && __privateGet(this, _frameUrl) && __privateGet(this, _frameUrl) !== frameUrl) {
+    throw new IntegrationError2(
+      "ChatKit frameUrl cannot be changed after initialization. Create a new element to use a different URL."
+    );
+  }
+  __privateSet(this, _frameUrl, frameUrl);
+};
+consumeFrameUrl_fn = function(options) {
+  if (!("frameUrl" in options)) return;
+  const frameUrl = options.frameUrl;
+  delete options.frameUrl;
+  if (frameUrl == null) return;
+  if (typeof frameUrl !== "string" || frameUrl.trim() === "") {
+    throw new IntegrationError2("ChatKit frameUrl must be a non-empty string.");
+  }
+  __privateMethod(this, _ChatKitElementBase_instances, setFrameUrl_fn).call(this, frameUrl);
+};
+_handleFrameLoad = /* @__PURE__ */ new WeakMap();
+_initialized = /* @__PURE__ */ new WeakMap();
+maybeInit_fn = function() {
+  if (__privateGet(this, _initialized) || !__privateGet(this, _frame) || !__privateGet(this, _opts)) {
+    return;
+  }
+  __privateSet(this, _initialized, true);
+  __privateMethod(this, _ChatKitElementBase_instances, setOptionsDataAttributes_fn).call(this, __privateGet(this, _opts));
+  const frameURL = new URL(__privateMethod(this, _ChatKitElementBase_instances, getFrameUrl_fn).call(this), window.location.origin);
+  __privateGet(this, _messenger).setTargetOrigin(frameURL.origin);
+  frameURL.hash = encodeBase64({
+    options: getInnerOptions(__privateMethod(this, _ChatKitElementBase_instances, getFrameOptions_fn).call(this, __privateGet(this, _opts))),
+    referrer: window.location.origin,
+    profile: this.profile
+  });
+  __privateGet(this, _messenger).connect();
+  __privateGet(this, _frame).src = frameURL.toString();
+  if (__privateGet(this, _wrapper)) {
+    __privateGet(this, _shadow).append(__privateGet(this, _wrapper));
+  }
+};
+__decorateElement(_init, 1, "focusComposer", _focusComposer_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "fetchUpdates", _fetchUpdates_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "sendUserMessage", _sendUserMessage_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "setComposerValue", _setComposerValue_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "setThreadId", _setThreadId_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "shareThread", _shareThread_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "sendCustomAction", _sendCustomAction_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "showHistory", _showHistory_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "hideHistory", _hideHistory_dec, ChatKitElementBase);
+__decorateElement(_init, 1, "setTrainingOptOut", _setTrainingOptOut_dec, ChatKitElementBase);
+__decoratorMetadata(_init, ChatKitElementBase);
+class ChatKitElement extends ChatKitElementBase {
+  constructor() {
+    super({ profile: "chatkit" });
+  }
+  sanitizeOptions(options) {
+    delete options.threadItemActions?.share;
+    return options;
+  }
+}
+function registerChatKitElement(tag = "xpertai-chatkit") {
+  if (!("customElements" in globalThis)) return;
+  if (!customElements.get(tag)) {
+    customElements.define(tag, ChatKitElement);
+  }
+}
+registerChatKitElement();
+//# sourceMappingURL=xpert-chatkit.js.map