@asiyst/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2366 @@
+'use strict';
+
+// src/errors/index.ts
+var AsiystError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "AsiystError";
+    this.code = code;
+  }
+};
+var ConfigurationError = class extends AsiystError {
+  constructor(message) {
+    super("configuration_error", message);
+    this.name = "ConfigurationError";
+  }
+};
+var AuthenticationError = class extends AsiystError {
+  constructor(message) {
+    super("authentication_error", message);
+    this.name = "AuthenticationError";
+  }
+};
+var InitializationError = class extends AsiystError {
+  constructor(message) {
+    super("initialization_error", message);
+    this.name = "InitializationError";
+  }
+};
+var TargetNotFoundError = class extends AsiystError {
+  constructor(message) {
+    super("target_not_found", message);
+    this.name = "TargetNotFoundError";
+  }
+};
+var ActionNotAllowedError = class extends AsiystError {
+  constructor(message) {
+    super("action_not_allowed", message);
+    this.name = "ActionNotAllowedError";
+  }
+};
+var NetworkError = class extends AsiystError {
+  constructor(message) {
+    super("network_error", message);
+    this.name = "NetworkError";
+  }
+};
+var TaskExecutionError = class extends AsiystError {
+  constructor(message) {
+    super("task_execution_error", message);
+    this.name = "TaskExecutionError";
+  }
+};
+
+// src/types/index.ts
+var ALL_ACTION_KINDS = [
+  "navigate",
+  "click",
+  "highlight",
+  "scroll",
+  "type",
+  "select",
+  "open-menu",
+  "open-modal",
+  "search",
+  "wait",
+  "explain",
+  "complete"
+];
+
+// src/core/constants.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_API_BASE_URL = "https://api.asiyst.com";
+var CONFIG_SCHEMA_VERSION = 1;
+var HOST_ELEMENT_ID = "asiyst-host";
+var DATA_ATTR = "data-asiyst";
+var DATA_ATTR_DESCRIPTION = "data-asiyst-description";
+var STORAGE_PREFIX = "asiyst";
+var ANALYTICS_FLUSH_INTERVAL_MS = 4e3;
+var ANALYTICS_BATCH_SIZE = 12;
+var DOM_SCAN_DEBOUNCE_MS = 350;
+var VIEWPORT_HANDLER_THROTTLE_MS = 80;
+var AVATAR_VIEWPORT_PADDING = 12;
+var AVATAR_TARGET_GAP = 16;
+var WEBSITE_MAP_TEXT_LIMIT = 80;
+var CONFIG_CACHE_TTL_MS = 1e3 * 60 * 10;
+
+// src/security/selectors.ts
+var DANGEROUS_SELECTOR = /javascript:|expression\(|@import|url\s*\(|behavior:|binding:|<script/i;
+var FORBIDDEN_SELECTOR_TOKENS = /[;{}]|\)\s*\[/;
+function isSafeSelector(selector) {
+  const trimmed = selector.trim();
+  if (!trimmed || trimmed.length > 240) {
+    return false;
+  }
+  if (DANGEROUS_SELECTOR.test(trimmed) || FORBIDDEN_SELECTOR_TOKENS.test(trimmed)) {
+    return false;
+  }
+  return true;
+}
+function querySafeSelector(root, selector) {
+  if (!isSafeSelector(selector)) {
+    return null;
+  }
+  try {
+    return root.querySelector(selector);
+  } catch {
+    return null;
+  }
+}
+
+// src/security/sanitize.ts
+var CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+function sanitizeText(input, maxLength = 2e3) {
+  return input.replace(CONTROL_CHARS, "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+function renderSafeText(node, text) {
+  node.textContent = sanitizeText(text);
+}
+
+// src/config/schema.ts
+var ANCHORS = [
+  "bottom-right",
+  "bottom-left",
+  "top-right",
+  "top-left"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value, fallback, max = 80) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  return sanitizeText(value, max) || fallback;
+}
+function asNumber(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function parseAllowedActions(value, fallback) {
+  if (!Array.isArray(value)) {
+    return [...fallback];
+  }
+  const allowed = new Set(ALL_ACTION_KINDS);
+  const next = [];
+  for (const item of value) {
+    if (typeof item === "string" && allowed.has(item)) {
+      next.push(item);
+    }
+  }
+  return next.length > 0 ? next : [...fallback];
+}
+function parseTheme(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  return {
+    accent: typeof value.accent === "string" ? sanitizeText(value.accent, 32) : void 0,
+    background: typeof value.background === "string" ? sanitizeText(value.background, 32) : void 0,
+    text: typeof value.text === "string" ? sanitizeText(value.text, 32) : void 0
+  };
+}
+function parsePersonality(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string" && key.length < 40) {
+      result[sanitizeText(key, 40)] = sanitizeText(entry, 120);
+    }
+  }
+  return result;
+}
+function parseBehavior(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  return {
+    walkingSpeed: asNumber(value.walkingSpeed, 1, 0.2, 4),
+    idleAnimation: typeof value.idleAnimation === "string" ? sanitizeText(value.idleAnimation, 40) : void 0,
+    pointingAnimation: typeof value.pointingAnimation === "string" ? sanitizeText(value.pointingAnimation, 40) : void 0,
+    greetingAnimation: typeof value.greetingAnimation === "string" ? sanitizeText(value.greetingAnimation, 40) : void 0,
+    thinkingAnimation: typeof value.thinkingAnimation === "string" ? sanitizeText(value.thinkingAnimation, 40) : void 0,
+    successAnimation: typeof value.successAnimation === "string" ? sanitizeText(value.successAnimation, 40) : void 0,
+    voiceSpeed: asNumber(value.voiceSpeed, 1, 0.5, 2),
+    speechBubble: typeof value.speechBubble === "boolean" ? value.speechBubble : true
+  };
+}
+function parseElementSelectors(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const result = {};
+  for (const [id, selector] of Object.entries(value)) {
+    if (typeof selector === "string" && isSafeSelector(selector)) {
+      result[sanitizeText(id, 64)] = selector.trim();
+    }
+  }
+  return result;
+}
+function fallbackConfig() {
+  return {
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    version: 0,
+    avatarName: "Asiyst",
+    avatar: "avatar_default",
+    size: 96,
+    position: "bottom-right",
+    animation: "friendly",
+    theme: {
+      accent: "#2563eb",
+      background: "#0f172a",
+      text: "#f8fafc"
+    },
+    personality: {},
+    behavior: {
+      walkingSpeed: 1,
+      speechBubble: true
+    },
+    mode: "guided",
+    allowedActions: ["navigate", "highlight", "scroll", "wait", "explain", "complete"],
+    elementSelectors: {}
+  };
+}
+function normalizeProjectConfig(raw) {
+  const base = fallbackConfig();
+  if (!isRecord(raw)) {
+    return base;
+  }
+  const position = ANCHORS.includes(raw.position) ? raw.position : base.position;
+  return {
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    version: asNumber(raw.version, base.version, 0, Number.MAX_SAFE_INTEGER),
+    avatarName: asString(raw.avatarName, base.avatarName, 40),
+    avatar: asString(raw.avatar, base.avatar, 64),
+    size: asNumber(raw.size, base.size, 48, 220),
+    position,
+    voice: typeof raw.voice === "string" ? sanitizeText(raw.voice, 64) : void 0,
+    animation: asString(raw.animation, base.animation ?? "friendly", 40),
+    theme: { ...base.theme, ...parseTheme(raw.theme) },
+    personality: parsePersonality(raw.personality),
+    behavior: { ...base.behavior, ...parseBehavior(raw.behavior) },
+    mode: raw.mode === "assist" ? "assist" : "guided",
+    allowedActions: parseAllowedActions(raw.allowedActions, base.allowedActions),
+    elementSelectors: parseElementSelectors(raw.elementSelectors)
+  };
+}
+function validateInitOptions(options) {
+  if (typeof options.projectId !== "string" || !options.projectId.trim()) {
+    throw new ConfigurationError("projectId is required");
+  }
+  if (typeof options.publicKey !== "string" || !options.publicKey.trim()) {
+    throw new ConfigurationError("publicKey is required");
+  }
+  if (options.projectId.length > 128 || options.publicKey.length > 256) {
+    throw new ConfigurationError("project credentials exceed allowed length");
+  }
+  return {
+    projectId: options.projectId.trim(),
+    publicKey: options.publicKey.trim()
+  };
+}
+
+// src/events/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.listeners.set(event, set);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) {
+      return;
+    }
+    for (const handler of [...handlers]) {
+      try {
+        handler(payload);
+      } catch {
+      }
+    }
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+};
+
+// src/communication/HttpTransport.ts
+var HttpTransport = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async request(req) {
+    const url = `${this.options.apiBaseUrl.replace(/\/$/, "")}${req.path}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: req.method,
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "X-Asiyst-Project-Id": this.options.projectId,
+          "X-Asiyst-Public-Key": this.options.publicKey,
+          "X-Asiyst-SDK-Version": SDK_VERSION
+        },
+        body: req.body === void 0 ? void 0 : JSON.stringify(req.body),
+        signal: req.signal
+      });
+    } catch {
+      throw new NetworkError("Asiyst Cloud is unreachable");
+    }
+    let data = null;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      try {
+        data = await response.json();
+      } catch {
+        data = null;
+      }
+    }
+    if (!response.ok) {
+      return { ok: false, status: response.status, data };
+    }
+    return { ok: true, status: response.status, data };
+  }
+};
+
+// src/communication/CloudClient.ts
+var CloudClient = class {
+  constructor(transport, projectId) {
+    this.transport = transport;
+    this.projectId = projectId;
+  }
+  async fetchConfig() {
+    const response = await this.transport.request({
+      path: `/v1/projects/${encodeURIComponent(this.projectId)}/config`,
+      method: "GET"
+    });
+    if (response.status === 401 || response.status === 403) {
+      throw new AuthenticationError("Project credentials were rejected");
+    }
+    if (!response.ok || !response.data) {
+      throw new NetworkError("Project configuration could not be loaded");
+    }
+    return normalizeProjectConfig(response.data.config ?? response.data);
+  }
+  async requestTask(userText, pageUrl) {
+    const response = await this.transport.request({
+      path: "/v1/tasks",
+      method: "POST",
+      body: {
+        projectId: this.projectId,
+        text: userText,
+        pageUrl
+      }
+    });
+    if (!response.ok || !response.data?.task?.id || !Array.isArray(response.data.task.steps)) {
+      throw new NetworkError("Task planning is unavailable");
+    }
+    return response.data.task;
+  }
+  async fetchWorkflow(workflowId) {
+    const response = await this.transport.request({
+      path: `/v1/workflows/${encodeURIComponent(workflowId)}`,
+      method: "GET"
+    });
+    if (!response.ok || !response.data?.workflow?.id || !Array.isArray(response.data.workflow.steps)) {
+      throw new NetworkError("Workflow is unavailable");
+    }
+    return response.data.workflow;
+  }
+  async sendConversationMessage(text, pageUrl) {
+    const response = await this.transport.request({
+      path: "/v1/conversations/messages",
+      method: "POST",
+      body: { projectId: this.projectId, text, pageUrl }
+    });
+    if (!response.ok || !response.data?.message?.text) {
+      throw new NetworkError("Conversation service is unavailable");
+    }
+    return response.data;
+  }
+  async sendWebsiteMap(snapshot) {
+    await this.safePost("/v1/website-maps", snapshot);
+  }
+  async sendAnalytics(events) {
+    await this.safePost("/v1/analytics", { events });
+  }
+  async sendTaskUpdate(taskId, status, stepId) {
+    await this.safePost(`/v1/tasks/${encodeURIComponent(taskId)}/events`, {
+      status,
+      stepId
+    });
+  }
+  async safePost(path, body) {
+    try {
+      await this.transport.request({ path, method: "POST", body });
+    } catch {
+    }
+  }
+};
+
+// src/storage/NamespacedStorage.ts
+var NamespacedStorage = class {
+  constructor(projectId, store) {
+    this.projectId = projectId;
+    this.store = store;
+  }
+  key(suffix) {
+    return `${STORAGE_PREFIX}:${this.projectId}:${suffix}`;
+  }
+  read(suffix) {
+    if (!this.store) {
+      return null;
+    }
+    try {
+      return this.store.getItem(this.key(suffix));
+    } catch {
+      return null;
+    }
+  }
+  write(suffix, value) {
+    if (!this.store) {
+      return;
+    }
+    try {
+      this.store.setItem(this.key(suffix), value);
+    } catch {
+    }
+  }
+  remove(suffix) {
+    if (!this.store) {
+      return;
+    }
+    try {
+      this.store.removeItem(this.key(suffix));
+    } catch {
+    }
+  }
+};
+function browserLocalStorage() {
+  try {
+    return typeof localStorage === "undefined" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+
+// src/config/ConfigCache.ts
+var ConfigCache = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  read(projectId) {
+    const raw = this.storage.read("config");
+    if (!raw) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.schemaVersion !== CONFIG_SCHEMA_VERSION || parsed.projectId !== projectId) {
+        return null;
+      }
+      if (Date.now() - parsed.fetchedAt > CONFIG_CACHE_TTL_MS) {
+        return null;
+      }
+      return normalizeProjectConfig(parsed.config);
+    } catch {
+      return null;
+    }
+  }
+  write(projectId, config) {
+    const envelope = {
+      schemaVersion: CONFIG_SCHEMA_VERSION,
+      projectId,
+      fetchedAt: Date.now(),
+      config
+    };
+    this.storage.write("config", JSON.stringify(envelope));
+  }
+};
+
+// src/config/ConfigManager.ts
+var ConfigManager = class {
+  constructor(options, cloud, events) {
+    this.options = options;
+    this.cloud = cloud;
+    this.events = events;
+    const credentials = validateInitOptions(options);
+    this.options = { ...options, ...credentials };
+    this.cache = new ConfigCache(
+      new NamespacedStorage(credentials.projectId, browserLocalStorage())
+    );
+    const cached = this.cache.read(credentials.projectId);
+    this.current = cached ?? this.localFallback();
+  }
+  get() {
+    return this.current;
+  }
+  async refresh() {
+    try {
+      const remote = await this.cloud.fetchConfig();
+      this.current = normalizeProjectConfig(remote);
+      this.cache.write(this.options.projectId, this.current);
+      return this.current;
+    } catch (error) {
+      this.events.emit("asiyst:error", {
+        code: "config_refresh_failed",
+        message: error instanceof Error ? error.message : "Failed to refresh configuration"
+      });
+      return this.current;
+    }
+  }
+  localFallback() {
+    const base = fallbackConfig();
+    return {
+      ...base,
+      mode: this.options.mode ?? base.mode,
+      allowedActions: this.options.allowedActions ?? base.allowedActions
+    };
+  }
+};
+
+// src/analytics/Analytics.ts
+var Analytics = class {
+  constructor(projectId, cloud) {
+    this.projectId = projectId;
+    this.cloud = cloud;
+    this.queue = [];
+    this.destroyed = false;
+  }
+  start() {
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, ANALYTICS_FLUSH_INTERVAL_MS);
+  }
+  track(name, properties) {
+    if (this.destroyed) {
+      return;
+    }
+    this.queue.push({
+      name,
+      at: Date.now(),
+      projectId: this.projectId,
+      properties
+    });
+    if (this.queue.length >= ANALYTICS_BATCH_SIZE) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const batch = this.queue.slice(0, ANALYTICS_BATCH_SIZE);
+    this.queue = this.queue.slice(batch.length);
+    try {
+      await this.cloud.sendAnalytics(batch);
+    } catch {
+      this.queue = batch.concat(this.queue).slice(0, 100);
+    }
+  }
+  async destroy() {
+    this.destroyed = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    await this.flush();
+  }
+  pendingCount() {
+    return this.queue.length;
+  }
+};
+
+// src/core/HostRoot.ts
+var HostRoot = class {
+  constructor(doc) {
+    this.host = doc.createElement("div");
+    this.host.id = HOST_ELEMENT_ID;
+    this.host.setAttribute("data-asiyst-root", "true");
+    this.host.style.all = "initial";
+    this.host.style.position = "relative";
+    this.host.style.zIndex = "2147483646";
+    this.shadow = this.host.attachShadow({ mode: "open" });
+    this.overlay = doc.createElement("div");
+    this.overlay.setAttribute("data-asiyst-layer", "overlay");
+    this.chrome = doc.createElement("div");
+    this.chrome.setAttribute("data-asiyst-layer", "chrome");
+    this.shadow.append(this.overlay, this.chrome);
+    doc.body.appendChild(this.host);
+  }
+  destroy() {
+    this.host.remove();
+  }
+};
+
+// src/dom/semantics.ts
+var SEARCH_HINT = /search|query|find/i;
+function classifyElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const role = el.getAttribute("role");
+  const type = (el.getAttribute("type") ?? "").toLowerCase();
+  const asiystId = el.getAttribute("data-asiyst") ?? "";
+  if (asiystId === "search" || SEARCH_HINT.test(asiystId) || type === "search") {
+    return "search";
+  }
+  if (tag === "dialog" || role === "dialog" || role === "alertdialog") {
+    return "dialog";
+  }
+  if (tag === "nav" || role === "navigation") {
+    return "navigation";
+  }
+  if (tag === "form") {
+    return "form";
+  }
+  if (tag === "select") {
+    return "select";
+  }
+  if (tag === "textarea") {
+    return "textarea";
+  }
+  if (tag === "input") {
+    return "input";
+  }
+  if (tag === "a") {
+    return "link";
+  }
+  if (tag === "button" || role === "button" || type === "button" || type === "submit") {
+    return "button";
+  }
+  if (role === "tab") {
+    return "tab";
+  }
+  if (role === "menu" || role === "menubar") {
+    return "menu";
+  }
+  if (/^h[1-6]$/.test(tag)) {
+    return "heading";
+  }
+  if (el.getAttribute("data-asiyst-kind") === "card" || /\bcard\b/i.test(el.className)) {
+    return "card";
+  }
+  if (tag === "header" || tag === "main" || tag === "footer" || tag === "section" || tag === "aside") {
+    return "section";
+  }
+  return "other";
+}
+function accessibleLabel(el) {
+  const labelledBy = el.getAttribute("aria-labelledby");
+  if (labelledBy && el.ownerDocument) {
+    const labels = labelledBy.split(/\s+/).map((id) => el.ownerDocument.getElementById(id)?.textContent?.trim()).filter((text) => Boolean(text));
+    if (labels.length > 0) {
+      return labels.join(" ");
+    }
+  }
+  return (el.getAttribute("aria-label") || el.getAttribute("title") || el.placeholder || "").trim();
+}
+function visibleText(el, max = 240) {
+  const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+  return text.slice(0, max);
+}
+function isDisabled(el) {
+  return el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true" || el instanceof HTMLInputElement && el.disabled;
+}
+function isSkippable(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "script" || tag === "style" || tag === "noscript" || tag === "link" || tag === "meta") {
+    return true;
+  }
+  if (el.id === "asiyst-host" || el.closest("#asiyst-host")) {
+    return true;
+  }
+  return false;
+}
+
+// src/dom/visibility.ts
+function isElementVisible(el) {
+  if (!(el instanceof HTMLElement)) {
+    return false;
+  }
+  if (el.hidden || el.getAttribute("aria-hidden") === "true") {
+    return false;
+  }
+  const style = el.ownerDocument.defaultView?.getComputedStyle(el);
+  if (!style) {
+    return true;
+  }
+  if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
+    return false;
+  }
+  const rect = el.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+function toViewportRect(el) {
+  const rect = el.getBoundingClientRect();
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+
+// src/dom/inspect.ts
+var CANDIDATE_SELECTOR = [
+  `[${DATA_ATTR}]`,
+  "a[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "form",
+  "nav",
+  "h1",
+  "h2",
+  "h3",
+  "[role='button']",
+  "[role='link']",
+  "[role='navigation']",
+  "[role='dialog']",
+  "[role='tab']",
+  "[role='menu']",
+  "[role='search']"
+].join(",");
+function sectionName(el) {
+  const section = el.closest("header, nav, main, footer, aside, section, [data-asiyst-section]");
+  if (!section) {
+    return null;
+  }
+  return section.getAttribute("data-asiyst-section") || section.getAttribute("aria-label") || section.tagName.toLowerCase();
+}
+function elementId(el, index) {
+  const explicit = el.getAttribute(DATA_ATTR);
+  if (explicit) {
+    return explicit;
+  }
+  const attrId = el.getAttribute("id");
+  if (attrId) {
+    return `dom:${attrId}`;
+  }
+  return `auto:${el.tagName.toLowerCase()}:${index}`;
+}
+function inspectDocument(doc) {
+  const pageUrl = doc.location?.href ?? "";
+  const nodes = Array.from(doc.querySelectorAll(CANDIDATE_SELECTOR));
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  nodes.forEach((el, index) => {
+    if (seen.has(el) || isSkippable(el) || el.closest(`#${HOST_ELEMENT_ID}`)) {
+      return;
+    }
+    seen.add(el);
+    const kind = classifyElement(el);
+    const developerDefined = el.hasAttribute(DATA_ATTR);
+    if (kind === "other" && !developerDefined) {
+      return;
+    }
+    const text = visibleText(el, WEBSITE_MAP_TEXT_LIMIT);
+    const label = accessibleLabel(el).slice(0, WEBSITE_MAP_TEXT_LIMIT);
+    results.push({
+      id: elementId(el, index),
+      kind,
+      tagName: el.tagName.toLowerCase(),
+      role: el.getAttribute("role"),
+      text,
+      label,
+      href: el instanceof HTMLAnchorElement ? el.getAttribute("href") : null,
+      pageUrl,
+      rect: toViewportRect(el),
+      visible: isElementVisible(el),
+      enabled: !isDisabled(el),
+      developerDefined,
+      description: el.getAttribute(DATA_ATTR_DESCRIPTION),
+      section: sectionName(el)
+    });
+  });
+  return results;
+}
+function findElementByAsiystId(doc, id) {
+  return doc.querySelector(`[${DATA_ATTR}="${cssEscape(id)}"]`);
+}
+function cssEscape(value) {
+  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+    return CSS.escape(value);
+  }
+  return value.replace(/"/g, '\\"');
+}
+
+// src/utils/timing.ts
+function debounce(fn, waitMs) {
+  let timer;
+  const wrapped = ((...args) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      fn(...args);
+    }, waitMs);
+  });
+  wrapped.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  return wrapped;
+}
+function throttle(fn, waitMs) {
+  let last = 0;
+  let timer;
+  let pending;
+  const invoke = (args) => {
+    last = Date.now();
+    fn(...args);
+  };
+  const wrapped = ((...args) => {
+    const now = Date.now();
+    const remaining = waitMs - (now - last);
+    pending = args;
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      invoke(args);
+      return;
+    }
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        if (pending) {
+          invoke(pending);
+        }
+      }, remaining);
+    }
+  });
+  wrapped.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    pending = void 0;
+  };
+  return wrapped;
+}
+
+// src/dom/DomObserver.ts
+var DomObserver = class {
+  constructor(onChange) {
+    this.notify = debounce(onChange, DOM_SCAN_DEBOUNCE_MS);
+  }
+  start(root) {
+    this.stop();
+    this.observer = new MutationObserver(() => this.notify());
+    this.observer.observe(root, {
+      subtree: true,
+      childList: true,
+      attributes: true,
+      attributeFilter: ["class", "style", "hidden", "aria-hidden", "data-asiyst", "disabled"]
+    });
+  }
+  stop() {
+    this.observer?.disconnect();
+    this.observer = void 0;
+    this.notify.cancel();
+  }
+};
+
+// src/dom/TargetResolver.ts
+function asRef(input) {
+  if (typeof input === "string") {
+    return { id: input };
+  }
+  return input;
+}
+function normalize(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+var TargetResolver = class {
+  constructor(doc, configuredSelectors, mappedElements) {
+    this.doc = doc;
+    this.configuredSelectors = configuredSelectors;
+    this.mappedElements = mappedElements;
+  }
+  resolve(input, source) {
+    const ref = asRef(input);
+    const element = this.findElement(ref, source);
+    if (!element || !isElementVisible(element) || isDisabled(element)) {
+      throw new TargetNotFoundError("Target does not exist or is not interactable");
+    }
+    const mapped = this.mappedElements().find((item) => this.matchesMapped(item, element, ref));
+    return {
+      element,
+      mapped: mapped ?? this.adHocMapped(element, ref)
+    };
+  }
+  tryResolve(input, source) {
+    try {
+      return this.resolve(input, source);
+    } catch {
+      return null;
+    }
+  }
+  findElement(ref, source) {
+    if (ref.id) {
+      const byAttr = findElementByAsiystId(this.doc, ref.id);
+      if (byAttr) {
+        return byAttr;
+      }
+      const configured = this.configuredSelectors()[ref.id];
+      if (configured) {
+        const found = querySafeSelector(this.doc, configured);
+        if (found) {
+          return found;
+        }
+      }
+      const mapped = this.mappedElements().find((item) => item.id === ref.id);
+      if (mapped) {
+        const byMapped = findElementByAsiystId(this.doc, mapped.id) ?? this.doc.getElementById(mapped.id.replace(/^dom:/, ""));
+        if (byMapped) {
+          return byMapped;
+        }
+      }
+    }
+    if (ref.selector && source === "developer") {
+      return querySafeSelector(this.doc, ref.selector);
+    }
+    if (ref.selector && source === "cloud") {
+      const allowed = Object.values(this.configuredSelectors());
+      if (allowed.includes(ref.selector)) {
+        return querySafeSelector(this.doc, ref.selector);
+      }
+      return null;
+    }
+    return this.matchBySemantics(ref);
+  }
+  matchBySemantics(ref) {
+    const wantedText = ref.text ? normalize(ref.text) : "";
+    const wantedRole = ref.role ? normalize(ref.role) : "";
+    let best;
+    let bestScore = 0;
+    for (const item of this.mappedElements()) {
+      if (!item.visible || !item.enabled) {
+        continue;
+      }
+      let score = 0;
+      if (wantedRole && (normalize(item.role ?? "") === wantedRole || item.kind === wantedRole)) {
+        score += 2;
+      }
+      const haystack = normalize(`${item.label} ${item.text} ${item.description ?? ""}`);
+      if (wantedText && haystack.includes(wantedText)) {
+        score += 3;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        best = item;
+      }
+    }
+    if (!best || bestScore < 2) {
+      return null;
+    }
+    return findElementByAsiystId(this.doc, best.id) ?? this.doc.querySelector(`[id="${best.id.replace(/^dom:/, "")}"]`);
+  }
+  matchesMapped(item, element, ref) {
+    if (ref.id && item.id === ref.id) {
+      return true;
+    }
+    return element.getAttribute("data-asiyst") === item.id;
+  }
+  adHocMapped(element, ref) {
+    return {
+      id: ref.id ?? element.getAttribute("data-asiyst") ?? "unknown",
+      kind: "other",
+      tagName: element.tagName.toLowerCase(),
+      role: element.getAttribute("role"),
+      text: (element.textContent ?? "").trim().slice(0, 80),
+      label: element.getAttribute("aria-label") ?? "",
+      href: element.getAttribute("href"),
+      pageUrl: this.doc.location?.href ?? "",
+      rect: { x: 0, y: 0, width: 0, height: 0 },
+      visible: true,
+      enabled: true,
+      developerDefined: element.hasAttribute("data-asiyst"),
+      description: element.getAttribute("data-asiyst-description"),
+      section: null
+    };
+  }
+};
+
+// src/website-map/WebsiteMap.ts
+var WebsiteMap = class {
+  constructor() {
+    this.elements = [];
+  }
+  replace(elements) {
+    this.elements = elements;
+  }
+  list() {
+    return this.elements;
+  }
+  snapshot(doc) {
+    const url = new URL(doc.location?.href ?? "https://invalid.local/");
+    url.search = "";
+    url.hash = "";
+    return {
+      pageUrl: url.toString(),
+      path: url.pathname,
+      title: (doc.title ?? "").slice(0, 120),
+      capturedAt: Date.now(),
+      elements: this.elements.filter((el) => el.visible).map((el) => ({
+        ...el,
+        href: el.href && !el.href.toLowerCase().startsWith("javascript:") ? el.href : null
+      }))
+    };
+  }
+};
+
+// src/navigation/HistoryObserver.ts
+var HistoryObserver = class {
+  constructor(onChange) {
+    this.wrapped = false;
+    this.onChange = onChange;
+  }
+  start(win, observeHistory) {
+    win.addEventListener("popstate", this.onChange);
+    win.addEventListener("hashchange", this.onChange);
+    if (!observeHistory || this.wrapped) {
+      return;
+    }
+    this.originalPush = win.history.pushState.bind(win.history);
+    this.originalReplace = win.history.replaceState.bind(win.history);
+    const notify = this.onChange;
+    win.history.pushState = (...args) => {
+      this.originalPush?.(...args);
+      notify();
+    };
+    win.history.replaceState = (...args) => {
+      this.originalReplace?.(...args);
+      notify();
+    };
+    this.wrapped = true;
+  }
+  stop(win) {
+    win.removeEventListener("popstate", this.onChange);
+    win.removeEventListener("hashchange", this.onChange);
+    if (this.wrapped && this.originalPush && this.originalReplace) {
+      win.history.pushState = this.originalPush;
+      win.history.replaceState = this.originalReplace;
+    }
+    this.wrapped = false;
+  }
+};
+
+// src/highlighting/HighlightLayer.ts
+var STYLE_TEXT = `
+.asiyst-highlight-root { position: fixed; inset: 0; pointer-events: none; z-index: 2147483646; }
+.asiyst-dim { position: absolute; inset: 0; background: rgba(2, 6, 23, 0.45); }
+.asiyst-box {
+  position: absolute;
+  border-radius: 10px;
+  box-sizing: border-box;
+  transition: top 80ms linear, left 80ms linear, width 80ms linear, height 80ms linear;
+}
+.asiyst-outline { border: 2px solid #38bdf8; box-shadow: 0 0 0 2px rgba(56, 189, 248, 0.25); }
+.asiyst-glow { box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.35), 0 0 24px rgba(56, 189, 248, 0.55); }
+.asiyst-pulse { border: 2px solid #38bdf8; animation: asiyst-pulse 1.4s ease-in-out infinite; }
+.asiyst-spotlight {
+  box-shadow: 0 0 0 9999px rgba(2, 6, 23, 0.55);
+  border: 2px solid #f8fafc;
+}
+.asiyst-pointer::after {
+  content: "";
+  position: absolute;
+  left: 50%;
+  top: -18px;
+  width: 10px;
+  height: 10px;
+  margin-left: -5px;
+  border-radius: 50%;
+  background: #38bdf8;
+}
+@keyframes asiyst-pulse {
+  0%, 100% { box-shadow: 0 0 0 0 rgba(56, 189, 248, 0.55); }
+  50% { box-shadow: 0 0 0 10px rgba(56, 189, 248, 0); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .asiyst-box, .asiyst-pulse { animation: none; transition: none; }
+}
+`;
+var HighlightLayer = class {
+  constructor(root, win) {
+    this.root = root;
+    this.win = win;
+    const style = root.ownerDocument.createElement("style");
+    style.textContent = STYLE_TEXT;
+    root.appendChild(style);
+    this.onViewport = throttle(() => this.sync(), VIEWPORT_HANDLER_THROTTLE_MS);
+  }
+  start() {
+    this.win.addEventListener("scroll", this.onViewport, true);
+    this.win.addEventListener("resize", this.onViewport);
+  }
+  show(target, style) {
+    this.target = target;
+    if (!this.box) {
+      this.box = this.root.ownerDocument.createElement("div");
+      this.box.className = "asiyst-box";
+      this.root.appendChild(this.box);
+    }
+    this.box.className = `asiyst-box asiyst-${style === "dim" ? "outline" : style}`;
+    if (style === "dim" || style === "spotlight") {
+      if (!this.dim) {
+        this.dim = this.root.ownerDocument.createElement("div");
+        this.dim.className = "asiyst-dim";
+        this.root.insertBefore(this.dim, this.box);
+      }
+      this.dim.style.display = style === "dim" ? "block" : "none";
+    } else if (this.dim) {
+      this.dim.style.display = "none";
+    }
+    this.sync();
+  }
+  hide() {
+    this.target = void 0;
+    if (this.box) {
+      this.box.style.display = "none";
+    }
+    if (this.dim) {
+      this.dim.style.display = "none";
+    }
+  }
+  isShowing() {
+    return Boolean(this.target);
+  }
+  stop() {
+    this.hide();
+    this.win.removeEventListener("scroll", this.onViewport, true);
+    this.win.removeEventListener("resize", this.onViewport);
+    this.onViewport.cancel();
+  }
+  sync() {
+    if (!this.box || !this.target) {
+      return;
+    }
+    const rect = this.target.getBoundingClientRect();
+    this.box.style.display = "block";
+    this.box.style.left = `${rect.left - 4}px`;
+    this.box.style.top = `${rect.top - 4}px`;
+    this.box.style.width = `${rect.width + 8}px`;
+    this.box.style.height = `${rect.height + 8}px`;
+  }
+};
+
+// src/avatar/CssAvatarRenderer.ts
+var AVATAR_CSS = `
+.asiyst-avatar {
+  position: fixed;
+  z-index: 2147483647;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 6px;
+  pointer-events: auto;
+  user-select: none;
+}
+.asiyst-avatar.asiyst-animate {
+  transition: left 420ms cubic-bezier(0.22, 1, 0.36, 1), top 420ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+.asiyst-figure {
+  border-radius: 28px;
+  display: grid;
+  place-items: center;
+  color: #fff;
+  font: 700 14px/1.2 system-ui, sans-serif;
+  box-shadow: 0 10px 30px rgba(15, 23, 42, 0.28);
+}
+.asiyst-figure[data-pose="point"] { transform: rotate(-12deg); }
+.asiyst-figure[data-pose="think"] { opacity: 0.85; }
+.asiyst-figure[data-pose="celebrate"] { transform: scale(1.08); }
+.asiyst-bubble {
+  max-width: 220px;
+  background: #0f172a;
+  color: #f8fafc;
+  border-radius: 12px;
+  padding: 8px 10px;
+  font: 13px/1.4 system-ui, sans-serif;
+  box-shadow: 0 8px 24px rgba(15, 23, 42, 0.2);
+}
+.asiyst-name { font: 600 12px/1 system-ui, sans-serif; color: #0f172a; }
+@media (prefers-reduced-motion: reduce) {
+  .asiyst-avatar.asiyst-animate { transition: none; }
+}
+`;
+var CssAvatarRenderer = class {
+  constructor() {
+    this.size = 96;
+    this.hidden = false;
+    this.facing = "right";
+    this.pose = "idle";
+  }
+  mount(container, config) {
+    const doc = container.ownerDocument;
+    const style = doc.createElement("style");
+    style.textContent = AVATAR_CSS;
+    container.appendChild(style);
+    this.root = doc.createElement("div");
+    this.root.className = "asiyst-avatar asiyst-animate";
+    this.root.setAttribute("role", "img");
+    this.figure = doc.createElement("button");
+    this.figure.type = "button";
+    this.figure.className = "asiyst-figure";
+    this.figure.setAttribute("aria-label", `${config.avatarName} assistant`);
+    this.nameEl = doc.createElement("div");
+    this.nameEl.className = "asiyst-name";
+    this.bubble = doc.createElement("div");
+    this.bubble.className = "asiyst-bubble";
+    this.bubble.hidden = true;
+    this.root.append(this.bubble, this.figure, this.nameEl);
+    container.appendChild(this.root);
+    this.applyConfig(config);
+  }
+  unmount() {
+    this.root?.remove();
+    this.root = void 0;
+  }
+  applyConfig(config) {
+    this.size = config.size;
+    if (this.figure) {
+      this.figure.style.width = `${config.size}px`;
+      this.figure.style.height = `${config.size}px`;
+      this.figure.style.background = config.theme.accent ?? "#2563eb";
+      renderSafeText(this.figure, config.avatarName.slice(0, 1).toUpperCase());
+    }
+    if (this.nameEl) {
+      renderSafeText(this.nameEl, config.avatarName);
+    }
+    if (this.root) {
+      this.root.setAttribute("aria-label", config.avatarName);
+    }
+  }
+  setPosition(x, y, animate) {
+    if (!this.root) {
+      return;
+    }
+    this.root.classList.toggle("asiyst-animate", animate);
+    this.root.style.left = `${x}px`;
+    this.root.style.top = `${y}px`;
+  }
+  setFacing(direction) {
+    this.facing = direction;
+    this.syncTransform();
+  }
+  setPose(pose) {
+    this.pose = pose;
+    this.figure?.setAttribute("data-pose", pose);
+    this.syncTransform();
+  }
+  syncTransform() {
+    if (!this.figure) {
+      return;
+    }
+    const face = this.facing === "left" ? "scaleX(-1)" : "";
+    const pose = this.pose === "point" ? "rotate(-12deg)" : this.pose === "celebrate" ? "scale(1.08)" : "";
+    this.figure.style.transform = `${face} ${pose}`.trim();
+  }
+  setSpeech(text) {
+    if (!this.bubble) {
+      return;
+    }
+    if (!text) {
+      this.bubble.hidden = true;
+      this.bubble.textContent = "";
+      return;
+    }
+    this.bubble.hidden = false;
+    renderSafeText(this.bubble, text);
+  }
+  getSize() {
+    return { width: this.size, height: this.size + 28 };
+  }
+  setHidden(hidden) {
+    this.hidden = hidden;
+    if (this.root) {
+      this.root.hidden = hidden;
+    }
+  }
+  isHidden() {
+    return this.hidden;
+  }
+  getFigure() {
+    return this.figure;
+  }
+};
+
+// src/accessibility/a11y.ts
+function prefersReducedMotion(windowLike) {
+  if (!windowLike || typeof windowLike.matchMedia !== "function") {
+    return false;
+  }
+  try {
+    return windowLike.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  } catch {
+    return false;
+  }
+}
+function createLiveRegion(root) {
+  const region = root.ownerDocument.createElement("div");
+  region.setAttribute("role", "status");
+  region.setAttribute("aria-live", "polite");
+  region.setAttribute("aria-atomic", "true");
+  region.style.position = "absolute";
+  region.style.width = "1px";
+  region.style.height = "1px";
+  region.style.overflow = "hidden";
+  region.style.clipPath = "inset(50%)";
+  root.appendChild(region);
+  return region;
+}
+
+// src/navigation/scroll.ts
+function estimateSafeInsets(doc) {
+  const insets = { top: 0, right: 0, bottom: 0, left: 0 };
+  const view = doc.defaultView;
+  if (!view) {
+    return insets;
+  }
+  const candidates = Array.from(doc.querySelectorAll("body *")).slice(0, 200);
+  for (const el of candidates) {
+    if (!(el instanceof HTMLElement) || el.id === "asiyst-host") {
+      continue;
+    }
+    const style = view.getComputedStyle(el);
+    const position = style.position;
+    if (position !== "fixed" && position !== "sticky") {
+      continue;
+    }
+    const rect = el.getBoundingClientRect();
+    if (rect.height <= 0 || rect.width <= 0) {
+      continue;
+    }
+    if (rect.top <= 8 && rect.height < view.innerHeight / 3) {
+      insets.top = Math.max(insets.top, Math.min(rect.bottom, 160));
+    }
+    if (rect.bottom >= view.innerHeight - 8 && rect.height < view.innerHeight / 3) {
+      insets.bottom = Math.max(insets.bottom, Math.min(view.innerHeight - rect.top, 120));
+    }
+  }
+  return insets;
+}
+async function scrollWindowTo(win, left, top, reducedMotion) {
+  win.scrollTo({
+    left,
+    top,
+    behavior: reducedMotion ? "auto" : "smooth"
+  });
+  if (!reducedMotion) {
+    await waitForScrollIdle(win);
+  }
+}
+function waitForScrollIdle(win) {
+  return new Promise((resolve) => {
+    let last = win.scrollY;
+    let stable = 0;
+    const timer = win.setInterval(() => {
+      if (Math.abs(win.scrollY - last) < 1) {
+        stable += 1;
+      } else {
+        stable = 0;
+        last = win.scrollY;
+      }
+      if (stable >= 3) {
+        win.clearInterval(timer);
+        resolve();
+      }
+    }, 50);
+    win.setTimeout(() => {
+      win.clearInterval(timer);
+      resolve();
+    }, 1200);
+  });
+}
+
+// src/utils/geometry.ts
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function isRectInComfortableView(target, viewport, insets) {
+  const top = insets.top + 8;
+  const left = insets.left + 8;
+  const right = viewport.width - insets.right - 8;
+  const bottom = viewport.height - insets.bottom - 8;
+  return target.x >= left && target.y >= top && target.x + target.width <= right && target.y + target.height <= bottom;
+}
+function computeScrollTarget(target, viewport, insets) {
+  const visibleHeight = viewport.height - insets.top - insets.bottom;
+  const visibleWidth = viewport.width - insets.left - insets.right;
+  const desiredTop = target.y + viewport.scrollY - insets.top - visibleHeight / 2 + target.height / 2;
+  const desiredLeft = target.x + viewport.scrollX - insets.left - visibleWidth / 2 + target.width / 2;
+  return {
+    left: Math.max(0, desiredLeft),
+    top: Math.max(0, desiredTop)
+  };
+}
+function computeAvatarDestination(input) {
+  const gap = input.gap ?? AVATAR_TARGET_GAP;
+  const padding = AVATAR_VIEWPORT_PADDING;
+  const { target, viewport, avatarSize, insets } = input;
+  const minX = insets.left + padding;
+  const minY = insets.top + padding;
+  const maxX = viewport.width - insets.right - avatarSize.width - padding;
+  const maxY = viewport.height - insets.bottom - avatarSize.height - padding;
+  const leftCandidate = target.x - avatarSize.width - gap;
+  const rightCandidate = target.x + target.width + gap;
+  const centeredY = target.y + target.height / 2 - avatarSize.height / 2;
+  let avatarX;
+  let facing;
+  if (leftCandidate >= minX) {
+    avatarX = leftCandidate;
+    facing = "right";
+  } else if (rightCandidate + avatarSize.width <= maxX + avatarSize.width) {
+    avatarX = rightCandidate;
+    facing = "left";
+  } else {
+    avatarX = minX;
+    facing = "right";
+  }
+  const avatarY = clamp(centeredY, minY, Math.max(minY, maxY));
+  avatarX = clamp(avatarX, minX, Math.max(minX, maxX));
+  const needsScroll = !isRectInComfortableView(target, viewport, insets);
+  const scroll = needsScroll ? computeScrollTarget(target, viewport, insets) : {
+    left: viewport.scrollX,
+    top: viewport.scrollY
+  };
+  return {
+    avatarX,
+    avatarY,
+    facing,
+    needsScroll,
+    scrollLeft: scroll.left,
+    scrollTop: scroll.top
+  };
+}
+function anchorToViewport(position, viewport, avatarSize, insets) {
+  const padding = AVATAR_VIEWPORT_PADDING;
+  const xLeft = insets.left + padding;
+  const yTop = insets.top + padding;
+  const xRight = viewport.width - insets.right - avatarSize.width - padding;
+  const yBottom = viewport.height - insets.bottom - avatarSize.height - padding;
+  switch (position) {
+    case "bottom-left":
+      return { x: xLeft, y: Math.max(yTop, yBottom) };
+    case "top-right":
+      return { x: Math.max(xLeft, xRight), y: yTop };
+    case "top-left":
+      return { x: xLeft, y: yTop };
+    case "bottom-right":
+    default:
+      return { x: Math.max(xLeft, xRight), y: Math.max(yTop, yBottom) };
+  }
+}
+
+// src/movement/MovementEngine.ts
+var MovementEngine = class {
+  constructor(win, doc, renderer, resolver, events, getConfig) {
+    this.win = win;
+    this.doc = doc;
+    this.renderer = renderer;
+    this.resolver = resolver;
+    this.events = events;
+    this.getConfig = getConfig;
+    this.x = 0;
+    this.y = 0;
+    this.onViewport = throttle(() => {
+      if (this.followTarget) {
+        this.placeBeside(this.followTarget, false);
+      }
+    }, VIEWPORT_HANDLER_THROTTLE_MS);
+  }
+  start() {
+    this.win.addEventListener("scroll", this.onViewport, true);
+    this.win.addEventListener("resize", this.onViewport);
+  }
+  stop() {
+    this.win.removeEventListener("scroll", this.onViewport, true);
+    this.win.removeEventListener("resize", this.onViewport);
+    this.onViewport.cancel();
+  }
+  goToAnchor() {
+    const config = this.getConfig();
+    const size = this.renderer.getSize();
+    const viewport = this.viewport();
+    const point = anchorToViewport(config.position, viewport, size, estimateSafeInsets(this.doc));
+    this.setPosition(point.x, point.y, !prefersReducedMotion(this.win));
+  }
+  async moveTo(target, source) {
+    const resolved = this.resolver.resolve(target, source);
+    this.events.emit("asiyst:target:found", { target: typeof target === "string" ? { id: target } : target, elementId: resolved.mapped.id });
+    await this.placeBeside(resolved.element, true);
+    this.followTarget = resolved.element;
+    return resolved.mapped.rect;
+  }
+  async pointAt(target, source) {
+    await this.moveTo(target, source);
+    this.renderer.setPose("point");
+  }
+  async placeBeside(element, mayScroll) {
+    const reduced = prefersReducedMotion(this.win);
+    const size = this.renderer.getSize();
+    const viewport = this.viewport();
+    const insets = estimateSafeInsets(this.doc);
+    const rect = element.getBoundingClientRect();
+    const plan = computeAvatarDestination({
+      target: { x: rect.left, y: rect.top, width: rect.width, height: rect.height },
+      viewport,
+      avatarSize: size,
+      insets
+    });
+    if (mayScroll && plan.needsScroll) {
+      await scrollWindowTo(this.win, plan.scrollLeft, plan.scrollTop, reduced);
+      return this.placeBeside(element, false);
+    }
+    this.renderer.setFacing(plan.facing);
+    this.renderer.setPose("walk");
+    this.setPosition(plan.avatarX, plan.avatarY, !reduced);
+    this.renderer.setPose("idle");
+  }
+  setPosition(x, y, animate) {
+    this.x = x;
+    this.y = y;
+    this.renderer.setPosition(x, y, animate);
+    this.events.emit("asiyst:avatar:moved", { x, y });
+  }
+  currentPosition() {
+    return { x: this.x, y: this.y };
+  }
+  viewport() {
+    return {
+      width: this.win.innerWidth,
+      height: this.win.innerHeight,
+      scrollX: this.win.scrollX,
+      scrollY: this.win.scrollY
+    };
+  }
+};
+
+// src/avatar/AvatarController.ts
+var AvatarController = class {
+  constructor(renderer, movement, highlights, resolver, events, liveRegion, getConfig) {
+    this.renderer = renderer;
+    this.movement = movement;
+    this.highlights = highlights;
+    this.resolver = resolver;
+    this.events = events;
+    this.liveRegion = liveRegion;
+    this.getConfig = getConfig;
+  }
+  show() {
+    this.renderer.setHidden(false);
+    this.movement.goToAnchor();
+    this.events.emit("asiyst:avatar:shown", { name: this.getConfig().avatarName });
+  }
+  hide() {
+    this.renderer.setHidden(true);
+    this.highlights.hide();
+    this.events.emit("asiyst:avatar:hidden", { name: this.getConfig().avatarName });
+  }
+  async moveTo(target, source = "developer") {
+    await this.movement.moveTo(target, source);
+  }
+  async pointAt(target, source = "developer") {
+    await this.movement.pointAt(target, source);
+  }
+  async highlight(target, style = "outline", source = "developer") {
+    const resolved = this.resolver.resolve(target, source);
+    await this.movement.moveTo(target, source);
+    this.highlights.show(resolved.element, style);
+    this.events.emit("asiyst:target:highlighted", {
+      elementId: resolved.mapped.id,
+      style
+    });
+    return resolved.mapped.id;
+  }
+  speak(message) {
+    const text = message.trim();
+    this.renderer.setSpeech(text || null);
+    this.renderer.setPose("speak");
+    renderSafeText(this.liveRegion, text);
+  }
+  think() {
+    this.renderer.setPose("think");
+  }
+  celebrate() {
+    this.renderer.setPose("celebrate");
+  }
+  setPosition(x, y) {
+    this.movement.setPosition(x, y, true);
+  }
+  applyConfig(config) {
+    this.renderer.applyConfig(config);
+  }
+  getFigure() {
+    return this.renderer.getFigure();
+  }
+};
+
+// src/interaction/permissions.ts
+function isActionAllowed(action, config, source) {
+  if (source === "developer") {
+    return true;
+  }
+  return config.allowedActions.includes(action);
+}
+function assertActionAllowed(action, config, source) {
+  if (!isActionAllowed(action, config, source)) {
+    throw new ActionNotAllowedError(`Action "${action}" is not permitted for this project`);
+  }
+}
+function shouldWaitForUser(action, mode, waitForUser) {
+  if (waitForUser === true) {
+    return true;
+  }
+  if (waitForUser === false) {
+    return false;
+  }
+  if (mode === "guided" && (action === "click" || action === "type" || action === "select" || action === "navigate")) {
+    return true;
+  }
+  return false;
+}
+
+// src/interaction/InteractionEngine.ts
+var InteractionEngine = class {
+  constructor(avatar, resolver, getConfig, win) {
+    this.avatar = avatar;
+    this.resolver = resolver;
+    this.getConfig = getConfig;
+    this.win = win;
+  }
+  cancelWait() {
+    this.stopWait?.();
+  }
+  async execute(step, source) {
+    const config = this.getConfig();
+    assertActionAllowed(step.action, config, source);
+    const wait = shouldWaitForUser(step.action, config.mode, step.waitForUser);
+    switch (step.action) {
+      case "explain":
+      case "wait":
+        if (step.message) {
+          this.avatar.speak(step.message);
+        }
+        return { ok: true, waitedForUser: false };
+      case "highlight":
+        return this.highlight(step, source, wait);
+      case "scroll":
+      case "click":
+      case "open-menu":
+      case "open-modal":
+      case "search":
+      case "type":
+      case "select":
+        return this.guideToward(step, source, wait);
+      case "navigate":
+        return this.navigate(step, source, wait);
+      case "complete":
+        this.avatar.celebrate();
+        if (step.message) {
+          this.avatar.speak(step.message);
+        }
+        return { ok: true, waitedForUser: false };
+      default:
+        throw new TaskExecutionError("Unsupported action");
+    }
+  }
+  async highlight(step, source, wait) {
+    if (!step.target) {
+      throw new TaskExecutionError("Highlight requires a target");
+    }
+    const style = step.highlightStyle ?? "outline";
+    const elementId2 = await this.avatar.highlight(step.target, style, source);
+    if (step.message) {
+      this.avatar.speak(step.message);
+    }
+    return { ok: true, waitedForUser: wait, elementId: elementId2 };
+  }
+  async guideToward(step, source, wait) {
+    if (!step.target) {
+      throw new TaskExecutionError(`${step.action} requires a target`);
+    }
+    if (step.action === "type" || step.action === "select" || step.action === "click") {
+      if (!wait) {
+        throw new TaskExecutionError(`${step.action} may only run when the user performs it or waitForUser is enabled`);
+      }
+    }
+    const elementId2 = await this.avatar.highlight(step.target, step.highlightStyle ?? "pulse", source);
+    if (step.message) {
+      this.avatar.speak(step.message);
+    } else {
+      this.avatar.speak(defaultInstruction(step.action, step.target));
+    }
+    return { ok: true, waitedForUser: true, elementId: elementId2 };
+  }
+  async navigate(step, source, wait) {
+    if (step.target) {
+      return this.guideToward(step, source, wait);
+    }
+    if (!step.url) {
+      throw new TaskExecutionError("Navigate requires a target or url");
+    }
+    if (!wait) {
+      throw new TaskExecutionError("Automatic navigation is not enabled");
+    }
+    if (step.message) {
+      this.avatar.speak(step.message);
+    }
+    return { ok: true, waitedForUser: true };
+  }
+  waitForElementClick(elementId2, timeoutMs) {
+    return new Promise((resolve) => {
+      const resolved = this.resolver.tryResolve(elementId2, "local");
+      if (!resolved) {
+        resolve(false);
+        return;
+      }
+      const finish = (clicked) => {
+        this.win.clearTimeout(timer);
+        this.win.removeEventListener("click", onClick, true);
+        this.stopWait = void 0;
+        resolve(clicked);
+      };
+      const timer = this.win.setTimeout(() => finish(false), timeoutMs);
+      const onClick = (event) => {
+        const node = event.target;
+        if (!(node instanceof Element)) {
+          return;
+        }
+        if (node === resolved.element || resolved.element.contains(node)) {
+          finish(true);
+        }
+      };
+      this.stopWait = () => finish(false);
+      this.win.addEventListener("click", onClick, true);
+    });
+  }
+};
+function defaultInstruction(action, target) {
+  const name = typeof target === "string" ? target : target.id ?? target.text ?? "this control";
+  switch (action) {
+    case "type":
+      return `Type into ${name}.`;
+    case "select":
+      return `Choose an option in ${name}.`;
+    case "navigate":
+      return `Open ${name}.`;
+    default:
+      return `Click ${name}.`;
+  }
+}
+
+// src/task/states.ts
+var TaskStatus = {
+  Idle: "idle",
+  UserRequest: "user_request",
+  IntentDetected: "intent_detected",
+  TaskCreated: "task_created",
+  TargetResolved: "target_resolved",
+  ActionStarted: "action_started",
+  WaitingForUser: "waiting_for_user",
+  UserActionDetected: "user_action_detected",
+  StepCompleted: "step_completed",
+  NextStep: "next_step",
+  TaskCompleted: "task_completed",
+  Failed: "failed",
+  Cancelled: "cancelled",
+  Timeout: "timeout",
+  TargetNotFound: "target_not_found"
+};
+var TRANSITIONS = {
+  [TaskStatus.Idle]: [TaskStatus.UserRequest],
+  [TaskStatus.UserRequest]: [TaskStatus.IntentDetected, TaskStatus.Failed, TaskStatus.Cancelled],
+  [TaskStatus.IntentDetected]: [TaskStatus.TaskCreated, TaskStatus.Failed, TaskStatus.Cancelled],
+  [TaskStatus.TaskCreated]: [TaskStatus.TargetResolved, TaskStatus.ActionStarted, TaskStatus.Failed, TaskStatus.Cancelled, TaskStatus.TargetNotFound],
+  [TaskStatus.TargetResolved]: [
+    TaskStatus.ActionStarted,
+    TaskStatus.Failed,
+    TaskStatus.Cancelled,
+    TaskStatus.TargetNotFound
+  ],
+  [TaskStatus.ActionStarted]: [
+    TaskStatus.WaitingForUser,
+    TaskStatus.StepCompleted,
+    TaskStatus.Failed,
+    TaskStatus.Cancelled,
+    TaskStatus.Timeout,
+    TaskStatus.TargetNotFound
+  ],
+  [TaskStatus.WaitingForUser]: [
+    TaskStatus.UserActionDetected,
+    TaskStatus.Timeout,
+    TaskStatus.Cancelled,
+    TaskStatus.Failed
+  ],
+  [TaskStatus.UserActionDetected]: [TaskStatus.StepCompleted, TaskStatus.Failed, TaskStatus.Cancelled],
+  [TaskStatus.StepCompleted]: [TaskStatus.NextStep, TaskStatus.TaskCompleted, TaskStatus.Cancelled],
+  [TaskStatus.NextStep]: [TaskStatus.TargetResolved, TaskStatus.ActionStarted, TaskStatus.Failed, TaskStatus.Cancelled, TaskStatus.TargetNotFound],
+  [TaskStatus.TaskCompleted]: [TaskStatus.Idle],
+  [TaskStatus.Failed]: [TaskStatus.Idle],
+  [TaskStatus.Cancelled]: [TaskStatus.Idle],
+  [TaskStatus.Timeout]: [TaskStatus.Idle, TaskStatus.Failed],
+  [TaskStatus.TargetNotFound]: [TaskStatus.Idle, TaskStatus.Failed]
+};
+function canTransition(from, to) {
+  return TRANSITIONS[from].includes(to);
+}
+function transition(from, to) {
+  if (!canTransition(from, to)) {
+    throw new Error(`Invalid task transition: ${from} -> ${to}`);
+  }
+  return to;
+}
+
+// src/task/TaskEngine.ts
+var TaskEngine = class {
+  constructor(interaction, events, analytics, cloud) {
+    this.interaction = interaction;
+    this.events = events;
+    this.analytics = analytics;
+    this.cloud = cloud;
+    this.status = TaskStatus.Idle;
+    this.abort = false;
+  }
+  getStatus() {
+    return this.status;
+  }
+  async run(task, source) {
+    this.abort = false;
+    this.active = task;
+    this.move(TaskStatus.UserRequest);
+    this.move(TaskStatus.IntentDetected);
+    this.move(TaskStatus.TaskCreated);
+    this.events.emit("asiyst:task:started", { taskId: task.id });
+    this.analytics.track("task_started", { taskId: task.id });
+    this.analytics.track("guide_started", { taskId: task.id });
+    void this.cloud.sendTaskUpdate(task.id, this.status);
+    try {
+      for (const [index, step] of task.steps.entries()) {
+        if (this.abort) {
+          return TaskStatus.Cancelled;
+        }
+        if (index > 0) {
+          this.move(TaskStatus.NextStep);
+        }
+        if (step.target) {
+          this.move(TaskStatus.TargetResolved);
+        }
+        this.move(TaskStatus.ActionStarted);
+        const result = await this.interaction.execute(step, source);
+        if (result.waitedForUser && result.elementId) {
+          this.move(TaskStatus.WaitingForUser);
+          const clicked = await this.interaction.waitForElementClick(result.elementId, step.timeoutMs ?? 3e4);
+          if (this.abort) {
+            return TaskStatus.Cancelled;
+          }
+          if (!clicked) {
+            this.move(TaskStatus.Timeout);
+            return this.finish(TaskStatus.Failed, "Timed out waiting for the user");
+          }
+          this.move(TaskStatus.UserActionDetected);
+          this.events.emit("asiyst:user:clicked", { elementId: result.elementId });
+          this.analytics.track("user_clicked_instructed_element", { elementId: result.elementId });
+        }
+        this.move(TaskStatus.StepCompleted);
+        this.events.emit("asiyst:task:step-completed", { taskId: task.id, stepId: step.id });
+        void this.cloud.sendTaskUpdate(task.id, this.status, step.id);
+      }
+      this.move(TaskStatus.TaskCompleted);
+      this.events.emit("asiyst:task:completed", { taskId: task.id });
+      this.analytics.track("task_completed", { taskId: task.id });
+      this.analytics.track("guide_completed", { taskId: task.id });
+      void this.cloud.sendTaskUpdate(task.id, this.status);
+      this.move(TaskStatus.Idle);
+      return TaskStatus.TaskCompleted;
+    } catch (error) {
+      if (error instanceof TargetNotFoundError) {
+        if (canTransition(this.status, TaskStatus.TargetNotFound)) {
+          this.move(TaskStatus.TargetNotFound);
+        }
+        this.events.emit("asiyst:target:not-found", { target: {} });
+        this.analytics.track("target_not_found", { taskId: task.id });
+        return this.finish(TaskStatus.Failed, error.message);
+      }
+      const message = error instanceof Error ? error.message : "Task failed";
+      return this.finish(TaskStatus.Failed, message);
+    }
+  }
+  cancel() {
+    this.abort = true;
+    this.interaction.cancelWait();
+    if (this.status !== TaskStatus.Idle) {
+      this.finish(TaskStatus.Cancelled);
+    }
+  }
+  finish(terminal, reason) {
+    const taskId = this.active?.id ?? "unknown";
+    if (this.status !== terminal && canTransition(this.status, terminal)) {
+      this.move(terminal);
+    }
+    if (terminal === TaskStatus.Cancelled) {
+      this.events.emit("asiyst:task:cancelled", { taskId });
+    } else if (terminal !== TaskStatus.TaskCompleted) {
+      this.events.emit("asiyst:task:failed", { taskId, reason: reason ?? terminal });
+      this.analytics.track("task_failed", { taskId });
+    }
+    if (canTransition(this.status, TaskStatus.Idle)) {
+      this.move(TaskStatus.Idle);
+    } else {
+      this.status = TaskStatus.Idle;
+    }
+    return terminal;
+  }
+  move(next) {
+    this.status = transition(this.status, next);
+  }
+};
+
+// src/workflow/WorkflowEngine.ts
+var WorkflowEngine = class {
+  constructor(cloud, tasks) {
+    this.cloud = cloud;
+    this.tasks = tasks;
+  }
+  async start(workflowId, source = "developer") {
+    const workflow = await this.cloud.fetchWorkflow(workflowId);
+    await this.run(workflow, source);
+  }
+  async run(workflow, source) {
+    await this.tasks.run(
+      {
+        id: workflow.id,
+        title: workflow.title,
+        steps: workflow.steps
+      },
+      source
+    );
+  }
+};
+
+// src/client/ConversationPanel.ts
+var ConversationPanel = class {
+  constructor(root, onSubmit, onToggle) {
+    this.onSubmit = onSubmit;
+    this.onToggle = onToggle;
+    this.conversationId = "";
+    this.openState = false;
+    const doc = root.ownerDocument;
+    const style = doc.createElement("style");
+    style.textContent = `
+      .asiyst-panel {
+        position: fixed;
+        right: 16px;
+        bottom: 16px;
+        width: min(360px, calc(100vw - 32px));
+        max-height: min(480px, 70vh);
+        background: #fff;
+        color: #0f172a;
+        border-radius: 16px;
+        box-shadow: 0 16px 50px rgba(15, 23, 42, 0.22);
+        display: flex;
+        flex-direction: column;
+        font: 14px/1.45 system-ui, sans-serif;
+        overflow: hidden;
+      }
+      .asiyst-panel[hidden] { display: none; }
+      .asiyst-panel header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 12px 14px;
+        background: #0f172a;
+        color: #f8fafc;
+      }
+      .asiyst-log { flex: 1; overflow: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
+      .asiyst-msg { padding: 8px 10px; border-radius: 10px; max-width: 90%; }
+      .asiyst-msg[data-role="user"] { align-self: flex-end; background: #dbeafe; }
+      .asiyst-msg[data-role="assistant"] { align-self: flex-start; background: #f1f5f9; }
+      .asiyst-form { display: flex; gap: 8px; padding: 10px; border-top: 1px solid #e2e8f0; }
+      .asiyst-form input { flex: 1; border: 1px solid #cbd5e1; border-radius: 8px; padding: 8px; }
+      .asiyst-form button, .asiyst-close {
+        border: 0; border-radius: 8px; padding: 8px 10px; background: #2563eb; color: #fff; cursor: pointer;
+      }
+      .asiyst-close { background: transparent; color: #f8fafc; }
+    `;
+    root.appendChild(style);
+    this.panel = doc.createElement("section");
+    this.panel.className = "asiyst-panel";
+    this.panel.hidden = true;
+    this.panel.setAttribute("role", "dialog");
+    this.panel.setAttribute("aria-modal", "false");
+    this.panel.setAttribute("aria-label", "Asiyst assistant");
+    const header = doc.createElement("header");
+    const title = doc.createElement("strong");
+    title.textContent = "Asiyst";
+    const close = doc.createElement("button");
+    close.type = "button";
+    close.className = "asiyst-close";
+    close.textContent = "Close";
+    close.addEventListener("click", () => this.close());
+    header.append(title, close);
+    this.log = doc.createElement("div");
+    this.log.className = "asiyst-log";
+    this.form = doc.createElement("form");
+    this.form.className = "asiyst-form";
+    this.input = doc.createElement("input");
+    this.input.type = "text";
+    this.input.setAttribute("aria-label", "Message Asiyst");
+    this.input.autocomplete = "off";
+    const send = doc.createElement("button");
+    send.type = "submit";
+    send.textContent = "Send";
+    this.form.append(this.input, send);
+    this.form.addEventListener("submit", (event) => {
+      event.preventDefault();
+      void this.submit();
+    });
+    this.panel.append(header, this.log, this.form);
+    root.appendChild(this.panel);
+    doc.addEventListener("keydown", (event) => {
+      if (event.key === "Escape" && this.openState) {
+        this.close();
+      }
+    });
+  }
+  isOpen() {
+    return this.openState;
+  }
+  getConversationId() {
+    return this.conversationId;
+  }
+  open() {
+    if (!this.conversationId) {
+      this.conversationId = `conv_${Date.now().toString(36)}`;
+    }
+    this.openState = true;
+    this.panel.hidden = false;
+    this.input.focus();
+    this.onToggle(true);
+  }
+  close() {
+    this.openState = false;
+    this.panel.hidden = true;
+    this.onToggle(false);
+  }
+  append(role, text) {
+    const item = this.log.ownerDocument.createElement("div");
+    item.className = "asiyst-msg";
+    item.setAttribute("data-role", role);
+    renderSafeText(item, text);
+    this.log.appendChild(item);
+    this.log.scrollTop = this.log.scrollHeight;
+  }
+  async submit() {
+    const text = sanitizeText(this.input.value);
+    if (!text) {
+      return;
+    }
+    this.input.value = "";
+    this.append("user", text);
+    await this.onSubmit(text);
+  }
+};
+
+// src/core/isolate.ts
+async function isolateAsync(fn, fallback) {
+  try {
+    return await fn();
+  } catch {
+    return fallback;
+  }
+}
+function withIsolation(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
+
+// src/core/Runtime.ts
+var AsiystRuntime = class {
+  constructor(options, doc, win) {
+    this.events = new EventBus();
+    this.map = new WebsiteMap();
+    this.observer = new DomObserver(() => this.rescan());
+    this.destroyed = false;
+    this.rescanDebounced = debounce(() => this.rescan(), DOM_SCAN_DEBOUNCE_MS);
+    if (!doc.body) {
+      throw new InitializationError("document.body is not available");
+    }
+    this.options = options;
+    const transport = new HttpTransport({
+      apiBaseUrl: options.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+      projectId: options.projectId,
+      publicKey: options.publicKey
+    });
+    this.cloud = new CloudClient(transport, options.projectId);
+    this.config = new ConfigManager(options, this.cloud, this.events);
+    this.analytics = new Analytics(options.projectId, this.cloud);
+    this.host = new HostRoot(doc);
+    this.resolver = new TargetResolver(
+      doc,
+      () => this.config.get().elementSelectors,
+      () => this.map.list()
+    );
+    this.renderer = new CssAvatarRenderer();
+    this.renderer.mount(this.host.chrome, this.config.get());
+    this.highlights = new HighlightLayer(this.host.overlay, win);
+    this.movement = new MovementEngine(win, doc, this.renderer, this.resolver, this.events, () => this.config.get());
+    const live = createLiveRegion(this.host.shadow);
+    this.avatar = new AvatarController(
+      this.renderer,
+      this.movement,
+      this.highlights,
+      this.resolver,
+      this.events,
+      live,
+      () => this.config.get()
+    );
+    const interaction = new InteractionEngine(this.avatar, this.resolver, () => this.config.get(), win);
+    this.tasks = new TaskEngine(interaction, this.events, this.analytics, this.cloud);
+    this.workflows = new WorkflowEngine(this.cloud, this.tasks);
+    this.panel = new ConversationPanel(
+      this.host.chrome,
+      (text) => this.handleUserMessage(text, doc),
+      (open) => {
+        if (open) {
+          this.analytics.track("assistant_opened");
+          this.events.emit("asiyst:conversation:started", { conversationId: this.panel.getConversationId() });
+        } else {
+          this.analytics.track("assistant_closed");
+          this.events.emit("asiyst:conversation:closed", { conversationId: this.panel.getConversationId() });
+        }
+      }
+    );
+    this.history = new HistoryObserver(() => this.rescanDebounced());
+    this.history.start(win, options.observeHistory !== false);
+    this.observer.start(doc.documentElement);
+    this.highlights.start();
+    this.movement.start();
+    this.analytics.start();
+    this.rescan();
+    this.avatar.show();
+    this.renderer.getFigure()?.addEventListener("click", () => this.open());
+    win.addEventListener("pagehide", () => {
+      void this.analytics.flush();
+    });
+  }
+  async start() {
+    this.events.emit("asiyst:initialized", { projectId: this.options.projectId });
+    const cfg = await isolateAsync(() => this.config.refresh(), this.config.get());
+    this.avatar.applyConfig(cfg);
+    this.avatar.show();
+    this.events.emit("asiyst:ready", { projectId: this.options.projectId, configVersion: cfg.version });
+  }
+  getConfig() {
+    return this.config.get();
+  }
+  open() {
+    this.panel.open();
+    this.avatar.show();
+  }
+  close() {
+    this.panel.close();
+  }
+  avatarApi() {
+    return this.avatar;
+  }
+  async startTaskFromText(text, doc) {
+    this.analytics.track("question_started");
+    const task = await this.cloud.requestTask(text, doc.location.href);
+    const result = await this.tasks.run(task, "cloud");
+    if (result === "task_completed") {
+      this.analytics.track("question_completed");
+    }
+  }
+  async startTask(task) {
+    await this.tasks.run(task, "developer");
+  }
+  cancelTask() {
+    this.tasks.cancel();
+  }
+  async startWorkflow(id) {
+    await this.workflows.start(id, "cloud");
+  }
+  async startWorkflowDefinition(workflow) {
+    await this.workflows.run(workflow, "developer");
+  }
+  on(event, handler) {
+    return this.events.on(event, handler);
+  }
+  off(event, handler) {
+    this.events.off(event, handler);
+  }
+  async destroy(win) {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.observer.stop();
+    this.history.stop(win);
+    this.movement.stop();
+    this.highlights.stop();
+    this.rescanDebounced.cancel();
+    this.renderer.unmount();
+    this.host.destroy();
+    this.events.emit("asiyst:destroyed", { projectId: this.options.projectId });
+    this.events.removeAll();
+    await this.analytics.destroy();
+  }
+  rescan() {
+    withIsolation(() => {
+      const doc = this.host.host.ownerDocument;
+      this.map.replace(inspectDocument(doc));
+      void this.cloud.sendWebsiteMap(this.map.snapshot(doc));
+    });
+  }
+  async handleUserMessage(text, doc) {
+    this.events.emit("asiyst:conversation:message", { role: "user", text });
+    this.avatar.think();
+    try {
+      const reply = await this.cloud.sendConversationMessage(text, doc.location.href);
+      this.panel.append("assistant", reply.message.text);
+      this.avatar.speak(reply.message.text);
+      this.events.emit("asiyst:conversation:message", { role: "assistant", text: reply.message.text });
+      await this.startTaskFromText(text, doc);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Asiyst Cloud is unavailable";
+      this.panel.append("assistant", message);
+      this.events.emit("asiyst:error", { code: "conversation_failed", message });
+      this.avatar.speak(message);
+    }
+  }
+};
+
+// src/client/Asiyst.ts
+var runtime;
+var initPromise;
+function requireRuntime() {
+  if (!runtime) {
+    throw new InitializationError("Call Asiyst.init() before using the SDK");
+  }
+  return runtime;
+}
+var Asiyst = {
+  async init(options) {
+    if (runtime) {
+      throw new InitializationError("Asiyst is already initialized");
+    }
+    const credentials = validateInitOptions(options);
+    const doc = document;
+    const win = window;
+    runtime = new AsiystRuntime({ ...options, ...credentials }, doc, win);
+    initPromise = runtime.start();
+    await initPromise;
+  },
+  async destroy() {
+    if (!runtime) {
+      return;
+    }
+    const current = runtime;
+    runtime = void 0;
+    initPromise = void 0;
+    await current.destroy(window);
+  },
+  open() {
+    withIsolation(() => requireRuntime().open());
+  },
+  close() {
+    withIsolation(() => requireRuntime().close());
+  },
+  getConfig() {
+    return requireRuntime().getConfig();
+  },
+  avatar: {
+    show() {
+      withIsolation(() => requireRuntime().avatarApi().show());
+    },
+    hide() {
+      withIsolation(() => requireRuntime().avatarApi().hide());
+    },
+    async moveTo(target) {
+      await requireRuntime().avatarApi().moveTo(target, "developer");
+    },
+    async pointAt(target) {
+      await requireRuntime().avatarApi().pointAt(target, "developer");
+    },
+    async highlight(target, style) {
+      await requireRuntime().avatarApi().highlight(target, style ?? "outline", "developer");
+    },
+    speak(message) {
+      withIsolation(() => requireRuntime().avatarApi().speak(message));
+    },
+    think() {
+      withIsolation(() => requireRuntime().avatarApi().think());
+    },
+    celebrate() {
+      withIsolation(() => requireRuntime().avatarApi().celebrate());
+    },
+    setPosition(x, y) {
+      withIsolation(() => requireRuntime().avatarApi().setPosition(x, y));
+    }
+  },
+  task: {
+    async start(input) {
+      const current = requireRuntime();
+      if (typeof input === "string") {
+        await current.startTaskFromText(input, document);
+        return;
+      }
+      await current.startTask(input);
+    },
+    cancel() {
+      withIsolation(() => requireRuntime().cancelTask());
+    }
+  },
+  workflow: {
+    async start(workflowId) {
+      await requireRuntime().startWorkflow(workflowId);
+    }
+  },
+  on(event, handler) {
+    return requireRuntime().on(event, handler);
+  },
+  off(event, handler) {
+    requireRuntime().off(event, handler);
+  }
+};
+
+exports.ActionNotAllowedError = ActionNotAllowedError;
+exports.Asiyst = Asiyst;
+exports.AsiystError = AsiystError;
+exports.AuthenticationError = AuthenticationError;
+exports.ConfigurationError = ConfigurationError;
+exports.InitializationError = InitializationError;
+exports.NetworkError = NetworkError;
+exports.SDK_VERSION = SDK_VERSION;
+exports.TargetNotFoundError = TargetNotFoundError;
+exports.TaskExecutionError = TaskExecutionError;
+exports.TaskStatus = TaskStatus;
+exports.anchorToViewport = anchorToViewport;
+exports.canTransition = canTransition;
+exports.computeAvatarDestination = computeAvatarDestination;
+exports.fallbackConfig = fallbackConfig;
+exports.isSafeSelector = isSafeSelector;
+exports.normalizeProjectConfig = normalizeProjectConfig;
+exports.sanitizeText = sanitizeText;
+exports.validateInitOptions = validateInitOptions;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map