@pagelines/sdk 1.0.150 → 1.0.152

package/dist/sdkClient-yg_rc4B7.js

@@ -0,0 +1,1015 @@
+var X = Object.defineProperty;
+var se = (h, e, t) => e in h ? X(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
+var c = (h, e) => X(h, "name", { value: e, configurable: !0 });
+var n = (h, e, t) => se(h, typeof e != "symbol" ? e + "" : e, t);
+import { watch as Z, ref as E, computed as ee } from "vue";
+import { APP_PORT as F, APP_PROD_URL as D } from "@pagelines/types";
+import { hc as ie } from "hono/client";
+function N(h = {}) {
+  const { prefix: e = "id_" } = h, t = e.length >= 3 ? e.substring(0, 3) : e.padEnd(3, "_"), r = Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0");
+  let o = "";
+  for (let s = 0; s < 16; s++)
+    o += Math.floor(Math.random() * 16).toString(16);
+  return t + r + o;
+}
+c(N, "objectId");
+const S = globalThis.process, m = typeof window < "u", B = typeof S < "u" && !m, x = m ? typeof window < "u" && window.location && !window.location.hostname.includes("localhost") : B && typeof S < "u" && S.env?.NODE_ENV === "production", ne = !x, A = {
+  error: { priority: 50, color: "#FF0000", nodeColor: "\x1B[31m" },
+  warn: { priority: 40, color: "#FFA500", nodeColor: "\x1B[33m" },
+  info: { priority: 30, color: "#00ABFF", nodeColor: "\x1B[36m" },
+  debug: { priority: 20, color: "#00BD0C", nodeColor: "\x1B[32m" },
+  trace: { priority: 10, color: "#5233FF", nodeColor: "\x1B[35m" }
+}, ae = ["password", "token", "secret", "apikey", "api_key", "authorization", "cookie"], y = class y {
+  constructor(e = {}, t) {
+    n(this, "settings");
+    n(this, "enabledInBrowser", !1);
+    n(this, "context");
+    this.context = t, this.settings = {
+      enabled: e.enabled ?? !0,
+      minLevel: e.minLevel ?? this.getDefaultLevel(),
+      timestamps: e.timestamps ?? !0
+    }, m && this.initBrowserLogging();
+  }
+  getDefaultLevel() {
+    if (B && typeof S < "u" && S.env?.LOG_LEVEL)
+      return S.env.LOG_LEVEL;
+    if (m && typeof localStorage < "u" && typeof localStorage.getItem == "function") {
+      const e = localStorage.getItem("PAGELINES_LOG_LEVEL");
+      if (e)
+        return e;
+    }
+    return x ? "info" : "debug";
+  }
+  initBrowserLogging() {
+    if (!m)
+      return;
+    const t = typeof localStorage?.getItem == "function" && localStorage.getItem("PAGELINES_LOG") === "true", r = window.location?.hostname || "";
+    this.enabledInBrowser = ne || t || r === "localhost" || r.includes("127.0.0.1"), x && !t && !y.hasShownHelp && (console.log(
+      "%cPageLines Logger (disabled in production)",
+      "color: #888; font-size: 12px"
+    ), console.log(
+      '%cTo enable: localStorage.setItem("PAGELINES_LOG", "true")',
+      "color: #888; font-size: 11px"
+    ), y.hasShownHelp = !0);
+  }
+  shouldLog(e) {
+    if (!this.settings.enabled || m && !this.enabledInBrowser)
+      return !1;
+    const t = A[e].priority, r = A[this.settings.minLevel].priority;
+    return t >= r;
+  }
+  formatTimestamp() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", {
+      hour12: !1,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+  }
+  formatISOTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  redactSensitive(e) {
+    if (typeof e != "object" || e === null)
+      return e;
+    if (Array.isArray(e))
+      return e.map((r) => this.redactSensitive(r));
+    const t = {};
+    for (const [r, o] of Object.entries(e)) {
+      const s = r.toLowerCase();
+      ae.some((i) => s.includes(i)) ? t[r] = "[REDACTED]" : typeof o == "object" && o !== null ? t[r] = this.redactSensitive(o) : t[r] = o;
+    }
+    return t;
+  }
+  formatData(e, t = 3, r = 0) {
+    if (r >= t)
+      return "[Max Depth]";
+    if (e == null)
+      return e;
+    if (e instanceof Error)
+      return {
+        name: e.name,
+        message: e.message,
+        stack: x ? e.stack?.split(`
+`).slice(0, 3).join(`
+`) : e.stack,
+        ...e
+        // Include any additional error properties
+      };
+    if (e instanceof Date)
+      return e.toISOString();
+    if (typeof e != "object")
+      return e;
+    if (Array.isArray(e))
+      return e.length > 20 && x ? `Array(${e.length}) [${e.slice(0, 3).map((o) => this.formatData(o, t, r + 1)).join(", ")}, ...]` : e.map((o) => this.formatData(o, t, r + 1));
+    try {
+      const o = {}, s = Object.entries(e), i = x ? 50 : 200;
+      for (const [l, u] of s.slice(0, i))
+        o[l] = this.formatData(u, t, r + 1);
+      return s.length > i && (o["..."] = `${s.length - i} more properties`), this.redactSensitive(o);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+  logToBrowser(e) {
+    if (!m || !this.shouldLog(e.level))
+      return;
+    const { level: t, description: r, context: o, data: s, error: i } = e, l = A[t], a = `[${o || this.context || "www"}] ${t.toUpperCase()}:`, d = `color: ${l.color}; font-weight: bold;`;
+    s !== void 0 ? console[t](`%c${a}`, d, r, this.formatData(s)) : console[t](`%c${a}`, d, r), i && (i instanceof Error ? console.error(i) : console.error("Error details:", i));
+  }
+  logToNode(e) {
+    if (!B || !this.shouldLog(e.level))
+      return;
+    const { level: t, description: r, context: o, data: s, error: i } = e, l = o || this.context || "www";
+    if (x) {
+      const u = {
+        timestamp: this.formatISOTimestamp(),
+        level: t.toUpperCase()
+      };
+      s && (u.data = this.formatData(s)), i && (u.error = this.formatData(i)), console[t](`${u.timestamp} ${u.level} [${l}] ${r}`, s || i ? JSON.stringify({ data: s, error: i }) : "");
+    } else {
+      const u = A[t], a = this.formatTimestamp(), d = "\x1B[0m", I = "\x1B[2m", g = u.nodeColor || "", k = `${I}${a}${d} ${g}${t.toUpperCase()} (${l}):${d} ${r}`;
+      console[t](k), s !== void 0 && console.log(JSON.stringify(this.formatData(s), null, 2)), i && (i instanceof Error ? (console.error(`\x1B[31mError:${d}`, i.message), i.stack && console.error(`\x1B[90m${i.stack}${d}`)) : console.error("Error:", i));
+    }
+  }
+  log(e) {
+    m ? this.logToBrowser(e) : B && this.logToNode(e);
+  }
+  error(e, t) {
+    this.log({ level: "error", description: e, data: t, context: this.context });
+  }
+  warn(e, t) {
+    this.log({ level: "warn", description: e, data: t, context: this.context });
+  }
+  info(e, t) {
+    this.log({ level: "info", description: e, data: t, context: this.context });
+  }
+  debug(e, t) {
+    this.log({ level: "debug", description: e, data: t, context: this.context });
+  }
+  trace(e, t) {
+    this.log({ level: "trace", description: e, data: t, context: this.context });
+  }
+  isEnabled() {
+    return m ? this.enabledInBrowser : !0;
+  }
+  setLevel(e) {
+    this.settings.minLevel = e;
+  }
+  createContextLogger(e) {
+    const t = new y(this.settings, e);
+    return {
+      error: /* @__PURE__ */ c((r, o) => t.error(r, o), "error"),
+      warn: /* @__PURE__ */ c((r, o) => t.warn(r, o), "warn"),
+      info: /* @__PURE__ */ c((r, o) => t.info(r, o), "info"),
+      debug: /* @__PURE__ */ c((r, o) => t.debug(r, o), "debug"),
+      trace: /* @__PURE__ */ c((r, o) => t.trace(r, o), "trace"),
+      isEnabled: /* @__PURE__ */ c(() => t.isEnabled(), "isEnabled"),
+      setLevel: /* @__PURE__ */ c((r) => t.setLevel(r), "setLevel")
+    };
+  }
+};
+c(y, "Logger"), n(y, "hasShownHelp", !1);
+let P = y;
+function re(h) {
+  return new P({}, h).createContextLogger(h);
+}
+c(re, "createLogger");
+const p = new P();
+p.error.bind(p);
+p.warn.bind(p);
+p.info.bind(p);
+p.debug.bind(p);
+p.trace.bind(p);
+const K = class K {
+  constructor(e, t) {
+    n(this, "name");
+    n(this, "settings");
+    n(this, "logger");
+    this.name = e, this.settings = t, this.logger = re(e);
+  }
+};
+c(K, "SettingsObject");
+let O = K;
+const z = class z {
+  constructor() {
+    // Configuration properties
+    n(this, "tokenName", "auth-token");
+    n(this, "tokenMaxAge", 3600 * 24 * 7);
+    // 7 days
+    n(this, "fallbackStorageKey", "token");
+    // For localStorage migration
+    n(this, "productionDomain", ".pagelines.com");
+  }
+  /**
+   * Get cookie value by name
+   */
+  getCookie(e) {
+    if (typeof document > "u")
+      return null;
+    const t = document.cookie.split(";");
+    for (const r of t) {
+      const [o, s] = r.trim().split("=");
+      if (o === e)
+        return decodeURIComponent(s || "");
+    }
+    return null;
+  }
+  /**
+   * Set cookie with secure defaults
+   */
+  setCookie(e, t, r = {}) {
+    if (typeof document > "u")
+      return;
+    const {
+      secure: o = !0,
+      sameSite: s = "lax",
+      maxAge: i = 3600 * 24 * 7,
+      // 7 days default
+      domain: l,
+      path: u = "/"
+    } = r;
+    let a = `${e}=${encodeURIComponent(t)}`;
+    a += `; Path=${u}`, a += `; Max-Age=${i}`, a += `; SameSite=${s}`, o && (a += "; Secure"), l && (a += `; Domain=${l}`), document.cookie = a;
+  }
+  /**
+   * Remove cookie by setting expired date
+   */
+  removeCookie(e, t = {}) {
+    this.setCookie(e, "", { ...t, maxAge: 0 });
+  }
+  /**
+   * Check if localStorage is fully functional (some test environments provide partial mocks)
+   */
+  isLocalStorageFunctional() {
+    return typeof window < "u" && typeof window.localStorage?.getItem == "function" && typeof window.localStorage?.setItem == "function" && typeof window.localStorage?.removeItem == "function";
+  }
+  /**
+   * Get auth token with fallback to localStorage for migration
+   */
+  getAuthToken() {
+    const e = this.getCookie(this.tokenName);
+    if (e)
+      return e;
+    if (this.isLocalStorageFunctional()) {
+      const t = window.localStorage.getItem(this.fallbackStorageKey);
+      if (t)
+        return this.setAuthToken(t), window.localStorage.removeItem(this.fallbackStorageKey), t;
+    }
+    return null;
+  }
+  /**
+   * Set auth token in cookie with production-ready settings
+   */
+  setAuthToken(e) {
+    const t = typeof window < "u" && window.location.hostname !== "localhost";
+    this.setCookie(this.tokenName, e, {
+      secure: t,
+      sameSite: "lax",
+      maxAge: this.tokenMaxAge,
+      domain: t ? this.productionDomain : void 0,
+      path: "/"
+    });
+  }
+  /**
+   * Remove auth token
+   */
+  removeAuthToken() {
+    const e = typeof window < "u" && window.location.hostname !== "localhost";
+    this.removeCookie(this.tokenName, {
+      domain: e ? this.productionDomain : void 0,
+      path: "/"
+    }), this.isLocalStorageFunctional() && window.localStorage.removeItem(this.fallbackStorageKey);
+  }
+};
+c(z, "CookieUtil");
+let M = z;
+const C = new M();
+function ce(h, e) {
+  const t = h.apiBase || (h.isDev ? `http://localhost:${F}` : D);
+  return ie(t, {
+    fetch: /* @__PURE__ */ c(async (o, s) => {
+      const i = C.getAuthToken(), l = await fetch(o, {
+        ...s,
+        headers: {
+          ...s?.headers,
+          "Content-Type": "application/json",
+          // Only include Authorization header if token exists
+          ...i && { Authorization: `Bearer ${i}` }
+        },
+        // Use 'omit' for Bearer tokens (not cookies) to allow CORS wildcard origin
+        credentials: "omit"
+      });
+      if (e) {
+        const u = l.json.bind(l);
+        l.json = async () => {
+          const a = await u();
+          return typeof a == "object" && a !== null && "ok" in a && ("user" in a || "token" in a) && e(a), a;
+        };
+      }
+      return l;
+    }, "fetch")
+  });
+}
+c(ce, "createApiClient");
+let le = /* @__PURE__ */ Symbol("clean"), f = [], w = 0;
+const $ = 4, oe = /* @__PURE__ */ c(/* @__NO_SIDE_EFFECTS__ */ (h) => {
+  let e = [], t = {
+    get() {
+      return t.lc || t.listen(() => {
+      })(), t.value;
+    },
+    lc: 0,
+    listen(r) {
+      return t.lc = e.push(r), () => {
+        for (let s = w + $; s < f.length; )
+          f[s] === r ? f.splice(s, $) : s += $;
+        let o = e.indexOf(r);
+        ~o && (e.splice(o, 1), --t.lc || t.off());
+      };
+    },
+    notify(r, o) {
+      let s = !f.length;
+      for (let i of e)
+        f.push(i, t.value, r, o);
+      if (s) {
+        for (w = 0; w < f.length; w += $)
+          f[w](
+            f[w + 1],
+            f[w + 2],
+            f[w + 3]
+          );
+        f.length = 0;
+      }
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    off() {
+    },
+    set(r) {
+      let o = t.value;
+      o !== r && (t.value = r, t.notify(o));
+    },
+    subscribe(r) {
+      let o = t.listen(r);
+      return r(t.value), o;
+    },
+    value: h
+  };
+  return process.env.NODE_ENV !== "production" && (t[le] = () => {
+    e = [], t.lc = 0, t.off();
+  }), t;
+}, "atom"), L = /* @__PURE__ */ oe(void 0), U = /* @__PURE__ */ oe(null), J = class J {
+  constructor() {
+    n(this, "logger", re("SDKStorage"));
+  }
+  /**
+   * Check if localStorage is fully functional (some test environments provide partial mocks)
+   */
+  isLocalStorageFunctional() {
+    return typeof window < "u" && typeof localStorage?.getItem == "function" && typeof localStorage?.setItem == "function" && typeof localStorage?.removeItem == "function";
+  }
+  /**
+   * Sync Vue reactive refs with global nanostores for cross-page persistence
+   */
+  syncWithGlobalStores(e, t) {
+    const r = L.get(), o = U.get();
+    r && (e.value = r), o && (t.value = o), Z(e, (s) => {
+      L.set(s);
+    }, { immediate: !0 }), Z(t, (s) => {
+      U.set(s);
+    }, { immediate: !0 }), L.subscribe((s) => {
+      s !== e.value && (e.value = s);
+    }), U.subscribe((s) => {
+      s !== t.value && (t.value = s);
+    });
+  }
+  /**
+   * Load user and token from browser storage on initialization
+   */
+  loadFromStorage(e, t) {
+    if (typeof window > "u")
+      return;
+    const r = C.getAuthToken();
+    if (r && (t.value = r), this.isLocalStorageFunctional())
+      try {
+        const o = localStorage.getItem("pagelines-user");
+        o && (e.value = JSON.parse(o));
+      } catch (o) {
+        this.logger.error("Failed to load user from localStorage", { data: o });
+      }
+  }
+  /**
+   * Save current user and token to browser storage
+   */
+  saveToStorage(e, t) {
+    if (!(typeof window > "u") && (t.value ? C.setAuthToken(t.value) : C.removeAuthToken(), this.isLocalStorageFunctional()))
+      try {
+        e.value ? localStorage.setItem("pagelines-user", JSON.stringify(e.value)) : localStorage.removeItem("pagelines-user");
+      } catch (r) {
+        this.logger.error("Failed to save user to localStorage", { data: r });
+      }
+  }
+  /**
+   * Clear all stored user data and tokens
+   */
+  clearStorage() {
+    if (!(typeof window > "u")) {
+      if (C.removeAuthToken(), this.isLocalStorageFunctional())
+        try {
+          localStorage.removeItem("pagelines-user");
+        } catch (e) {
+          this.logger.error("Failed to clear user from localStorage", { data: e });
+        }
+      L.set(void 0), U.set(null);
+    }
+  }
+  /**
+   * Generic localStorage getter
+   */
+  getItem(e) {
+    if (!this.isLocalStorageFunctional())
+      return null;
+    try {
+      return localStorage.getItem(e);
+    } catch (t) {
+      return this.logger.error("Failed to get item from localStorage", { key: e, error: t }), null;
+    }
+  }
+  /**
+   * Generic localStorage setter
+   */
+  setItem(e, t) {
+    if (this.isLocalStorageFunctional())
+      try {
+        localStorage.setItem(e, t);
+      } catch (r) {
+        this.logger.error("Failed to set item in localStorage", { key: e, error: r });
+      }
+  }
+};
+c(J, "SDKStorage");
+let G = J;
+const V = class V {
+  constructor(e) {
+    this.ctx = e;
+  }
+  async sendCode(e) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const r = await (await this.ctx.api.auth["check-email"].$post({
+        json: { email: e }
+      })).json();
+      if (!r.ok)
+        throw this.ctx.error.value = r.error, new Error(r.error);
+    } catch (t) {
+      this.ctx.logger.error("Send code error", { data: t });
+      const r = t instanceof Error ? t.message : "Failed to send verification code";
+      throw this.ctx.error.value = r, t;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async verifyCode(e, t) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const o = await (await this.ctx.api.auth["verify-code"].$post({
+        json: { email: e, code: t }
+      })).json();
+      if (!o.ok)
+        throw this.ctx.error.value = o.error, new Error(o.error);
+    } catch (r) {
+      this.ctx.logger.error("Verify code error", { data: r });
+      const o = r instanceof Error ? r.message : "Failed to verify code";
+      throw this.ctx.error.value = o, r;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async login(e, t) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const o = await (await this.ctx.api.auth.login.$post({
+        json: { email: e, password: t }
+      })).json();
+      if (!o.ok)
+        throw this.ctx.error.value = o.error, new Error(o.error);
+    } catch (r) {
+      this.ctx.logger.error("Login error", { data: r });
+      const o = r instanceof Error ? r.message : "Login failed";
+      throw this.ctx.error.value = o, r;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async logout() {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      await this.ctx.api.auth.logout.$post(), this.ctx.activeUser.value = void 0, this.ctx.token.value = null, this.ctx.storage.clearStorage();
+    } catch (e) {
+      this.ctx.logger.error("Logout error (user still logged out locally)", { data: e }), this.ctx.activeUser.value = void 0, this.ctx.token.value = null, this.ctx.storage.clearStorage();
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async getCurrentUser() {
+    if (this.ctx.token.value) {
+      this.ctx.loading.value = !0;
+      try {
+        const t = await (await this.ctx.api.auth.me.$get()).json();
+        if (!t.ok) {
+          this.ctx.error.value = t.error, t.error.includes("Authentication") && (this.ctx.activeUser.value = void 0, this.ctx.token.value = null, this.ctx.storage.clearStorage());
+          return;
+        }
+        return t.user;
+      } catch (e) {
+        this.ctx.logger.error("Get current user error", { data: e }), this.ctx.error.value = e instanceof Error ? e.message : "Failed to get user info";
+        return;
+      } finally {
+        this.ctx.loading.value = !1;
+      }
+    }
+  }
+  async requestAuthCode(e) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const r = await (await this.ctx.api.auth["check-email"].$post({
+        json: { email: e.email }
+      })).json();
+      return r.ok ? (this.ctx.logger.info("Auth code requested successfully", { email: e.email }), !0) : (this.ctx.error.value = r.error, this.ctx.logger.error("Failed to request auth code", { email: e.email, error: r.error }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Request auth code error", { email: e.email, error: t }), this.ctx.error.value = t instanceof Error ? t.message : "Failed to request auth code", !1;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async loginWithCode(e) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const r = await (await this.ctx.api.auth["verify-code"].$post({
+        json: { email: e.email, code: e.code }
+      })).json();
+      return this.ctx.logger.info("Login with code response", {
+        hasUser: !!r.user,
+        hasToken: !!r.token,
+        ok: r.ok
+      }), r.ok ? (this.ctx.logger.info("Login successful", { email: e.email }), e.orgId && e.autoCreateContact !== !1 && this.ctx.activeUser.value?.userId && await this.autoCreateContact({
+        userId: this.ctx.activeUser.value.userId,
+        orgId: e.orgId
+      }), !0) : (this.ctx.error.value = r.error, this.ctx.logger.error("Login failed", { email: e.email, error: r.error }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Login with code error", { email: e.email, error: t }), this.ctx.error.value = t instanceof Error ? t.message : "Login failed", !1;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async autoCreateContact(e) {
+    try {
+      const r = await (await this.ctx.api.contact.resolve.$post({
+        json: { userId: e.userId, orgId: e.orgId }
+      })).json();
+      return r.ok ? (this.ctx.logger.info("Contact resolved", { userId: e.userId, orgId: e.orgId }), !0) : (this.ctx.logger.error("Failed to auto-create contact", { error: r.error, args: e }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Auto-create contact error", { error: t, args: e }), !1;
+    }
+  }
+  loginWithGoogle(e) {
+    if (typeof window > "u") {
+      this.ctx.logger.error("loginWithGoogle: Only available in browser");
+      return;
+    }
+    const t = this.ctx.apiBase || (this.ctx.isDev ? `http://localhost:${F}` : D), r = window.location.origin, o = `${t}/auth/google-popup?origin=${encodeURIComponent(r)}`, s = 500, i = 600, l = window.screenX + (window.outerWidth - s) / 2, u = window.screenY + (window.outerHeight - i) / 2, a = window.open(
+      o,
+      "google-auth",
+      `width=${s},height=${i},left=${l},top=${u},popup=yes`
+    );
+    if (!a) {
+      const g = "Popup was blocked. Please allow popups for this site.";
+      this.ctx.error.value = g, e?.onError?.(g);
+      return;
+    }
+    const d = /* @__PURE__ */ c((g) => {
+      const k = new URL(t).origin;
+      if (g.origin === k) {
+        if (g.data?.type === "auth-success") {
+          window.removeEventListener("message", d);
+          const { token: v, user: b } = g.data;
+          this.ctx.processApiResponse({ ok: !0, data: {}, token: v, user: b }), this.ctx.logger.info("Google login successful"), e?.onSuccess?.(b);
+        } else if (g.data?.type === "auth-error") {
+          window.removeEventListener("message", d);
+          const v = g.data.error || "Google authentication failed";
+          this.ctx.error.value = v, this.ctx.logger.error("Google login failed", { error: v }), e?.onError?.(v);
+        }
+      }
+    }, "handler");
+    window.addEventListener("message", d);
+    const I = setInterval(() => {
+      a.closed && (clearInterval(I), window.removeEventListener("message", d));
+    }, 500);
+  }
+};
+c(V, "AuthClient");
+let R = V;
+const H = class H {
+  constructor(e) {
+    this.ctx = e;
+  }
+  async chatStream(e) {
+    const r = `${this.ctx.apiBase || (this.ctx.isDev ? `http://localhost:${F}` : D)}/api/agent/public/${encodeURIComponent(e.handle)}/chat/stream`;
+    try {
+      const o = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: e.message,
+          conversationId: e.conversationId,
+          history: e.history,
+          visitorId: e.visitorId
+        })
+      });
+      if (!o.ok) {
+        const a = await o.json().catch(() => ({ error: "Request failed" }));
+        e.onError(a.error || `HTTP ${o.status}`);
+        return;
+      }
+      const s = o.body?.getReader();
+      if (!s) {
+        e.onError("No response stream");
+        return;
+      }
+      const i = new TextDecoder();
+      let l = "", u = e.conversationId || "";
+      for (; ; ) {
+        const { done: a, value: d } = await s.read();
+        if (a)
+          break;
+        l += i.decode(d, { stream: !0 });
+        const I = l.split(`
+`);
+        l = I.pop() || "";
+        for (const g of I) {
+          if (!g.startsWith("data: "))
+            continue;
+          const k = g.slice(6).trim();
+          if (k === "[DONE]") {
+            e.onDone(u);
+            return;
+          }
+          try {
+            const v = JSON.parse(k);
+            v.pl_metadata?.conversationId && (u = v.pl_metadata.conversationId);
+            const b = v.choices?.[0]?.delta;
+            b?.content && e.onDelta(b.content);
+          } catch {
+          }
+        }
+      }
+      e.onDone(u);
+    } catch (o) {
+      e.onError(o instanceof Error ? o.message : "Stream failed");
+    }
+  }
+  async chatMessage(e) {
+    const r = `${this.ctx.apiBase || (this.ctx.isDev ? `http://localhost:${F}` : D)}/api/agent/public/${encodeURIComponent(e.handle)}/chat`;
+    try {
+      const s = await (await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: e.message,
+          conversationId: e.conversationId,
+          visitorId: e.visitorId
+        })
+      })).json();
+      if (!s.ok || !s.data) {
+        this.ctx.logger.error("chatMessage failed", { error: !s.ok && "error" in s ? s.error : "Unknown" });
+        return;
+      }
+      return {
+        conversationId: s.data.conversationId,
+        content: s.data.message.content
+      };
+    } catch (o) {
+      this.ctx.logger.error("chatMessage error", { error: o });
+      return;
+    }
+  }
+  async saveMessage(e) {
+    try {
+      const r = await (await this.ctx.api.conversation.messages.$post({
+        json: {
+          sessionId: e.conversationId,
+          participantId: e.participantId,
+          content: e.content,
+          role: e.role
+        }
+      })).json();
+      return r.ok ? !0 : (this.ctx.logger.error("Failed to save message", { error: "error" in r ? r.error : "Unknown error", args: e }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Save message error", { error: t, args: e }), !1;
+    }
+  }
+};
+c(H, "ChatClient");
+let _ = H;
+const Q = class Q {
+  constructor(e) {
+    this.ctx = e;
+  }
+  async getPublicAgent(e) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const r = await (await this.ctx.api.agent.public[":handle"].$get({
+        param: { handle: e.handle }
+      })).json();
+      if (!r.ok) {
+        this.ctx.error.value = r.error, this.ctx.logger.error("Failed to fetch public agent", { handle: e.handle, error: r.error });
+        return;
+      }
+      return r.data;
+    } catch (t) {
+      this.ctx.logger.error("Get public agent error", { handle: e.handle, error: t }), this.ctx.error.value = t instanceof Error ? t.message : "Failed to fetch agent";
+      return;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async getAgentByEmail(e) {
+    this.ctx.loading.value = !0, this.ctx.error.value = null;
+    try {
+      const r = await (await this.ctx.api.agent["by-email"][":email"].$get({
+        param: { email: e.email }
+      })).json();
+      if (!r.ok) {
+        this.ctx.error.value = r.error, this.ctx.logger.error("Failed to fetch agent by email", { email: e.email, error: r.error });
+        return;
+      }
+      return r.data;
+    } catch (t) {
+      this.ctx.logger.error("Get agent by email error", { email: e.email, error: t }), this.ctx.error.value = t instanceof Error ? t.message : "Failed to fetch agent";
+      return;
+    } finally {
+      this.ctx.loading.value = !1;
+    }
+  }
+  async trackUsage(e) {
+    try {
+      const t = this.ctx.currentAgent.value;
+      if (!t?.orgId)
+        return this.ctx.logger.error("Cannot track usage: no current agent with orgId", { args: e }), !1;
+      const o = await (await this.ctx.api.usage.record.$post({
+        json: {
+          orgId: t.orgId,
+          agentId: e.agentId,
+          sessionId: this.ctx.sessionId,
+          // Auto-managed by SDK
+          type: e.type,
+          quantity: e.quantity,
+          // Track the participant if provided, otherwise use current user or anonymous
+          userId: e.participantId || this.ctx.activeUser.value?.userId || "anonymous"
+        }
+      })).json();
+      return o.ok ? !0 : (this.ctx.logger.error("Failed to track usage", { error: o.error, args: e }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Track usage error", { error: t, args: e }), !1;
+    }
+  }
+  async startConversation(e) {
+    try {
+      const t = this.ctx.currentAgent.value;
+      if (!t?.orgId) {
+        this.ctx.logger.error("Cannot start conversation: no current agent with orgId", { args: e });
+        return;
+      }
+      const o = await (await this.ctx.api.conversation.start.$post({
+        json: {
+          orgId: t.orgId,
+          agentId: e.agentId,
+          userId: e.userId || this.ctx.activeUser.value?.userId,
+          anonId: e.anonId,
+          channel: e.channel
+        }
+      })).json();
+      if (!o.ok || !o.data) {
+        const s = o.ok ? "No conversation data returned" : "error" in o ? o.error : "Unknown error";
+        this.ctx.logger.error("Failed to start conversation", { error: s, args: e });
+        return;
+      }
+      return this.ctx.logger.info("Conversation started", { conversationId: o.data.conversationId }), o.data;
+    } catch (t) {
+      this.ctx.logger.error("Start conversation error", { error: t, args: e });
+      return;
+    }
+  }
+  async autoCreateContact(e) {
+    try {
+      const r = await (await this.ctx.api.contact.resolve.$post({
+        json: { userId: e.userId, orgId: e.orgId }
+      })).json();
+      return r.ok ? (this.ctx.logger.info("Contact resolved", { userId: e.userId, orgId: e.orgId }), !0) : (this.ctx.logger.error("Failed to auto-create contact", { error: r.error, args: e }), !1);
+    } catch (t) {
+      return this.ctx.logger.error("Auto-create contact error", { error: t, args: e }), !1;
+    }
+  }
+  generateAnonId() {
+    const e = "pagelinesAnonId";
+    let t = this.ctx.storage.getItem(e);
+    return t || (t = N({ prefix: "anon" }), this.ctx.storage.setItem(e, t)), t;
+  }
+  track(e) {
+    try {
+      typeof window < "u" && window.parent !== window && window.parent.postMessage({
+        type: "pagelines_track",
+        event: e.event,
+        agentId: e.agentId,
+        properties: e.properties || {}
+      }, "*"), this.ctx.logger.info("SDK event tracked", { event: e.event, agentId: e.agentId });
+    } catch (t) {
+      this.ctx.logger.error("Track event error", { error: t, args: e });
+    }
+  }
+};
+c(Q, "UserClient");
+let q = Q;
+const Y = class Y {
+  constructor() {
+    n(this, "key", "__PAGELINES_SDK__");
+  }
+  get() {
+    if (!(typeof window > "u"))
+      return globalThis[this.key];
+  }
+  set(e) {
+    typeof window < "u" && (globalThis[this.key] = e);
+  }
+  delete() {
+    typeof window < "u" && delete globalThis[this.key];
+  }
+};
+c(Y, "SDKGlobal");
+let W = Y;
+const T = new W(), j = class j extends O {
+  constructor(t = {}) {
+    const r = T.get();
+    if (r)
+      return console.debug("[PageLinesSDK] Returning existing singleton instance"), r;
+    super("PageLinesSDK", t);
+    // Vue reactive state
+    n(this, "activeUser", E());
+    n(this, "token", E(null));
+    n(this, "loading", E(!1));
+    n(this, "error", E(null));
+    n(this, "apiBase", this.settings.apiBase || void 0);
+    // Storage handler for persistence
+    n(this, "storage", new G());
+    // Auto-managed session ID for usage tracking
+    n(this, "sessionId", N({ prefix: "ses" }));
+    // Typed Hono RPC client - uses SDKAppType (auth/self/usage routes only)
+    // Initialized in constructor (definite assignment via singleton pattern)
+    n(this, "apiClient");
+    // Computed properties derived from activeUser (matches UserClient pattern)
+    n(this, "currentAgent", ee(() => {
+      const t = this.activeUser.value;
+      if (!t?.agents)
+        return;
+      const r = t.primaryAgentId || t.agents[0]?.agentId;
+      if (r)
+        return t.agents.find((o) => o.agentId === r);
+    }));
+    n(this, "currentOrg", ee(() => {
+      const t = this.currentAgent.value;
+      if (!t?.orgId)
+        return;
+      const r = this.activeUser.value;
+      if (r?.orgs)
+        return r.orgs.find((o) => o.orgId === t.orgId);
+    }));
+    // Initialization state
+    n(this, "initialized");
+    n(this, "resolveUser");
+    // Sub-clients (new preferred API surface)
+    n(this, "auth");
+    n(this, "chat");
+    n(this, "user");
+    T.set(this), this.apiClient = ce(
+      { isDev: this.isDev, apiBase: this.apiBase },
+      this.processApiResponse.bind(this)
+    );
+    const o = {
+      api: this.api,
+      apiBase: this.apiBase,
+      isDev: this.isDev,
+      activeUser: this.activeUser,
+      token: this.token,
+      loading: this.loading,
+      error: this.error,
+      currentAgent: this.currentAgent,
+      storage: this.storage,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      processApiResponse: this.processApiResponse.bind(this)
+    };
+    this.auth = new R(o), this.chat = new _(o), this.user = new q(o), this.logger.info("PageLinesSDK initialized"), this.storage.loadFromStorage(this.activeUser, this.token), this.storage.syncWithGlobalStores(this.activeUser, this.token), this.initialized = new Promise((s) => {
+      this.resolveUser = s;
+    }), this.token.value && !this.activeUser.value ? this.getCurrentUser().then((s) => {
+      this.resolveUser && (this.resolveUser(s), this.resolveUser = void 0);
+    }).catch((s) => {
+      this.logger.error("Auto user fetch failed", { data: s }), this.resolveUser && (this.resolveUser(void 0), this.resolveUser = void 0);
+    }) : this.activeUser.value ? this.resolveUser?.(this.activeUser.value) : this.resolveUser?.(void 0);
+  }
+  /**
+   * Get singleton instance in browser (creates if doesn't exist)
+   * Node.js: Always creates new instance (no singleton)
+   * Recommended: Use this instead of constructor for shared state
+   */
+  static getInstance(t = {}) {
+    return T.get() || new j(t);
+  }
+  get isDev() {
+    return this.settings.isDev ?? (typeof window < "u" ? window.location.hostname === "localhost" || window.location.hostname.includes("127.0.0.1") : !1);
+  }
+  // Bypass stub typing for route access (production builds use SDKAppType stub)
+  // Runtime types are validated via Zod at API boundaries
+  get api() {
+    return this.apiClient.api;
+  }
+  // Process ApiResponse for automatic user/token updates - public for dependency injection
+  processApiResponse(t) {
+    t.ok && t.user && (this.activeUser.value = t.user, this.logger.info("User updated from API response", { data: t.user })), t.ok && t.token && (this.token.value = t.token, this.storage.saveToStorage(this.activeUser, this.token), this.logger.info("Token updated from API response")), this.resolveUser && t.ok && (this.resolveUser(t.user), this.resolveUser = void 0);
+  }
+  // Clear all user data and tokens
+  clearSession() {
+    this.logger.info("Clearing session"), this.activeUser.value = void 0, this.token.value = null, this.error.value = null, this.storage.clearStorage();
+  }
+  // Full reset - clears session + state + destroys singleton
+  clear() {
+    this.logger.info("Clearing SDK completely"), this.clearSession(), this.loading.value = !1, this.sessionId = N({ prefix: "ses" }), T.delete();
+  }
+  // Backward-compatible delegates -- these forward to sub-clients
+  // Can be removed in a future breaking change
+  async sendCode(t) {
+    return this.auth.sendCode(t);
+  }
+  async verifyCode(t, r) {
+    return this.auth.verifyCode(t, r);
+  }
+  async login(t, r) {
+    return this.auth.login(t, r);
+  }
+  async logout() {
+    return this.auth.logout();
+  }
+  async getCurrentUser() {
+    return this.auth.getCurrentUser();
+  }
+  async requestAuthCode(t) {
+    return this.auth.requestAuthCode(t);
+  }
+  async loginWithCode(t) {
+    return this.auth.loginWithCode(t);
+  }
+  loginWithGoogle(t) {
+    return this.auth.loginWithGoogle(t);
+  }
+  async chatStream(t) {
+    return this.chat.chatStream(t);
+  }
+  async chatMessage(t) {
+    return this.chat.chatMessage(t);
+  }
+  async saveMessage(t) {
+    return this.chat.saveMessage(t);
+  }
+  async getPublicAgent(t) {
+    return this.user.getPublicAgent(t);
+  }
+  async getAgentByEmail(t) {
+    return this.user.getAgentByEmail(t);
+  }
+  async trackUsage(t) {
+    return this.user.trackUsage(t);
+  }
+  async startConversation(t) {
+    return this.user.startConversation(t);
+  }
+  async autoCreateContact(t) {
+    return this.user.autoCreateContact(t);
+  }
+  generateAnonId() {
+    return this.user.generateAnonId();
+  }
+  track(t) {
+    return this.user.track(t);
+  }
+};
+c(j, "PageLinesSDK");
+let te = j;
+export {
+  R as A,
+  _ as C,
+  te as P,
+  O as S,
+  q as U,
+  re as c
+};
+//# sourceMappingURL=sdkClient-yg_rc4B7.js.map