@getnexorai/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1423 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/errors.ts
+var NexorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NexorError";
+  }
+};
+var NexorAPIError = class extends NexorError {
+  constructor(opts) {
+    super(opts.message);
+    this.name = "NexorAPIError";
+    this.status = opts.status;
+    this.code = opts.code ?? statusToCode(opts.status);
+    this.body = opts.body;
+    this.requestId = opts.requestId;
+  }
+};
+var NexorAuthError = class extends NexorAPIError {
+  constructor(opts) {
+    super({ status: 401, code: "unauthorized", ...opts });
+    this.name = "NexorAuthError";
+  }
+};
+var NexorValidationError = class extends NexorAPIError {
+  constructor(opts) {
+    super({ status: 400, code: "validation_error", ...opts });
+    this.name = "NexorValidationError";
+  }
+};
+var NexorNetworkError = class extends NexorError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NexorNetworkError";
+    this.cause = cause;
+  }
+};
+function statusToCode(status) {
+  if (status === 400) return "validation_error";
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "not_found";
+  if (status === 409) return "conflict";
+  if (status === 422) return "unprocessable_entity";
+  if (status === 429) return "rate_limited";
+  if (status >= 500) return "server_error";
+  return "http_error";
+}
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.getnexor.ai";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var SDK_VERSION = "0.1.0";
+function resolveConfig(opts) {
+  if (!opts || typeof opts.apiKey !== "string" || opts.apiKey.trim() === "") {
+    throw new Error(
+      "Nexor SDK: `apiKey` is required. Get one in the dashboard at https://app.getnexor.ai"
+    );
+  }
+  const fetchImpl = opts.fetch ?? (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  if (!fetchImpl) {
+    throw new Error(
+      "Nexor SDK: no global fetch found. Pass a `fetch` implementation via init() or upgrade to Node 18+."
+    );
+  }
+  const ua = `nexor-sdk-js/${SDK_VERSION}${opts.userAgentSuffix ? ` ${opts.userAgentSuffix}` : ""}`;
+  return {
+    apiKey: opts.apiKey.trim(),
+    baseUrl: stripTrailingSlash(opts.baseUrl ?? DEFAULT_BASE_URL),
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: opts.maxRetries ?? DEFAULT_MAX_RETRIES,
+    fetchImpl,
+    userAgent: ua
+  };
+}
+async function request(cfg, req) {
+  const url = buildUrl(cfg.baseUrl, req.path, req.query);
+  const headers = {
+    "X-API-Key": cfg.apiKey,
+    Accept: "application/json",
+    "User-Agent": cfg.userAgent
+  };
+  if (req.options?.idempotencyKey) {
+    headers["Idempotency-Key"] = req.options.idempotencyKey;
+  }
+  let body;
+  if (req.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(req.body);
+  }
+  const timeoutMs = req.options?.timeoutMs ?? cfg.timeoutMs;
+  let lastErr;
+  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+    const controller = new AbortController();
+    const externalSignal = req.options?.signal;
+    const onAbort = () => controller.abort();
+    if (externalSignal) {
+      if (externalSignal.aborted) controller.abort();
+      else externalSignal.addEventListener("abort", onAbort);
+    }
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await cfg.fetchImpl(url, {
+        method: req.method,
+        headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      externalSignal?.removeEventListener("abort", onAbort);
+      const requestId = res.headers.get("x-request-id") ?? void 0;
+      if (res.ok) {
+        if (res.status === 204) return void 0;
+        const text = await res.text();
+        if (!text) return void 0;
+        try {
+          return JSON.parse(text);
+        } catch {
+          throw new NexorAPIError({
+            status: res.status,
+            message: "Failed to parse JSON response",
+            body: text,
+            requestId
+          });
+        }
+      }
+      const errBody = await safeJson(res);
+      const message = pickMessage(errBody) ?? `HTTP ${res.status}`;
+      const err = makeError(res.status, message, errBody, requestId);
+      if (shouldRetry(res.status) && attempt < cfg.maxRetries) {
+        await sleep(backoffMs(attempt, res));
+        lastErr = err;
+        continue;
+      }
+      throw err;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      externalSignal?.removeEventListener("abort", onAbort);
+      if (err instanceof NexorAPIError) throw err;
+      const isAbort = err instanceof Error && (err.name === "AbortError" || /abort/i.test(err.message));
+      if (isAbort && externalSignal?.aborted) throw err;
+      lastErr = err;
+      if (attempt < cfg.maxRetries) {
+        await sleep(backoffMs(attempt));
+        continue;
+      }
+      throw new NexorNetworkError(
+        isAbort ? `Request timed out after ${timeoutMs}ms` : `Network error: ${err?.message ?? String(err)}`,
+        err
+      );
+    }
+  }
+  throw lastErr ?? new NexorNetworkError("Request failed");
+}
+function makeError(status, message, body, requestId) {
+  if (status === 401 || status === 403) {
+    return new NexorAuthError({ message, body, requestId });
+  }
+  if (status === 400 || status === 422) {
+    return new NexorValidationError({ message, body, requestId });
+  }
+  return new NexorAPIError({ status, message, body, requestId });
+}
+function pickMessage(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (typeof b.message === "string") return b.message;
+  if (typeof b.error === "string") return b.error;
+  return void 0;
+}
+async function safeJson(res) {
+  try {
+    const txt = await res.text();
+    if (!txt) return null;
+    try {
+      return JSON.parse(txt);
+    } catch {
+      return txt;
+    }
+  } catch {
+    return null;
+  }
+}
+function shouldRetry(status) {
+  return status === 429 || status >= 500 && status <= 599;
+}
+function backoffMs(attempt, res) {
+  if (res) {
+    const ra = res.headers.get("retry-after");
+    if (ra) {
+      const n = Number(ra);
+      if (!Number.isNaN(n) && n > 0) return Math.min(n * 1e3, 1e4);
+    }
+  }
+  const base = 300 * 2 ** attempt;
+  return base + Math.floor(Math.random() * 200);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function stripTrailingSlash(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+function buildUrl(baseUrl, path, query) {
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const qs = encodeQuery(query);
+  return `${baseUrl}${p}${qs ? `?${qs}` : ""}`;
+}
+function encodeQuery(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      if (v.length === 0) continue;
+      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(v.join(","))}`);
+    } else {
+      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+  }
+  return parts.join("&");
+}
+
+// src/client.ts
+var PUBLIC_PREFIX = "/api/public";
+var NexorClient = class {
+  constructor(opts) {
+    this.cfg = resolveConfig(opts);
+  }
+  // ─── Leads ───────────────────────────────────────────────────────────────
+  /** Create a single lead, optionally assigning it to a workflow. */
+  createLead(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/leads`,
+      body: input,
+      options
+    });
+  }
+  /** Create many leads in one request (max 1000). */
+  createLeadsBulk(inputs, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/leads`,
+      body: inputs,
+      options
+    });
+  }
+  /** Update an existing lead. metadata is shallow-merged server-side. */
+  updateLead(leadId, updates, options) {
+    return request(this.cfg, {
+      method: "PUT",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}`,
+      body: updates,
+      options
+    });
+  }
+  /** Fetch a lead with its captured variables and per-channel engagement. */
+  getLead(leadId, options) {
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}`,
+      options
+    });
+  }
+  /** Full chronological history: messages, transcripts, activity. */
+  getLeadHistory(leadId, params = {}, options) {
+    const channel = Array.isArray(params.channel) ? params.channel : params.channel ? [params.channel] : void 0;
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}/history`,
+      query: { channel, limit: params.limit, offset: params.offset },
+      options
+    });
+  }
+  /** Has automation been paused (human takeover) for this lead? */
+  isLeadPaused(leadId, params = {}, options) {
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}/is_paused`,
+      query: { workflow_id: params.workflow_id },
+      options
+    });
+  }
+  /** Pause automation (engage human takeover) on a specific workflow run. */
+  stopAutomation(leadId, input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}/automation/stop`,
+      body: input,
+      options
+    });
+  }
+  /** Resume automation; pass resume_cadence: true to restart scheduled touches. */
+  resumeAutomation(leadId, input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}/automation/resume`,
+      body: input,
+      options
+    });
+  }
+  /**
+   * Replace the tag set on a lead (identified by lead_id OR email).
+   * Tags missing from the input are unassigned; new tags are find-or-created.
+   */
+  syncLeadTags(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/leads/tags`,
+      body: input,
+      options
+    });
+  }
+  /** All meetings on file for a lead (optionally filter by status). */
+  listLeadMeetings(leadId, params = {}, options) {
+    const status = Array.isArray(params.status) ? params.status.join(",") : params.status;
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/leads/${encodeURIComponent(leadId)}/meetings`,
+      query: { status },
+      options
+    });
+  }
+  // ─── Workflows / Campaigns / Templates ──────────────────────────────────
+  /** Active workflows in your account. */
+  listWorkflows(options) {
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/workflows`,
+      options
+    });
+  }
+  /** Campaigns in your account. */
+  listCampaigns(options) {
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/campaigns`,
+      options
+    });
+  }
+  /** Approved WhatsApp templates. */
+  listTemplates(params = {}, options) {
+    return request(this.cfg, {
+      method: "GET",
+      path: `${PUBLIC_PREFIX}/templates`,
+      query: { status: params.status, category: params.category },
+      options
+    });
+  }
+  // ─── Messages ───────────────────────────────────────────────────────────
+  /** Send a one-off message (WhatsApp/email) or trigger a call. */
+  sendMessage(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/messages`,
+      body: input,
+      options
+    });
+  }
+  // ─── Meetings ───────────────────────────────────────────────────────────
+  /** Log a booked meeting against an existing lead (matched by email). */
+  createMeeting(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/meetings`,
+      body: input,
+      options
+    });
+  }
+  /** Push a note-taker transcript / summary / action items to a meeting. */
+  createMeetingNotes(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/meeting-notes`,
+      body: input,
+      options
+    });
+  }
+  // ─── Chat (used by initChat widget) ─────────────────────────────────────
+  /**
+   * Send a turn in a browser-embedded chat session. Backed by
+   * POST /api/public/chat on the Nexor API.
+   *
+   * Most users will not call this directly — `initChat()` handles it.
+   */
+  chat(input, options) {
+    return request(this.cfg, {
+      method: "POST",
+      path: `${PUBLIC_PREFIX}/chat`,
+      body: input,
+      options
+    });
+  }
+};
+
+// src/chat/config.ts
+function applyDefaults(o) {
+  return {
+    workflowId: o.workflowId,
+    title: o.title ?? "Chat with us",
+    subtitle: o.subtitle ?? "We typically reply in a few minutes",
+    greeting: o.greeting ?? "Hi there! \u{1F44B} How can we help?",
+    errorText: o.errorText ?? "Sorry, something went wrong. Please try again in a moment.",
+    locale: o.locale ?? (typeof navigator !== "undefined" ? navigator.language : void 0),
+    accentColor: o.accentColor ?? "#111827",
+    accentTextColor: o.accentTextColor ?? "#ffffff",
+    showBranding: o.showBranding ?? true,
+    position: o.position ?? "bottom-right",
+    openOnLoad: o.openOnLoad ?? false,
+    debounceMs: o.debounceMs ?? 700,
+    container: o.container,
+    systemPrompt: o.systemPrompt,
+    clientPrompt: o.clientPrompt,
+    lead: o.lead,
+    capture: {
+      fields: o.capture?.fields ?? ["first_name", "email"],
+      mode: o.capture?.mode ?? "before",
+      label: o.capture?.label ?? "Tell us a bit about you to get started:",
+      submitLabel: o.capture?.submitLabel ?? "Start chat"
+    },
+    metadata: o.metadata,
+    onOpen: o.onOpen,
+    onClose: o.onClose,
+    onMessage: o.onMessage,
+    onLeadCaptured: o.onLeadCaptured,
+    onError: o.onError
+  };
+}
+function needsCapture(cfg) {
+  if (cfg.capture.mode === "skip") return false;
+  if (cfg.lead) {
+    const have = cfg.lead;
+    return cfg.capture.fields.some((f) => !have[f]);
+  }
+  return true;
+}
+
+// src/chat/session.ts
+var SESSION_KEY = "nexor.chat.session_id";
+var SESSION_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+function ensureSessionId() {
+  const now = Date.now();
+  try {
+    const rec = readRecord();
+    if (rec && now - rec.ts < SESSION_RETENTION_MS) {
+      writeRecord(rec.id, now);
+      return rec.id;
+    }
+  } catch {
+  }
+  const id = `sess_${randomHex(16)}`;
+  try {
+    writeRecord(id, now);
+  } catch {
+  }
+  return id;
+}
+function touchSession() {
+  try {
+    const rec = readRecord();
+    if (rec) writeRecord(rec.id, Date.now());
+  } catch {
+  }
+}
+function readRecord() {
+  const raw = window.localStorage.getItem(SESSION_KEY);
+  if (!raw) return null;
+  try {
+    const o = JSON.parse(raw);
+    if (o && typeof o.id === "string" && typeof o.ts === "number") return o;
+  } catch {
+  }
+  if (raw.startsWith("sess_")) return { id: raw, ts: Date.now() };
+  return null;
+}
+function writeRecord(id, ts) {
+  window.localStorage.setItem(SESSION_KEY, JSON.stringify({ id, ts }));
+}
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(arr);
+  } else {
+    for (let i = 0; i < bytes; i++) arr[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/chat/styles.ts
+var widgetCss = (accent, accentText) => `
+.nexor-chat,
+.nexor-chat * {
+  box-sizing: border-box;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+
+.nexor-chat {
+  position: fixed;
+  z-index: 2147483640;
+  bottom: 20px;
+  right: 20px;
+  font-size: 14px;
+  line-height: 1.4;
+  color: #111;
+}
+
+.nexor-chat[data-position="bottom-left"] {
+  right: auto;
+  left: 20px;
+}
+
+/* \u2500\u2500 Launcher bubble \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 */
+.nexor-chat__launcher {
+  width: 56px;
+  height: 56px;
+  border-radius: 9999px;
+  background: ${accent};
+  color: ${accentText};
+  border: none;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.18);
+  transition: transform 160ms cubic-bezier(.2,.7,.2,1.1),
+              box-shadow 160ms ease,
+              background 200ms ease;
+  padding: 0;
+  position: relative;
+  animation: nexor-launcher-in 360ms cubic-bezier(.2,.7,.2,1.1) both;
+}
+.nexor-chat__launcher:hover {
+  transform: translateY(-2px) scale(1.04);
+  box-shadow: 0 10px 24px rgba(0, 0, 0, 0.24);
+}
+.nexor-chat__launcher:active {
+  transform: translateY(0) scale(0.97);
+  transition-duration: 80ms;
+}
+.nexor-chat__launcher:focus-visible {
+  outline: 2px solid ${accent};
+  outline-offset: 2px;
+}
+.nexor-chat[data-open="true"] .nexor-chat__launcher {
+  transform: scale(0.85);
+  opacity: 0.75;
+}
+.nexor-chat__launcher svg { width: 24px; height: 24px; transition: transform 200ms ease; }
+.nexor-chat[data-open="true"] .nexor-chat__launcher svg { transform: rotate(8deg); }
+
+.nexor-chat__unread {
+  position: absolute;
+  top: -4px;
+  right: -4px;
+  min-width: 18px;
+  height: 18px;
+  background: #ef4444;
+  color: #fff;
+  border-radius: 9999px;
+  font-size: 11px;
+  font-weight: 600;
+  padding: 0 5px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: 2px solid #fff;
+  animation: nexor-pop-in 300ms cubic-bezier(.2,.7,.2,1.1) both;
+}
+
+@keyframes nexor-launcher-in {
+  from { transform: translateY(20px) scale(0.6); opacity: 0; }
+  to   { transform: translateY(0) scale(1);     opacity: 1; }
+}
+@keyframes nexor-pop-in {
+  from { transform: scale(0); }
+  to   { transform: scale(1); }
+}
+
+/* \u2500\u2500 Panel \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\u2500\u2500\u2500\u2500\u2500\u2500 */
+.nexor-chat__panel {
+  position: absolute;
+  bottom: 72px;
+  right: 0;
+  width: 360px;
+  max-width: calc(100vw - 32px);
+  height: 540px;
+  max-height: calc(100vh - 120px);
+  background: #fff;
+  border-radius: 14px;
+  box-shadow: 0 24px 60px rgba(0, 0, 0, 0.22);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  transform: translateY(14px) scale(0.96);
+  opacity: 0;
+  pointer-events: none;
+  transition: transform 220ms cubic-bezier(.2,.7,.2,1.1),
+              opacity 220ms ease;
+  border: 1px solid rgba(0, 0, 0, 0.06);
+  /* Use visibility so screen readers don't read collapsed content */
+  visibility: hidden;
+}
+.nexor-chat[data-position="bottom-left"] .nexor-chat__panel {
+  right: auto;
+  left: 0;
+}
+.nexor-chat[data-open="true"] .nexor-chat__panel {
+  transform: translateY(0) scale(1);
+  opacity: 1;
+  pointer-events: auto;
+  visibility: visible;
+}
+
+.nexor-chat__header {
+  background: ${accent};
+  color: ${accentText};
+  padding: 14px 16px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+.nexor-chat__title {
+  font-weight: 600;
+  font-size: 15px;
+  margin: 0;
+}
+.nexor-chat__subtitle {
+  font-size: 12px;
+  opacity: 0.85;
+  margin: 2px 0 0;
+}
+.nexor-chat__status-dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 9999px;
+  background: #34d399;
+  margin-right: 6px;
+  vertical-align: 1px;
+  animation: nexor-pulse 2.4s ease-in-out infinite;
+  box-shadow: 0 0 0 0 rgba(52, 211, 153, 0.6);
+}
+@keyframes nexor-pulse {
+  0%, 100% { box-shadow: 0 0 0 0 rgba(52, 211, 153, 0.55); }
+  50%      { box-shadow: 0 0 0 6px rgba(52, 211, 153, 0);    }
+}
+.nexor-chat__close {
+  background: transparent;
+  border: none;
+  color: inherit;
+  cursor: pointer;
+  padding: 4px;
+  border-radius: 6px;
+  opacity: 0.9;
+  transition: background 140ms ease, transform 140ms ease;
+}
+.nexor-chat__close:hover { background: rgba(255,255,255,0.18); opacity: 1; }
+.nexor-chat__close:active { transform: scale(0.92); }
+.nexor-chat__close svg { width: 18px; height: 18px; display: block; }
+
+/* \u2500\u2500 Body / messages \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 */
+.nexor-chat__body {
+  flex: 1;
+  overflow-y: auto;
+  padding: 14px;
+  background: #f6f7f9;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  scroll-behavior: smooth;
+  /* Prevent layout shift when scrollbar appears */
+  scrollbar-gutter: stable;
+}
+.nexor-chat__body::-webkit-scrollbar { width: 6px; }
+.nexor-chat__body::-webkit-scrollbar-thumb {
+  background: rgba(0,0,0,0.15);
+  border-radius: 9999px;
+}
+
+.nexor-chat__msg {
+  max-width: 80%;
+  padding: 8px 12px;
+  border-radius: 14px;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  animation: nexor-msg-in 240ms cubic-bezier(.2,.7,.2,1.1) both;
+  will-change: transform, opacity;
+}
+.nexor-chat__msg--bot {
+  background: #fff;
+  align-self: flex-start;
+  border: 1px solid rgba(0,0,0,0.06);
+  border-bottom-left-radius: 4px;
+  box-shadow: 0 1px 2px rgba(0,0,0,0.04);
+}
+.nexor-chat__msg--user {
+  background: ${accent};
+  color: ${accentText};
+  align-self: flex-end;
+  border-bottom-right-radius: 4px;
+  animation-name: nexor-msg-in-user;
+}
+.nexor-chat__msg--system {
+  background: transparent;
+  color: #6b7280;
+  font-size: 12px;
+  align-self: center;
+  text-align: center;
+  max-width: 100%;
+  animation-name: nexor-fade-in;
+}
+.nexor-chat__msg-time {
+  display: block;
+  margin-top: 4px;
+  font-size: 10px;
+  line-height: 1;
+  opacity: 0.55;
+  text-align: right;
+}
+.nexor-chat__msg--bot .nexor-chat__msg-time { text-align: left; }
+
+@keyframes nexor-msg-in {
+  from { transform: translateY(8px) scale(0.96); opacity: 0; }
+  to   { transform: translateY(0) scale(1);     opacity: 1; }
+}
+@keyframes nexor-msg-in-user {
+  from { transform: translateY(8px) translateX(8px) scale(0.96); opacity: 0; }
+  to   { transform: translateY(0) translateX(0) scale(1);        opacity: 1; }
+}
+@keyframes nexor-fade-in {
+  from { opacity: 0; }
+  to   { opacity: 1; }
+}
+
+.nexor-chat__typing {
+  align-self: flex-start;
+  background: #fff;
+  border: 1px solid rgba(0,0,0,0.06);
+  border-radius: 14px;
+  border-bottom-left-radius: 4px;
+  padding: 10px 14px;
+  display: inline-flex;
+  gap: 4px;
+  animation: nexor-msg-in 240ms cubic-bezier(.2,.7,.2,1.1) both;
+}
+.nexor-chat__typing span {
+  width: 6px; height: 6px; border-radius: 9999px;
+  background: #9ca3af;
+  display: inline-block;
+  animation: nexor-blink 1.2s infinite ease-in-out;
+}
+.nexor-chat__typing span:nth-child(2) { animation-delay: 0.15s; }
+.nexor-chat__typing span:nth-child(3) { animation-delay: 0.30s; }
+@keyframes nexor-blink {
+  0%, 60%, 100% { opacity: 0.3; transform: translateY(0); }
+  30%           { opacity: 1;   transform: translateY(-3px); }
+}
+
+/* \u2500\u2500 Lead capture form \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 */
+.nexor-chat__capture {
+  background: #fff;
+  border: 1px solid rgba(0,0,0,0.06);
+  border-radius: 12px;
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin-top: 4px;
+  animation: nexor-msg-in 280ms cubic-bezier(.2,.7,.2,1.1) both;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+}
+.nexor-chat__capture-label {
+  font-size: 12px;
+  color: #6b7280;
+  margin: 0;
+}
+.nexor-chat__capture-row {
+  display: flex;
+  gap: 8px;
+}
+.nexor-chat__capture-row > * { flex: 1; }
+.nexor-chat__input,
+.nexor-chat__capture input {
+  font: inherit;
+  padding: 8px 10px;
+  border: 1px solid #d1d5db;
+  border-radius: 8px;
+  background: #fff;
+  color: #111;
+  outline: none;
+  width: 100%;
+  transition: border-color 140ms ease, box-shadow 140ms ease;
+}
+.nexor-chat__input:focus,
+.nexor-chat__capture input:focus {
+  border-color: ${accent};
+  box-shadow: 0 0 0 3px ${accent}33;
+}
+.nexor-chat__capture-submit {
+  background: ${accent};
+  color: ${accentText};
+  border: none;
+  border-radius: 8px;
+  padding: 8px 12px;
+  font: inherit;
+  font-weight: 600;
+  cursor: pointer;
+  transition: transform 140ms ease, filter 140ms ease;
+}
+.nexor-chat__capture-submit:hover { filter: brightness(1.08); }
+.nexor-chat__capture-submit:active { transform: scale(0.97); }
+.nexor-chat__capture-submit[disabled] { opacity: 0.6; cursor: not-allowed; }
+
+/* \u2500\u2500 Composer \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\u2500\u2500\u2500 */
+.nexor-chat__composer {
+  display: flex;
+  gap: 8px;
+  padding: 10px;
+  background: #fff;
+  border-top: 1px solid rgba(0,0,0,0.06);
+  align-items: stretch;
+}
+.nexor-chat__send {
+  background: ${accent};
+  color: ${accentText};
+  border: none;
+  border-radius: 8px;
+  padding: 0 14px;
+  font: inherit;
+  font-weight: 600;
+  cursor: pointer;
+  min-width: 44px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: transform 140ms ease, filter 140ms ease;
+}
+.nexor-chat__send:hover { filter: brightness(1.08); }
+.nexor-chat__send:active { transform: scale(0.95); }
+.nexor-chat__send[disabled] {
+  opacity: 0.6;
+  cursor: not-allowed;
+  transform: none;
+}
+.nexor-chat__send svg {
+  width: 18px;
+  height: 18px;
+  transition: transform 200ms ease;
+}
+.nexor-chat__send:not([disabled]):hover svg { transform: translateX(2px); }
+
+/* Small spinner inside the send button while a turn is in flight */
+.nexor-chat__send--loading svg { display: none; }
+.nexor-chat__send--loading::after {
+  content: "";
+  width: 14px;
+  height: 14px;
+  border-radius: 9999px;
+  border: 2px solid currentColor;
+  border-top-color: transparent;
+  animation: nexor-spin 700ms linear infinite;
+}
+@keyframes nexor-spin {
+  to { transform: rotate(360deg); }
+}
+
+.nexor-chat__footer {
+  text-align: center;
+  font-size: 11px;
+  color: #9ca3af;
+  padding: 6px;
+  background: #fff;
+  border-top: 1px solid rgba(0,0,0,0.04);
+}
+.nexor-chat__footer a {
+  color: inherit;
+  text-decoration: none;
+  font-weight: 600;
+}
+.nexor-chat__footer a:hover { text-decoration: underline; }
+
+/* Respect users who request reduced motion. */
+@media (prefers-reduced-motion: reduce) {
+  .nexor-chat,
+  .nexor-chat * {
+    animation-duration: 0.001ms !important;
+    transition-duration: 0.001ms !important;
+  }
+  .nexor-chat__status-dot { animation: none; }
+}
+`;
+
+// src/chat/dom.ts
+var STYLE_ATTR = "data-nexor-chat-styles";
+function injectStyles(accent, accentText) {
+  if (document.querySelector(`style[${STYLE_ATTR}]`)) return;
+  const style = document.createElement("style");
+  style.setAttribute(STYLE_ATTR, "1");
+  style.textContent = widgetCss(accent, accentText);
+  document.head.appendChild(style);
+}
+function buildLauncher() {
+  const el = document.createElement("button");
+  el.type = "button";
+  el.className = "nexor-chat__launcher";
+  el.setAttribute("aria-label", "Open chat");
+  el.innerHTML = `
+    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+      <path d="M4 5.5C4 4.67 4.67 4 5.5 4h13c.83 0 1.5.67 1.5 1.5v9c0 .83-.67 1.5-1.5 1.5H9l-4 4V5.5Z"
+            stroke="currentColor" stroke-width="1.8" stroke-linejoin="round"/>
+    </svg>
+  `;
+  const badge = document.createElement("span");
+  badge.className = "nexor-chat__unread";
+  badge.style.display = "none";
+  el.appendChild(badge);
+  return { el, badge };
+}
+function buildPanel(cfg) {
+  const el = document.createElement("div");
+  el.className = "nexor-chat__panel";
+  el.setAttribute("role", "dialog");
+  el.setAttribute("aria-label", cfg.title);
+  const { header, closeBtn } = buildHeader(cfg);
+  const { body, captureForm, captureInputs } = buildBody(cfg);
+  const { form, input, send } = buildComposer();
+  const footer = cfg.showBranding ? buildFooter() : null;
+  el.appendChild(header);
+  el.appendChild(body);
+  el.appendChild(form);
+  if (footer) el.appendChild(footer);
+  return { el, closeBtn, body, form, input, send, captureForm, captureInputs };
+}
+function buildHeader(cfg) {
+  const header = document.createElement("div");
+  header.className = "nexor-chat__header";
+  const subtitleHtml = cfg.subtitle ? `<p class="nexor-chat__subtitle">
+         <span class="nexor-chat__status-dot" aria-hidden="true"></span>${escapeHtml(cfg.subtitle)}
+       </p>` : "";
+  header.innerHTML = `
+    <div>
+      <p class="nexor-chat__title">${escapeHtml(cfg.title)}</p>
+      ${subtitleHtml}
+    </div>
+  `;
+  const closeBtn = document.createElement("button");
+  closeBtn.type = "button";
+  closeBtn.className = "nexor-chat__close";
+  closeBtn.setAttribute("aria-label", "Close chat");
+  closeBtn.innerHTML = `
+    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+      <path d="M6 6l12 12M6 18L18 6" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+    </svg>
+  `;
+  header.appendChild(closeBtn);
+  return { header, closeBtn };
+}
+function buildBody(cfg) {
+  const body = document.createElement("div");
+  body.className = "nexor-chat__body";
+  const captureInputs = {};
+  let captureForm = null;
+  if (needsCapture(cfg)) {
+    captureForm = buildCaptureForm(cfg, captureInputs);
+    body.appendChild(captureForm);
+  }
+  return { body, captureForm, captureInputs };
+}
+function buildCaptureForm(cfg, inputsOut) {
+  const form = document.createElement("form");
+  form.className = "nexor-chat__capture";
+  form.noValidate = true;
+  const label = document.createElement("p");
+  label.className = "nexor-chat__capture-label";
+  label.textContent = cfg.capture.label;
+  form.appendChild(label);
+  const fields = cfg.capture.fields;
+  if (fields.includes("first_name") || fields.includes("last_name")) {
+    const row = document.createElement("div");
+    row.className = "nexor-chat__capture-row";
+    if (fields.includes("first_name")) {
+      inputsOut.first_name = makeInput("first_name", "First name", "text", cfg.lead?.first_name);
+      row.appendChild(inputsOut.first_name);
+    }
+    if (fields.includes("last_name")) {
+      inputsOut.last_name = makeInput("last_name", "Last name", "text", cfg.lead?.last_name);
+      row.appendChild(inputsOut.last_name);
+    }
+    if (row.childElementCount > 0) form.appendChild(row);
+  }
+  if (fields.includes("email")) {
+    inputsOut.email = makeInput("email", "Email", "email", cfg.lead?.email);
+    form.appendChild(inputsOut.email);
+  }
+  if (fields.includes("phone")) {
+    inputsOut.phone = makeInput("phone", "Phone", "tel", cfg.lead?.phone);
+    form.appendChild(inputsOut.phone);
+  }
+  const submit = document.createElement("button");
+  submit.type = "submit";
+  submit.className = "nexor-chat__capture-submit";
+  submit.textContent = cfg.capture.submitLabel;
+  form.appendChild(submit);
+  return form;
+}
+function buildComposer() {
+  const form = document.createElement("form");
+  form.className = "nexor-chat__composer";
+  const input = document.createElement("input");
+  input.type = "text";
+  input.className = "nexor-chat__input";
+  input.placeholder = "Type a message\u2026";
+  input.autocomplete = "off";
+  const send = document.createElement("button");
+  send.type = "submit";
+  send.className = "nexor-chat__send";
+  send.setAttribute("aria-label", "Send message");
+  send.innerHTML = `
+    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+      <path d="M3.4 11.2 20.5 4.3c.7-.3 1.4.4 1.1 1.1l-6.9 17.1c-.3.8-1.4.8-1.8 0L10 14l-7.5-3c-.8-.3-.8-1.5 0-1.8Z"
+            stroke="currentColor" stroke-width="1.6" stroke-linejoin="round" fill="currentColor"/>
+    </svg>
+  `;
+  form.appendChild(input);
+  form.appendChild(send);
+  return { form, input, send };
+}
+function buildFooter() {
+  const el = document.createElement("div");
+  el.className = "nexor-chat__footer";
+  el.innerHTML = `Powered by <a href="https://www.getnexor.ai" target="_blank" rel="noopener noreferrer">Nexor</a>`;
+  return el;
+}
+function buildMessage(role, text, ts, locale) {
+  const el = document.createElement("div");
+  el.className = `nexor-chat__msg nexor-chat__msg--${role}`;
+  const body = document.createElement("span");
+  body.className = "nexor-chat__msg-text";
+  body.textContent = text;
+  el.appendChild(body);
+  if (role !== "system" && ts) {
+    const time = document.createElement("time");
+    time.className = "nexor-chat__msg-time";
+    time.dataset.ts = String(ts);
+    time.textContent = formatRelativeTime(ts, locale);
+    el.appendChild(time);
+  }
+  return el;
+}
+function formatRelativeTime(ts, locale, now = Date.now()) {
+  try {
+    const diff = Math.max(0, now - ts);
+    const min = Math.round(diff / 6e4);
+    const hr = Math.round(diff / 36e5);
+    const day = Math.round(diff / 864e5);
+    const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+    if (diff < 45e3) return rtf.format(0, "second");
+    if (min < 60) return rtf.format(-min, "minute");
+    if (hr < 24) return rtf.format(-hr, "hour");
+    if (day < 7) return rtf.format(-day, "day");
+    return new Date(ts).toLocaleDateString(locale, {
+      day: "numeric",
+      month: "short"
+    });
+  } catch {
+    try {
+      return new Date(ts).toLocaleTimeString(locale, {
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+    } catch {
+      return "";
+    }
+  }
+}
+function buildTypingIndicator() {
+  const el = document.createElement("div");
+  el.className = "nexor-chat__typing";
+  el.innerHTML = "<span></span><span></span><span></span>";
+  return el;
+}
+function makeInput(name, placeholder, type, value) {
+  const i = document.createElement("input");
+  i.name = name;
+  i.type = type;
+  i.placeholder = placeholder;
+  if (value) i.value = value;
+  return i;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/chat/index.ts
+var TYPING_DELAY_MS = 220;
+function initChat(client, options) {
+  ensureBrowser();
+  if (!options || !options.workflowId) {
+    throw new Error("Nexor SDK: initChat() requires `workflowId`.");
+  }
+  const cfg = applyDefaults(options);
+  injectStyles(cfg.accentColor, cfg.accentTextColor);
+  const sessionId = ensureSessionId();
+  const historyKey = `nexor.chat.history.${sessionId}`;
+  const root = buildRoot(cfg);
+  const launcher = buildLauncher();
+  const panel = buildPanel(cfg);
+  root.appendChild(launcher.el);
+  root.appendChild(panel.el);
+  (cfg.container ?? document.body).appendChild(root);
+  const state = {
+    isOpen: false,
+    unread: 0,
+    leadId: void 0,
+    captured: !needsCapture(cfg),
+    pendingLead: { ...cfg.lead ?? {} },
+    history: []
+  };
+  launcher.el.addEventListener("click", toggle);
+  panel.closeBtn.addEventListener("click", close);
+  panel.form.addEventListener("submit", onComposerSubmit);
+  panel.captureForm?.addEventListener("submit", onCaptureSubmit);
+  syncComposerLock();
+  const restored = loadHistory();
+  if (restored.length) {
+    state.history = restored;
+    for (const m of restored) appendBubble(m.role === "user" ? "user" : "bot", m.text, m.ts);
+    scrollToBottom();
+  }
+  if (cfg.openOnLoad) open();
+  function open() {
+    if (state.isOpen) return;
+    state.isOpen = true;
+    root.setAttribute("data-open", "true");
+    clearUnread();
+    if (state.history.length === 0 && cfg.greeting && state.captured) {
+      appendBot(cfg.greeting);
+    }
+    panel.input.focus();
+    cfg.onOpen?.();
+  }
+  function close() {
+    if (!state.isOpen) return;
+    state.isOpen = false;
+    root.setAttribute("data-open", "false");
+    cfg.onClose?.();
+  }
+  function toggle() {
+    state.isOpen ? close() : open();
+  }
+  function onCaptureSubmit(e) {
+    e.preventDefault();
+    const collected = readCaptureFields(panel);
+    const required = cfg.capture.fields;
+    for (const f of required) {
+      if (!collected[f]) {
+        panel.captureInputs[f]?.focus();
+        return;
+      }
+    }
+    state.pendingLead = { ...state.pendingLead, ...collected };
+    state.captured = true;
+    panel.captureForm?.remove();
+    syncComposerLock();
+    panel.input.focus();
+    if (cfg.greeting && state.history.length === 0) appendBot(cfg.greeting);
+  }
+  const send = {
+    pending: [],
+    timer: 0,
+    typingTimer: 0,
+    inFlight: false,
+    typing: null
+  };
+  function onComposerSubmit(e) {
+    e.preventDefault();
+    const text = panel.input.value.trim();
+    if (!text) return;
+    panel.input.value = "";
+    queueMessage(text);
+  }
+  function queueMessage(text) {
+    if (!state.captured) {
+      panel.captureInputs.first_name?.focus();
+      return;
+    }
+    appendUser(text);
+    send.pending.push(text);
+    scheduleFlush();
+  }
+  function scheduleFlush() {
+    if (send.timer) window.clearTimeout(send.timer);
+    send.timer = window.setTimeout(() => void flush(), cfg.debounceMs);
+  }
+  async function flush() {
+    if (send.inFlight || send.pending.length === 0) return;
+    const batch = send.pending.splice(0, send.pending.length);
+    const message = batch.join("\n");
+    send.inFlight = true;
+    send.typingTimer = window.setTimeout(() => {
+      send.typing = appendNode(buildTypingIndicator());
+    }, TYPING_DELAY_MS);
+    try {
+      const res = await client.chat({
+        workflow_id: cfg.workflowId,
+        session_id: sessionId,
+        message,
+        system_prompt: cfg.systemPrompt,
+        client_prompt: cfg.clientPrompt,
+        lead: Object.keys(state.pendingLead).length ? state.pendingLead : void 0,
+        metadata: cfg.metadata
+      });
+      if (res.lead_id && !state.leadId) {
+        state.leadId = res.lead_id;
+        cfg.onLeadCaptured?.(state.leadId);
+      }
+      const reply = (res.reply ?? "").trim();
+      if (reply) {
+        appendBot(reply);
+      } else {
+        appendSystem(cfg.errorText);
+        cfg.onError?.(new Error("Nexor SDK: empty reply from server"));
+      }
+    } catch (err) {
+      appendSystem(cfg.errorText);
+      cfg.onError?.(err);
+    } finally {
+      window.clearTimeout(send.typingTimer);
+      send.typing?.remove();
+      send.typing = null;
+      send.inFlight = false;
+      panel.input.focus();
+      if (send.pending.length) scheduleFlush();
+    }
+  }
+  function appendUser(text) {
+    const ts = Date.now();
+    appendBubble("user", text, ts);
+    state.history.push({ role: "user", text, ts });
+    saveHistory();
+    cfg.onMessage?.({ role: "user", text });
+  }
+  function appendBot(text) {
+    const ts = Date.now();
+    appendBubble("bot", text, ts);
+    state.history.push({ role: "bot", text, ts });
+    saveHistory();
+    if (!state.isOpen) bumpUnread();
+    cfg.onMessage?.({ role: "bot", text });
+  }
+  function saveHistory() {
+    try {
+      window.localStorage.setItem(
+        historyKey,
+        JSON.stringify({ ts: Date.now(), history: state.history })
+      );
+      touchSession();
+    } catch {
+    }
+  }
+  function loadHistory() {
+    try {
+      const raw = window.localStorage.getItem(historyKey);
+      if (!raw) return [];
+      const o = JSON.parse(raw);
+      if (!o || !Array.isArray(o.history)) return [];
+      if (Date.now() - (o.ts || 0) > SESSION_RETENTION_MS) {
+        window.localStorage.removeItem(historyKey);
+        return [];
+      }
+      return o.history;
+    } catch {
+      return [];
+    }
+  }
+  function appendSystem(text) {
+    appendBubble("system", text);
+  }
+  function appendBubble(role, text, ts) {
+    return appendNode(buildMessage(role, text, ts, cfg.locale));
+  }
+  const refreshTimer = window.setInterval(() => {
+    panel.body.querySelectorAll(".nexor-chat__msg-time[data-ts]").forEach((el) => {
+      const ts = Number(el.dataset.ts);
+      if (ts) el.textContent = formatRelativeTime(ts, cfg.locale);
+    });
+  }, 6e4);
+  function appendNode(node) {
+    panel.body.appendChild(node);
+    scrollToBottom();
+    return node;
+  }
+  function scrollToBottom() {
+    panel.body.scrollTop = panel.body.scrollHeight;
+  }
+  function bumpUnread() {
+    state.unread++;
+    launcher.badge.textContent = String(state.unread);
+    launcher.badge.style.display = "flex";
+  }
+  function clearUnread() {
+    state.unread = 0;
+    launcher.badge.style.display = "none";
+  }
+  function syncComposerLock() {
+    const lock = !state.captured;
+    panel.input.disabled = lock;
+    panel.send.disabled = lock;
+    panel.input.placeholder = lock ? "Complete the form above to start\u2026" : "Type a message\u2026";
+  }
+  return {
+    open,
+    close,
+    toggle,
+    // Programmatic send goes through the same debounce/coalesce path. Resolves
+    // immediately — the message is queued, not necessarily sent yet.
+    send: (text) => {
+      queueMessage(text);
+      return Promise.resolve();
+    },
+    destroy: () => {
+      if (send.timer) window.clearTimeout(send.timer);
+      if (send.typingTimer) window.clearTimeout(send.typingTimer);
+      window.clearInterval(refreshTimer);
+      root.remove();
+    },
+    getSessionId: () => sessionId
+  };
+}
+function ensureBrowser() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("Nexor SDK: initChat() requires a browser environment.");
+  }
+}
+function buildRoot(cfg) {
+  const root = document.createElement("div");
+  root.className = "nexor-chat";
+  root.setAttribute("data-position", cfg.position);
+  root.setAttribute("data-open", "false");
+  return root;
+}
+function readCaptureFields(panel) {
+  const out = {};
+  const inputs = panel.captureInputs;
+  if (inputs.first_name) out.first_name = inputs.first_name.value.trim();
+  if (inputs.last_name) out.last_name = inputs.last_name.value.trim();
+  if (inputs.email) out.email = inputs.email.value.trim();
+  if (inputs.phone) out.phone = inputs.phone.value.trim();
+  return out;
+}
+
+// src/index.ts
+function createClient(opts) {
+  return new NexorClient(opts);
+}
+var _client = null;
+function getClient() {
+  if (!_client) {
+    throw new Error(
+      "Nexor SDK: call `nexor.init({ apiKey })` before using the API."
+    );
+  }
+  return _client;
+}
+function init(opts) {
+  _client = new NexorClient(opts);
+  return _client;
+}
+function isInitialized() {
+  return _client !== null;
+}
+function reset() {
+  _client = null;
+}
+var nexor = {
+  init,
+  isInitialized,
+  reset,
+  get client() {
+    return getClient();
+  },
+  // Leads
+  createLead: ((...args) => getClient().createLead(...args)),
+  createLeadsBulk: ((...args) => getClient().createLeadsBulk(...args)),
+  updateLead: ((...args) => getClient().updateLead(...args)),
+  getLead: ((...args) => getClient().getLead(...args)),
+  getLeadHistory: ((...args) => getClient().getLeadHistory(...args)),
+  isLeadPaused: ((...args) => getClient().isLeadPaused(...args)),
+  stopAutomation: ((...args) => getClient().stopAutomation(...args)),
+  resumeAutomation: ((...args) => getClient().resumeAutomation(...args)),
+  syncLeadTags: ((...args) => getClient().syncLeadTags(...args)),
+  listLeadMeetings: ((...args) => getClient().listLeadMeetings(...args)),
+  // Workflows / Campaigns / Templates
+  listWorkflows: ((...args) => getClient().listWorkflows(...args)),
+  listCampaigns: ((...args) => getClient().listCampaigns(...args)),
+  listTemplates: ((...args) => getClient().listTemplates(...args)),
+  // Messages
+  sendMessage: ((...args) => getClient().sendMessage(...args)),
+  // Meetings
+  createMeeting: ((...args) => getClient().createMeeting(...args)),
+  createMeetingNotes: ((...args) => getClient().createMeetingNotes(...args)),
+  // Chat widget
+  initChat: (options) => initChat(getClient(), options)
+};
+var src_default = nexor;
+
+exports.NexorAPIError = NexorAPIError;
+exports.NexorAuthError = NexorAuthError;
+exports.NexorClient = NexorClient;
+exports.NexorError = NexorError;
+exports.NexorNetworkError = NexorNetworkError;
+exports.NexorValidationError = NexorValidationError;
+exports.createClient = createClient;
+exports.default = src_default;
+exports.nexor = nexor;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map