@fiction/sdk 1.0.16 → 1.0.18

package/dist/sdkClient-C9BL_Op4.js

@@ -0,0 +1,731 @@
+var O = Object.defineProperty;
+var Q = (c, t, e) => t in c ? O(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
+var l = (c, t) => O(c, "name", { value: t, configurable: !0 });
+var n = (c, t, e) => Q(c, typeof t != "symbol" ? t + "" : t, e);
+import { objectId as M } from "@fiction/utils";
+import { watch as P, ref as k, computed as G } from "vue";
+import { hc as H } from "hono/client";
+const y = globalThis.process, g = typeof window < "u", x = typeof y < "u" && !g, m = g ? typeof window < "u" && window.location && !window.location.hostname.includes("localhost") : x && typeof y < "u" && y.env?.NODE_ENV === "production", Y = !m, S = {
+  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" }
+}, X = ["password", "token", "secret", "apikey", "api_key", "authorization", "cookie"], p = class p {
+  constructor(t = {}, e) {
+    n(this, "settings");
+    n(this, "enabledInBrowser", !1);
+    n(this, "context");
+    this.context = e, this.settings = {
+      enabled: t.enabled ?? !0,
+      minLevel: t.minLevel ?? this.getDefaultLevel(),
+      timestamps: t.timestamps ?? !0
+    }, g && this.initBrowserLogging();
+  }
+  getDefaultLevel() {
+    if (x && typeof y < "u" && y.env?.LOG_LEVEL)
+      return y.env.LOG_LEVEL;
+    if (g && typeof localStorage < "u") {
+      const t = localStorage.getItem("FICTION_LOG_LEVEL");
+      if (t)
+        return t;
+    }
+    return m ? "info" : "debug";
+  }
+  initBrowserLogging() {
+    if (!g)
+      return;
+    const e = localStorage.getItem("FICTION_LOG") === "true", r = window.location?.hostname || "";
+    this.enabledInBrowser = Y || e || r === "localhost" || r.includes("127.0.0.1"), m && !e && !p.hasShownHelp && (console.log(
+      "%cFiction WWW Logger (disabled in production)",
+      "color: #888; font-size: 12px"
+    ), console.log(
+      '%cTo enable: localStorage.setItem("FICTION_LOG", "true")',
+      "color: #888; font-size: 11px"
+    ), p.hasShownHelp = !0);
+  }
+  shouldLog(t) {
+    if (!this.settings.enabled || g && !this.enabledInBrowser)
+      return !1;
+    const e = S[t].priority, r = S[this.settings.minLevel].priority;
+    return e >= 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(t) {
+    if (typeof t != "object" || t === null)
+      return t;
+    if (Array.isArray(t))
+      return t.map((r) => this.redactSensitive(r));
+    const e = {};
+    for (const [r, o] of Object.entries(t)) {
+      const s = r.toLowerCase();
+      X.some((i) => s.includes(i)) ? e[r] = "[REDACTED]" : typeof o == "object" && o !== null ? e[r] = this.redactSensitive(o) : e[r] = o;
+    }
+    return e;
+  }
+  formatData(t, e = 3, r = 0) {
+    if (r >= e)
+      return "[Max Depth]";
+    if (t == null)
+      return t;
+    if (t instanceof Error)
+      return {
+        name: t.name,
+        message: t.message,
+        stack: m ? t.stack?.split(`
+`).slice(0, 3).join(`
+`) : t.stack,
+        ...t
+        // Include any additional error properties
+      };
+    if (t instanceof Date)
+      return t.toISOString();
+    if (typeof t != "object")
+      return t;
+    if (Array.isArray(t))
+      return t.length > 20 && m ? `Array(${t.length}) [${t.slice(0, 3).map((o) => this.formatData(o, e, r + 1)).join(", ")}, ...]` : t.map((o) => this.formatData(o, e, r + 1));
+    try {
+      const o = {}, s = Object.entries(t), i = m ? 50 : 200;
+      for (const [u, d] of s.slice(0, i))
+        o[u] = this.formatData(d, e, r + 1);
+      return s.length > i && (o["..."] = `${s.length - i} more properties`), this.redactSensitive(o);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+  logToBrowser(t) {
+    if (!g || !this.shouldLog(t.level))
+      return;
+    const { level: e, description: r, context: o, data: s, error: i } = t, u = S[e], a = `[${o || this.context || "www"}] ${e.toUpperCase()}:`, I = `color: ${u.color}; font-weight: bold;`;
+    s !== void 0 ? console[e](`%c${a}`, I, r, this.formatData(s)) : console[e](`%c${a}`, I, r), i && (i instanceof Error ? console.error(i) : console.error("Error details:", i));
+  }
+  async logToNode(t) {
+    if (!x || !this.shouldLog(t.level))
+      return;
+    const { level: e, description: r, context: o, data: s, error: i } = t, u = o || this.context || "www";
+    if (m) {
+      const d = {
+        timestamp: this.formatISOTimestamp(),
+        level: e.toUpperCase()
+      };
+      s && (d.data = this.formatData(s)), i && (d.error = this.formatData(i)), console[e](`${d.timestamp} ${d.level} [${u}] ${r}`, s || i ? JSON.stringify({ data: s, error: i }) : "");
+    } else
+      try {
+        const a = (await import("./index-C-0XxdQQ.js").catch(() => null))?.default, I = S[e], N = this.formatTimestamp();
+        if (a) {
+          const K = a.dim, B = a.hex(I.color), V = K(`${N} `), J = B(`${e.toUpperCase()} `), W = B(`(${u}): `), _ = `${V}${J}${W}${r}`;
+          console[e](_), s !== void 0 && console.log(JSON.stringify(this.formatData(s), null, 2)), i && (i instanceof Error && a ? (console.error(a.red("Error:"), i.message), i.stack && console.error(a.gray(i.stack))) : console.error("Error:", i));
+        } else
+          console[e](`${N} ${e.toUpperCase()} (${u}): ${r}`), s !== void 0 && console.log(JSON.stringify(this.formatData(s), null, 2)), i && console.error("Error:", i);
+      } catch {
+        console[e](`${this.formatTimestamp()} ${e.toUpperCase()} (${u}): ${r}`), s !== void 0 && console.log(JSON.stringify(this.formatData(s), null, 2)), i && console.error("Error:", i);
+      }
+  }
+  log(t) {
+    g ? this.logToBrowser(t) : x && this.logToNode(t).catch(console.error);
+  }
+  error(t, e) {
+    this.log({ level: "error", description: t, data: e, context: this.context });
+  }
+  warn(t, e) {
+    this.log({ level: "warn", description: t, data: e, context: this.context });
+  }
+  info(t, e) {
+    this.log({ level: "info", description: t, data: e, context: this.context });
+  }
+  debug(t, e) {
+    this.log({ level: "debug", description: t, data: e, context: this.context });
+  }
+  trace(t, e) {
+    this.log({ level: "trace", description: t, data: e, context: this.context });
+  }
+  isEnabled() {
+    return g ? this.enabledInBrowser : !0;
+  }
+  setLevel(t) {
+    this.settings.minLevel = t;
+  }
+  createContextLogger(t) {
+    const e = new p(this.settings, t);
+    return {
+      error: /* @__PURE__ */ l((r, o) => e.error(r, o), "error"),
+      warn: /* @__PURE__ */ l((r, o) => e.warn(r, o), "warn"),
+      info: /* @__PURE__ */ l((r, o) => e.info(r, o), "info"),
+      debug: /* @__PURE__ */ l((r, o) => e.debug(r, o), "debug"),
+      trace: /* @__PURE__ */ l((r, o) => e.trace(r, o), "trace"),
+      isEnabled: /* @__PURE__ */ l(() => e.isEnabled(), "isEnabled"),
+      setLevel: /* @__PURE__ */ l((r) => e.setLevel(r), "setLevel")
+    };
+  }
+};
+l(p, "Logger"), n(p, "hasShownHelp", !1);
+let U = p;
+function q(c) {
+  return new U({}, c).createContextLogger(c);
+}
+l(q, "createLogger");
+const f = new U();
+f.error.bind(f);
+f.warn.bind(f);
+f.info.bind(f);
+f.debug.bind(f);
+f.trace.bind(f);
+const A = class A {
+  constructor(t, e) {
+    n(this, "name");
+    n(this, "settings");
+    n(this, "logger");
+    this.name = t, this.settings = e, this.logger = q(t);
+  }
+};
+l(A, "SettingsObject");
+let E = A;
+const F = class F {
+  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", ".fiction.com");
+  }
+  /**
+   * Get cookie value by name
+   */
+  getCookie(t) {
+    if (typeof document > "u")
+      return null;
+    const e = document.cookie.split(";");
+    for (const r of e) {
+      const [o, s] = r.trim().split("=");
+      if (o === t)
+        return decodeURIComponent(s || "");
+    }
+    return null;
+  }
+  /**
+   * Set cookie with secure defaults
+   */
+  setCookie(t, e, r = {}) {
+    if (typeof document > "u")
+      return;
+    const {
+      secure: o = !0,
+      sameSite: s = "lax",
+      maxAge: i = 3600 * 24 * 7,
+      // 7 days default
+      domain: u,
+      path: d = "/"
+    } = r;
+    let a = `${t}=${encodeURIComponent(e)}`;
+    a += `; Path=${d}`, a += `; Max-Age=${i}`, a += `; SameSite=${s}`, o && (a += "; Secure"), u && (a += `; Domain=${u}`), document.cookie = a;
+  }
+  /**
+   * Remove cookie by setting expired date
+   */
+  removeCookie(t, e = {}) {
+    this.setCookie(t, "", { ...e, maxAge: 0 });
+  }
+  /**
+   * Get auth token with fallback to localStorage for migration
+   */
+  getAuthToken() {
+    const t = this.getCookie(this.tokenName);
+    if (t)
+      return t;
+    if (typeof localStorage < "u") {
+      const e = localStorage.getItem(this.fallbackStorageKey);
+      if (e)
+        return this.setAuthToken(e), localStorage.removeItem(this.fallbackStorageKey), e;
+    }
+    return null;
+  }
+  /**
+   * Set auth token in cookie with production-ready settings
+   */
+  setAuthToken(t) {
+    const e = typeof window < "u" && window.location.hostname !== "localhost";
+    this.setCookie(this.tokenName, t, {
+      secure: e,
+      sameSite: "lax",
+      maxAge: this.tokenMaxAge,
+      domain: e ? this.productionDomain : void 0,
+      path: "/"
+    });
+  }
+  /**
+   * Remove auth token
+   */
+  removeAuthToken() {
+    const t = typeof window < "u" && window.location.hostname !== "localhost";
+    this.removeCookie(this.tokenName, {
+      domain: t ? this.productionDomain : void 0,
+      path: "/"
+    }), typeof localStorage < "u" && localStorage.removeItem(this.fallbackStorageKey);
+  }
+};
+l(F, "CookieUtil");
+let L = F;
+const w = new L();
+function Z(c, t) {
+  const e = c.apiBase || (c.isDev ? "http://localhost:5555" : "https://app.fiction.com");
+  return H(e, {
+    fetch: /* @__PURE__ */ l(async (o, s) => {
+      const i = await fetch(o, {
+        ...s,
+        credentials: "include",
+        headers: {
+          ...s?.headers,
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${w.getAuthToken() || ""}`
+        }
+      });
+      if (t) {
+        const u = i.json.bind(i), d = i.clone();
+        return Object.defineProperty(d, "json", {
+          value: /* @__PURE__ */ l(async () => {
+            const a = await u();
+            return typeof a == "object" && a !== null && "ok" in a && ("user" in a || "token" in a) && t(a), a;
+          }, "value")
+        }), d;
+      }
+      return i;
+    }, "fetch")
+  });
+}
+l(Z, "createApiClient");
+let ee = Symbol("clean"), h = [], v = 0;
+const b = 4;
+let z = /* @__PURE__ */ l((c) => {
+  let t = [], e = {
+    get() {
+      return e.lc || e.listen(() => {
+      })(), e.value;
+    },
+    lc: 0,
+    listen(r) {
+      return e.lc = t.push(r), () => {
+        for (let s = v + b; s < h.length; )
+          h[s] === r ? h.splice(s, b) : s += b;
+        let o = t.indexOf(r);
+        ~o && (t.splice(o, 1), --e.lc || e.off());
+      };
+    },
+    notify(r, o) {
+      let s = !h.length;
+      for (let i of t)
+        h.push(i, e.value, r, o);
+      if (s) {
+        for (v = 0; v < h.length; v += b)
+          h[v](
+            h[v + 1],
+            h[v + 2],
+            h[v + 3]
+          );
+        h.length = 0;
+      }
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    off() {
+    },
+    set(r) {
+      let o = e.value;
+      o !== r && (e.value = r, e.notify(o));
+    },
+    subscribe(r) {
+      let o = e.listen(r);
+      return r(e.value), o;
+    },
+    value: c
+  };
+  return process.env.NODE_ENV !== "production" && (e[ee] = () => {
+    t = [], e.lc = 0, e.off();
+  }), e;
+}, "atom");
+const C = z(void 0), $ = z(null), j = class j {
+  constructor() {
+    n(this, "logger", q("SDKStorage"));
+  }
+  /**
+   * Sync Vue reactive refs with global nanostores for cross-page persistence
+   */
+  syncWithGlobalStores(t, e) {
+    const r = C.get(), o = $.get();
+    r && (t.value = r), o && (e.value = o), P(t, (s) => {
+      C.set(s);
+    }, { immediate: !0 }), P(e, (s) => {
+      $.set(s);
+    }, { immediate: !0 }), C.subscribe((s) => {
+      s !== t.value && (t.value = s);
+    }), $.subscribe((s) => {
+      s !== e.value && (e.value = s);
+    });
+  }
+  /**
+   * Load user and token from browser storage on initialization
+   */
+  loadFromStorage(t, e) {
+    if (typeof window > "u")
+      return;
+    const r = w.getAuthToken();
+    r && (e.value = r);
+    try {
+      const o = localStorage.getItem("fiction-user");
+      o && (t.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(t, e) {
+    if (!(typeof window > "u")) {
+      e.value ? w.setAuthToken(e.value) : w.removeAuthToken();
+      try {
+        t.value ? localStorage.setItem("fiction-user", JSON.stringify(t.value)) : localStorage.removeItem("fiction-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")) {
+      w.removeAuthToken();
+      try {
+        localStorage.removeItem("fiction-user");
+      } catch (t) {
+        this.logger.error("Failed to clear user from localStorage", { data: t });
+      }
+      C.set(void 0), $.set(null);
+    }
+  }
+  /**
+   * Generic localStorage getter
+   */
+  getItem(t) {
+    if (typeof window > "u")
+      return null;
+    try {
+      return localStorage.getItem(t);
+    } catch (e) {
+      return this.logger.error("Failed to get item from localStorage", { key: t, error: e }), null;
+    }
+  }
+  /**
+   * Generic localStorage setter
+   */
+  setItem(t, e) {
+    if (!(typeof window > "u"))
+      try {
+        localStorage.setItem(t, e);
+      } catch (r) {
+        this.logger.error("Failed to set item in localStorage", { key: t, error: r });
+      }
+  }
+};
+l(j, "SDKStorage");
+let T = j;
+const D = class D extends E {
+  constructor(e = {}) {
+    super("FictionSDK", e);
+    // Vue reactive state
+    n(this, "activeUser", k());
+    n(this, "token", k(null));
+    n(this, "loading", k(!1));
+    n(this, "error", k(null));
+    n(this, "apiBase", this.settings.apiBase || void 0);
+    // Storage handler for persistence
+    n(this, "storage", new T());
+    // Auto-managed session ID for usage tracking
+    n(this, "sessionId", M({ prefix: "ses" }));
+    // Typed Hono RPC client - uses SDKAppType (auth/self/usage routes only)
+    n(this, "apiClient");
+    // Computed properties derived from activeUser (matches UserClient pattern)
+    n(this, "currentSelf", G(() => {
+      const e = this.activeUser.value;
+      if (!e?.selves)
+        return;
+      const r = e.primarySelfId || e.selves[0]?.selfId;
+      if (r)
+        return e.selves.find((o) => o.selfId === r);
+    }));
+    n(this, "currentOrg", G(() => {
+      const e = this.currentSelf.value;
+      if (!e?.orgId)
+        return;
+      const r = this.activeUser.value;
+      if (r?.orgs)
+        return r.orgs.find((o) => o.orgId === e.orgId);
+    }));
+    // Initialization state
+    n(this, "initialized");
+    n(this, "resolveUser");
+    this.apiClient = Z(
+      { isDev: this.isDev, apiBase: this.apiBase },
+      this.processApiResponse.bind(this)
+    ), this.logger.info("FictionSDK initialized"), this.storage.loadFromStorage(this.activeUser, this.token), this.storage.syncWithGlobalStores(this.activeUser, this.token), this.initialized = new Promise((r) => {
+      this.resolveUser = r;
+    }), this.token.value && !this.activeUser.value ? this.getCurrentUser().then((r) => {
+      this.resolveUser && (this.resolveUser(r), this.resolveUser = void 0);
+    }).catch((r) => {
+      this.logger.error("Auto user fetch failed", { data: r }), this.resolveUser && (this.resolveUser(void 0), this.resolveUser = void 0);
+    }) : this.activeUser.value ? this.resolveUser?.(this.activeUser.value) : this.resolveUser?.(void 0);
+  }
+  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(e) {
+    e.ok && e.user && (this.activeUser.value = e.user, this.logger.info("User updated from API response", { data: e.user })), e.ok && e.token && (this.token.value = e.token, this.storage.saveToStorage(this.activeUser, this.token), this.logger.info("Token updated from API response")), this.resolveUser && e.ok && (this.resolveUser(e.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();
+  }
+  // Convenience methods for common auth operations
+  async sendCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const o = await (await this.api.auth["check-email"].$post({
+        json: { email: e }
+      })).json();
+      if (!o.ok)
+        throw this.error.value = o.error, new Error(o.error);
+    } catch (r) {
+      this.logger.error("Send code error", { data: r });
+      const o = r instanceof Error ? r.message : "Failed to send verification code";
+      throw this.error.value = o, r;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async verifyCode(e, r) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const s = await (await this.api.auth["verify-code"].$post({
+        json: { email: e, code: r }
+      })).json();
+      if (!s.ok)
+        throw this.error.value = s.error, new Error(s.error);
+    } catch (o) {
+      this.logger.error("Verify code error", { data: o });
+      const s = o instanceof Error ? o.message : "Failed to verify code";
+      throw this.error.value = s, o;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async login(e, r) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const s = await (await this.api.auth.login.$post({
+        json: { email: e, password: r }
+      })).json();
+      if (!s.ok)
+        throw this.error.value = s.error, new Error(s.error);
+    } catch (o) {
+      this.logger.error("Login error", { data: o });
+      const s = o instanceof Error ? o.message : "Login failed";
+      throw this.error.value = s, o;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async logout() {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      await this.api.auth.logout.$post(), this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage();
+    } catch (e) {
+      this.logger.error("Logout error (user still logged out locally)", { data: e }), this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage();
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async getCurrentUser() {
+    if (this.token.value) {
+      this.loading.value = !0;
+      try {
+        const r = await (await this.api.auth.me.$get()).json();
+        if (!r.ok) {
+          this.error.value = r.error, r.error.includes("Authentication") && (this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage());
+          return;
+        }
+        return r.user;
+      } catch (e) {
+        this.logger.error("Get current user error", { data: e }), this.error.value = e instanceof Error ? e.message : "Failed to get user info";
+        return;
+      } finally {
+        this.loading.value = !1;
+      }
+    }
+  }
+  async getPublicSelf(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const o = await (await this.api.self.public[":handle"].$get({
+        param: { handle: e.handle }
+      })).json();
+      if (!o.ok) {
+        this.error.value = o.error, this.logger.error("Failed to fetch public self", { handle: e.handle, error: o.error });
+        return;
+      }
+      return o.data;
+    } catch (r) {
+      this.logger.error("Get public self error", { handle: e.handle, error: r }), this.error.value = r instanceof Error ? r.message : "Failed to fetch self";
+      return;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async requestAuthCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const o = await (await this.api.auth["check-email"].$post({
+        json: { email: e.email }
+      })).json();
+      return o.ok ? (this.logger.info("Auth code requested successfully", { email: e.email }), !0) : (this.error.value = o.error, this.logger.error("Failed to request auth code", { email: e.email, error: o.error }), !1);
+    } catch (r) {
+      return this.logger.error("Request auth code error", { email: e.email, error: r }), this.error.value = r instanceof Error ? r.message : "Failed to request auth code", !1;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async loginWithCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const o = await (await this.api.auth["verify-code"].$post({
+        json: { email: e.email, code: e.code }
+      })).json();
+      return o.ok ? (this.logger.info("Login successful", { email: e.email }), e.orgId && e.autoCreateContact !== !1 && this.activeUser.value?.userId && await this.autoCreateContact({
+        userId: this.activeUser.value.userId,
+        orgId: e.orgId
+      }), !0) : (this.error.value = o.error, this.logger.error("Login failed", { email: e.email, error: o.error }), !1);
+    } catch (r) {
+      return this.logger.error("Login with code error", { email: e.email, error: r }), this.error.value = r instanceof Error ? r.message : "Login failed", !1;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async trackUsage(e) {
+    try {
+      const r = this.currentSelf.value;
+      if (!r?.orgId)
+        return this.logger.error("Cannot track usage: no current self with orgId", { args: e }), !1;
+      const s = await (await this.api.usage.record.$post({
+        json: {
+          orgId: r.orgId,
+          selfId: e.selfId,
+          sessionId: this.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.activeUser.value?.userId || "anonymous"
+        }
+      })).json();
+      return s.ok ? !0 : (this.logger.error("Failed to track usage", { error: s.error, args: e }), !1);
+    } catch (r) {
+      return this.logger.error("Track usage error", { error: r, args: e }), !1;
+    }
+  }
+  /**
+   * Auto-create contact on authentication
+   * Called internally by loginWithCode - can be disabled with autoCreateContact: false
+   */
+  async autoCreateContact(e) {
+    try {
+      const o = await (await this.api.contact.resolve.$post({
+        json: { userId: e.userId, orgId: e.orgId }
+      })).json();
+      return o.ok ? (this.logger.info("Contact resolved", { userId: e.userId, orgId: e.orgId }), !0) : (this.logger.error("Failed to auto-create contact", { error: o.error, args: e }), !1);
+    } catch (r) {
+      return this.logger.error("Auto-create contact error", { error: r, args: e }), !1;
+    }
+  }
+  /**
+   * Start conversation session (auto-creates conversation if needed)
+   * Returns conversation data for tracking messages
+   */
+  async startConversation(e) {
+    try {
+      const r = this.currentSelf.value;
+      if (!r?.orgId) {
+        this.logger.error("Cannot start conversation: no current self with orgId", { args: e });
+        return;
+      }
+      const s = await (await this.api.conversation.start.$post({
+        json: {
+          orgId: r.orgId,
+          selfId: e.selfId,
+          userId: e.userId || this.activeUser.value?.userId,
+          anonId: e.anonId
+        }
+      })).json();
+      if (!s.ok || !s.data) {
+        const i = s.ok ? "No conversation data returned" : "error" in s ? s.error : "Unknown error";
+        this.logger.error("Failed to start conversation", { error: i, args: e });
+        return;
+      }
+      return this.logger.info("Conversation started", { conversationId: s.data.conversationId }), s.data;
+    } catch (r) {
+      this.logger.error("Start conversation error", { error: r, args: e });
+      return;
+    }
+  }
+  /**
+   * Generate anonymous ID for tracking unauthenticated users
+   * Stored in localStorage for persistence across sessions
+   */
+  generateAnonId() {
+    const e = "fictionAnonId";
+    let r = this.storage.getItem(e);
+    return r || (r = M({ prefix: "anon" }), this.storage.setItem(e, r)), r;
+  }
+  /**
+   * Save message to conversation
+   * Called by SelfController to persist messages
+   */
+  async saveMessage(e) {
+    try {
+      const o = await (await this.api.conversation.messages.$post({
+        json: {
+          sessionId: e.conversationId,
+          participantId: e.participantId,
+          content: e.content,
+          role: e.role
+        }
+      })).json();
+      return o.ok ? !0 : (this.logger.error("Failed to save message", { error: "error" in o ? o.error : "Unknown error", args: e }), !1);
+    } catch (r) {
+      return this.logger.error("Save message error", { error: r, args: e }), !1;
+    }
+  }
+};
+l(D, "FictionSDK");
+let R = D;
+export {
+  R as F,
+  E as S
+};
+//# sourceMappingURL=sdkClient-C9BL_Op4.js.map