arcy.js 0.0.2 → 0.1.1

package/dist/index.js

@@ -0,0 +1,4743 @@
+import { DESIGN_MODE_PROTOCOL, DESIGN_MODE_EXIT, DESIGN_MODE_SCREENSHOT, DESIGN_MODE_PICK, DESIGN_MODE_READY } from './chunk-7VVKR3AO.js';
+import { FONT_KEY_PROPERTY, FALLBACK_CHROME, readViewport, POLICY_LINK_CLASS, BAR_TRAY_CLASS, ATTACHABLE_TYPES, TOOLTIP_CSS, surfaceWidth, clampOffsetX, dragTransform, carriesFiles, droppedFiles, MOBILE_MARGIN, CHAT_CONTRACT, CHAT_GLOBAL } from './chunk-6HBSGVRN.js';
+import { createShellState, safeStore, browserSessionStorage, writeJson, browserLocalStorage, readJson, hasPendingPreview, createFlowRunState, FLOW_CONTRACT, FLOW_GLOBAL } from './chunk-FR6SJSDU.js';
+import { PICKER_CONTRACT, PICKER_GLOBAL } from './chunk-DKYMIAYF.js';
+import { warn, reportCspViolations, releaseHostFocus, Z_INDEX, createShell, injectStyles } from './chunk-LGWYJSYX.js';
+import { captureEventFingerprint, containsPii } from './chunk-NY3NXM2V.js';
+
+/* arcy.js — https://arcyai.com */
+
+// src/emitter.ts
+function createEmitter() {
+  const handlers = /* @__PURE__ */ new Map();
+  function on(event, handler) {
+    if (typeof handler !== "function") {
+      warn(`on("${event}") needs a function. Ignoring.`);
+      return () => {
+      };
+    }
+    let set = handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  function emit(event) {
+    const set = handlers.get(event);
+    if (!set) return;
+    for (const handler of [...set]) {
+      try {
+        handler();
+      } catch (error) {
+        warn(`A "${event}" handler threw. ${String(error)}`);
+      }
+    }
+  }
+  return { on, emit };
+}
+
+// src/telemetry/route.ts
+var MAX_ROUTE_LENGTH = 2048;
+var OPAQUE = /^(?:\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{12,})$/i;
+var EMAIL = /^[^@\s/]+@[^@\s/]+\.[^@\s/]+$/;
+function decodeForTest(segment) {
+  if (segment.indexOf("%") === -1) return segment;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function isIdentifierShaped(segment) {
+  if (segment.length === 0) return false;
+  if (OPAQUE.test(segment)) return true;
+  return EMAIL.test(decodeForTest(segment));
+}
+function scrubPath(path) {
+  const scrubbed = path.split("/").map((segment) => isIdentifierShaped(segment) ? ":id" : segment).join("/");
+  let trimmed = scrubbed;
+  while (trimmed.length > 1 && trimmed.charAt(trimmed.length - 1) === "/") {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed.length === 0 ? "/" : trimmed;
+}
+function scrubQuery(query) {
+  if (query.length === 0) return "";
+  const keys = [];
+  for (const pair of query.split("&")) {
+    if (pair.length === 0) continue;
+    const eq = pair.indexOf("=");
+    const raw = eq === -1 ? pair : pair.slice(0, eq);
+    if (raw.length === 0) continue;
+    const key = isIdentifierShaped(raw) ? ":id" : raw;
+    if (keys.indexOf(key) === -1) keys.push(key);
+  }
+  if (keys.length === 0) return "";
+  keys.sort();
+  return `?${keys.join("&")}`;
+}
+function split(href, base) {
+  try {
+    const url = new URL(href, base ?? void 0);
+    return { path: url.pathname, query: url.search.slice(1) };
+  } catch {
+    const noHash = href.split("#")[0] ?? "";
+    if (!noHash.startsWith("/")) return null;
+    const q = noHash.indexOf("?");
+    return q === -1 ? { path: noHash, query: "" } : { path: noHash.slice(0, q), query: noHash.slice(q + 1) };
+  }
+}
+function normalizeRoute(href, base) {
+  if (typeof href !== "string" || href.length === 0) return null;
+  const parts = split(href, base);
+  if (parts === null) return null;
+  const path = scrubPath(parts.path);
+  if (!path) return null;
+  if (path.length >= MAX_ROUTE_LENGTH) return path.slice(0, MAX_ROUTE_LENGTH);
+  const query = scrubQuery(parts.query);
+  if (query.length === 0) return path;
+  return path.length + query.length > MAX_ROUTE_LENGTH ? path : path + query;
+}
+
+// src/picker/notice.ts
+var NOTICE_HOST_ID = "arcy-picker-notice";
+var CARD_OFFSET = [
+  ["left", "50%"],
+  ["bottom", "24px"]
+];
+var CARD_STYLE = [
+  ["transform", "translateX(-50%)"],
+  ["box-sizing", "border-box"],
+  ["max-width", "min(520px, calc(100vw - 32px))"],
+  ["padding", "14px 16px"],
+  ["border-radius", "12px"],
+  ["background", "#101828"],
+  ["color", "#ffffff"],
+  [
+    "font",
+    '13px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'
+  ],
+  ["box-shadow", "0 8px 24px rgba(16, 24, 40, 0.28)"]
+];
+var TITLE_STYLE = [
+  ["font-weight", "600"],
+  ["margin-bottom", "4px"]
+];
+var BODY_STYLE = [["color", "#d0d5dd"]];
+var BUTTON_STYLE = [
+  ["appearance", "none"],
+  ["margin-top", "10px"],
+  ["border", "1px solid rgba(255, 255, 255, 0.25)"],
+  ["border-radius", "999px"],
+  ["background", "transparent"],
+  ["color", "#ffffff"],
+  ["font", "inherit"],
+  ["padding", "4px 12px"],
+  ["cursor", "pointer"]
+];
+function style(el, declarations) {
+  for (const [property, value] of declarations) {
+    el.style.setProperty(property, value);
+  }
+}
+var shown = false;
+function showDesignModeNotice(message) {
+  if (shown) return;
+  let shell = null;
+  try {
+    shell = createShell({ id: NOTICE_HOST_ID });
+    if (!shell) return;
+    shown = true;
+    const doc = shell.host.ownerDocument;
+    const card = doc.createElement("div");
+    card.style.setProperty("position", "absolute", "important");
+    card.style.setProperty("pointer-events", "auto", "important");
+    for (const [property, value] of CARD_OFFSET) {
+      card.style.setProperty(property, value, "important");
+    }
+    style(card, CARD_STYLE);
+    const title = doc.createElement("div");
+    style(title, TITLE_STYLE);
+    title.textContent = "ARCY element picker did not start";
+    const body = doc.createElement("div");
+    style(body, BODY_STYLE);
+    body.textContent = message;
+    const dismiss = doc.createElement("button");
+    dismiss.type = "button";
+    style(dismiss, BUTTON_STYLE);
+    dismiss.textContent = "Dismiss";
+    const held = shell;
+    dismiss.addEventListener("click", () => {
+      try {
+        held.destroy();
+      } catch {
+      }
+    });
+    card.append(title, body, dismiss);
+    shell.root.appendChild(card);
+  } catch {
+    try {
+      shell?.destroy();
+    } catch {
+    }
+  }
+}
+
+// src/picker/activate.ts
+function refuse(message) {
+  warn(message);
+  showDesignModeNotice(message);
+}
+var PICKER_PARAM = "arcy_picker";
+var PICKER_VERIFY_PATH = "/api/v1/sdk/tagging/verify";
+var PICKER_LOAD_TIMEOUT_MS = 15e3;
+var VERIFY_TIMEOUT_MS = 1e4;
+function detectPickerNonce(search, hash) {
+  return readNonce(search) ?? readNonce(hash);
+}
+function readNonce(source) {
+  if (!source) return null;
+  try {
+    const nonce = new URLSearchParams(
+      source.charAt(0) === "#" ? source.slice(1) : source
+    ).get(PICKER_PARAM);
+    return nonce && nonce.length > 0 ? nonce : null;
+  } catch {
+    return null;
+  }
+}
+function stripPickerParam(win) {
+  try {
+    const url = new URL(win.location.href);
+    const inQuery = url.searchParams.has(PICKER_PARAM);
+    const inHash = readNonce(url.hash) !== null;
+    if (!inQuery && !inHash) return;
+    if (inQuery) url.searchParams.delete(PICKER_PARAM);
+    if (inHash) url.hash = "";
+    win.history.replaceState(win.history.state, "", url.toString());
+  } catch {
+  }
+}
+async function verifyPickerNonce(options) {
+  const {
+    apiBase,
+    token,
+    nonce,
+    fetchImpl,
+    timeoutMs = VERIFY_TIMEOUT_MS,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms)
+  } = options;
+  if (!fetchImpl) return null;
+  const attempt = async () => {
+    try {
+      const response = await fetchImpl(`${apiBase}${PICKER_VERIFY_PATH}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ token: nonce }),
+        credentials: "omit"
+      });
+      if (!response.ok) return null;
+      const body = await response.json();
+      if (body?.ok !== true) return null;
+      const returnOrigin = normalizeOrigin(body.returnOrigin);
+      if (!returnOrigin) {
+        refuse(
+          "This ARCY server has not been told where its dashboard lives, so a pick would have nowhere to go. Set FRONTEND_DASHBOARD_URL and try again."
+        );
+        return null;
+      }
+      return {
+        returnOrigin,
+        screenshotsEnabled: body.elementScreenshotsEnabled !== false
+      };
+    } catch {
+      return null;
+    }
+  };
+  const deadline = new Promise((resolve) => {
+    try {
+      setTimeoutImpl(() => resolve(null), timeoutMs);
+    } catch {
+    }
+  });
+  return Promise.race([attempt(), deadline]);
+}
+function normalizeOrigin(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  try {
+    const { origin } = new URL(value);
+    return origin && origin !== "null" ? origin : null;
+  } catch {
+    return null;
+  }
+}
+function currentPath(win) {
+  try {
+    const path = win.location.pathname;
+    if (typeof path !== "string" || !path.startsWith("/")) return "/";
+    return scrubPath(path);
+  } catch {
+    return "/";
+  }
+}
+function hasOpener(win) {
+  try {
+    const opener = win.opener;
+    return !!opener && !opener.closed;
+  } catch {
+    return false;
+  }
+}
+function postToOpener(win, returnOrigin, message) {
+  try {
+    const opener = win.opener;
+    if (!opener || opener.closed) {
+      warn("The ARCY dashboard window is gone, so that pick could not be sent.");
+      return;
+    }
+    opener.postMessage(message, returnOrigin);
+  } catch (error) {
+    warn(`That pick could not be sent to the ARCY dashboard. ${String(error)}`);
+  }
+}
+async function maybeActivateDesignMode(options) {
+  try {
+    const {
+      win,
+      token,
+      apiBase,
+      fetchImpl,
+      onVerified,
+      loadChunk,
+      loadTimeoutMs = PICKER_LOAD_TIMEOUT_MS,
+      setTimeoutImpl = (fn, ms) => setTimeout(fn, ms)
+    } = options;
+    const nonce = detectPickerNonce(win.location.search, win.location.hash);
+    if (!nonce) return "no_nonce";
+    stripPickerParam(win);
+    if (!hasOpener(win)) {
+      refuse(
+        "This page was not opened by the ARCY dashboard, so a picked element would have nowhere to go. If you did start it from the flow builder, this site is severing the link back: a Cross-Origin-Opener-Policy header on this page (helmet sets one by default) does exactly that. Serve this page with Cross-Origin-Opener-Policy: unsafe-none while you author."
+      );
+      return "no_opener";
+    }
+    const verified = await verifyPickerNonce({
+      apiBase,
+      token,
+      nonce,
+      fetchImpl,
+      setTimeoutImpl
+    });
+    if (!verified) {
+      refuse(
+        "The design-mode link is invalid, expired, or could not be verified. It is single-use and short-lived, so a reload spends it. Check that this page carries the same environment Token as the flow you are editing, then open the picker again from the dashboard."
+      );
+      return "rejected";
+    }
+    try {
+      onVerified();
+    } catch {
+    }
+    const registration = await loadChunk(win, loadTimeoutMs, setTimeoutImpl);
+    if (!registration) return "load_failed";
+    const { returnOrigin, screenshotsEnabled } = verified;
+    const handle = registration.mount({
+      // 15.10's kill switch: decided before the chunk even loads.
+      screenshotsEnabled,
+      // Delivered as it happens, with no confirm step (D502): the dashboard
+      // field is the confirmation, and a second one would only ever disagree
+      // with the first.
+      onPick: (target, matchCount) => {
+        postToOpener(win, returnOrigin, {
+          type: DESIGN_MODE_PICK,
+          protocol: DESIGN_MODE_PROTOCOL,
+          target,
+          // Read now, not at mount: browse mode means the operator may have
+          // routed somewhere else since (D504).
+          route: currentPath(win),
+          // Scored by the chunk against this page's live document at the
+          // moment of the pick (ADR 0132). The core cannot compute it: doing
+          // so would pull `matchTarget` into the gated bundle.
+          matchCount
+        });
+      },
+      // Resolves after the pick above, and separately (15.7): a screenshot
+      // must never delay or gate the pick's own delivery (D502).
+      onScreenshot: (screenshot) => {
+        postToOpener(win, returnOrigin, {
+          type: DESIGN_MODE_SCREENSHOT,
+          protocol: DESIGN_MODE_PROTOCOL,
+          screenshot
+        });
+      },
+      onExit: () => {
+        postToOpener(win, returnOrigin, {
+          type: DESIGN_MODE_EXIT,
+          protocol: DESIGN_MODE_PROTOCOL
+        });
+      }
+    });
+    if (!handle) {
+      refuse("The element picker could not start. Design mode is off.");
+      return "mount_failed";
+    }
+    postToOpener(win, returnOrigin, {
+      type: DESIGN_MODE_READY,
+      protocol: DESIGN_MODE_PROTOCOL
+    });
+    return "active";
+  } catch (error) {
+    refuse(`Design mode could not start. ${String(error)}`);
+    return "load_failed";
+  }
+}
+
+// src/flow/preview.ts
+var PREVIEW_PARAM = "arcy_preview";
+var PREVIEW_PROTOCOL = 1;
+var PREVIEW_VERIFY_PATH = "/api/v1/sdk/flows/preview/verify";
+var VERIFY_TIMEOUT_MS2 = 1e4;
+function detectPreviewNonce(search, hash) {
+  return readNonce2(search) ?? readNonce2(hash);
+}
+function readNonce2(source) {
+  if (!source) return null;
+  try {
+    const nonce = new URLSearchParams(
+      source.charAt(0) === "#" ? source.slice(1) : source
+    ).get(PREVIEW_PARAM);
+    return nonce && nonce.length > 0 ? nonce : null;
+  } catch {
+    return null;
+  }
+}
+function stripPreviewParam(win) {
+  try {
+    const url = new URL(win.location.href);
+    const inQuery = url.searchParams.has(PREVIEW_PARAM);
+    const inHash = readNonce2(url.hash) !== null;
+    if (!inQuery && !inHash) return;
+    if (inQuery) url.searchParams.delete(PREVIEW_PARAM);
+    if (inHash) url.hash = "";
+    win.history.replaceState(win.history.state, "", url.toString());
+  } catch {
+  }
+}
+function detectPreviewIntent(win, token) {
+  try {
+    const nonce = detectPreviewNonce(win.location.search, win.location.hash);
+    if (nonce) {
+      stripPreviewParam(win);
+      return { kind: "nonce", nonce };
+    }
+    if (hasPendingPreview(token)) return { kind: "pending" };
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function verifyPreviewNonce(options) {
+  const {
+    apiBase,
+    token,
+    nonce,
+    sessionToken,
+    userTraits,
+    fetchImpl,
+    timeoutMs = VERIFY_TIMEOUT_MS2,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms)
+  } = options;
+  if (!fetchImpl) return null;
+  const refuse2 = (message) => {
+    warn(message);
+    try {
+      showDesignModeNotice(message);
+    } catch {
+    }
+    return null;
+  };
+  const attempt = async () => {
+    try {
+      const response = await fetchImpl(`${apiBase}${PREVIEW_VERIFY_PATH}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          token: nonce,
+          ...sessionToken ? { sessionToken } : {},
+          ...userTraits && Object.keys(userTraits).length > 0 ? { userTraits } : {}
+        }),
+        credentials: "omit"
+      });
+      if (!response.ok) {
+        return refuse2(
+          "ARCY could not verify this preview link. Close this tab and press Preview in the dashboard again."
+        );
+      }
+      const body = await response.json();
+      if (body?.ok !== true || body.flow === void 0 || body.flow === null) {
+        return refuse2(
+          "ARCY could not verify this preview link. Close this tab and press Preview in the dashboard again."
+        );
+      }
+      if (body.protocol !== PREVIEW_PROTOCOL) {
+        return refuse2(
+          "This page runs an older version of arcy.js than the dashboard expects. The preview cannot run until the script updates."
+        );
+      }
+      return body.flow;
+    } catch {
+      return refuse2(
+        "ARCY could not reach its server to start this preview. Check the connection and press Preview again."
+      );
+    }
+  };
+  let settled = false;
+  let timer;
+  const deadline = new Promise((resolve) => {
+    try {
+      timer = setTimeoutImpl(() => {
+        if (settled) return;
+        settled = true;
+        resolve(
+          refuse2(
+            "ARCY took too long to verify this preview link. Close this tab and press Preview in the dashboard again."
+          )
+        );
+      }, timeoutMs);
+    } catch {
+    }
+  });
+  const result = await Promise.race([
+    attempt().then((value) => {
+      settled = true;
+      return value;
+    }),
+    deadline
+  ]);
+  try {
+    if (timer !== void 0) clearTimeout(timer);
+  } catch {
+  }
+  return result;
+}
+
+// src/session/bootstrap.ts
+var DEFAULT_API_BASE = "https://api.arcyai.com";
+var SESSION_INIT_PATH = "/api/v1/sdk/session/init";
+var RETRY_DELAY_MS = 2e3;
+var ATTEMPT_TIMEOUT_MS = 5e3;
+var FAILURE_COOLDOWN_MS = 3e4;
+var TELEMETRY_STATES = ["ON", "REQUIRE_CONSENT", "OFF"];
+function readConfig(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return null;
+  const raw = body;
+  const state = raw.behavioralTelemetry;
+  const customization = raw.effectiveCustomization;
+  const widget = raw.widget;
+  const identity = raw.identity;
+  const identityAccepted = identity && typeof identity === "object" && !Array.isArray(identity) ? identity.accepted : void 0;
+  return {
+    sessionToken: typeof raw.sessionToken === "string" ? raw.sessionToken : null,
+    behavioralTelemetry: typeof state === "string" && TELEMETRY_STATES.indexOf(state) !== -1 ? state : null,
+    customization: customization && typeof customization === "object" && !Array.isArray(customization) ? customization : null,
+    widget: widget && typeof widget === "object" && !Array.isArray(widget) ? widget : null,
+    identityAccepted: typeof identityAccepted === "boolean" ? identityAccepted : null
+  };
+}
+function createSessionBootstrap(options) {
+  const {
+    token,
+    apiBase = DEFAULT_API_BASE,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    now = () => Date.now(),
+    retryDelayMs = RETRY_DELAY_MS,
+    attemptTimeoutMs = ATTEMPT_TIMEOUT_MS,
+    failureCooldownMs = FAILURE_COOLDOWN_MS
+  } = options;
+  const fetchImpl = options.fetchImpl !== void 0 ? options.fetchImpl : typeof fetch !== "undefined" ? fetch.bind(globalThis) : null;
+  const url = `${apiBase}${SESSION_INIT_PATH}`;
+  let latest = null;
+  let sent = null;
+  let failed = null;
+  let inFlight = null;
+  let sequence = 0;
+  function body(payload) {
+    const out = {
+      publicKey: token,
+      sessionId: payload.sessionId
+    };
+    if (payload.visitorId !== void 0) out.visitorId = payload.visitorId;
+    if (payload.userId !== void 0) out.userId = payload.userId;
+    if (payload.userHash !== void 0) out.userHash = payload.userHash;
+    if (payload.userTraits !== void 0) out.userTraits = payload.userTraits;
+    if (payload.uiLanguage !== void 0) out.uiLanguage = payload.uiLanguage;
+    if (payload.contentLocale !== void 0)
+      out.contentLocale = payload.contentLocale;
+    if (payload.viewerLocale !== void 0)
+      out.viewerLocale = payload.viewerLocale;
+    if (payload.route !== void 0) out.route = payload.route;
+    if (payload.sessionContext !== void 0)
+      out.sessionContext = payload.sessionContext;
+    return JSON.stringify(out);
+  }
+  async function attempt(json) {
+    if (!fetchImpl) return { ok: false, reason: "unusable" };
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: json,
+        credentials: "omit"
+      });
+    } catch {
+      return null;
+    }
+    if (response.status >= 500) return null;
+    if (!response.ok) {
+      return { ok: false, reason: "rejected" };
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch {
+      return { ok: false, reason: "unusable" };
+    }
+    const config = readConfig(parsed);
+    if (!config) return { ok: false, reason: "unusable" };
+    return { ok: true, config };
+  }
+  function wait(ms) {
+    return new Promise((resolve) => {
+      try {
+        setTimeoutImpl(() => resolve(), ms);
+      } catch {
+        resolve();
+      }
+    });
+  }
+  function bounded(json) {
+    return Promise.race([
+      attempt(json),
+      wait(attemptTimeoutMs).then(() => null)
+    ]);
+  }
+  async function run(json) {
+    const first = await bounded(json);
+    if (first) return first;
+    await wait(retryDelayMs);
+    const second = await bounded(json);
+    return second ?? { ok: false, reason: "network" };
+  }
+  return {
+    async sync(payload) {
+      const json = body(payload);
+      if (inFlight && json === sent) return inFlight;
+      if (!inFlight && json === sent && latest) {
+        return { ok: true, config: latest };
+      }
+      if (failed && failed.json === json && now() - failed.at < failureCooldownMs) {
+        return { ok: false, reason: "network" };
+      }
+      sent = json;
+      const mySequence = ++sequence;
+      const request = run(json).then((result) => {
+        if (mySequence === sequence) {
+          if (result.ok) {
+            latest = result.config;
+            failed = null;
+          } else {
+            failed = { json, at: now() };
+            if (sent === json) sent = null;
+          }
+        }
+        if (inFlight === request) inFlight = null;
+        return result;
+      });
+      inFlight = request;
+      return request;
+    },
+    config: () => latest
+  };
+}
+
+// src/shell/chat-loader.ts
+var CHAT_LOAD_TIMEOUT_MS = 15e3;
+function createChatController(options) {
+  const {
+    root,
+    host,
+    win = typeof window !== "undefined" ? window : void 0,
+    loadChunk,
+    loadTimeoutMs = CHAT_LOAD_TIMEOUT_MS,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    onRequestClose,
+    bar,
+    apiBase,
+    getSessionToken,
+    getSessionId,
+    getRoute,
+    getMaxHeightPercent,
+    onStartFlow,
+    publicKey,
+    getConversationId,
+    setConversationId,
+    touchConversation,
+    getVisitorId,
+    onOrgCapExceeded,
+    onStopFlow,
+    track,
+    getWidget,
+    onSelectLocale
+  } = options;
+  const isolated = root !== host;
+  let handle = null;
+  let loading = null;
+  let destroyed = false;
+  let wantOpen = false;
+  async function ensureMounted() {
+    if (handle || destroyed) return;
+    if (loading) return loading;
+    loading = (async () => {
+      if (!win) return;
+      try {
+        const registration = await loadChunk(win, loadTimeoutMs, setTimeoutImpl);
+        if (!registration || destroyed) return;
+        const context = {
+          root,
+          host,
+          isolated,
+          onRequestClose,
+          bar,
+          apiBase,
+          getSessionToken,
+          getSessionId,
+          getRoute,
+          getMaxHeightPercent,
+          onStartFlow,
+          publicKey,
+          getConversationId,
+          setConversationId,
+          touchConversation,
+          getVisitorId,
+          onOrgCapExceeded,
+          onStopFlow,
+          track,
+          getWidget,
+          onSelectLocale
+        };
+        handle = registration.mount(context);
+        if (!handle) warn("The chat panel could not start.");
+      } catch (error) {
+        warn(`The chat panel could not load. ${String(error)}`);
+      } finally {
+        loading = null;
+      }
+    })();
+    return loading;
+  }
+  return {
+    async open() {
+      if (destroyed) return;
+      wantOpen = true;
+      await ensureMounted();
+      if (!wantOpen || destroyed) return;
+      try {
+        handle?.open();
+      } catch (error) {
+        warn(`The chat panel could not open. ${String(error)}`);
+      }
+    },
+    close() {
+      wantOpen = false;
+      try {
+        handle?.close();
+      } catch (error) {
+        warn(`The chat panel could not close. ${String(error)}`);
+      }
+    },
+    destroy() {
+      destroyed = true;
+      wantOpen = false;
+      const current = handle;
+      handle = null;
+      try {
+        current?.destroy();
+      } catch (error) {
+        warn(`The chat panel could not be removed. ${String(error)}`);
+      }
+    },
+    reposition() {
+      try {
+        handle?.reposition?.();
+      } catch (error) {
+        warn(`The chat panel could not move. ${String(error)}`);
+      }
+    },
+    refreshChrome() {
+      try {
+        handle?.refreshChrome?.();
+      } catch (error) {
+        warn(`The chat panel could not apply its texts. ${String(error)}`);
+      }
+    },
+    async promptFill(request) {
+      if (destroyed) return null;
+      await ensureMounted();
+      if (destroyed || !handle?.promptFill) return null;
+      try {
+        return await handle.promptFill(request);
+      } catch (error) {
+        warn(`The flow's question could not be shown. ${String(error)}`);
+        return null;
+      }
+    },
+    cancelFill() {
+      try {
+        handle?.cancelFill?.();
+      } catch (error) {
+        warn(`The flow's question could not be withdrawn. ${String(error)}`);
+      }
+    },
+    async showFlowFailure() {
+      if (destroyed) return;
+      wantOpen = true;
+      await ensureMounted();
+      if (!wantOpen || destroyed || !handle?.showFlowFailure) return;
+      try {
+        handle.showFlowFailure();
+      } catch (error) {
+        warn(`The flow's failure notice could not be shown. ${String(error)}`);
+      }
+    }
+  };
+}
+
+// src/flow/flow-loader.ts
+var FLOW_LOAD_TIMEOUT_MS = 15e3;
+function createFlowController(options) {
+  const {
+    win = typeof window !== "undefined" ? window : void 0,
+    loadChunk,
+    loadTimeoutMs = FLOW_LOAD_TIMEOUT_MS,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    context
+  } = options;
+  let handle = null;
+  let loading = null;
+  let destroyed = false;
+  async function ensureMounted() {
+    if (handle || destroyed) return;
+    if (loading) return loading;
+    loading = (async () => {
+      if (!win) return;
+      try {
+        const registration = await loadChunk(win, loadTimeoutMs, setTimeoutImpl);
+        if (!registration || destroyed) return;
+        handle = registration.mount({ ...context, doc: win.document, win });
+        if (!handle) warn("The flow engine could not start.");
+      } catch (error) {
+        warn(`The flow engine could not load. ${String(error)}`);
+      } finally {
+        loading = null;
+      }
+    })();
+    return loading;
+  }
+  return {
+    async start(flowCvid) {
+      if (destroyed) return;
+      await ensureMounted();
+      if (destroyed) return;
+      try {
+        await handle?.start(flowCvid);
+      } catch (error) {
+        warn(`The flow could not start. ${String(error)}`);
+      }
+    },
+    async resume() {
+      if (destroyed) return false;
+      const pending = createFlowRunState(context.token).read();
+      if (!pending) return false;
+      await ensureMounted();
+      if (destroyed || !handle) return false;
+      try {
+        return await handle.resume();
+      } catch (error) {
+        warn(`The flow could not resume. ${String(error)}`);
+        return false;
+      }
+    },
+    async startPreview(flow) {
+      if (destroyed) return;
+      await ensureMounted();
+      if (destroyed) return;
+      try {
+        await handle?.startPreview?.(flow);
+      } catch (error) {
+        warn(`The preview could not start. ${String(error)}`);
+      }
+    },
+    async resumePreview() {
+      if (destroyed) return false;
+      if (!hasPendingPreview(context.token)) return false;
+      await ensureMounted();
+      if (destroyed || !handle?.resumePreview) return false;
+      try {
+        return await handle.resumePreview();
+      } catch (error) {
+        warn(`The preview could not resume. ${String(error)}`);
+        return false;
+      }
+    },
+    stop() {
+      if (destroyed) return;
+      try {
+        handle?.stop?.();
+      } catch (error) {
+        warn(`The flow could not be stopped. ${String(error)}`);
+      }
+    },
+    destroy() {
+      destroyed = true;
+      const current = handle;
+      handle = null;
+      try {
+        current?.destroy();
+      } catch (error) {
+        warn(`The flow engine could not be removed. ${String(error)}`);
+      }
+    }
+  };
+}
+
+// src/shell/styles.ts
+var BAR_CSS = TOOLTIP_CSS + `
+.arcy-bar-wrap {
+  gap: 6px;
+  font: 14px/1.4 var(--_arcy-font, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif);
+  /* Only ever animates from a concrete pixel value: bar.ts's render()
+     freezes the wrap's current width before writing the target so this has
+     two real numbers to interpolate between, never the "max-content"
+     keyword most engines cannot transition. */
+  transition: width 220ms cubic-bezier(0.4, 0, 0.2, 1);
+  /* Above the panel, always (.arcy-chat-panel's own z-index in chat.ts):
+     both are position: absolute siblings inside the same shared root with
+     nothing else to order them, so without this the panel simply painted
+     over the bar whenever they overlapped, because the panel is always the
+     later of the two to mount (it loads lazily, on first open()) and DOM
+     order was the only tiebreaker. This is its own stacking context, so the
+     bar's own menu and tooltips (z-index 2 inside it, tooltip.ts) stay
+     above the panel too, not just the bar's own box. */
+  z-index: 2;
+}
+
+/* The corner launcher the widget becomes when a visitor docks it from the
+   panel's Settings sheet. Its size and placement are written inline from
+   bar.ts, for the reason at the top of this file: docked, this button is the
+   only way back into the widget, so losing this sheet has to leave it plain
+   rather than unfindable.
+
+   It is the WELCOME MARK: same size token, same brand colours, same
+   overflow-hidden circle an upload is inset into. The welcome screen's own
+   rule, in chat.ts, is its twin, and the two are meant to be
+   indistinguishable, because docked this button is that mark. */
+.arcy-bar-dock {
+  overflow: hidden;
+  appearance: none;
+  border: 0;
+  /* box-sizing: border-box comes from bar.ts's SURVIVAL_STYLE. calc() against
+     the size token itself, NOT a percentage: a percentage padding resolves
+     against the containing block's width, not this button's own, and would
+     inflate a 34px button to match the page instead of insetting the icon. */
+  padding: calc(var(--_arcy-chat-welcome-icon-size, 34px) * 0.15);
+  cursor: pointer;
+  border-radius: 999px;
+  background: var(--_arcy-brand-bg, #101828);
+  color: var(--_arcy-brand-text, #ffffff);
+  -webkit-tap-highlight-color: transparent;
+  /* Its own stacking context, above the panel, same as the bar's wrap. */
+  z-index: 2;
+  transition: transform 160ms cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.arcy-bar-dock:hover {
+  transform: scale(1.06);
+}
+
+.arcy-bar-dock:focus-visible {
+  outline: 2px solid currentColor;
+  outline-offset: 3px;
+}
+
+.arcy-bar {
+  position: relative;
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 52px;
+  padding: 0 8px 0 8px;
+  border-radius: var(--arcy-bar-radius, 16px);
+  background: var(--_arcy-main-bg, #ffffff);
+  color: var(--_arcy-main-text, #101828);
+  /* The shared base.border (D832): one value, this edge and the panel's. */
+  border: var(--_arcy-border-width, 0px) solid
+    var(--_arcy-border-color, color-mix(in srgb, var(--_arcy-main-text, #101828) 15%, transparent));
+  /* The focus ring rides in front of the operator's own shadow rather than
+     replacing it (D908), so a focused bar keeps whatever depth they chose. */
+  box-shadow: var(--_arcy-bar-focus-ring, 0 0 #0000),
+    var(--arcy-bar-shadow, 0 8px 24px rgba(16, 24, 40, 0.28));
+  transition: box-shadow 160ms ease, background 160ms ease,
+    border-color 160ms ease;
+}
+
+/* Flow mode's status surface reads left to right (dot, name, step, stop),
+   so the left edge sits closer to the composer's usual text inset while the
+   right stays flush with the stop control (D930/D979). */
+.arcy-bar[data-mode="flow"] {
+  padding: 0 8px 0 16px;
+}
+
+/* Glassiness (\xA75.4): a blur behind the bar plus an alpha on
+   main.background. Only where the browser can blur; elsewhere the bar stays
+   opaque, never transparent. With no glass set the alpha is 0% and this is
+   a no-op. */
+@supports (backdrop-filter: blur(1px)) {
+  .arcy-bar {
+    background: color-mix(in srgb, var(--_arcy-main-bg, #ffffff) calc(100% - var(--_arcy-glass-alpha, 0%)), transparent);
+    backdrop-filter: blur(var(--_arcy-glass-blur, 0px));
+    -webkit-backdrop-filter: blur(var(--_arcy-glass-blur, 0px));
+  }
+}
+
+.arcy-bar-form {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex: 1 1 auto;
+  min-width: 0;
+  margin: 0;
+}
+
+.arcy-bar-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  appearance: none;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  padding: 12px 0;
+  outline: none;
+}
+
+/* Collapsed, the whole pill is the target (ADR 0103): the input inside it is
+   a few pixels wide, and a visitor aiming for it is a visitor who misses. */
+.arcy-bar[data-collapsed="true"] {
+  cursor: pointer;
+}
+
+.arcy-bar[data-collapsed="true"] .arcy-bar-input {
+  /* No cursor override here, unlike the pill above: this is a real,
+     focusable input, not a decoration, and hovering directly over it
+     should give the same text-caret cue any input gives. The surrounding
+     pill's own pointer cursor still covers the rest of the target. */
+  /* Takes the row's spare width, exactly as it does open (ADR 0149): the
+     pill is bar.collapsedWidth wide now rather than as wide as its own
+     text, and an input that kept sizing itself to the placeholder would
+     leave the operator's extra pixels stranded behind the send control. */
+  padding-right: 8px;
+}
+
+/* The left slot. As a mark it is not a control, so it takes no hover, no
+   pointer and no tab stop; as the menu's plus it is an icon button. */
+.arcy-bar-grip {
+  /* Outside the composer's own controls: what it moves is the whole bar, so
+     it takes neither the left slot's hover treatment nor its padding
+     (ADR 0111). Rendered on BOTH widths of the bar, resting and expanded,
+     and only when the operator has allowed it: the data-grip rule below is
+     driven by that setting alone. The handle used to vanish the moment the panel
+     opened even though dragging the open bar already worked underneath,
+     which is a control that is functional but invisible. */
+  display: none;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  padding: 0 2px 0 4px;
+  margin-right: -2px;
+  border: 0;
+  background: transparent;
+  /* Matches the leading icon's own resting contrast (see .arcy-bar-leading
+     below). The previous, much lower value read as barely-there against
+     either theme, which made the handle hard to spot rather than subtle. */
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 65%, transparent);
+  cursor: grab;
+  touch-action: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.arcy-bar[data-grip="true"] .arcy-bar-grip {
+  display: flex;
+}
+
+.arcy-bar-grip:active {
+  cursor: grabbing;
+}
+
+.arcy-bar-grip:hover {
+  color: var(--_arcy-main-text, #101828);
+}
+
+.arcy-bar-leading {
+  appearance: none;
+  border: 0;
+  padding: 8px;
+  border-radius: 999px;
+  background: transparent;
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 65%, transparent);
+  font: inherit;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.arcy-bar-leading[data-role="menu"] {
+  cursor: pointer;
+}
+
+.arcy-bar-leading[data-role="menu"]:hover {
+  background: color-mix(in srgb, var(--_arcy-main-text, #101828) 8%, transparent);
+}
+
+.arcy-bar-leading[data-role="mark"] {
+  cursor: inherit;
+  color: var(--_arcy-brand-bg, #101828);
+  opacity: 1;
+}
+
+.arcy-bar-menu {
+  position: absolute;
+  left: 0;
+  bottom: calc(100% + 8px);
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 200px;
+  padding: 6px;
+  border-radius: 12px;
+  background: var(--_arcy-main-bg, #ffffff);
+  color: var(--_arcy-main-text, #101828);
+  border: 1px solid
+    color-mix(in srgb, var(--_arcy-main-text, #101828) 12%, transparent);
+  box-shadow: 0 12px 32px rgba(16, 24, 40, 0.18);
+}
+
+/* The menu is a surface the visitor sees, so it wears base.glassiness like
+   the bar and the panel do (D832's one-value rule, one layer out). It gets
+   its own @supports block rather than joining the bar's above, because this
+   sheet declares the menu's opaque background AFTER that block: sharing it
+   would put the two rules at equal specificity with the opaque one last,
+   and the menu stayed white on a glassy bar.
+
+   Note this sheet is a template literal. No backticks in these comments. */
+@supports (backdrop-filter: blur(1px)) {
+  .arcy-bar-menu {
+    background: color-mix(in srgb, var(--_arcy-main-bg, #ffffff) calc(100% - var(--_arcy-glass-alpha, 0%)), transparent);
+    backdrop-filter: blur(var(--_arcy-glass-blur, 0px));
+    -webkit-backdrop-filter: blur(var(--_arcy-glass-blur, 0px));
+  }
+}
+
+.arcy-bar-menu-item {
+  appearance: none;
+  border: 0;
+  cursor: pointer;
+  font: inherit;
+  text-align: left;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 10px;
+  border-radius: 8px;
+  background: transparent;
+  color: inherit;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.arcy-bar-menu-item:hover {
+  background: color-mix(in srgb, var(--_arcy-main-text, #101828) 8%, transparent);
+}
+
+.arcy-bar-input::placeholder {
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 55%, transparent);
+  /* Opera and older Firefox dim placeholders by default, which on a light
+     bar reads as a disabled input. */
+  opacity: 1;
+}
+
+.arcy-bar-input:disabled {
+  opacity: 0.6;
+}
+
+.arcy-bar-icon,
+.arcy-bar-send,
+.arcy-bar-stop {
+  appearance: none;
+  border: 0;
+  cursor: pointer;
+  font: inherit;
+  -webkit-tap-highlight-color: transparent;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+}
+
+.arcy-bar-icon {
+  padding: 8px;
+  border-radius: 999px;
+  background: transparent;
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 65%, transparent);
+}
+
+.arcy-bar-icon:hover {
+  background: color-mix(in srgb, var(--_arcy-main-text, #101828) 8%, transparent);
+}
+
+.arcy-bar-send {
+  padding: 10px;
+  border-radius: 999px;
+  background: var(--_arcy-brand-bg, #101828);
+  color: var(--_arcy-brand-text, #ffffff);
+}
+
+/* The send control answers the pointer whatever colour the operator chose
+   (D888). The hover token defaults to the base colour, so a background swap
+   alone is invisible on every theme that did not set one; a lift and a
+   contact shadow read on any colour, including white on white. */
+.arcy-bar-send {
+  transition: background 120ms ease, transform 120ms ease, box-shadow 120ms ease;
+}
+
+.arcy-bar-send:hover {
+  background: var(--_arcy-brand-bg-hover, var(--_arcy-brand-bg, #101828));
+  transform: translateY(-1px);
+  box-shadow: 0 2px 8px rgba(16, 24, 40, 0.18);
+}
+
+.arcy-bar-send:active {
+  background: var(--_arcy-brand-bg-active, var(--_arcy-brand-bg, #101828));
+  transform: translateY(0);
+  box-shadow: none;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .arcy-bar-send {
+    transition: background 120ms ease;
+  }
+  .arcy-bar-send:hover,
+  .arcy-bar-send:active {
+    transform: none;
+  }
+}
+
+.arcy-bar-send:disabled,
+.arcy-bar-icon:disabled {
+  cursor: default;
+  opacity: 0.6;
+}
+
+/* The input takes NO ring of its own (D887). It fills a bar that already
+   looks like an input, so a rectangle drawn around the text reads as a
+   browser artefact rather than as focus, and it was the first thing a
+   visitor saw on clicking. The bar carries the state instead.
+
+   The border goes brand (D908). base.border.width defaults to 0, so a
+   colour change alone would be invisible on most themes; the 1px ring is
+   what actually paints the edge there, and on a theme that HAS a border the
+   two land on the same line. */
+.arcy-bar:focus-within {
+  outline: none;
+  border-color: var(--_arcy-brand-bg, #101828);
+  --_arcy-bar-focus-ring: 0 0 0 1px var(--_arcy-brand-bg, #101828);
+}
+
+/* A control inside the bar still says which control it is: the bar's ring
+   says "the widget has focus", this one says "and it is this button". */
+.arcy-bar-icon:focus-visible,
+.arcy-bar-send:focus-visible,
+.arcy-bar-stop:focus-visible,
+.arcy-bar-leading:focus-visible,
+.arcy-bar-menu-item:focus-visible {
+  outline: 2px solid var(--_arcy-main-text, #101828);
+  outline-offset: 1px;
+}
+
+/* The attachment tray. See bar.ts's renderTray(). */
+.arcy-bar-tray {
+  display: none;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  padding: 10px 4px 2px 4px;
+  min-width: 0;
+}
+
+/* A composer holding pictures is two rows, not one. */
+.arcy-bar[data-attachments="true"] {
+  flex-direction: column;
+  align-items: stretch;
+}
+
+/* \u2500\u2500 Flow-running mode \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+
+.arcy-bar-status {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.arcy-bar-dot {
+  flex: 0 0 auto;
+  width: 8px;
+  height: 8px;
+  border-radius: 999px;
+  background: var(--_arcy-brand-bg, #101828);
+  animation: arcy-bar-pulse 1.4s ease-in-out infinite;
+}
+
+@keyframes arcy-bar-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.35; }
+}
+
+.arcy-bar-flow-name {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 13px;
+}
+
+.arcy-bar-flow-step {
+  flex: 0 0 auto;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 60%, transparent);
+}
+
+.arcy-bar-stop {
+  gap: 6px;
+  padding: 6px 12px;
+  border-radius: 999px;
+  font-size: 12px;
+  background: color-mix(in srgb, var(--_arcy-main-text, #101828) 8%, transparent);
+  color: inherit;
+}
+
+.arcy-bar-stop:hover {
+  background: color-mix(in srgb, var(--_arcy-main-text, #101828) 14%, transparent);
+}
+
+/* ADR 0169: the combined input rendering. The status row sits on a slim top
+   row and the composer stays live beneath it, so a fill question can be
+   answered without losing sight of the run. */
+.arcy-bar[data-mode="input"] {
+  flex-direction: column;
+  align-items: stretch;
+  padding: 6px 8px 0 8px;
+}
+
+.arcy-bar[data-mode="input"] .arcy-bar-status {
+  flex: 0 0 auto;
+  padding: 2px 8px 4px 8px;
+  border-bottom: 1px solid
+    color-mix(in srgb, var(--_arcy-main-text, #101828) 8%, transparent);
+}
+
+.arcy-bar[data-mode="input"] .arcy-bar-form {
+  padding-left: 8px;
+}
+
+/* D1296: the done state. The run is over, so the dot stops pulsing and the
+   check mark takes the counter's place. */
+.arcy-bar[data-phase="done"] .arcy-bar-dot {
+  animation: none;
+  opacity: 1;
+}
+
+.arcy-bar[data-phase="done"] .arcy-bar-flow-step {
+  color: var(--_arcy-main-text, #101828);
+  font-size: 14px;
+}
+
+/* The AI disclosure. Under the bar, and only while the panel is open: a
+   quiet page stays quiet. */
+.arcy-bar-disclaimer {
+  font-size: 10.5px;
+  text-align: center;
+  color: color-mix(in srgb, var(--_arcy-main-text, #101828) 55%, transparent);
+  /* The wrap is centred on the bar, so this must not be able to widen it. */
+  max-width: 100%;
+}
+
+/* The privacy-policy link inline in the bar disclosure (D979/D981-followup).
+   Underlined so it reads as clickable against text that otherwise is not. */
+.arcy-chat-policy {
+  color: inherit;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+  cursor: pointer;
+}
+
+.arcy-chat-policy:hover {
+  color: var(--_arcy-main-text, #101828);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .arcy-bar,
+  .arcy-bar-wrap,
+  .arcy-bar-dock,
+  .arcy-bar-dot {
+    transition: none;
+    animation: none;
+  }
+}
+`;
+
+// src/shell/bar.ts
+var MAX_INPUT_LENGTH = 1e4;
+var BAR_HEIGHT = 52;
+var DEFAULT_BOTTOM_OFFSET = 24;
+var DEFAULT_BAR_ICON_SIZE = 18;
+var DEFAULT_WIDTH_PERCENT = 30;
+var DEFAULT_COLLAPSED_WIDTH = 280;
+var DOCK_SIZE_CSS = "var(--_arcy-chat-welcome-icon-size, 34px)";
+var DOCK_GLYPH_SHARE = "53%";
+var DOCK_RIGHT_OFFSET = 24;
+var SVG_NS = "http://www.w3.org/2000/svg";
+var SURVIVAL_STYLE = [
+  ["box-sizing", "border-box"],
+  ["margin", "0"],
+  ["display", "flex"]
+];
+var SURVIVAL_IMPORTANT = [
+  ["position", "absolute"],
+  ["pointer-events", "auto"]
+];
+var REVEAL_FADE_MS = 260;
+var REVEAL_AFTER_LOAD_MS = 300;
+var REVEAL_SETTLED_MS = 150;
+var REVEAL_MAX_MS = 3e3;
+function createIcon(doc, path, size2, strokeWidth = 2) {
+  const svg = doc.createElementNS(SVG_NS, "svg");
+  svg.setAttribute("viewBox", "0 0 24 24");
+  svg.setAttribute("aria-hidden", "true");
+  svg.setAttribute("width", String(size2));
+  svg.setAttribute("height", String(size2));
+  const node = doc.createElementNS(SVG_NS, "path");
+  node.setAttribute("d", path);
+  node.setAttribute("fill", "none");
+  node.setAttribute("stroke", "currentColor");
+  node.setAttribute("stroke-width", String(strokeWidth));
+  node.setAttribute("stroke-linecap", "round");
+  node.setAttribute("stroke-linejoin", "round");
+  svg.appendChild(node);
+  return svg;
+}
+function createImageIcon(doc, url, size2) {
+  const img = doc.createElement("img");
+  img.src = url;
+  img.alt = "";
+  img.setAttribute("aria-hidden", "true");
+  img.width = size2;
+  img.height = size2;
+  img.style.setProperty("width", `${size2}px`);
+  img.style.setProperty("height", `${size2}px`);
+  img.style.setProperty("object-fit", "contain");
+  return img;
+}
+var ATTACH_PATH = "M5 3H19A2 2 0 0 1 21 5V19A2 2 0 0 1 19 21H5A2 2 0 0 1 3 19V5A2 2 0 0 1 5 3ZM7 9a2 2 0 1 0 4 0a2 2 0 1 0-4 0M21 15l-3.086-3.086a2 2 0 0 0-2.828 0L6 21";
+var ZERO_OFFSET = { x: 0, y: 0 };
+var PLUS_PATH = "M12 5v14M5 12h14";
+var GRIP_PATH = "M8 12a1 1 0 1 0 2 0a1 1 0 1 0 -2 0M8 5a1 1 0 1 0 2 0a1 1 0 1 0 -2 0M8 19a1 1 0 1 0 2 0a1 1 0 1 0 -2 0M14 12a1 1 0 1 0 2 0a1 1 0 1 0 -2 0M14 5a1 1 0 1 0 2 0a1 1 0 1 0 -2 0M14 19a1 1 0 1 0 2 0a1 1 0 1 0 -2 0";
+var SPARKLES_PATH = "M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594zM20 2v4M22 4h-4M4 20m-2 0a2 2 0 1 0 4 0a2 2 0 1 0-4 0";
+var MESSAGE_CIRCLE_PATH = "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z";
+var SEND_PATH = "M12 19V5M5 12l7-7 7 7";
+var STOP_PATH = "M6 6h12v12H6z";
+function safe(label, fn) {
+  return (...args) => {
+    try {
+      fn(...args);
+    } catch (error) {
+      warn(`${label} failed. ${String(error)}`);
+    }
+  };
+}
+var DEFAULT_LABELS = {
+  send: "Send",
+  attachMenu: "Add",
+  attachImage: "Attach an image",
+  flowStop: "Stop",
+  openChat: "Open chat",
+  moveBar: "Move the chat bar",
+  flowStep: "Step {step} of {total}"
+};
+function createBar(options = {}) {
+  let labels = { ...DEFAULT_LABELS, ...options.labels ?? {} };
+  let geometry = {
+    widthPercent: options.geometry?.widthPercent ?? DEFAULT_WIDTH_PERCENT,
+    bottomOffset: options.geometry?.bottomOffset ?? DEFAULT_BOTTOM_OFFSET,
+    collapsedWidth: options.geometry?.collapsedWidth ?? DEFAULT_COLLAPSED_WIDTH
+  };
+  let shell = null;
+  let revealed = false;
+  let wrap = null;
+  let bar = null;
+  let form = null;
+  let input = null;
+  let leading = null;
+  let leadingIcon = null;
+  let iconUrl = options.iconUrl ?? null;
+  let iconSize = options.iconSize ?? DEFAULT_BAR_ICON_SIZE;
+  let welcomeIconUrl = options.welcomeIconUrl ?? null;
+  let failedWelcomeIconUrl = null;
+  let grip = null;
+  let draggable = false;
+  let dock = null;
+  let dockIcon = null;
+  let docked = false;
+  let offset = { x: 0, y: 0 };
+  let menu = null;
+  let attach = null;
+  let picker = null;
+  let submit = null;
+  let status = null;
+  let statusName = null;
+  let statusStep = null;
+  let stop = null;
+  let disclaimer = null;
+  let tray = null;
+  let mode = "idle";
+  let flow = null;
+  let awaitingInput = false;
+  let attachEnabled = false;
+  let attachmentCount = 0;
+  let menuOpen = false;
+  let gestureActivated = false;
+  let vp = { width: 0, height: 0, isMobile: false, keyboardOffset: 0 };
+  function isCollapsed() {
+    return !flow && mode !== "open";
+  }
+  function clampOffset(next) {
+    const width = wrap?.offsetWidth ?? 0;
+    const height = wrap?.offsetHeight ?? 0;
+    if (!vp.width || !vp.height) return next;
+    const bottom = geometry.bottomOffset + vp.keyboardOffset;
+    const maxUp = Math.max(0, vp.height - height - bottom);
+    return {
+      x: clampOffsetX(next.x, width, vp.width),
+      // Negative is up. Down is bounded by the offset the operator set,
+      // which is the floor the bar rests on.
+      y: Math.min(bottom, Math.max(-maxUp, next.y))
+    };
+  }
+  function handleGripDown(event) {
+    if (!draggable || vp.isMobile) return;
+    event.preventDefault();
+    event.stopPropagation();
+    const startX = event.clientX;
+    const startY = event.clientY;
+    const origin = offset;
+    const handle = grip;
+    const win = grip?.ownerDocument?.defaultView ?? (typeof window !== "undefined" ? window : null);
+    const move = (moveEvent) => {
+      if (moveEvent.pointerId !== event.pointerId) return;
+      offset = clampOffset({
+        x: origin.x + (moveEvent.clientX - startX),
+        y: origin.y + (moveEvent.clientY - startY)
+      });
+      render();
+      options.onGeometryChange?.();
+    };
+    const end = (endEvent) => {
+      if (endEvent.pointerId !== event.pointerId) return;
+      win?.removeEventListener("pointermove", move, true);
+      win?.removeEventListener("pointerup", end, true);
+      win?.removeEventListener("pointercancel", end, true);
+      try {
+        handle?.releasePointerCapture(endEvent.pointerId);
+      } catch {
+      }
+      options.onPositionChange?.(offset);
+    };
+    try {
+      handle?.setPointerCapture(event.pointerId);
+    } catch {
+    }
+    win?.addEventListener("pointermove", move, true);
+    win?.addEventListener("pointerup", end, true);
+    win?.addEventListener("pointercancel", end, true);
+  }
+  function renderDock() {
+    wrap?.style.setProperty("display", docked ? "none" : "flex", "important");
+    if (!dock) return;
+    dock.style.setProperty("display", docked ? "flex" : "none", "important");
+    if (!docked) return;
+    dock.style.setProperty(
+      "bottom",
+      `${geometry.bottomOffset + vp.keyboardOffset}px`,
+      "important"
+    );
+    dock.style.setProperty("right", `${DOCK_RIGHT_OFFSET}px`, "important");
+  }
+  function render() {
+    renderDock();
+    if (!wrap) return;
+    const collapsed = isCollapsed();
+    const width = surfaceWidth(geometry.widthPercent, vp);
+    const bottom = geometry.bottomOffset + vp.keyboardOffset;
+    wrap.style.setProperty("bottom", `${bottom}px`, "important");
+    wrap.style.setProperty("left", "50%", "important");
+    wrap.style.setProperty("translate", "-50%", "important");
+    const moved = draggable && !vp.isMobile ? clampOffset(offset) : ZERO_OFFSET;
+    offset = moved;
+    const applied = flow ? ZERO_OFFSET : {
+      x: clampOffsetX(
+        moved.x,
+        collapsed ? geometry.collapsedWidth : width,
+        vp.width
+      ),
+      y: moved.y
+    };
+    wrap.style.setProperty("transform", dragTransform(applied));
+    bar?.setAttribute(
+      "data-grip",
+      draggable && !vp.isMobile && !flow ? "true" : "false"
+    );
+    wrap.style.setProperty(
+      "width",
+      collapsed ? `${geometry.collapsedWidth}px` : `${width}px`
+    );
+    const roomOnMobile = `calc(100% - ${MOBILE_MARGIN * 2}px)`;
+    wrap.style.setProperty("max-width", vp.isMobile ? roomOnMobile : "none");
+    wrap.setAttribute("data-mobile", vp.isMobile ? "" : "false");
+  }
+  function renderLeading() {
+    if (!leading || !leadingIcon) return;
+    const doc = leading.ownerDocument;
+    const hasMenu = !isCollapsed() && attachEnabled;
+    const next = hasMenu ? createIcon(doc, PLUS_PATH, 18) : iconUrl ? createImageIcon(doc, iconUrl, iconSize) : createIcon(doc, SPARKLES_PATH, iconSize);
+    leading.replaceChild(next, leadingIcon);
+    leadingIcon = next;
+    leading.setAttribute("aria-label", labels.attachMenu);
+    if (hasMenu) leading.setAttribute("data-tip", labels.attachMenu);
+    else leading.removeAttribute("data-tip");
+    leading.setAttribute("aria-haspopup", hasMenu ? "menu" : "false");
+    leading.setAttribute("data-role", hasMenu ? "menu" : "mark");
+    leading.disabled = !hasMenu;
+    leading.setAttribute("aria-hidden", hasMenu ? "false" : "true");
+    leading.tabIndex = hasMenu ? 0 : -1;
+    if (!hasMenu) closeMenu();
+  }
+  function renderTray() {
+    if (!tray || !bar) return;
+    const visible = attachEnabled && attachmentCount > 0 && !isCollapsed();
+    const was = bar.getAttribute("data-attachments") === "true";
+    tray.style.setProperty("display", visible ? "flex" : "none");
+    bar.setAttribute("data-attachments", visible ? "true" : "false");
+    if (was === visible) return;
+    safe("onGeometryChange", () => options.onGeometryChange?.())();
+  }
+  function setMenuOpen(open) {
+    menuOpen = open;
+    if (menu) menu.style.setProperty("display", open ? "flex" : "none");
+    leading?.setAttribute("aria-expanded", open ? "true" : "false");
+    if (open) attach?.focus();
+  }
+  function closeMenu() {
+    if (!menuOpen) return;
+    const active = menu?.getRootNode();
+    const focusInMenu = Boolean(
+      active && "activeElement" in active && active.activeElement && menu?.contains(active.activeElement)
+    );
+    setMenuOpen(false);
+    if (focusInMenu) leading?.focus();
+  }
+  function renderDockIcon() {
+    if (!dock || !dockIcon) return;
+    const doc = dock.ownerDocument;
+    const url = welcomeIconUrl && welcomeIconUrl !== failedWelcomeIconUrl ? welcomeIconUrl : null;
+    let next;
+    if (url) {
+      const img = doc.createElement("img");
+      img.src = url;
+      img.alt = "";
+      img.setAttribute("aria-hidden", "true");
+      img.style.setProperty("width", "100%");
+      img.style.setProperty("height", "100%");
+      img.style.setProperty("object-fit", "contain");
+      img.style.setProperty("display", "block");
+      img.addEventListener(
+        "error",
+        () => {
+          failedWelcomeIconUrl = url;
+          renderDockIcon();
+        },
+        { once: true }
+      );
+      next = img;
+    } else {
+      const glyph = createIcon(doc, MESSAGE_CIRCLE_PATH, 18);
+      glyph.setAttribute("width", DOCK_GLYPH_SHARE);
+      glyph.setAttribute("height", DOCK_GLYPH_SHARE);
+      next = glyph;
+    }
+    dock.replaceChild(next, dockIcon);
+    dockIcon = next;
+  }
+  function renderMode() {
+    if (!bar || !form || !status) return;
+    const effective = flow ? awaitingInput ? "input" : "flow" : mode;
+    const done = flow?.phase === "done";
+    bar.setAttribute("data-mode", effective);
+    bar.setAttribute(
+      "data-phase",
+      flow ? done ? "done" : "running" : "none"
+    );
+    bar.setAttribute("data-collapsed", isCollapsed() ? "true" : "false");
+    renderLeading();
+    renderTray();
+    render();
+    form.style.setProperty("display", effective === "flow" ? "none" : "flex");
+    status.style.setProperty(
+      "display",
+      effective === "flow" || effective === "input" ? "flex" : "none"
+    );
+    submit?.style.setProperty("display", "flex");
+    bar.setAttribute("aria-expanded", effective === "open" ? "true" : "false");
+    if (flow && statusName && statusStep) {
+      statusName.textContent = flow.name;
+      statusStep.textContent = done ? "\u2713" : labels.flowStep.replace("{step}", String(flow.step)).replace("{total}", String(flow.total));
+      stop?.style.setProperty("display", done ? "none" : "flex");
+    }
+    if (disclaimer) {
+      disclaimer.style.setProperty(
+        "display",
+        effective === "open" && disclaimer.textContent ? "block" : "none"
+      );
+    }
+  }
+  function onResize() {
+    vp = readViewport(typeof window !== "undefined" ? window : null);
+    render();
+    safe("onGeometryChange", () => options.onGeometryChange?.())();
+  }
+  function onSubmitEvent(event) {
+    event.preventDefault();
+    const value = input?.value.trim() ?? "";
+    if (!value && attachmentCount === 0) {
+      activate();
+      return;
+    }
+    if (input) input.value = "";
+    safe("onSubmit", () => options.onSubmit?.(value))();
+  }
+  function onFocus() {
+    activate();
+  }
+  function activate() {
+    if (flow || mode === "open" || gestureActivated) return;
+    gestureActivated = true;
+    safe("onActivate", () => options.onActivate?.())();
+  }
+  function onBarClick(event) {
+    if (flow || mode === "open") return;
+    if (menu && event.target instanceof Node && menu.contains(event.target)) {
+      return;
+    }
+    activate();
+    try {
+      input?.focus();
+    } catch {
+    }
+  }
+  function onPointerDown() {
+    gestureActivated = false;
+  }
+  function onLeadingClick(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (isCollapsed() || !attachEnabled) return;
+    setMenuOpen(!menuOpen);
+  }
+  function openPicker() {
+    try {
+      picker?.click();
+    } catch {
+    }
+  }
+  function onAttachItem(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    closeMenu();
+    openPicker();
+    options.onAttach?.();
+  }
+  function onPicked() {
+    const chosen = picker?.files;
+    const files = chosen ? Array.from(chosen) : [];
+    if (picker) picker.value = "";
+    if (!attachEnabled || files.length === 0) return;
+    options.onFiles?.(files);
+  }
+  function onRootKeyDown(event) {
+    if (event.key === "Escape" && menuOpen) closeMenu();
+  }
+  function onShadowPointerDown(event) {
+    if (!menuOpen) return;
+    const target = event.target;
+    const onMenu = target instanceof Node && (leading?.contains(target) === true || menu?.contains(target) === true);
+    if (!onMenu) closeMenu();
+  }
+  function onRootPointerDown(event) {
+    const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+    const target = event.target;
+    const host = shell?.host;
+    const insideWidgetPath = Boolean(
+      host && (path.some((node) => node === host) || path.length === 0 && target instanceof Node && host.contains(target))
+    );
+    if (menuOpen && !insideWidgetPath) closeMenu();
+    if (flow || mode !== "open") return;
+    if (!host || insideWidgetPath) return;
+    safe("onDismiss", () => options.onDismiss?.())();
+  }
+  function onDragOver(event) {
+    if (!carriesFiles(event)) return;
+    event.preventDefault();
+  }
+  function onDrop(event) {
+    if (!carriesFiles(event)) return;
+    event.preventDefault();
+    if (!attachEnabled) return;
+    const files = droppedFiles(event);
+    if (files.length === 0) return;
+    options.onFiles?.(files);
+  }
+  const handleResize = safe("resize", onResize);
+  const handleSubmit = safe("submit", onSubmitEvent);
+  const handleFocus = safe("focus", onFocus);
+  const handleBarClick = safe("barClick", onBarClick);
+  const handlePointerDown = safe("pointerdown", onPointerDown);
+  const handleLeading = safe("attachMenu", onLeadingClick);
+  const handleAttach = safe("attach", onAttachItem);
+  const handlePicked = safe("picked", onPicked);
+  const handleStop = safe("stop", () => options.onStop?.());
+  const handleRootKeyDown = safe("menuKey", onRootKeyDown);
+  const handleRootPointerDown = safe("menuDismiss", onRootPointerDown);
+  const handleShadowPointerDown = safe("menuDismissInside", onShadowPointerDown);
+  const handleDragOver = safe("dragover", onDragOver);
+  const handleDrop = safe("drop", onDrop);
+  const handleDock = safe("undock", () => options.onUndock?.());
+  function reveal(host) {
+    if (revealed) return;
+    revealed = true;
+    try {
+      host.style.setProperty("opacity", "1");
+    } catch {
+    }
+  }
+  function scheduleReveal(host, win) {
+    if (revealed) return;
+    if (!win || typeof win.setTimeout !== "function") {
+      revealed = true;
+      return;
+    }
+    try {
+      host.style.setProperty("opacity", "0");
+      host.style.setProperty("transition", `opacity ${REVEAL_FADE_MS}ms ease`);
+    } catch {
+      revealed = true;
+      return;
+    }
+    const after = (ms) => {
+      try {
+        win.setTimeout(() => reveal(host), ms);
+      } catch {
+        reveal(host);
+      }
+    };
+    if (host.ownerDocument.readyState === "complete") {
+      after(REVEAL_SETTLED_MS);
+      return;
+    }
+    try {
+      win.addEventListener("load", () => after(REVEAL_AFTER_LOAD_MS), {
+        once: true
+      });
+    } catch {
+    }
+    after(REVEAL_MAX_MS);
+  }
+  function mount() {
+    if (shell?.host.isConnected) {
+      warn("The chat bar is already mounted. Ignoring the second mount.");
+      return;
+    }
+    shell = null;
+    const created = createShell({ container: options.container });
+    if (!created) return;
+    shell = created;
+    scheduleReveal(created.host, created.host.ownerDocument.defaultView);
+    injectStyles(shell, BAR_CSS);
+    const doc = shell.host.ownerDocument;
+    wrap = doc.createElement("div");
+    wrap.className = "arcy-bar-wrap";
+    for (const [property, value] of SURVIVAL_STYLE) {
+      wrap.style.setProperty(property, value);
+    }
+    for (const [property, value] of SURVIVAL_IMPORTANT) {
+      wrap.style.setProperty(property, value, "important");
+    }
+    wrap.style.setProperty("flex-direction", "column");
+    wrap.style.setProperty("align-items", "center");
+    bar = doc.createElement("div");
+    bar.className = "arcy-bar";
+    bar.setAttribute("role", "group");
+    bar.setAttribute("aria-label", labels.openChat);
+    form = doc.createElement("form");
+    form.className = "arcy-bar-form";
+    input = doc.createElement("input");
+    input.type = "text";
+    input.className = "arcy-bar-input";
+    input.maxLength = MAX_INPUT_LENGTH;
+    input.setAttribute("aria-label", labels.openChat);
+    input.autocomplete = "off";
+    tray = doc.createElement("div");
+    tray.className = BAR_TRAY_CLASS;
+    tray.style.setProperty("display", "none");
+    grip = doc.createElement("button");
+    grip.type = "button";
+    grip.className = "arcy-bar-grip";
+    grip.setAttribute("aria-label", labels.moveBar);
+    grip.setAttribute("data-tip", labels.moveBar);
+    grip.appendChild(createIcon(doc, GRIP_PATH, 16));
+    grip.addEventListener("pointerdown", handleGripDown);
+    grip.addEventListener("click", (event) => event.stopPropagation());
+    leading = doc.createElement("button");
+    leading.type = "button";
+    leading.className = "arcy-bar-leading";
+    leadingIcon = iconUrl ? createImageIcon(doc, iconUrl, iconSize) : createIcon(doc, SPARKLES_PATH, iconSize);
+    leading.appendChild(leadingIcon);
+    menu = doc.createElement("div");
+    menu.className = "arcy-bar-menu";
+    menu.setAttribute("role", "menu");
+    menu.style.setProperty("display", "none");
+    attach = doc.createElement("button");
+    attach.type = "button";
+    attach.className = "arcy-bar-menu-item";
+    attach.setAttribute("role", "menuitem");
+    attach.appendChild(createIcon(doc, ATTACH_PATH, 16));
+    attach.appendChild(doc.createTextNode(labels.attachImage));
+    menu.appendChild(attach);
+    picker = doc.createElement("input");
+    picker.type = "file";
+    picker.accept = ATTACHABLE_TYPES.join(",");
+    picker.multiple = true;
+    picker.tabIndex = -1;
+    picker.setAttribute("aria-hidden", "true");
+    picker.style.setProperty("display", "none");
+    bar.appendChild(picker);
+    submit = doc.createElement("button");
+    submit.type = "submit";
+    submit.className = "arcy-bar-send";
+    submit.setAttribute("aria-label", labels.send);
+    submit.appendChild(createIcon(doc, SEND_PATH, 18));
+    form.appendChild(grip);
+    form.appendChild(leading);
+    form.appendChild(input);
+    form.appendChild(submit);
+    status = doc.createElement("div");
+    status.className = "arcy-bar-status";
+    status.style.setProperty("display", "none");
+    const dot = doc.createElement("span");
+    dot.className = "arcy-bar-dot";
+    dot.setAttribute("aria-hidden", "true");
+    statusName = doc.createElement("span");
+    statusName.className = "arcy-bar-flow-name";
+    statusStep = doc.createElement("span");
+    statusStep.className = "arcy-bar-flow-step";
+    stop = doc.createElement("button");
+    stop.type = "button";
+    stop.className = "arcy-bar-stop";
+    stop.appendChild(createIcon(doc, STOP_PATH, 15, 2));
+    stop.appendChild(doc.createTextNode(labels.flowStop));
+    status.appendChild(dot);
+    status.appendChild(statusName);
+    status.appendChild(statusStep);
+    status.appendChild(stop);
+    bar.appendChild(tray);
+    bar.appendChild(form);
+    bar.appendChild(status);
+    bar.appendChild(menu);
+    disclaimer = doc.createElement("div");
+    disclaimer.className = "arcy-bar-disclaimer";
+    disclaimer.style.setProperty("display", "none");
+    wrap.appendChild(bar);
+    wrap.appendChild(disclaimer);
+    dock = doc.createElement("button");
+    dock.type = "button";
+    dock.className = "arcy-bar-dock";
+    dock.setAttribute("aria-label", labels.openChat);
+    dock.setAttribute("data-tip", labels.openChat);
+    dock.setAttribute("data-tip-placement", "above");
+    dock.setAttribute("data-tip-align", "end");
+    for (const [property, value] of SURVIVAL_STYLE) {
+      dock.style.setProperty(property, value);
+    }
+    for (const [property, value] of SURVIVAL_IMPORTANT) {
+      dock.style.setProperty(property, value, "important");
+    }
+    dock.style.setProperty("align-items", "center");
+    dock.style.setProperty("justify-content", "center");
+    dock.style.setProperty("width", DOCK_SIZE_CSS);
+    dock.style.setProperty("height", DOCK_SIZE_CSS);
+    dockIcon = createIcon(doc, MESSAGE_CIRCLE_PATH, 18);
+    dock.appendChild(dockIcon);
+    renderDockIcon();
+    dock.addEventListener("click", handleDock);
+    form.addEventListener("submit", handleSubmit);
+    input.addEventListener("focus", handleFocus);
+    bar.addEventListener("click", handleBarClick);
+    bar.addEventListener("pointerdown", handlePointerDown, true);
+    leading.addEventListener("click", handleLeading);
+    attach.addEventListener("click", handleAttach);
+    picker.addEventListener("change", handlePicked);
+    stop.addEventListener("click", handleStop);
+    bar.addEventListener("dragover", handleDragOver);
+    bar.addEventListener("drop", handleDrop);
+    doc.addEventListener("pointerdown", handleRootPointerDown, true);
+    shell.root.addEventListener("pointerdown", handleShadowPointerDown, true);
+    doc.addEventListener("keydown", handleRootKeyDown, true);
+    const win = doc.defaultView;
+    win?.addEventListener("resize", handleResize);
+    win?.addEventListener("orientationchange", handleResize);
+    win?.visualViewport?.addEventListener("resize", handleResize);
+    win?.visualViewport?.addEventListener("scroll", handleResize);
+    shell.root.appendChild(wrap);
+    shell.root.appendChild(dock);
+    vp = readViewport(win ?? null);
+    docked = options.readDocked?.() === true;
+    render();
+    renderMode();
+  }
+  function unmount() {
+    if (!shell) return;
+    const win = shell.host.ownerDocument.defaultView;
+    win?.removeEventListener("resize", handleResize);
+    win?.removeEventListener("orientationchange", handleResize);
+    win?.visualViewport?.removeEventListener("resize", handleResize);
+    win?.visualViewport?.removeEventListener("scroll", handleResize);
+    form?.removeEventListener("submit", handleSubmit);
+    input?.removeEventListener("focus", handleFocus);
+    bar?.removeEventListener("click", handleBarClick);
+    bar?.removeEventListener("pointerdown", handlePointerDown, true);
+    leading?.removeEventListener("click", handleLeading);
+    attach?.removeEventListener("click", handleAttach);
+    picker?.removeEventListener("change", handlePicked);
+    stop?.removeEventListener("click", handleStop);
+    bar?.removeEventListener("dragover", handleDragOver);
+    bar?.removeEventListener("drop", handleDrop);
+    dock?.removeEventListener("click", handleDock);
+    const doc = shell.host.ownerDocument;
+    doc.removeEventListener("pointerdown", handleRootPointerDown, true);
+    shell.root.removeEventListener("pointerdown", handleShadowPointerDown, true);
+    doc.removeEventListener("keydown", handleRootKeyDown, true);
+    shell.destroy();
+    shell = null;
+    wrap = bar = form = status = statusName = statusStep = disclaimer = null;
+    input = null;
+    attach = submit = stop = null;
+    picker = null;
+    leading = null;
+    leadingIcon = null;
+    dock = null;
+    dockIcon = null;
+    menu = null;
+    tray = null;
+    menuOpen = false;
+    flow = null;
+    mode = "idle";
+  }
+  return {
+    mount,
+    unmount,
+    isMounted: () => shell !== null && shell.host.isConnected,
+    getElement: () => bar,
+    getRoot: () => shell?.root ?? null,
+    getHost: () => shell?.host ?? null,
+    setMode(next) {
+      if (mode === next) return;
+      mode = next;
+      gestureActivated = false;
+      renderMode();
+    },
+    getMode: () => flow ? "flow" : mode,
+    setGeometry(next) {
+      geometry = {
+        widthPercent: next.widthPercent ?? geometry.widthPercent,
+        bottomOffset: next.bottomOffset ?? geometry.bottomOffset,
+        collapsedWidth: next.collapsedWidth ?? geometry.collapsedWidth
+      };
+      render();
+    },
+    getMetrics: () => ({
+      ...geometry,
+      // What is actually rendered, not what is stored: a running flow is
+      // pinned to the bottom centre (see `render`), and the panel and the
+      // executor's scroll-into-view both place against this.
+      offset: flow || !draggable || vp.isMobile ? ZERO_OFFSET : offset,
+      height: wrap?.offsetHeight || bar?.offsetHeight || BAR_HEIGHT,
+      keyboardOffset: vp.keyboardOffset,
+      isMobile: vp.isMobile,
+      viewportHeight: vp.height,
+      viewportWidth: vp.width
+    }),
+    getHeight: () => wrap?.offsetHeight || bar?.offsetHeight || BAR_HEIGHT,
+    setLabels(next) {
+      labels = { ...labels, ...next };
+      try {
+        submit?.setAttribute("aria-label", labels.send);
+        if (attach) {
+          const text = attach.lastChild;
+          if (text) text.textContent = labels.attachImage;
+        }
+        bar?.setAttribute("aria-label", labels.openChat);
+        input?.setAttribute("aria-label", labels.openChat);
+        if (dock) {
+          dock.setAttribute("aria-label", labels.openChat);
+          dock.setAttribute("data-tip", labels.openChat);
+        }
+        if (grip) {
+          grip.setAttribute("aria-label", labels.moveBar);
+          grip.setAttribute("data-tip", labels.moveBar);
+        }
+        if (stop) {
+          const text = stop.lastChild;
+          if (text) text.textContent = labels.flowStop;
+        }
+      } catch {
+      }
+      renderMode();
+    },
+    setPlaceholder(text) {
+      try {
+        if (input) input.placeholder = text ?? "";
+      } catch {
+      }
+    },
+    setDisabled(disabled) {
+      try {
+        if (input) input.disabled = disabled;
+        if (submit) submit.disabled = disabled;
+        if (attach) attach.disabled = disabled;
+        if (disabled) closeMenu();
+      } catch {
+      }
+    },
+    setAttachEnabled(enabled) {
+      if (attachEnabled === enabled) return;
+      attachEnabled = enabled;
+      renderMode();
+    },
+    setDraggable(enabled) {
+      if (draggable === enabled) return;
+      draggable = enabled;
+      offset = enabled ? options.readPosition?.() ?? ZERO_OFFSET : ZERO_OFFSET;
+      render();
+      options.onGeometryChange?.();
+    },
+    setIcon(url) {
+      if (iconUrl === url) return;
+      iconUrl = url;
+      renderLeading();
+    },
+    setIconSize(size2) {
+      if (iconSize === size2) return;
+      iconSize = size2;
+      renderLeading();
+    },
+    setWelcomeIcon(url) {
+      if (welcomeIconUrl === url) return;
+      welcomeIconUrl = url;
+      failedWelcomeIconUrl = null;
+      renderDockIcon();
+    },
+    setDocked(next) {
+      if (docked === next) return;
+      docked = next;
+      safe("onDockedChange", () => options.onDockedChange?.(next))();
+      if (next) closeMenu();
+      render();
+      safe("onGeometryChange", () => options.onGeometryChange?.())();
+    },
+    isDocked: () => docked,
+    setFlow(next) {
+      flow = next;
+      if (!next) awaitingInput = false;
+      renderMode();
+    },
+    setAwaitingInput(next) {
+      if (awaitingInput === next) return;
+      awaitingInput = next;
+      renderMode();
+      safe("onGeometryChange", () => options.onGeometryChange?.())();
+    },
+    setDisclaimer(input2) {
+      try {
+        if (disclaimer) {
+          disclaimer.textContent = "";
+          if (input2 == null) {
+          } else if (typeof input2 === "string") {
+            disclaimer.textContent = input2;
+          } else {
+            const doc = disclaimer.ownerDocument;
+            disclaimer.appendChild(doc.createTextNode(input2.before));
+            const link = doc.createElement("a");
+            link.className = POLICY_LINK_CLASS;
+            link.href = input2.linkHref;
+            link.target = "_blank";
+            link.rel = "noopener noreferrer";
+            link.textContent = input2.linkLabel;
+            disclaimer.appendChild(link);
+            if (input2.after) disclaimer.appendChild(doc.createTextNode(input2.after));
+          }
+        }
+      } catch {
+      }
+      renderMode();
+    },
+    setAttachmentCount(count) {
+      attachmentCount = count;
+      try {
+        renderTray();
+      } catch {
+      }
+    },
+    attachmentSlot: () => tray,
+    focusInput() {
+      try {
+        if (shell) releaseHostFocus(shell.host.ownerDocument, shell.host);
+        input?.focus();
+      } catch {
+      }
+    },
+    reposition: () => {
+      vp = readViewport(typeof window !== "undefined" ? window : null);
+      render();
+    },
+    readValue: () => input?.value ?? "",
+    clearValue() {
+      try {
+        if (input) input.value = "";
+      } catch {
+      }
+    }
+  };
+}
+
+// src/shell/tokens.ts
+var HEX = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var FONT_KEY = /^[a-z0-9-]{1,32}$/;
+var SHADOWS = {
+  none: "none",
+  soft: "0 0 2px rgba(16, 24, 40, 0.04), 0 0 8px rgba(16, 24, 40, 0.06)",
+  medium: "0 0 4px rgba(16, 24, 40, 0.05), 0 0 20px rgba(16, 24, 40, 0.10)",
+  strong: "0 0 8px rgba(16, 24, 40, 0.07), 0 0 36px rgba(16, 24, 40, 0.16)",
+  bold: "0 0 12px rgba(16, 24, 40, 0.10), 0 0 48px rgba(16, 24, 40, 0.22)"
+};
+var MIN_WIDTH_PERCENT = 20;
+var MAX_WIDTH_PERCENT = 50;
+var MIN_MAX_HEIGHT_PERCENT = 30;
+var MAX_MAX_HEIGHT_PERCENT = 80;
+var MIN_BOTTOM_OFFSET = 0;
+var MAX_BOTTOM_OFFSET = 120;
+var MIN_BAR_ICON_SIZE = 14;
+var MAX_BAR_ICON_SIZE = 28;
+var MIN_COLLAPSED_WIDTH = 180;
+var MAX_COLLAPSED_WIDTH = 480;
+var MAX_Z_INDEX = 2147483647;
+var NO_TOKENS = {
+  vars: {},
+  widthPercent: null,
+  bottomOffset: null,
+  collapsedWidth: null,
+  barIconSize: null,
+  maxHeightPercent: null,
+  zIndex: null
+};
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function size(value, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.min(max, Math.max(min, value));
+}
+function colors(vars, group, fields) {
+  if (!group) return;
+  for (const [field, property] of fields) {
+    const raw = group[field];
+    if (typeof raw === "string" && HEX.test(raw)) vars[property] = raw;
+  }
+}
+function pixels(vars, property, value, min, max) {
+  const n = size(value, min, max);
+  if (n !== null) vars[property] = `${n}px`;
+}
+function shadow(vars, property, value) {
+  if (typeof value === "string" && value in SHADOWS) {
+    vars[property] = SHADOWS[value];
+  }
+}
+function readTokens(value) {
+  const tokens = object(value);
+  if (!tokens) return NO_TOKENS;
+  const vars = {};
+  const base = object(tokens.base);
+  colors(vars, object(base?.brand), [
+    ["text", "--_arcy-brand-text"],
+    ["background", "--_arcy-brand-bg"],
+    ["hover", "--_arcy-brand-bg-hover"],
+    ["active", "--_arcy-brand-bg-active"]
+  ]);
+  colors(vars, object(base?.main), [
+    ["text", "--_arcy-main-text"],
+    ["background", "--_arcy-main-bg"]
+  ]);
+  const border = object(base?.border);
+  pixels(vars, "--_arcy-border-width", border?.width, 0, 8);
+  colors(vars, border, [["color", "--_arcy-border-color"]]);
+  const glass = size(base?.glassiness, 0, 100);
+  if (glass !== null && glass > 0) {
+    vars["--_arcy-glass-blur"] = `${Math.round(glass / 5)}px`;
+    vars["--_arcy-glass-alpha"] = `${Math.round(glass / 2)}%`;
+  }
+  const font = base?.fontFamily;
+  if (typeof font === "string" && FONT_KEY.test(font) && font !== "system") {
+    vars[FONT_KEY_PROPERTY] = font;
+  }
+  const zIndex = size(base?.zIndex, 0, MAX_Z_INDEX);
+  pixels(vars, "--arcy-bar-radius", base?.borderRadius, 0, 32);
+  pixels(vars, "--_arcy-chat-radius", base?.borderRadius, 0, 32);
+  shadow(vars, "--arcy-bar-shadow", base?.shadow);
+  shadow(vars, "--_arcy-chat-shadow", base?.shadow);
+  const bar = object(tokens.bar);
+  const chat = object(tokens.chat);
+  pixels(vars, "--_arcy-chat-logo-size", chat?.logoSize, 16, 48);
+  pixels(vars, "--_arcy-chat-welcome-icon-size", chat?.welcomeIconSize, 16, 72);
+  colors(vars, object(chat?.assistantBubble), [
+    ["background", "--_arcy-assistant-bg"],
+    ["text", "--_arcy-assistant-text"]
+  ]);
+  const scrollbar = object(chat?.scrollbar);
+  pixels(vars, "--_arcy-scroll-width", scrollbar?.width, 2, 16);
+  colors(vars, scrollbar, [
+    ["track", "--_arcy-scroll-track"],
+    ["thumb", "--_arcy-scroll-thumb"],
+    ["thumbHover", "--_arcy-scroll-thumb-hover"]
+  ]);
+  return {
+    vars,
+    // Read as numbers rather than written as custom properties: `bar.ts`
+    // (width) and `chat.ts`'s `place()` (max height) do their own viewport
+    // maths with them, and one writer is what keeps the rendered bar and
+    // the panel's placement from disagreeing.
+    widthPercent: size(chat?.width, MIN_WIDTH_PERCENT, MAX_WIDTH_PERCENT),
+    bottomOffset: size(bar?.bottomOffset, MIN_BOTTOM_OFFSET, MAX_BOTTOM_OFFSET),
+    collapsedWidth: size(
+      bar?.collapsedWidth,
+      MIN_COLLAPSED_WIDTH,
+      MAX_COLLAPSED_WIDTH
+    ),
+    barIconSize: size(bar?.iconSize, MIN_BAR_ICON_SIZE, MAX_BAR_ICON_SIZE),
+    maxHeightPercent: size(
+      chat?.maxHeight,
+      MIN_MAX_HEIGHT_PERCENT,
+      MAX_MAX_HEIGHT_PERCENT
+    ),
+    zIndex: zIndex !== null ? Math.round(zIndex) : null
+  };
+}
+var MANAGED = [
+  "--_arcy-brand-text",
+  "--_arcy-brand-bg",
+  "--_arcy-brand-bg-hover",
+  "--_arcy-brand-bg-active",
+  "--_arcy-main-text",
+  "--_arcy-main-bg",
+  "--_arcy-border-width",
+  "--_arcy-border-color",
+  "--_arcy-glass-blur",
+  "--_arcy-glass-alpha",
+  FONT_KEY_PROPERTY,
+  "--arcy-bar-radius",
+  "--arcy-bar-shadow",
+  "--_arcy-chat-radius",
+  "--_arcy-chat-logo-size",
+  "--_arcy-chat-welcome-icon-size",
+  "--_arcy-chat-shadow",
+  "--_arcy-assistant-bg",
+  "--_arcy-assistant-text",
+  "--_arcy-scroll-width",
+  "--_arcy-scroll-track",
+  "--_arcy-scroll-thumb",
+  "--_arcy-scroll-thumb-hover"
+];
+function applyTokens(host, tokens) {
+  try {
+    for (const property of MANAGED) {
+      const value = tokens.vars[property];
+      if (value === void 0) host.style.removeProperty(property);
+      else host.style.setProperty(property, value);
+    }
+    host.style.setProperty(
+      "z-index",
+      tokens.zIndex === null ? Z_INDEX : String(tokens.zIndex),
+      "important"
+    );
+  } catch (error) {
+    warn(`The widget could not apply its theme. ${String(error)}`);
+  }
+}
+var TOKEN_KEY_PREFIX = "arcy.tokens.";
+var MAX_STORED = 4096;
+var MAX_NAME = 100;
+var MAX_URL = 2048;
+function readIdentity(value) {
+  const raw = object(value);
+  if (!raw) return null;
+  const name = typeof raw.name === "string" ? raw.name.slice(0, MAX_NAME) : "";
+  const url = raw.logoUrl;
+  const logoUrl = typeof url === "string" && url.length <= MAX_URL && /^https:\/\//i.test(url) ? url : null;
+  return { name, logoUrl };
+}
+function createTokenCache(token, raw = browserLocalStorage()) {
+  const store = safeStore(raw);
+  const key = TOKEN_KEY_PREFIX + token;
+  return {
+    read() {
+      const blob = object(readJson(store, key));
+      return {
+        tokens: readTokens(blob?.t),
+        identity: readIdentity(blob?.w)
+      };
+    },
+    remember(tokens, identity) {
+      const t = object(tokens);
+      const w = readIdentity(identity);
+      if (!t && !w) {
+        store.removeItem(key);
+        return;
+      }
+      try {
+        const blob = { t: t ?? void 0, w: w ?? void 0 };
+        if (JSON.stringify(blob).length > MAX_STORED) return;
+        writeJson(store, key, blob);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/session/visit.ts
+var VISIT_KEY_PREFIX = "arcy.visit.";
+var FIRST_VISIT_VALUE = "first";
+function createVisitState(token, raw = browserSessionStorage()) {
+  const store = safeStore(raw);
+  const key = VISIT_KEY_PREFIX + token;
+  return {
+    markFirstVisit() {
+      store.setItem(key, FIRST_VISIT_VALUE);
+    },
+    isFirstVisit() {
+      return store.getItem(key) === FIRST_VISIT_VALUE;
+    }
+  };
+}
+
+// src/telemetry/ulid.ts
+var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_CHARS = 10;
+var RANDOM_CHARS = 16;
+var defaultRandomFill = (out) => {
+  const source = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (source && typeof source.getRandomValues === "function") {
+    source.getRandomValues(out);
+    return;
+  }
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Math.floor(Math.random() * 256);
+  }
+};
+function ulid(now, fill = defaultRandomFill) {
+  let time = "";
+  let remaining = Math.floor(now);
+  for (let i = 0; i < TIME_CHARS; i++) {
+    time = (ALPHABET[remaining % 32] ?? "0") + time;
+    remaining = Math.floor(remaining / 32);
+  }
+  const bytes = new Uint8Array(RANDOM_CHARS);
+  fill(bytes);
+  let random = "";
+  for (let i = 0; i < RANDOM_CHARS; i++) {
+    random += ALPHABET[(bytes[i] ?? 0) % 32];
+  }
+  return time + random;
+}
+
+// src/shell/conversation.ts
+var CONVERSATION_KEY_PREFIX = "arcy.chat.";
+var CONVERSATION_TTL_MS = 24 * 60 * 60 * 1e3;
+function createConversationStore(token, { store: raw = browserLocalStorage(), fill = defaultRandomFill, now = Date.now } = {}) {
+  const store = safeStore(raw);
+  const key = CONVERSATION_KEY_PREFIX + token;
+  function readRaw() {
+    return readJson(store, key) ?? {};
+  }
+  function mint() {
+    const id = ulid(now(), fill);
+    writeJson(store, key, { id, lastActiveAt: now() });
+    return id;
+  }
+  return {
+    id() {
+      const stored = readRaw();
+      const id = typeof stored.id === "string" ? stored.id : null;
+      const lastActiveAt = typeof stored.lastActiveAt === "number" ? stored.lastActiveAt : null;
+      if (id && lastActiveAt !== null && now() - lastActiveAt < CONVERSATION_TTL_MS) {
+        return id;
+      }
+      return mint();
+    },
+    touch() {
+      const stored = readRaw();
+      if (typeof stored.id !== "string") return;
+      writeJson(store, key, { ...stored, lastActiveAt: now() });
+    },
+    reset() {
+      mint();
+    },
+    adopt(conversationId) {
+      if (typeof conversationId !== "string" || conversationId.length === 0) {
+        return this.id();
+      }
+      writeJson(store, key, { id: conversationId, lastActiveAt: now() });
+      return conversationId;
+    },
+    startNew() {
+      return mint();
+    }
+  };
+}
+
+// src/session/context.ts
+var CAMPAIGN_KEYS = [
+  ["utm_source", "utmSource"],
+  ["utm_medium", "utmMedium"],
+  ["utm_campaign", "utmCampaign"],
+  ["utm_content", "utmContent"],
+  ["utm_term", "utmTerm"]
+];
+var MAX_CAMPAIGN_LENGTH = 255;
+var MAX_REFERRER_LENGTH = 512;
+var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/g;
+function clean(value, max) {
+  const trimmed = value.replace(CONTROL_CHARACTERS, "").trim();
+  if (trimmed.length === 0) return void 0;
+  return trimmed.slice(0, max);
+}
+function scrubReferrer(referrer) {
+  if (typeof referrer !== "string" || referrer.length === 0) return void 0;
+  try {
+    const url = new URL(referrer);
+    const host = url.host;
+    if (!host) return void 0;
+    const path = scrubPath(url.pathname);
+    return clean(path === "/" ? host : host + path, MAX_REFERRER_LENGTH);
+  } catch {
+    return void 0;
+  }
+}
+function readCampaign(search) {
+  const out = {};
+  if (typeof search !== "string" || search.length === 0) return out;
+  const query = search.charAt(0) === "?" ? search.slice(1) : search;
+  for (const pair of query.split("&")) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) continue;
+    const rawKey = pair.slice(0, eq).toLowerCase();
+    const match = CAMPAIGN_KEYS.find((entry) => entry[0] === rawKey);
+    if (!match) continue;
+    let value = pair.slice(eq + 1).replace(/\+/g, " ");
+    try {
+      value = decodeURIComponent(value);
+    } catch {
+    }
+    const cleaned = clean(value, MAX_CAMPAIGN_LENGTH);
+    if (cleaned) out[match[1]] = cleaned;
+  }
+  return out;
+}
+function readBrowser(userAgent) {
+  const ua = typeof userAgent === "string" ? userAgent : "";
+  if (ua.length === 0) return void 0;
+  if (/Edg[A-Z]?\//.test(ua)) return "Edge";
+  if (/OPR\/|Opera/.test(ua)) return "Opera";
+  if (/SamsungBrowser\//.test(ua)) return "Samsung Internet";
+  if (/Firefox\/|FxiOS\//.test(ua)) return "Firefox";
+  if (/Chrome\/|CriOS\//.test(ua)) return "Chrome";
+  if (/Safari\//.test(ua)) return "Safari";
+  return void 0;
+}
+function readOs(userAgent) {
+  const ua = typeof userAgent === "string" ? userAgent : "";
+  if (ua.length === 0) return void 0;
+  if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
+  if (/Android/.test(ua)) return "Android";
+  if (/CrOS/.test(ua)) return "ChromeOS";
+  if (/Windows/.test(ua)) return "Windows";
+  if (/Mac OS X|Macintosh/.test(ua)) return "macOS";
+  if (/Linux/.test(ua)) return "Linux";
+  return void 0;
+}
+function viewportBucket(width) {
+  if (typeof width !== "number" || !(width > 0)) return void 0;
+  if (width < 480) return "xs";
+  if (width < 768) return "sm";
+  if (width < 1024) return "md";
+  if (width < 1280) return "lg";
+  return "xl";
+}
+function captureSessionContext(input) {
+  const context = { ...readCampaign(input.search) };
+  const referrer = scrubReferrer(input.referrer);
+  if (referrer) context.referrer = referrer;
+  const browser = readBrowser(input.userAgent);
+  if (browser) context.browser = browser;
+  const os = readOs(input.userAgent);
+  if (os) context.os = os;
+  const viewport = viewportBucket(input.viewportWidth);
+  if (viewport) context.viewport = viewport;
+  return Object.keys(context).length > 0 ? context : void 0;
+}
+
+// src/telemetry/consent.ts
+var STATES = ["ON", "REQUIRE_CONSENT", "OFF"];
+function createConsentCache(store, key) {
+  function read() {
+    const raw = readJson(store, key);
+    if (!raw) return {};
+    const state = typeof raw.state === "string" && STATES.indexOf(raw.state) !== -1 ? raw.state : void 0;
+    const consent = typeof raw.consent === "boolean" ? raw.consent : void 0;
+    return { state, consent };
+  }
+  function write(next) {
+    if (next.state === void 0 && next.consent === void 0) {
+      store.removeItem(key);
+      return;
+    }
+    writeJson(store, key, next);
+  }
+  return {
+    state: () => read().state ?? null,
+    consent: () => read().consent ?? null,
+    setState(state) {
+      write({ ...read(), state });
+    },
+    setConsent(granted) {
+      const current = read();
+      write({ state: current.state, consent: granted ? true : void 0 });
+    },
+    clearState() {
+      write({ state: void 0, consent: read().consent });
+    },
+    shouldCapture() {
+      const { state, consent } = read();
+      if (state === void 0) return false;
+      if (state === "OFF") return false;
+      if (state === "REQUIRE_CONSENT") return consent === true;
+      return true;
+    }
+  };
+}
+
+// src/telemetry/device.ts
+var MOBILE = /iPhone|iPod|Android.*Mobile|Windows Phone|BlackBerry|Opera Mini|IEMobile/i;
+var TABLET = /iPad|Tablet|PlayBook|Silk|Kindle/i;
+function deviceClass(nav) {
+  const ua = nav?.userAgent ?? "";
+  if (TABLET.test(ua)) return "tablet";
+  if (nav?.platform === "MacIntel" && typeof nav.maxTouchPoints === "number" && nav.maxTouchPoints > 1) {
+    return "tablet";
+  }
+  if (MOBILE.test(ua)) return "mobile";
+  if (/Android/i.test(ua)) return "tablet";
+  return "desktop";
+}
+
+// src/telemetry/describe.ts
+var MAX_TEXT_LENGTH = 100;
+var PII_SCAN_MAX = 4096;
+var VALUE_BEARING = ["INPUT", "TEXTAREA", "SELECT"];
+function readableCopy(raw) {
+  if (raw.length === 0) return void 0;
+  if (containsPii(raw.slice(0, PII_SCAN_MAX))) return void 0;
+  return raw.slice(0, MAX_TEXT_LENGTH);
+}
+function describeElementPayload(element, describeElement) {
+  const tag = (element.tagName ?? "").toUpperCase();
+  const payload = { tag: tag.toLowerCase() };
+  const role = element.getAttribute("role");
+  if (role) payload.role = role.slice(0, 64);
+  const type = element.getAttribute("type");
+  if (type) payload.type = type.slice(0, 32);
+  if (VALUE_BEARING.indexOf(tag) === -1) {
+    const text = (element.textContent ?? "").replace(/\s+/g, " ").trim();
+    const readable = readableCopy(text);
+    if (readable) payload.text = readable;
+  } else {
+    const label = element.getAttribute("aria-label") ?? element.getAttribute("name");
+    const readable = readableCopy(label ?? "");
+    if (readable) payload.label = readable;
+  }
+  if (describeElement) {
+    const fingerprint = describeElement(element);
+    if (fingerprint && Object.keys(fingerprint).length > 0) {
+      payload.fingerprint = fingerprint;
+    }
+  }
+  return payload;
+}
+function describeClick(element, describeElement) {
+  return describeElementPayload(element, describeElement);
+}
+function describeField(element, describeElement) {
+  const payload = describeElementPayload(element, describeElement);
+  const valid = element.validity?.valid;
+  if (typeof valid === "boolean") payload.valid = valid;
+  return payload;
+}
+function describeSubmit(form, describeElement) {
+  const payload = describeElementPayload(form, describeElement);
+  const name = form.getAttribute("name") ?? form.getAttribute("id");
+  if (name) payload.form = name.slice(0, MAX_TEXT_LENGTH);
+  const count = form.elements?.length;
+  if (typeof count === "number") payload.fieldCount = count;
+  return payload;
+}
+
+// src/telemetry/errors.ts
+var REQUEST_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+var OTHER_METHOD = "OTHER";
+var FAILED_STATUS_MIN = 400;
+var ERROR_MESSAGE_MAX = 200;
+var CONTROL_CHARACTERS2 = /[\u0000-\u001f\u007f]+/g;
+function readErrorMessage(raw) {
+  let text = null;
+  if (typeof raw === "string") text = raw;
+  else if (raw && typeof raw === "object") {
+    const message = raw.message;
+    if (typeof message === "string") text = message;
+  }
+  if (text === null) return null;
+  const flattened = text.replace(CONTROL_CHARACTERS2, " ").trim();
+  if (flattened.length === 0) return null;
+  return flattened.length > ERROR_MESSAGE_MAX ? flattened.slice(0, ERROR_MESSAGE_MAX) : flattened;
+}
+function normalizeMethod(raw) {
+  if (typeof raw !== "string") return "GET";
+  const upper = raw.toUpperCase();
+  return REQUEST_METHODS.indexOf(upper) === -1 ? OTHER_METHOD : upper;
+}
+function isFailedStatus(status) {
+  return typeof status === "number" && status >= FAILED_STATUS_MIN;
+}
+function installNetworkWatch(options) {
+  const { target, report, ignore } = options;
+  const restores = [];
+  function emit(method, status, raw) {
+    try {
+      if (!isFailedStatus(status)) return;
+      if (raw !== null && ignore?.(raw)) return;
+      report({
+        method,
+        status,
+        url: raw === null ? null : normalizeRoute(raw, target.location?.href)
+      });
+    } catch {
+    }
+  }
+  function installFetch() {
+    const original = target.fetch;
+    if (typeof original !== "function") return;
+    const wrapper = function(...args) {
+      const result = original.apply(this, args);
+      try {
+        const promise = result;
+        if (typeof promise?.then !== "function") return result;
+        promise.then(
+          (response) => {
+            const status = response?.status;
+            emit(fetchMethod(args), status, fetchUrl(args));
+          },
+          () => {
+          }
+        );
+      } catch {
+      }
+      return result;
+    };
+    target.fetch = wrapper;
+    restores.push(() => {
+      if (target.fetch === wrapper) target.fetch = original;
+    });
+  }
+  function installXhr() {
+    const proto = target.XMLHttpRequest?.prototype;
+    const originalOpen = proto?.open;
+    const originalSend = proto?.send;
+    if (!proto || typeof originalOpen !== "function" || typeof originalSend !== "function") {
+      return;
+    }
+    if (typeof WeakMap !== "function") return;
+    const pending = /* @__PURE__ */ new WeakMap();
+    const open = function(...args) {
+      const result = originalOpen.apply(this, args);
+      try {
+        pending.set(this, {
+          method: normalizeMethod(args[0]),
+          url: typeof args[1] === "string" ? args[1] : null,
+          listening: pending.get(this)?.listening ?? false
+        });
+      } catch {
+      }
+      return result;
+    };
+    const send = function(...args) {
+      try {
+        const xhr = this;
+        const record = pending.get(this);
+        if (typeof xhr.addEventListener === "function" && record?.listening !== true) {
+          if (record) record.listening = true;
+          xhr.addEventListener("loadend", () => {
+            const current = pending.get(this);
+            emit(current?.method ?? "GET", xhr.status, current?.url ?? null);
+          });
+        }
+      } catch {
+      }
+      return originalSend.apply(this, args);
+    };
+    proto.open = open;
+    restores.push(() => {
+      if (proto.open === open) proto.open = originalOpen;
+    });
+    proto.send = send;
+    restores.push(() => {
+      if (proto.send === send) proto.send = originalSend;
+    });
+  }
+  try {
+    installFetch();
+    installXhr();
+  } catch {
+    for (const restore of restores) {
+      try {
+        restore();
+      } catch {
+      }
+    }
+    return null;
+  }
+  if (restores.length === 0) return null;
+  return () => {
+    for (const restore of restores) {
+      try {
+        restore();
+      } catch {
+      }
+    }
+    restores.length = 0;
+  };
+}
+function fetchMethod(args) {
+  const init = args[1];
+  if (init && typeof init === "object" && typeof init.method === "string") {
+    return normalizeMethod(init.method);
+  }
+  const input = args[0];
+  if (input && typeof input === "object" && typeof input.method === "string") {
+    return normalizeMethod(input.method);
+  }
+  return "GET";
+}
+function fetchUrl(args) {
+  const input = args[0];
+  if (typeof input === "string") return input;
+  if (!input || typeof input !== "object") return null;
+  const url = input.url;
+  if (typeof url === "string") return url;
+  const href = input.href;
+  return typeof href === "string" ? href : null;
+}
+
+// src/telemetry/events.ts
+function buildEvent(id, name, occurredAt, context, payload) {
+  const event = {
+    id,
+    name,
+    occurredAt,
+    sessionId: context.sessionId
+  };
+  if (context.userId) event.userId = context.userId;
+  if (context.visitorId) event.visitorId = context.visitorId;
+  if (context.route) event.route = context.route;
+  if (context.localeCode) event.localeCode = context.localeCode;
+  if (context.deviceClass) event.deviceClass = context.deviceClass;
+  if (context.flowSessionId) event.flowSessionId = context.flowSessionId;
+  if (payload && Object.keys(payload).length > 0) event.payload = payload;
+  return event;
+}
+
+// src/telemetry/fields.ts
+var NON_FIELD_TYPES = [
+  "button",
+  "submit",
+  "reset",
+  "image",
+  "hidden",
+  "checkbox",
+  "radio"
+];
+var FIELD_TAGS = ["INPUT", "TEXTAREA", "SELECT"];
+function isFieldElement(element) {
+  if (!element || typeof element.getAttribute !== "function") return false;
+  const tag = (element.tagName ?? "").toUpperCase();
+  if (FIELD_TAGS.indexOf(tag) === -1) return false;
+  if (tag !== "INPUT") return true;
+  const type = (element.getAttribute("type") ?? "text").toLowerCase();
+  return NON_FIELD_TYPES.indexOf(type) === -1;
+}
+function isEmpty(element) {
+  const value = element.value;
+  return typeof value === "string" ? value.length === 0 : value == null;
+}
+function createFieldObserver(options) {
+  let active = null;
+  return {
+    focus(element) {
+      if (!isFieldElement(element)) return;
+      active = {
+        element,
+        empty: isEmpty(element),
+        filled: false,
+        cleared: false
+      };
+      options.emit("field_focused", element);
+    },
+    change(element) {
+      if (!active || active.element !== element) return;
+      const empty = isEmpty(element);
+      if (empty === active.empty) return;
+      active.empty = empty;
+      if (!empty) {
+        if (active.filled) return;
+        active.filled = true;
+        options.emit("input_filled", element);
+        return;
+      }
+      if (active.cleared) return;
+      active.cleared = true;
+      options.emit("input_cleared", element);
+    },
+    blur(element) {
+      if (active && active.element === element) active = null;
+    }
+  };
+}
+
+// src/telemetry/interactive.ts
+var INTERACTIVE_TAGS = [
+  "A",
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "SUMMARY",
+  "OPTION",
+  "LABEL"
+];
+var INTERACTIVE_ROLES = [
+  "button",
+  "link",
+  "checkbox",
+  "radio",
+  "switch",
+  "tab",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "combobox",
+  "textbox",
+  "searchbox",
+  "slider",
+  "spinbutton",
+  "treeitem"
+];
+var MAX_ANCESTOR_DEPTH = 6;
+function isInteractiveSelf(element, cursorOf) {
+  const tag = (element.tagName ?? "").toUpperCase();
+  if (INTERACTIVE_TAGS.indexOf(tag) !== -1) return true;
+  const role = element.getAttribute("role");
+  if (role && INTERACTIVE_ROLES.indexOf(role.toLowerCase()) !== -1) return true;
+  if (element.getAttribute("onclick") !== null) return true;
+  const tabIndex = element.getAttribute("tabindex");
+  if (tabIndex !== null && Number(tabIndex) >= 0) return true;
+  if (element.getAttribute("contenteditable") === "true") return true;
+  return cursorOf ? cursorOf(element) === "pointer" : false;
+}
+function findInteractive(target, cursorOf) {
+  let node = target;
+  for (let depth = 0; node && depth < MAX_ANCESTOR_DEPTH; depth++) {
+    if (isInteractiveSelf(node, cursorOf)) return node;
+    node = node.parentElement;
+  }
+  return null;
+}
+
+// src/telemetry/scroll.ts
+var SCROLL_MILESTONES = [25, 50, 75, 100];
+var SCROLL_THROTTLE_MS = 250;
+var FINAL_MILESTONE = 100;
+function createScrollObserver(options) {
+  const {
+    readDepth,
+    emit,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    clearTimeoutImpl = (handle) => clearTimeout(handle),
+    throttleMs = SCROLL_THROTTLE_MS
+  } = options;
+  let reported = 0;
+  let pending = null;
+  function evaluate() {
+    pending = null;
+    let depth = null;
+    try {
+      depth = readDepth();
+    } catch {
+      return;
+    }
+    if (depth === null) return;
+    let reached = 0;
+    for (const milestone of SCROLL_MILESTONES) {
+      if (depth >= milestone) reached = milestone;
+    }
+    if (reached <= reported) return;
+    reported = reached;
+    emit(reached);
+  }
+  return {
+    scrolled() {
+      if (pending !== null) return;
+      if (reported >= FINAL_MILESTONE) return;
+      try {
+        pending = setTimeoutImpl(evaluate, throttleMs);
+      } catch {
+        pending = null;
+      }
+    },
+    reset() {
+      reported = 0;
+      if (pending !== null) {
+        try {
+          clearTimeoutImpl(pending);
+        } catch {
+        }
+        pending = null;
+      }
+    },
+    dispose() {
+      if (pending === null) return;
+      try {
+        clearTimeoutImpl(pending);
+      } catch {
+      }
+      pending = null;
+    }
+  };
+}
+function scrollDepthPercent(metrics) {
+  const viewport = metrics.innerHeight ?? 0;
+  const total = metrics.documentHeight ?? 0;
+  const scrollable = total - viewport;
+  if (!(scrollable > 0) || !(viewport > 0)) return null;
+  const scrolled = (metrics.scrollY ?? 0) + viewport;
+  const percent = scrolled / total * 100;
+  if (!(percent > 0)) return 0;
+  return percent > 100 ? 100 : percent;
+}
+
+// src/telemetry/session.ts
+var SESSION_WINDOW_MS = 30 * 60 * 1e3;
+var TOUCH_WRITE_INTERVAL_MS = 60 * 1e3;
+function createSessionStore({
+  store,
+  key,
+  now,
+  fill,
+  windowMs = SESSION_WINDOW_MS
+}) {
+  function touch() {
+    const at = now();
+    const existing = readJson(store, key);
+    const alive = existing && typeof existing.id === "string" && existing.id.length > 0 && typeof existing.seen === "number" && at - existing.seen < windowMs;
+    if (alive) {
+      if (at - existing.seen >= TOUCH_WRITE_INTERVAL_MS) {
+        writeJson(store, key, { id: existing.id, seen: at });
+      }
+      return existing.id;
+    }
+    const id = ulid(at, fill);
+    writeJson(store, key, { id, seen: at });
+    return id;
+  }
+  return {
+    touch,
+    peek: () => readJson(store, key),
+    clear() {
+      store.removeItem(key);
+    }
+  };
+}
+
+// src/telemetry/transport.ts
+var FLUSH_EVENT_THRESHOLD = 20;
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_EVENTS_PER_REQUEST = 100;
+var MAX_REQUEST_BYTES = 64 * 1024;
+var MAX_QUEUED_EVENTS = 1e3;
+var DEFAULT_API_BASE2 = "https://api.arcyai.com";
+var TELEMETRY_PATH = "/api/v1/sdk/telemetry";
+function utf8Length(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319) {
+      bytes += 4;
+      i++;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function chunkEvents(events) {
+  const chunks = [];
+  let current = [];
+  let bytes = 13;
+  for (const event of events) {
+    const size2 = utf8Length(JSON.stringify(event)) + 1;
+    const wouldOverflow = current.length >= MAX_EVENTS_PER_REQUEST || current.length > 0 && bytes + size2 > MAX_REQUEST_BYTES;
+    if (wouldOverflow) {
+      chunks.push(current);
+      current = [];
+      bytes = 13;
+    }
+    current.push(event);
+    bytes += size2;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+function createTransport(options) {
+  const {
+    token,
+    apiBase = DEFAULT_API_BASE2,
+    fetchImpl,
+    sendBeacon,
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    clearTimeoutImpl = (handle) => clearTimeout(handle),
+    sessionStore,
+    stopKey,
+    onTelemetryOff
+  } = options;
+  const url = `${apiBase}${TELEMETRY_PATH}`;
+  let queue = [];
+  let timer = null;
+  let stopReason = readPersistedStop();
+  let inFlight = Promise.resolve();
+  function readPersistedStop() {
+    if (!sessionStore || !stopKey) return null;
+    return sessionStore.getItem(stopKey) === "tracked_events_cap" ? "tracked_events_cap" : null;
+  }
+  function stop(reason) {
+    stopReason = reason;
+    queue = [];
+    cancelTimer();
+    if (reason === "tracked_events_cap") {
+      if (sessionStore && stopKey) sessionStore.setItem(stopKey, reason);
+    } else if (onTelemetryOff) {
+      onTelemetryOff();
+    }
+  }
+  function cancelTimer() {
+    if (timer !== null) {
+      clearTimeoutImpl(timer);
+      timer = null;
+    }
+  }
+  function scheduleFlush() {
+    if (timer !== null) return;
+    timer = setTimeoutImpl(() => {
+      timer = null;
+      void flush(false);
+    }, FLUSH_INTERVAL_MS);
+  }
+  function enqueue(event) {
+    if (stopReason !== null) return;
+    queue.push(event);
+    if (queue.length > MAX_QUEUED_EVENTS) {
+      queue.splice(0, queue.length - MAX_QUEUED_EVENTS);
+    }
+    if (queue.length >= FLUSH_EVENT_THRESHOLD) {
+      void flush(false);
+      return;
+    }
+    scheduleFlush();
+  }
+  async function rejectionCode(response) {
+    try {
+      const body = await response.json();
+      if (body && typeof body === "object") {
+        const code = body.code;
+        if (typeof code === "string") return code;
+      }
+    } catch {
+    }
+    return null;
+  }
+  async function send(chunk) {
+    if (!fetchImpl) return chunk;
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ events: chunk }),
+        // Not `keepalive` here: the ordinary path has no unload pressure, and
+        // keepalive requests share a small per-page budget that the final
+        // flush needs.
+        credentials: "omit"
+      });
+    } catch {
+      return chunk;
+    }
+    if (response.status === 403) {
+      const code = await rejectionCode(response);
+      if (code === "telemetry_off") {
+        stop("telemetry_off");
+        return [];
+      }
+      return [];
+    }
+    if (response.status === 429) {
+      const code = await rejectionCode(response);
+      if (code === "tracked_events_cap") {
+        stop("tracked_events_cap");
+        return [];
+      }
+      return chunk;
+    }
+    if (response.status >= 500) return chunk;
+    return [];
+  }
+  function sendFinal(chunk) {
+    const body = JSON.stringify({ events: chunk });
+    const beaconUrl = `${url}?token=${encodeURIComponent(token)}`;
+    if (sendBeacon && typeof Blob !== "undefined") {
+      try {
+        if (sendBeacon(beaconUrl, new Blob([body], { type: "application/json" }))) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    if (fetchImpl) {
+      try {
+        void fetchImpl(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body,
+          keepalive: true,
+          credentials: "omit"
+        }).catch(() => {
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  async function flush(final = false) {
+    cancelTimer();
+    if (stopReason !== null || queue.length === 0) {
+      await inFlight;
+      return;
+    }
+    const batch = queue;
+    queue = [];
+    const chunks = chunkEvents(batch);
+    if (final) {
+      for (const chunk of chunks) sendFinal(chunk);
+      return;
+    }
+    inFlight = inFlight.then(async () => {
+      const retained = [];
+      for (const chunk of chunks) {
+        if (stopReason !== null) return;
+        retained.push(...await send(chunk));
+      }
+      if (retained.length > 0 && stopReason === null) {
+        queue = retained.concat(queue);
+        if (queue.length > MAX_QUEUED_EVENTS) {
+          queue.splice(0, queue.length - MAX_QUEUED_EVENTS);
+        }
+        scheduleFlush();
+      }
+    });
+    await inFlight;
+  }
+  return {
+    enqueue,
+    flush,
+    stopped: () => stopReason,
+    discard() {
+      queue = [];
+      cancelTimer();
+    },
+    dispose() {
+      cancelTimer();
+    }
+  };
+}
+
+// src/telemetry/collector.ts
+var ROUTE_CHANGE_EVENT = "arcy:routechange";
+var SESSION_KEY_PREFIX = "arcy.session.";
+var CONSENT_KEY_PREFIX = "arcy.telemetry.";
+var STOP_KEY_PREFIX = "arcy.telemetry.stop.";
+function isSynthetic(raw) {
+  return raw.isTrusted === false;
+}
+function createTelemetry(options) {
+  const {
+    token,
+    apiBase,
+    describeElement,
+    getUserId,
+    getVisitorId,
+    getFlowSessionId,
+    now = () => Date.now(),
+    fill
+  } = options;
+  const win = options.win !== void 0 ? options.win : typeof window !== "undefined" ? window : null;
+  const doc = options.doc !== void 0 ? options.doc : typeof document !== "undefined" ? document : null;
+  const localStore = options.localStore ?? browserLocalStorage();
+  const consent = createConsentCache(
+    localStore,
+    CONSENT_KEY_PREFIX + token
+  );
+  const session = createSessionStore({
+    store: localStore,
+    key: SESSION_KEY_PREFIX + token,
+    now,
+    fill
+  });
+  const transport = createTransport({
+    token,
+    apiBase,
+    fetchImpl: options.fetchImpl !== void 0 ? options.fetchImpl : typeof fetch !== "undefined" ? fetch.bind(globalThis) : null,
+    sendBeacon: win?.navigator?.sendBeacon && typeof win.navigator.sendBeacon === "function" ? win.navigator.sendBeacon.bind(win.navigator) : null,
+    setTimeoutImpl: options.setTimeoutImpl,
+    clearTimeoutImpl: options.clearTimeoutImpl,
+    sessionStore: options.sessionStore ?? browserSessionStorage(),
+    stopKey: STOP_KEY_PREFIX + token,
+    onTelemetryOff: () => consent.clearState()
+  });
+  const resolvedDeviceClass = deviceClass(win?.navigator);
+  const localeCode = win?.navigator?.language ?? void 0;
+  let started = false;
+  let halted = false;
+  let lastRoute = null;
+  let loadNavigationPending = false;
+  function currentRoute() {
+    return normalizeRoute(win?.location?.href) ?? void 0;
+  }
+  function capture(name, payload, fields2) {
+    if (halted) return false;
+    if (!consent.shouldCapture()) return false;
+    if (transport.stopped() !== null) return false;
+    const at = now();
+    const sessionId = session.touch();
+    const event = buildEvent(
+      ulid(at, fill),
+      name,
+      at,
+      {
+        sessionId,
+        userId: getUserId?.() ?? void 0,
+        visitorId: getVisitorId?.() ?? void 0,
+        route: currentRoute(),
+        localeCode,
+        deviceClass: resolvedDeviceClass,
+        flowSessionId: fields2?.flowSessionId ?? getFlowSessionId?.() ?? void 0
+      },
+      payload
+    );
+    if (fields2?.flowId) event.flowId = fields2.flowId;
+    if (fields2?.flowVersion) event.flowVersion = fields2.flowVersion;
+    if (fields2?.stepCvid) event.stepCvid = fields2.stepCvid;
+    transport.enqueue(event);
+    return true;
+  }
+  const onClick = (event) => {
+    try {
+      const raw = event;
+      if (isSynthetic(raw)) return;
+      const cursorOf = win?.getComputedStyle ? (element2) => {
+        try {
+          return win.getComputedStyle(element2).cursor ?? null;
+        } catch {
+          return null;
+        }
+      } : void 0;
+      const element = findInteractive(raw.target, cursorOf);
+      if (!element) return;
+      capture("interaction_click", describeClick(element, describeElement));
+    } catch {
+    }
+  };
+  const onSubmit = (event) => {
+    try {
+      const raw = event;
+      if (isSynthetic(raw)) return;
+      if (!raw.target || typeof raw.target.getAttribute !== "function") return;
+      capture("form_submit", describeSubmit(raw.target, describeElement));
+    } catch {
+    }
+  };
+  const onNavigate = () => {
+    try {
+      const route = currentRoute() ?? null;
+      if (route === lastRoute) return;
+      const from = lastRoute;
+      lastRoute = route;
+      scroll.reset();
+      capture("navigation", from ? { from } : void 0);
+    } catch {
+    }
+  };
+  const fields = createFieldObserver({
+    emit: (name, element) => {
+      capture(name, describeField(element, describeElement));
+    }
+  });
+  const scroll = createScrollObserver({
+    readDepth: () => scrollDepthPercent({
+      scrollY: win?.scrollY,
+      innerHeight: win?.innerHeight,
+      documentHeight: doc?.documentElement?.scrollHeight
+    }),
+    emit: (percent) => {
+      capture("scroll_depth", { percent });
+    },
+    setTimeoutImpl: options.setTimeoutImpl,
+    clearTimeoutImpl: options.clearTimeoutImpl
+  });
+  let sessionEnded = false;
+  const onFocusIn = (event) => {
+    try {
+      const raw = event;
+      if (isSynthetic(raw) || !raw.target) return;
+      fields.focus(raw.target);
+    } catch {
+    }
+  };
+  const onFieldChange = (event) => {
+    try {
+      const raw = event;
+      if (isSynthetic(raw) || !raw.target) return;
+      fields.change(raw.target);
+    } catch {
+    }
+  };
+  const onFocusOut = (event) => {
+    try {
+      const raw = event;
+      if (!raw.target) return;
+      fields.blur(raw.target);
+    } catch {
+    }
+  };
+  const onScroll = () => {
+    try {
+      scroll.scrolled();
+    } catch {
+    }
+  };
+  const onVisibilityChange = () => {
+    try {
+      if (doc?.visibilityState === "visible") {
+        capture("page_visible");
+        return;
+      }
+      capture("page_hidden");
+      void transport.flush(true);
+    } catch {
+    }
+  };
+  const onPageHide = () => {
+    try {
+      if (!sessionEnded) {
+        sessionEnded = true;
+        capture("session_end");
+      }
+      void transport.flush(true);
+    } catch {
+    }
+  };
+  const onError = (event) => {
+    try {
+      const raw = event;
+      captureError({
+        message: readErrorMessage(raw.message) ?? "Uncaught error",
+        kind: "error",
+        source: scrubSource(raw.filename)
+      });
+    } catch {
+    }
+  };
+  const onRejection = (event) => {
+    try {
+      const raw = event;
+      captureError({
+        // The kind alone when the reason is neither a string nor an `Error`.
+        // Serializing an unknown object from the customer's application is the
+        // one thing this event must never do.
+        message: readErrorMessage(raw.reason) ?? "Unhandled promise rejection",
+        kind: "unhandledrejection"
+      });
+    } catch {
+    }
+  };
+  function captureError(encounter) {
+    const payload = {
+      message: encounter.message,
+      kind: encounter.kind
+    };
+    if (encounter.source) payload.source = encounter.source;
+    capture("js_error", payload);
+  }
+  function scrubSource(raw) {
+    if (typeof raw !== "string") return void 0;
+    return normalizeRoute(raw, win?.location?.href) ?? void 0;
+  }
+  const ownOrigin = (apiBase ?? DEFAULT_API_BASE2).replace(/\/+$/, "");
+  let uninstallNetworkWatch = null;
+  return {
+    start() {
+      if (started || halted) return;
+      started = true;
+      lastRoute = currentRoute() ?? null;
+      doc?.addEventListener("click", onClick, true);
+      doc?.addEventListener("submit", onSubmit, true);
+      doc?.addEventListener("focusin", onFocusIn, true);
+      doc?.addEventListener("focusout", onFocusOut, true);
+      doc?.addEventListener("input", onFieldChange, true);
+      doc?.addEventListener("change", onFieldChange, true);
+      win?.addEventListener(ROUTE_CHANGE_EVENT, onNavigate);
+      win?.addEventListener("popstate", onNavigate);
+      win?.addEventListener("scroll", onScroll, { passive: true });
+      win?.addEventListener("pagehide", onPageHide);
+      doc?.addEventListener("visibilitychange", onVisibilityChange);
+      win?.addEventListener("error", onError);
+      win?.addEventListener("unhandledrejection", onRejection);
+      if (win && uninstallNetworkWatch === null) {
+        uninstallNetworkWatch = installNetworkWatch({
+          target: win,
+          report: (failure) => {
+            const payload = {
+              method: failure.method,
+              status: failure.status
+            };
+            if (failure.url) payload.url = failure.url;
+            capture("request_failed", payload);
+          },
+          ignore: (url) => url.indexOf(ownOrigin) === 0
+        });
+      }
+      loadNavigationPending = !capture("navigation") && consent.state() === null;
+    },
+    stop(options2) {
+      halted = true;
+      if (!started) return;
+      started = false;
+      doc?.removeEventListener("click", onClick, true);
+      doc?.removeEventListener("submit", onSubmit, true);
+      doc?.removeEventListener("focusin", onFocusIn, true);
+      doc?.removeEventListener("focusout", onFocusOut, true);
+      doc?.removeEventListener("input", onFieldChange, true);
+      doc?.removeEventListener("change", onFieldChange, true);
+      win?.removeEventListener(ROUTE_CHANGE_EVENT, onNavigate);
+      win?.removeEventListener("popstate", onNavigate);
+      win?.removeEventListener("scroll", onScroll);
+      win?.removeEventListener("pagehide", onPageHide);
+      doc?.removeEventListener("visibilitychange", onVisibilityChange);
+      win?.removeEventListener("error", onError);
+      win?.removeEventListener("unhandledrejection", onRejection);
+      if (uninstallNetworkWatch) {
+        uninstallNetworkWatch();
+        uninstallNetworkWatch = null;
+      }
+      scroll.dispose();
+      if (options2?.discard) transport.discard();
+      else void transport.flush(false);
+      transport.dispose();
+    },
+    setTelemetryState(state) {
+      consent.setState(state);
+      if (loadNavigationPending) {
+        loadNavigationPending = false;
+        capture("navigation");
+      }
+    },
+    setTelemetryConsent(granted) {
+      consent.setConsent(granted);
+      if (!granted) transport.discard();
+    },
+    track(name, payload, fields2) {
+      capture(name, payload, fields2);
+    },
+    flush: () => transport.flush(false),
+    sessionId: () => session.touch(),
+    resetSession: () => session.clear(),
+    stopped: () => transport.stopped(),
+    state: () => consent.state()
+  };
+}
+
+// src/version.ts
+var VERSION = "0.1.1";
+
+// src/api.ts
+var OPTION_KEYS = [
+  "telemetry",
+  "locale",
+  "defaultOpen",
+  "contentLocale",
+  "apiBase"
+];
+function emptyIdentity() {
+  return { userId: null, isAnonymous: false, attributes: {} };
+}
+function readUserHash(value, caller) {
+  if (value === void 0 || value === null)
+    return { ok: true, hash: void 0 };
+  if (typeof value !== "string" || value.length === 0) {
+    warn(`${caller}() was given a userHash that is not a string. Ignoring it.`);
+    return { ok: false };
+  }
+  return { ok: true, hash: value };
+}
+function sanitizeAttributes(attributes, method) {
+  if (attributes === void 0) return {};
+  if (typeof attributes !== "object" || attributes === null || Array.isArray(attributes)) {
+    warn(`${method}() attributes must be an object. Ignoring the call.`);
+    return null;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value === void 0) continue;
+    if (value === null) {
+      out[key] = null;
+      continue;
+    }
+    const type = typeof value;
+    if (type === "string" || type === "number" || type === "boolean") {
+      out[key] = value;
+      continue;
+    }
+    if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+      out[key] = value;
+      continue;
+    }
+    warn(
+      `${method}() dropped "${key}": an attribute must be a string, number, boolean, null, or an array of strings.`
+    );
+  }
+  return out;
+}
+var unavailableChunks = {
+  cdnBase: null,
+  loadChat: () => Promise.resolve(null),
+  loadFlow: () => Promise.resolve(null),
+  loadPicker: () => Promise.resolve(null)
+};
+function createArcy(chunks) {
+  return createArcyInternals({ chunks }).api;
+}
+function createArcyInternals(internalOptions = {}) {
+  const chunks = internalOptions.chunks ?? unavailableChunks;
+  const emitter = createEmitter();
+  function resolveApiBase() {
+    const fromOptions = options.apiBase;
+    if (typeof fromOptions === "string" && fromOptions.length > 0) {
+      return fromOptions.replace(/\/+$/, "");
+    }
+    return internalOptions.apiBase ?? DEFAULT_API_BASE;
+  }
+  let token = null;
+  let options = {};
+  let identity = emptyIdentity();
+  let isOpen = false;
+  let bar = null;
+  let chatController = null;
+  let flowController = null;
+  let flowResumeAttempted = false;
+  let previewIntent = null;
+  let telemetry = null;
+  let bootstrap = null;
+  let sendSessionSequence = 0;
+  let entryRouteValue;
+  let sessionContextValue;
+  let sessionContextResolved = false;
+  let shellState = null;
+  let visitState = null;
+  let conversationStore = null;
+  let visitorId = null;
+  let tokenCache = null;
+  let tokens = NO_TOKENS;
+  let widgetIdentity = null;
+  let barSubmit = null;
+  let barFiles = null;
+  let pendingFiles = null;
+  let pendingMessage = null;
+  let fillPending = false;
+  let openPending = false;
+  function requireInit(method) {
+    if (token === null) {
+      warn(`${method}() was called before init(). Ignoring.`);
+      return false;
+    }
+    return true;
+  }
+  async function init(nextToken, nextOptions) {
+    if (typeof nextToken !== "string" || nextToken.length === 0) {
+      warn("init() needs an environment token. Ignoring the call.");
+      return;
+    }
+    if (token !== null) {
+      warn("init() has already been called. Ignoring the second call.");
+      return;
+    }
+    token = nextToken;
+    options = {};
+    if (nextOptions !== void 0) {
+      if (typeof nextOptions !== "object" || nextOptions === null) {
+        warn("init() options must be an object. Continuing without them.");
+      } else {
+        for (const [key, value] of Object.entries(nextOptions)) {
+          if (!OPTION_KEYS.includes(key)) {
+            warn(
+              `init() ignored unknown option "${key}". Only telemetry, locale, defaultOpen, contentLocale, and apiBase can be set in code; everything else is configured in the dashboard.`
+            );
+            continue;
+          }
+          options[key] = value;
+        }
+      }
+    }
+    if (typeof window !== "undefined") {
+      reportCspViolations(window, {
+        apiBase: resolveApiBase(),
+        cdnBase: chunks.cdnBase
+      });
+    }
+    start(nextToken);
+    startDesignMode(nextToken);
+    startPreviewMode(nextToken);
+    await syncSession();
+    emitter.emit("ready");
+    if (options.defaultOpen) {
+      open();
+    }
+  }
+  function start(activeToken) {
+    try {
+      shellState = createShellState(activeToken);
+      const hadAnonymousId = shellState.read().anonymousId !== null;
+      visitorId = shellState.anonymousId();
+      visitState = createVisitState(activeToken);
+      if (!hadAnonymousId) visitState.markFirstVisit();
+    } catch (error) {
+      shellState = null;
+      visitorId = null;
+      warn(`The ARCY session could not be started. ${String(error)}`);
+    }
+    try {
+      conversationStore = createConversationStore(activeToken);
+    } catch (error) {
+      conversationStore = null;
+      warn(`The ARCY session could not be started. ${String(error)}`);
+    }
+    try {
+      tokenCache = createTokenCache(activeToken);
+      const cached = tokenCache.read();
+      tokens = cached.tokens;
+      widgetIdentity = cached.identity;
+    } catch (error) {
+      tokenCache = null;
+      tokens = NO_TOKENS;
+      warn(`The ARCY session could not be started. ${String(error)}`);
+    }
+    try {
+      telemetry = createTelemetry({
+        token: activeToken,
+        // The same seam the bootstrap gets. Without it the collector's batches
+        // leave through the real `fetch` even under test, so nothing in this
+        // package could ever assert what a captured event actually carries.
+        apiBase: resolveApiBase(),
+        fetchImpl: internalOptions.fetchImpl,
+        // 15.1 plugs in here. This is what makes a click on the customer's
+        // page resolvable to the element the dashboard picked: both sides
+        // produce byte-identical JSON for the same node, and the server hashes
+        // it into one key (ADR 0059).
+        describeElement: (element) => captureEventFingerprint(
+          element
+        ),
+        getUserId: () => identity.isAnonymous ? null : identity.userId,
+        // Slice 1.8. Read per event rather than captured, so the id a
+        // `reset()` cleared stops being attached from that moment on rather
+        // than at the next page load.
+        getVisitorId: () => visitorId
+      });
+      if (options.telemetry !== void 0) {
+        telemetry.setTelemetryConsent(options.telemetry === true);
+      }
+      telemetry.start();
+    } catch (error) {
+      warn(`Telemetry could not start. ${String(error)}`);
+    }
+    try {
+      bootstrap = createSessionBootstrap({
+        token: activeToken,
+        apiBase: resolveApiBase(),
+        fetchImpl: internalOptions.fetchImpl,
+        setTimeoutImpl: internalOptions.setTimeoutImpl
+      });
+    } catch (error) {
+      warn(`The ARCY session could not be started. ${String(error)}`);
+    }
+    mountWidget();
+  }
+  function startDesignMode(activeToken) {
+    if (typeof window === "undefined") return;
+    try {
+      void maybeActivateDesignMode({
+        win: window,
+        token: activeToken,
+        loadChunk: chunks.loadPicker,
+        apiBase: resolveApiBase(),
+        fetchImpl: internalOptions.fetchImpl !== void 0 ? internalOptions.fetchImpl : typeof fetch !== "undefined" ? fetch.bind(globalThis) : null,
+        setTimeoutImpl: internalOptions.setTimeoutImpl,
+        // Discard, not flush (D490, D492): the queue at this moment is the
+        // operator's own page load, which is exactly what must not be sent.
+        onVerified: () => telemetry?.stop({ discard: true })
+      });
+    } catch (error) {
+      warn(`Design mode could not start. ${String(error)}`);
+    }
+  }
+  function startPreviewMode(activeToken) {
+    if (typeof window === "undefined") return;
+    try {
+      const intent = detectPreviewIntent(window, activeToken);
+      if (!intent) return;
+      telemetry?.stop({ discard: true });
+      flowResumeAttempted = true;
+      previewIntent = intent;
+    } catch (error) {
+      warn(`The preview could not start. ${String(error)}`);
+    }
+  }
+  function verifyPreview(nonce) {
+    return verifyPreviewNonce({
+      apiBase: resolveApiBase(),
+      token: token ?? "",
+      nonce,
+      sessionToken: bootstrap?.config()?.sessionToken ?? null,
+      userTraits: identity.attributes,
+      fetchImpl: internalOptions.fetchImpl !== void 0 ? internalOptions.fetchImpl : typeof fetch !== "undefined" ? fetch.bind(globalThis) : null,
+      setTimeoutImpl: internalOptions.setTimeoutImpl
+    });
+  }
+  function hideWidget() {
+    openPending = false;
+    bar?.unmount();
+    bar = null;
+    chatController?.destroy();
+    chatController = null;
+    flowController?.destroy();
+    flowController = null;
+    barSubmit = null;
+    barFiles = null;
+    pendingFiles = null;
+    close();
+  }
+  function mountWidget() {
+    try {
+      if (!bar) mountBar();
+      applyTheme();
+      applyChrome();
+      chatController?.refreshChrome();
+      if (openPending) {
+        openPending = false;
+        open();
+      }
+    } catch (error) {
+      warn(`The chat bar could not render. ${String(error)}`);
+    }
+  }
+  function applyTheme() {
+    try {
+      const host = bar?.getHost();
+      if (!bar || !host) return;
+      applyTokens(host, tokens);
+      bar.setGeometry({
+        // One value, two readers (ADR 0101): the bar's width IS the panel's,
+        // so they can never be configured out of line with each other.
+        widthPercent: tokens.widthPercent ?? DEFAULT_WIDTH_PERCENT,
+        bottomOffset: tokens.bottomOffset ?? DEFAULT_BOTTOM_OFFSET,
+        // The resting width is the bar's alone (ADR 0149): collapsed, there
+        // is no panel above it to share an edge with.
+        collapsedWidth: tokens.collapsedWidth ?? DEFAULT_COLLAPSED_WIDTH
+      });
+      bar.setIconSize(tokens.barIconSize ?? DEFAULT_BAR_ICON_SIZE);
+    } catch (error) {
+      warn(`The widget could not apply its theme. ${String(error)}`);
+    }
+  }
+  function readWidgetChrome() {
+    const raw = bootstrap?.config()?.widget;
+    const identity2 = readIdentity(raw) ?? widgetIdentity;
+    if (!identity2) return null;
+    const text = (value) => typeof value === "string" ? value : "";
+    const chrome = raw?.chrome && typeof raw.chrome === "object" && !Array.isArray(raw.chrome) ? { ...FALLBACK_CHROME, ...raw.chrome } : FALLBACK_CHROME;
+    const welcomeIconUrl = raw?.welcomeIconUrl;
+    const chatBarIconUrl = raw?.chatBarIconUrl;
+    return {
+      name: identity2.name,
+      logoUrl: identity2.logoUrl,
+      // Re-checked here rather than trusted, same as privacyPolicyUrl below:
+      // a rewritten bootstrap must not be able to point this at a
+      // non-`https` URL (ADR 0050).
+      welcomeIconUrl: typeof welcomeIconUrl === "string" && /^https:\/\//i.test(welcomeIconUrl) ? welcomeIconUrl : null,
+      // Same re-check, same reason: this renders into an `<img src>` on a
+      // page ARCY does not control (ADR 0050).
+      chatBarIconUrl: typeof chatBarIconUrl === "string" && /^https:\/\//i.test(chatBarIconUrl) ? chatBarIconUrl : null,
+      welcomeMessage: text(raw?.welcomeMessage),
+      inputPlaceholder: text(raw?.inputPlaceholder),
+      welcomeHeadline: text(raw?.welcomeHeadline),
+      // Re-checked here rather than trusted: a rewritten bootstrap must not
+      // be able to turn a camera prompt on for an operator who never did
+      // (ADR 0050, ADR 0102).
+      allowImageUpload: raw?.allowImageUpload === true,
+      // Re-checked rather than trusted, for the reason above it: a rewritten
+      // bootstrap must not be able to make the bar movable on an install
+      // whose operator never allowed it (ADR 0050, ADR 0111).
+      barDraggable: raw?.barDraggable === true,
+      privacyPolicyUrl: typeof raw?.privacyPolicyUrl === "string" && /^https:\/\//i.test(raw.privacyPolicyUrl) ? raw.privacyPolicyUrl : null,
+      chrome,
+      // D1058: which locales the operator enabled, and which one this
+      // session landed on. Shape-checked rather than trusted, the same
+      // posture as everything else read out of the bootstrap (ADR 0050): a
+      // row missing either half would render an unpressable picker row.
+      locales: readLocales(raw?.locales),
+      activeLocale: typeof raw?.activeLocale === "string" ? raw.activeLocale : ""
+    };
+  }
+  function readLocales(value) {
+    if (!Array.isArray(value)) return [];
+    const out = [];
+    for (const entry of value) {
+      if (!entry || typeof entry !== "object") continue;
+      const { code, label } = entry;
+      if (typeof code !== "string" || code.length === 0) continue;
+      if (typeof label !== "string" || label.length === 0) continue;
+      out.push({ code, label });
+    }
+    return out;
+  }
+  function mountBar() {
+    try {
+      bar = createBar({
+        geometry: {
+          widthPercent: tokens.widthPercent ?? DEFAULT_WIDTH_PERCENT,
+          bottomOffset: tokens.bottomOffset ?? DEFAULT_BOTTOM_OFFSET,
+          collapsedWidth: tokens.collapsedWidth ?? DEFAULT_COLLAPSED_WIDTH
+        },
+        // The strings ARCY owns, from the last bootstrap or the shipped
+        // English. Re-applied by `applyChrome()` once the bootstrap answers.
+        labels: barLabels(),
+        // Whatever the last bootstrap said, re-applied by `applyChrome()`
+        // once the fresh one answers, same as the labels above.
+        iconUrl: readWidgetChrome()?.chatBarIconUrl ?? null,
+        // The docked launcher wears the WELCOME mark, at the size the
+        // welcome screen draws it, so the two are one shape. Re-applied by
+        // `applyChrome()` on every bootstrap like the icon above it.
+        welcomeIconUrl: readWidgetChrome()?.welcomeIconUrl ?? null,
+        // Whatever the theme currently in force says, re-applied by
+        // `applyTheme()` on every theme change, same as bottomOffset below.
+        iconSize: tokens.barIconSize ?? DEFAULT_BAR_ICON_SIZE,
+        // A tap, or a focus, on a collapsed bar. Both mean "open": the bar
+        // is an input, and an input a visitor is typing into with no surface
+        // above it is the launcher's old problem in a new shape.
+        onActivate: () => open(),
+        // The submit handler proper belongs to the panel, which owns the
+        // transcript the message lands in. Until the chunk registers one, a
+        // submit opens the panel and the text is re-sent by the panel's own
+        // handler on the next tick.
+        onSubmit: (text) => {
+          if (!fillPending) open();
+          if (barSubmit) {
+            barSubmit(text);
+            return;
+          }
+          pendingMessage = text;
+        },
+        // The bar has already opened the file dialog by the time this runs,
+        // inside the visitor's own click. All that is left is to bring the
+        // panel up behind it, so the chips and any rejection have somewhere
+        // to land.
+        onAttach: () => {
+          open();
+        },
+        onFiles: (files) => {
+          open();
+          if (barFiles) {
+            barFiles(files);
+            return;
+          }
+          pendingFiles = files;
+        },
+        // A pointer on the customer's own page collapses the widget back to
+        // its resting pill (D890). `close()` is idempotent and emits the
+        // public `close` event exactly as the collapse control does, so a
+        // page listening for it cannot tell the two apart, which is right:
+        // the visitor closed the chat either way.
+        onDismiss: () => {
+          close();
+        },
+        onStop: () => {
+          flowController?.stop();
+          flushFlowStatus();
+        },
+        // A resize, a rotation, or an opening keyboard all move the bar, and
+        // the panel sits on the bar.
+        onGeometryChange: () => chatController?.reposition(),
+        // ADR 0111. The position belongs to this browser, so it is read from
+        // and written to the shell key rather than sent anywhere: where a
+        // visitor wants the bar is a property of the window they are in.
+        readPosition: () => shellState?.read().position ?? null,
+        onPositionChange: (position) => shellState?.rememberPosition(position),
+        // The dock, same posture as the position above it: a visitor who
+        // shrank ARCY to a corner button said so about this browser, so it
+        // is remembered here and sent nowhere.
+        readDocked: () => shellState?.read().docked === true,
+        onDockedChange: (value) => shellState?.rememberDocked(value),
+        // One press gets the visitor all the way back: `open()` undocks and
+        // opens the panel, rather than leaving them with a bar they then
+        // have to press again.
+        onUndock: () => open()
+      });
+      bar.mount();
+      mountChatController();
+    } catch (error) {
+      warn(`The chat bar could not render. ${String(error)}`);
+    }
+  }
+  function applyChrome() {
+    try {
+      if (!bar) return;
+      const chrome = readWidgetChrome();
+      bar.setLabels(barLabels());
+      if (bar.getMode() !== "flow") {
+        bar.setPlaceholder(chrome?.inputPlaceholder ?? null);
+      }
+      bar.setAttachEnabled(chrome?.allowImageUpload === true);
+      bar.setDraggable(chrome?.barDraggable === true);
+      bar.setIcon(chrome?.chatBarIconUrl ?? null);
+      bar.setWelcomeIcon(chrome?.welcomeIconUrl ?? null);
+    } catch (error) {
+      warn(`The widget could not apply its texts. ${String(error)}`);
+    }
+  }
+  function barLabels() {
+    const chrome = readWidgetChrome()?.chrome ?? FALLBACK_CHROME;
+    return {
+      send: chrome.send,
+      attachMenu: chrome.attachMenu,
+      attachImage: chrome.attachImage,
+      flowStop: chrome.flowStop,
+      openChat: chrome.openChat,
+      moveBar: chrome.moveBar,
+      flowStep: chrome.flowStep
+    };
+  }
+  const FLOW_STEP_HOLD_MS = 600;
+  const FLOW_DONE_HOLD_MS = 4e3;
+  let flowStatusTimer = null;
+  let flowStatusQueue = [];
+  let shownFlowStatus = null;
+  function startFlowStatusHold(status) {
+    const hold = status.phase === "done" ? FLOW_DONE_HOLD_MS : FLOW_STEP_HOLD_MS;
+    try {
+      flowStatusTimer = setTimeout(() => {
+        flowStatusTimer = null;
+        while (flowStatusQueue.length > 0) {
+          const next = flowStatusQueue.shift();
+          applyFlowStatus(next);
+          if (next !== null) {
+            startFlowStatusHold(next);
+            return;
+          }
+        }
+      }, hold);
+    } catch {
+    }
+  }
+  function setFlowStatus(status) {
+    if (status === null) {
+      const endedWell = shownFlowStatus?.phase === "done" || flowStatusQueue.some((queued) => queued?.phase === "done");
+      if (flowStatusTimer !== null && endedWell) {
+        if (flowStatusQueue[flowStatusQueue.length - 1] !== null) {
+          flowStatusQueue.push(null);
+        }
+        return;
+      }
+      flushFlowStatus();
+      return;
+    }
+    if (flowStatusTimer !== null) {
+      const last = flowStatusQueue[flowStatusQueue.length - 1];
+      if (status.phase !== "done" && last !== void 0 && last !== null && last.phase !== "done") {
+        flowStatusQueue[flowStatusQueue.length - 1] = status;
+        return;
+      }
+      flowStatusQueue.push(status);
+      return;
+    }
+    applyFlowStatus(status);
+    startFlowStatusHold(status);
+  }
+  function flushFlowStatus() {
+    if (flowStatusTimer !== null) {
+      try {
+        clearTimeout(flowStatusTimer);
+      } catch {
+      }
+      flowStatusTimer = null;
+    }
+    flowStatusQueue = [];
+    applyFlowStatus(null);
+  }
+  function applyFlowStatus(status) {
+    shownFlowStatus = status;
+    try {
+      if (status) bar?.setDocked(false);
+      bar?.setFlow(status);
+      if (status) {
+        close();
+        return;
+      }
+      bar?.setPlaceholder(readWidgetChrome()?.inputPlaceholder ?? null);
+    } catch (error) {
+      warn(`The flow status could not be shown. ${String(error)}`);
+    }
+  }
+  function mountChatController() {
+    try {
+      const root = bar?.getRoot();
+      const host = bar?.getHost();
+      const mountedBar = bar;
+      if (!root || !host || !mountedBar) return;
+      chatController = createChatController({
+        root,
+        host,
+        loadChunk: chunks.loadChat,
+        // The panel's collapse control reaches the public close() through
+        // here, so isOpen() has exactly one writer. There is no close, only
+        // collapse: the bar never leaves.
+        onRequestClose: () => close(),
+        // The bar is the widget's only composer, and it lives in the core
+        // while the transcript lives in the chunk. This is the whole of the
+        // bridge between them (26.3).
+        bar: {
+          onSubmit: (handler) => {
+            barSubmit = handler;
+            if (pendingMessage !== null) {
+              const text = pendingMessage;
+              pendingMessage = null;
+              handler(text);
+            }
+          },
+          onFiles: (handler) => {
+            barFiles = handler;
+            if (pendingFiles !== null) {
+              const files = pendingFiles;
+              pendingFiles = null;
+              handler(files);
+            }
+          },
+          setPlaceholder: (text) => mountedBar.setPlaceholder(text),
+          setDisabled: (disabled) => mountedBar.setDisabled(disabled),
+          setMode: (mode) => mountedBar.setMode(mode),
+          setFlow: (status) => mountedBar.setFlow(status),
+          setAwaitingInput: (awaiting) => mountedBar.setAwaitingInput(awaiting),
+          setDisclaimer: (text) => mountedBar.setDisclaimer(text),
+          setAttachEnabled: (enabled) => mountedBar.setAttachEnabled(enabled),
+          setAttachmentCount: (count) => mountedBar.setAttachmentCount(count),
+          // Where the panel's image tiles render: inside the composer, above
+          // its input. The tiles stay the panel's (it owns the upload they
+          // stand for); only the place is the bar's.
+          attachmentSlot: () => mountedBar.attachmentSlot(),
+          focusInput: () => mountedBar.focusInput(),
+          getMetrics: () => mountedBar.getMetrics(),
+          // The panel's Settings sheet asked for the widget to become a
+          // corner button. The panel has already collapsed itself by the
+          // time this runs, so this is only the bar's half.
+          dock: () => mountedBar.setDocked(true)
+        },
+        // The flows catalog fetch inputs; read live rather than captured,
+        // same reasoning as everything else in this options object, since
+        // the panel can mount before the bootstrap resolves.
+        apiBase: resolveApiBase(),
+        getSessionToken: () => bootstrap?.config()?.sessionToken ?? null,
+        getSessionId: () => telemetry?.sessionId(),
+        getRoute: () => typeof window !== "undefined" ? window.location.pathname : "",
+        getMaxHeightPercent: () => tokens.maxHeightPercent ?? void 0,
+        onStartFlow: (flowCvid) => {
+          ensureFlowController();
+          void flowController?.start(flowCvid);
+        },
+        onStopFlow: () => {
+          flowController?.stop();
+          flushFlowStatus();
+        },
+        // D774: the widget's basic chat query loop.
+        publicKey: token ?? void 0,
+        getConversationId: () => conversationStore?.id() ?? null,
+        setConversationId: (conversationId) => conversationId === null ? conversationStore?.startNew() ?? null : conversationStore?.adopt(conversationId) ?? null,
+        touchConversation: () => conversationStore?.touch(),
+        // D858: Recent chats are scoped to this, never to an identify()
+        // userId. Identity verification is optional per environment, so an
+        // unverified identify() from a console would otherwise hand an
+        // attacker another person's transcripts.
+        getVisitorId: () => visitorId,
+        // #714/closes 13.5: the one teardown path (`hideWidget`).
+        onOrgCapExceeded: () => hideWidget(),
+        // Same bridge buildFlowContext() already wires for the flow engine.
+        track: (name, fields, payload) => {
+          telemetry?.track(name, payload, fields);
+        },
+        getWidget: () => readWidgetChrome(),
+        onSelectLocale: (localeCode) => void selectLocale(localeCode)
+      });
+    } catch (error) {
+      warn(`The chat panel could not be prepared. ${String(error)}`);
+    }
+  }
+  async function selectLocale(localeCode) {
+    try {
+      if (typeof localeCode !== "string" || localeCode.length === 0) return;
+      if (shellState?.read().locale === localeCode) return;
+      shellState?.rememberLocale(localeCode);
+      await syncSession();
+      applyChrome();
+      chatController?.refreshChrome();
+    } catch (error) {
+      warn(`The widget could not change its language. ${String(error)}`);
+    }
+  }
+  function buildFlowContext() {
+    if (!token) return null;
+    const sessionToken = bootstrap?.config()?.sessionToken;
+    if (!sessionToken) return null;
+    const visits = visitState;
+    return {
+      apiBase: resolveApiBase(),
+      token,
+      sessionToken,
+      sessionId: telemetry?.sessionId(),
+      // Slice 18.1's trigger conditions read traits set via identify();
+      // `Attributes` also allows null and string[], neither of which
+      // `ConditionContext.getTrait` accepts, so both degrade to
+      // "unresolvable" rather than being coerced into something wrong.
+      getTrait: (codeName) => {
+        const value = identity.attributes[codeName];
+        if (value === void 0 || value === null || Array.isArray(value)) {
+          return void 0;
+        }
+        return value;
+      },
+      // D1299: absent entirely (rather than answering false) when storage
+      // failed at start(), so a `visitor` condition reads as unresolvable
+      // instead of every visitor counting as returning.
+      ...visits ? { isFirstVisit: () => visits.isFirstVisit() } : {},
+      // The fill-step bridge (ADR 0168/0169): the chat chunk renders the
+      // question in the compact card beside the bar; the panel is never
+      // opened for it. Absent a mounted chunk (a failed mount, or an org
+      // cap denial), a fill step waits rather than acting on a value nobody
+      // asked for. A visitor who docked the widget gets it back: the card
+      // and the composer both live on the bar.
+      promptFill: (request) => {
+        bar?.setDocked(false);
+        fillPending = true;
+        const prompt = chatController?.promptFill(request) ?? Promise.resolve(null);
+        return prompt.finally(() => {
+          fillPending = false;
+        });
+      },
+      // ADR 0166/D1294: the run ended, so a question still waiting is
+      // withdrawn wherever it is showing.
+      cancelFill: () => {
+        fillPending = false;
+        chatController?.cancelFill();
+      },
+      // D1085's clean failure stop: the run already ended and the bar is
+      // back to normal by the time this fires; the panel shows the
+      // localized apology and the composer is ready for a question.
+      // Routed through open() first for the same `isOpen` bookkeeping
+      // reason `promptFill` documents above.
+      onFailure: () => {
+        if (!isOpen) open();
+        void chatController?.showFlowFailure();
+      },
+      // 18.5's telemetry bridge: forwards straight into the one `track()`
+      // pipeline this bundle already owns (`telemetry/collector.ts`), so a
+      // flow's lifecycle events go through the exact same consent gate and
+      // batching every other event family does. Absent telemetry (it failed
+      // to initialize, or this session opted out), the flow runs and simply
+      // emits nothing, same posture as `promptFill` above.
+      track: (name, fields, payload) => {
+        telemetry?.track(name, payload, fields);
+      },
+      // 26.4: the bar is the running flow's status surface, and the panel
+      // gets out of the way so the user can watch their own product being
+      // driven.
+      onStatus: (status) => setFlowStatus(status),
+      // The bar covers the bottom of the screen, so a target under it is
+      // scrolled into view before it is clicked or filled. Without this a
+      // flow "successfully" clicks a button nobody can see.
+      getBottomOcclusion: () => {
+        const metrics = bar?.getMetrics();
+        if (!metrics) return 0;
+        return metrics.bottomOffset + metrics.keyboardOffset + metrics.height;
+      }
+    };
+  }
+  function ensureFlowController() {
+    if (flowController) return;
+    try {
+      const context = buildFlowContext();
+      if (!context) return;
+      flowController = createFlowController({ context, loadChunk: chunks.loadFlow });
+    } catch (error) {
+      warn(`The flow engine could not be prepared. ${String(error)}`);
+    }
+  }
+  async function syncSession() {
+    try {
+      await sendSession();
+    } catch (error) {
+      warn(`The ARCY session could not be started. ${String(error)}`);
+    }
+    try {
+      const config = bootstrap?.config();
+      if (config) {
+        const next = (config.customization ?? {}).tokens;
+        tokenCache?.remember(next, config.widget);
+        tokens = readTokens(next);
+        widgetIdentity = readIdentity(config.widget) ?? widgetIdentity;
+      }
+    } catch (error) {
+      warn(`The widget could not read its theme. ${String(error)}`);
+    }
+    if (!flowResumeAttempted) {
+      ensureFlowController();
+      if (flowController) {
+        flowResumeAttempted = true;
+        void flowController.resume();
+      }
+    }
+    if (previewIntent) {
+      const intent = previewIntent;
+      previewIntent = null;
+      void (async () => {
+        ensureFlowController();
+        if (!flowController) return;
+        if (intent.kind === "pending") {
+          await flowController.resumePreview();
+          return;
+        }
+        const flow = await verifyPreview(intent.nonce);
+        if (!flow) return;
+        await flowController.startPreview(flow);
+      })().catch((error) => warn(`The preview could not run. ${String(error)}`));
+    }
+    mountWidget();
+  }
+  function entryRoute() {
+    if (entryRouteValue !== void 0) return entryRouteValue;
+    try {
+      const path = typeof window !== "undefined" ? window.location.pathname : null;
+      if (typeof path !== "string" || !path.startsWith("/")) return void 0;
+      entryRouteValue = scrubPath(path);
+      return entryRouteValue;
+    } catch {
+      return void 0;
+    }
+  }
+  function sessionContext() {
+    if (sessionContextResolved) return sessionContextValue;
+    sessionContextResolved = true;
+    try {
+      if (typeof window === "undefined") return void 0;
+      sessionContextValue = captureSessionContext({
+        referrer: typeof document !== "undefined" ? document.referrer : null,
+        search: window.location?.search ?? null,
+        userAgent: typeof navigator !== "undefined" ? navigator.userAgent : null,
+        viewportWidth: window.innerWidth
+      });
+      return sessionContextValue;
+    } catch {
+      return void 0;
+    }
+  }
+  async function sendSession() {
+    if (!bootstrap || !telemetry) return;
+    const mySequence = ++sendSessionSequence;
+    const result = await bootstrap.sync({
+      sessionId: telemetry.sessionId(),
+      // The **entry** route, frozen at the first send of this page load, not
+      // the route the user is standing on now (D338). The Users and
+      // Organizations session tables read it to answer "where did this
+      // session start", and freezing it is what keeps an SPA calling
+      // identify() per route change from making every navigation a new
+      // payload, which is the re-send storm D338's skip exists to prevent.
+      route: entryRoute(),
+      // Frozen with the entry route and for the same reason. Segmentation
+      // dimensions, not behavior: they land on the session row rather than on
+      // four hundred events that would each repeat them (#790).
+      sessionContext: sessionContext(),
+      // Sent whether or not this browser has identified (D517). It is the
+      // Lift Subject for anyone who never will, and the anonymous half of the
+      // pairing ADR 0055 discovers for everyone who does.
+      visitorId: visitorId ?? void 0,
+      userId: identity.isAnonymous ? void 0 : identity.userId ?? void 0,
+      // Sent with every payload that asserts the id, not only the call that
+      // supplied it (D158). Bootstrap is the only browser-reachable assertion
+      // of a user id until 6.5 lands the session-token identify route (D168),
+      // so this is the whole of the widget's half of PRD 6.
+      userHash: identity.isAnonymous ? void 0 : identity.userHash,
+      userTraits: Object.keys(identity.attributes).length ? identity.attributes : void 0,
+      // Only the two locales the DTO's enum accepts. Passing a third would
+      // fail validation and take the whole bootstrap down, so an unsupported
+      // locale falls back to the environment default rather than 400ing.
+      uiLanguage: options.locale === "en" || options.locale === "tr" ? options.locale : void 0,
+      // `options.contentLocale`'s bootstrap-time seed for `SdkSession.localeCode`
+      // (D733). Sent as-is, unlike `uiLanguage` above: the DTO's own
+      // `normalizeLocaleCode` (not an enum, unlike `uiLanguage`'s two-entry
+      // one) is the single point that validates it and falls through the
+      // rest of the chain on a miss, so a typo here degrades gracefully
+      // server-side rather than needing a second whitelist here that could
+      // drift from the backend's catalogue.
+      contentLocale: typeof options.contentLocale === "string" ? options.contentLocale : void 0,
+      // D1058/ADR 0130: the language the visitor picked for themselves in
+      // the panel's Settings sheet, which outranks every tier above. Read
+      // from storage on every send rather than held in a variable: the pick
+      // is written before the re-bootstrap it triggers, and reading it here
+      // is what makes the choice govern the NEXT page load too, from the
+      // first payload, with no round trip to learn it.
+      viewerLocale: shellState?.read().locale ?? void 0
+    });
+    if (!result.ok) {
+      warn(
+        "The ARCY session could not be started. The widget will keep working, and telemetry stays off until configuration arrives."
+      );
+      return;
+    }
+    if (mySequence !== sendSessionSequence) return;
+    if (result.config.identityAccepted === false) {
+      warn(
+        "This environment enforces identity verification and no valid userHash was supplied, so this user was not identified and none of their attributes were stored. Pass a signed userHash: arcy.identify(userId, attributes, { userHash }). See Settings > Identity verification in the ARCY dashboard."
+      );
+    }
+    if (result.config.behavioralTelemetry) {
+      telemetry.setTelemetryState(result.config.behavioralTelemetry);
+    }
+  }
+  async function identify(userId, attributes, options2) {
+    if (!requireInit("identify")) return;
+    if (typeof userId !== "string" || userId.length === 0) {
+      warn("identify() needs a user id. Ignoring the call.");
+      return;
+    }
+    const clean2 = sanitizeAttributes(attributes, "identify");
+    if (clean2 === null) return;
+    const hash = readUserHash((options2 ?? {}).userHash, "identify");
+    if (!hash.ok) return;
+    const sameUser = identity.userId === userId && !identity.isAnonymous;
+    identity = {
+      userId,
+      isAnonymous: false,
+      attributes: sameUser ? { ...identity.attributes, ...clean2 } : clean2,
+      // **The proof carries over for the same id and never across ids.** An
+      // SPA re-identifying the same user on every route change passes the hash
+      // once at login and nothing afterwards, and dropping it there would
+      // unprove an identity that was proven. Carrying it to a *different* id
+      // is the identity takeover D170 caught in 6.2 from the other side: a
+      // proof is a proof of one id, so a new user starts from whatever this
+      // call actually carried, which is usually nothing.
+      userHash: sameUser ? hash.hash ?? identity.userHash : hash.hash
+    };
+    await syncSession();
+  }
+  async function identifyAnonymous(attributes) {
+    if (!requireInit("identifyAnonymous")) return;
+    const clean2 = sanitizeAttributes(attributes, "identifyAnonymous");
+    if (clean2 === null) return;
+    identity = { userId: null, isAnonymous: true, attributes: clean2 };
+    await syncSession();
+  }
+  async function updateUser(attributes) {
+    if (!requireInit("updateUser")) return;
+    if (!identity.userId && !identity.isAnonymous) {
+      warn(
+        "updateUser() was called before identify() or identifyAnonymous(). Ignoring the call."
+      );
+      return;
+    }
+    const clean2 = sanitizeAttributes(attributes, "updateUser");
+    if (clean2 === null) return;
+    identity = { ...identity, attributes: { ...identity.attributes, ...clean2 } };
+    await syncSession();
+  }
+  function reset() {
+    identity = emptyIdentity();
+    shellState?.forgetAnonymousId();
+    visitorId = shellState?.anonymousId() ?? null;
+    telemetry?.resetSession();
+    conversationStore?.reset();
+    close();
+  }
+  function open() {
+    if (!requireInit("open")) return;
+    if (!bar) {
+      openPending = true;
+      return;
+    }
+    if (isOpen) return;
+    bar?.setDocked(false);
+    isOpen = true;
+    bar?.setMode("open");
+    void chatController?.open();
+    emitter.emit("open");
+  }
+  function close() {
+    if (!isOpen) return;
+    isOpen = false;
+    bar?.setMode("idle");
+    chatController?.close();
+    emitter.emit("close");
+  }
+  function on(event, handler) {
+    return emitter.on(event, handler);
+  }
+  return {
+    api: {
+      init,
+      identify,
+      identifyAnonymous,
+      updateUser,
+      reset,
+      open,
+      close,
+      on,
+      VERSION
+    },
+    getToken: () => token,
+    getOptions: () => options,
+    getIdentity: () => identity,
+    isOpen: () => isOpen,
+    getBar: () => bar,
+    getChatController: () => chatController,
+    getFlowController: () => flowController,
+    getTelemetry: () => telemetry,
+    getConfig: () => bootstrap?.config() ?? null,
+    selectLocale,
+    getShellState: () => shellState,
+    getTokens: () => tokens
+  };
+}
+
+// src/chunks/bundled.ts
+async function importChunk(win, importer, globalKey, contract, surface, timeoutMs, setTimeoutImpl) {
+  const holder = win;
+  let warned = false;
+  const complain = (message) => {
+    if (warned) return;
+    warned = true;
+    warn(message);
+  };
+  const read = () => {
+    let registration2;
+    try {
+      registration2 = holder[globalKey];
+    } catch {
+      complain(`The ${surface} registration could not be read. It will not start.`);
+      return null;
+    }
+    if (!registration2) return null;
+    if (typeof registration2.mount !== "function") {
+      complain(`The ${surface} registered something unusable. It will not start.`);
+      return null;
+    }
+    let declared;
+    try {
+      declared = registration2.contract;
+    } catch {
+      declared = void 0;
+    }
+    if (declared !== contract) {
+      complain(
+        `The bundled ${surface} speaks contract ${typeof declared === "number" ? declared : "unknown"}, this arcy.js speaks ${contract}. Reinstall arcy.js so both halves come from one version.`
+      );
+      return null;
+    }
+    return registration2;
+  };
+  let present = false;
+  try {
+    present = holder[globalKey] !== void 0;
+  } catch {
+    present = true;
+  }
+  if (present) return read();
+  const arrived = await Promise.race([
+    importer().then(
+      () => "loaded",
+      (error) => {
+        warn(
+          `The ${surface} chunk could not be loaded from your own build. ${String(error)}`
+        );
+        return "failed";
+      }
+    ),
+    new Promise((resolve) => {
+      try {
+        setTimeoutImpl(() => resolve("timeout"), timeoutMs);
+      } catch {
+      }
+    })
+  ]);
+  if (arrived === "failed") return null;
+  if (arrived === "timeout") {
+    warn(`The ${surface} did not load in time.`);
+    return null;
+  }
+  const registration = read();
+  if (!registration && !warned) {
+    complain(`The ${surface} loaded but did not register. It will not start.`);
+  }
+  return registration;
+}
+var bundledChunks = {
+  cdnBase: null,
+  loadChat: (win, timeoutMs, setTimeoutImpl) => importChunk(
+    win,
+    () => import('./chat-BK57WIAA.js'),
+    CHAT_GLOBAL,
+    CHAT_CONTRACT,
+    "chat panel",
+    timeoutMs,
+    setTimeoutImpl
+  ),
+  loadFlow: (win, timeoutMs, setTimeoutImpl) => importChunk(
+    win,
+    () => import('./flow-M7W3H3C5.js'),
+    FLOW_GLOBAL,
+    FLOW_CONTRACT,
+    "flow engine",
+    timeoutMs,
+    setTimeoutImpl
+  ),
+  loadPicker: (win, timeoutMs, setTimeoutImpl) => importChunk(
+    win,
+    () => import('./picker-JPESE6JJ.js'),
+    PICKER_GLOBAL,
+    PICKER_CONTRACT,
+    "design-mode picker",
+    timeoutMs,
+    setTimeoutImpl
+  )
+};
+
+// src/index.ts
+var arcy = createArcy(bundledChunks);
+var src_default = arcy;
+
+export { VERSION, src_default as default };