@strands.gg/accui 2.18.1 → 2.19.1

package/dist/useStrandsAuth-D2HvStMt.es.js

@@ -0,0 +1,787 @@
+import { computed as u, ref as g, getCurrentInstance as Ae, onUnmounted as ke } from "vue";
+import { u as Ee } from "./useStrandsConfig-B8h5hDy7.es.js";
+const j = "strands_known_accounts";
+function U() {
+  if (typeof document > "u") return [];
+  try {
+    const n = document.cookie.split(";").map((p) => p.trim()).find((p) => p.startsWith(`${j}=`));
+    if (!n) return [];
+    const d = n.slice(j.length + 1), m = decodeURIComponent(d), h = JSON.parse(m);
+    return Array.isArray(h) ? h : [];
+  } catch {
+    return [];
+  }
+}
+const E = g(U());
+function xe() {
+  function n() {
+    E.value = U();
+  }
+  const d = u(
+    () => E.value.find((s) => s.active) ?? null
+  ), m = u(
+    () => E.value.filter((s) => !s.active)
+  ), h = u(() => E.value.length > 1), p = u(() => E.value.length > 0);
+  return {
+    accounts: E,
+    activeAccount: d,
+    otherAccounts: m,
+    hasMultipleAccounts: h,
+    hasKnownAccounts: p,
+    refreshFromCookie: n
+  };
+}
+class Oe {
+  cache = /* @__PURE__ */ new Map();
+  DEFAULT_TTL = 300 * 1e3;
+  // 5 minutes
+  /**
+   * Memoized fetch - prevents duplicate requests and caches results
+   */
+  async fetch(d, m, h = this.DEFAULT_TTL) {
+    const p = Date.now(), s = this.cache.get(d);
+    if (s && p - s.timestamp < s.ttl)
+      return s.promise;
+    this.cleanExpired();
+    const f = m().finally(() => {
+      setTimeout(() => {
+        this.cache.delete(d);
+      }, h);
+    });
+    return this.cache.set(d, {
+      promise: f,
+      timestamp: p,
+      ttl: h
+    }), f;
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Remove a specific cache entry
+   */
+  invalidate(d) {
+    this.cache.delete(d);
+  }
+  /**
+   * Clean expired cache entries
+   */
+  cleanExpired() {
+    const d = Date.now();
+    for (const [m, h] of this.cache.entries())
+      d - h.timestamp > h.ttl && this.cache.delete(m);
+  }
+  /**
+   * Get cache statistics (for debugging)
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      entries: Array.from(this.cache.keys())
+    };
+  }
+}
+const y = new Oe();
+function be() {
+  return {
+    fetch: y.fetch.bind(y),
+    clear: y.clear.bind(y),
+    invalidate: y.invalidate.bind(y),
+    getStats: y.getStats.bind(y)
+  };
+}
+function Ie(n, d) {
+  let m = null;
+  return (...h) => {
+    m && clearTimeout(m), m = setTimeout(() => {
+      n(...h);
+    }, d);
+  };
+}
+const R = Ie((n, d) => {
+  typeof window < "u" && localStorage.setItem(n, d);
+}, 300), x = (n) => ({
+  id: n.id,
+  email: n.email,
+  firstName: n.first_name || n.firstName || "",
+  lastName: n.last_name || n.lastName || "",
+  avatar: n.avatar_url || n.avatar,
+  mfaEnabled: n.mfa_enabled ?? n.mfaEnabled ?? !1,
+  emailVerified: n.email_verified ?? n.emailVerified ?? !1,
+  passwordUpdatedAt: n.password_updated_at || n.passwordUpdatedAt,
+  settings: n.settings || {},
+  xp: n.xp || 0,
+  level: n.level || 1,
+  next_level_xp: n.next_level_xp || n.next_level_xp || 4,
+  username: n.username,
+  usernameLastChangedAt: n.username_last_changed_at || n.usernameLastChangedAt,
+  createdAt: n.created_at || n.createdAt,
+  updatedAt: n.updated_at || n.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+}), J = () => {
+  if (typeof window > "u")
+    return {
+      currentUser: g(null),
+      currentSession: g(null),
+      loadingStates: g({
+        initializing: !0,
+        signingIn: !1,
+        signingUp: !1,
+        signingOut: !1,
+        refreshingToken: !1,
+        sendingMfaEmail: !1,
+        verifyingMfa: !1,
+        loadingProfile: !1
+      }),
+      isInitialized: g(!1),
+      mfaRequired: g(!1),
+      mfaSessionId: g(null),
+      availableMfaMethods: g([]),
+      promise: null,
+      refreshTimer: null,
+      heartbeatTimer: null,
+      refreshPromise: null,
+      refreshTokenFn: null,
+      startTimerFn: null,
+      stopTimerFn: null
+    };
+  const n = window;
+  return n.__STRANDS_AUTH_STATE__ || (n.__STRANDS_AUTH_STATE__ = {
+    currentUser: g(null),
+    currentSession: g(null),
+    loadingStates: g({
+      initializing: !0,
+      signingIn: !1,
+      signingUp: !1,
+      signingOut: !1,
+      refreshingToken: !1,
+      sendingMfaEmail: !1,
+      verifyingMfa: !1,
+      loadingProfile: !1
+    }),
+    isInitialized: g(!1),
+    mfaRequired: g(!1),
+    mfaSessionId: g(null),
+    availableMfaMethods: g([]),
+    promise: null,
+    refreshTimer: null,
+    heartbeatTimer: null,
+    refreshPromise: null,
+    refreshTokenFn: null,
+    startTimerFn: null,
+    stopTimerFn: null
+  }), n.__STRANDS_AUTH_STATE__;
+}, l = J();
+function Fe() {
+  const { getUrl: n, config: d } = Ee(), { fetch: m, clear: h, invalidate: p } = be(), { currentUser: s, currentSession: f, loadingStates: i, isInitialized: T, mfaRequired: _, mfaSessionId: v, availableMfaMethods: A } = l, { refreshFromCookie: I } = xe(), M = () => {
+    if (s.value = null, f.value = null, _.value = !1, v.value = null, A.value = [], k(), l.refreshPromise = null, h(), typeof window < "u" && d.value?.onSignOutUrl) {
+      const t = window.location.pathname + window.location.search, e = d.value.onSignOutUrl;
+      if (t !== e && !t.startsWith(e)) {
+        const a = encodeURIComponent(t), r = e.includes("?") ? "&" : "?";
+        window.location.href = `${e}${r}redirect=${a}`;
+      }
+    }
+  }, z = u(() => i.value.initializing), L = u(() => i.value.signingIn), H = u(() => i.value.signingUp), K = u(() => i.value.signingOut), V = u(() => i.value.refreshingToken), q = u(() => i.value.sendingMfaEmail), B = u(() => i.value.verifyingMfa);
+  u(() => i.value.loadingProfile);
+  const C = u(
+    () => i.value.signingIn || i.value.signingUp || i.value.signingOut || i.value.refreshingToken || i.value.sendingMfaEmail || i.value.verifyingMfa || i.value.loadingProfile
+  ), G = u(() => i.value.initializing || C.value), W = u(() => {
+    const t = i.value;
+    return t.initializing ? "Checking authentication..." : t.signingIn ? "Signing you in..." : t.signingUp ? "Creating your account..." : t.signingOut ? "Signing you out..." : t.refreshingToken ? "Refreshing session..." : t.sendingMfaEmail ? "Sending verification code..." : t.verifyingMfa ? "Verifying code..." : t.loadingProfile ? "Loading profile..." : "Loading...";
+  }), Y = () => ({
+    "Content-Type": "application/json"
+  }), Q = async () => {
+    try {
+      const t = await fetch(n("authStatus"), {
+        method: "GET",
+        credentials: "include"
+      });
+      if (!t.ok)
+        return !1;
+      const e = await t.json();
+      if (e.authenticated && e.user) {
+        s.value = x(e.user);
+        const a = e.expires_at ? new Date(e.expires_at * 1e3) : new Date(Date.now() + 480 * 60 * 1e3);
+        return f.value = {
+          accessToken: "",
+          // Token is in HttpOnly cookie
+          refreshToken: "",
+          // Token is in HttpOnly cookie
+          expiresAt: a,
+          userId: e.user.id
+        }, !0;
+      }
+      return !1;
+    } catch {
+      return !1;
+    }
+  }, X = async (t, e, a) => {
+    const r = await fetch(n("mfaHardwareCompleteRegistration"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include",
+      body: JSON.stringify({
+        device_id: t,
+        credential: e
+      })
+    });
+    if (!r.ok) {
+      const c = await r.text();
+      let o = "Failed to complete hardware key registration";
+      try {
+        const w = JSON.parse(c);
+        o = w.message || w.error || c;
+      } catch {
+        o = c || "Failed to complete hardware key registration";
+      }
+      throw new Error(o);
+    }
+    return r.json();
+  }, Z = async (t, e, a = "hardware") => {
+    const r = await fetch(n("mfaHardwareStartRegistration"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include",
+      body: JSON.stringify({
+        device_name: t,
+        device_type: a
+      })
+    });
+    if (!r.ok) {
+      const c = await r.text();
+      let o = "Failed to start hardware key registration";
+      try {
+        const w = JSON.parse(c);
+        o = w.message || w.error || c;
+      } catch {
+        o = c || "Failed to start hardware key registration";
+      }
+      throw new Error(o);
+    }
+    return r.json();
+  }, ee = u(() => s.value !== null), te = async (t) => {
+    i.value.signingIn = !0;
+    try {
+      _.value = !1, v.value = null, A.value = [];
+      const e = {
+        "Content-Type": "application/json"
+      };
+      typeof window < "u" && window.location && (e.Origin = window.location.origin);
+      const a = await fetch(n("signIn"), {
+        method: "POST",
+        headers: e,
+        credentials: "include",
+        // Include cookies for auth
+        body: JSON.stringify(t)
+      });
+      if (!a.ok)
+        throw a.status === 401 ? new Error("Invalid email or password") : a.status === 403 ? new Error("Please verify your email address before signing in") : new Error(`Sign in failed: ${a.status} ${a.statusText}`);
+      const r = await a.json();
+      if (r.mfa_required) {
+        _.value = !0, v.value = r.mfa_session_id || null;
+        const c = (r.available_mfa_methods || []).map((o) => {
+          let w = `${o.device_type.charAt(0).toUpperCase() + o.device_type.slice(1)} Authentication`;
+          return o.device_type === "hardware" ? w = o.device_name || "Security Key" : o.device_type === "totp" ? w = o.device_name || "Authenticator App" : o.device_type === "email" && (w = o.device_name || "Email Verification"), {
+            id: o.device_id,
+            device_type: o.device_type,
+            device_name: o.device_name || w,
+            is_active: !0,
+            created_at: (/* @__PURE__ */ new Date()).toISOString(),
+            last_used_at: o.last_used_at,
+            // Pass through additional metadata if available
+            credential_id: o.credential_id,
+            device_info: o.device_info
+          };
+        });
+        return A.value = c, i.value.signingIn = !1, r;
+      }
+      return await b(r), r;
+    } catch (e) {
+      throw e;
+    } finally {
+      i.value.signingIn = !1;
+    }
+  }, ne = async (t) => {
+    i.value.signingUp = !0;
+    try {
+      throw new Error("Sign up not implemented - please integrate with auth SDK");
+    } finally {
+      i.value.signingUp = !1;
+    }
+  }, ae = async (t) => {
+    i.value.signingOut = !0;
+    try {
+      const e = t?.all ? `${n("signOut")}?all=true` : n("signOut");
+      await (await fetch(e, {
+        method: "POST",
+        credentials: "include"
+        // Cookies will be cleared by server response
+      })).text(), k(), l.refreshPromise = null, h(), s.value = null, f.value = null, _.value = !1, v.value = null, A.value = [], T.value = !1, I(), typeof window < "u" && d.value?.onSignOutUrl && (window.location.href = d.value.onSignOutUrl);
+    } finally {
+      i.value.signingOut = !1;
+    }
+  }, O = async () => {
+    if (l.refreshPromise)
+      return await l.refreshPromise;
+    l.refreshPromise = (async () => {
+      i.value.refreshingToken = !0;
+      try {
+        const e = await fetch(n("refresh"), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          credentials: "include"
+          // Refresh token sent via cookie
+        });
+        if (!e.ok) {
+          if (e.status === 401)
+            return M(), !1;
+          throw new Error(`Token refresh failed: ${e.status} ${e.statusText}`);
+        }
+        const a = await e.json();
+        a.user && (s.value = x(a.user));
+        const c = {
+          accessToken: "",
+          // Token is in HttpOnly cookie
+          refreshToken: "",
+          // Token is in HttpOnly cookie
+          expiresAt: a.expires_at ? new Date(a.expires_at * 1e3) : new Date(Date.now() + 480 * 60 * 1e3),
+          userId: a.user?.id || s.value?.id
+        };
+        return f.value = c, S(), p(`sessions:${s.value?.id || "unknown"}`), !0;
+      } catch {
+        return M(), !1;
+      } finally {
+        i.value.refreshingToken = !1;
+      }
+    })();
+    const t = await l.refreshPromise;
+    return l.refreshPromise = null, t;
+  }, ie = async () => {
+    const t = `profile:${f.value.accessToken.slice(0, 20)}`;
+    i.value.loadingProfile = !0;
+    try {
+      return await m(t, async () => {
+        const e = await fetch(n("profile"), {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${f.value?.accessToken}`
+          }
+        });
+        if (!e.ok)
+          throw e.status === 401 ? new Error("Authentication expired. Please sign in again.") : new Error(`Failed to fetch profile: ${e.status} ${e.statusText}`);
+        const a = await e.json();
+        return s.value = x(a), s.value && typeof window < "u" && localStorage.setItem("strands_auth_user", JSON.stringify(s.value)), s.value;
+      });
+    } finally {
+      i.value.loadingProfile = !1;
+    }
+  }, se = async (t) => {
+    i.value.loadingProfile = !0;
+    try {
+      const e = await fetch(n("profile"), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${f.value.accessToken}`
+        },
+        body: JSON.stringify({
+          first_name: t.firstName,
+          last_name: t.lastName
+        })
+      });
+      if (!e.ok)
+        throw e.status === 401 ? new Error("Authentication expired. Please sign in again.") : new Error(`Profile update failed: ${e.status} ${e.statusText}`);
+      const a = await e.json();
+      return s.value = x(a), s.value && R("strands_auth_user", JSON.stringify(s.value)), s.value;
+    } finally {
+      i.value.loadingProfile = !1;
+    }
+  }, re = async (t) => {
+    i.value.loadingProfile = !0;
+    try {
+      const e = await fetch(n("settings"), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${f.value.accessToken}`
+        },
+        body: JSON.stringify({
+          settings: t
+        })
+      });
+      if (!e.ok)
+        throw e.status === 401 ? new Error("Authentication expired. Please sign in again.") : new Error(`Settings update failed: ${e.status} ${e.statusText}`);
+      const a = await e.json();
+      return s.value = x(a), s.value && R("strands_auth_user", JSON.stringify(s.value)), s.value;
+    } finally {
+      i.value.loadingProfile = !1;
+    }
+  }, oe = async (t, e) => {
+    i.value.loadingProfile = !0;
+    try {
+      const a = await fetch(n("changeEmail"), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${f.value.accessToken}`
+        },
+        body: JSON.stringify({
+          new_email: t,
+          password: e
+        })
+      });
+      if (!a.ok) {
+        if (a.status === 401)
+          throw new Error("Authentication expired. Please sign in again.");
+        {
+          const c = await a.json().catch(() => ({}));
+          throw new Error(c.message || `Email change failed: ${a.status} ${a.statusText}`);
+        }
+      }
+      const r = await a.json();
+      return s.value && (s.value = {
+        ...s.value,
+        email: t,
+        emailVerified: !1,
+        // Email needs to be verified again
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }, typeof window < "u" && localStorage.setItem("strands_auth_user", JSON.stringify(s.value))), r;
+    } finally {
+      i.value.loadingProfile = !1;
+    }
+  }, le = async (t, e, a = !1) => {
+    if (!v.value)
+      throw new Error("No MFA session available");
+    i.value.verifyingMfa = !0;
+    try {
+      const r = n(a ? "mfaBackupCodeVerify" : "mfaSigninVerify"), c = a ? { mfa_session_id: v.value, backup_code: e } : { mfa_session_id: v.value, device_id: t, code: e }, o = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify(c)
+      });
+      if (!o.ok) {
+        const D = await o.text();
+        let F = "MFA verification failed";
+        try {
+          const $ = JSON.parse(D);
+          F = $.message || $.error || D;
+        } catch {
+          F = D || "MFA verification failed";
+        }
+        throw new Error(F);
+      }
+      const w = await o.json();
+      return _.value = !1, v.value = null, A.value = [], await b(w), w;
+    } finally {
+      i.value.verifyingMfa = !1;
+    }
+  }, ce = async (t) => {
+    if (!v.value)
+      throw new Error("No MFA session available");
+    i.value.sendingMfaEmail = !0;
+    try {
+      const e = await fetch(n("mfaSigninSendEmail"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          mfa_session_id: v.value,
+          device_id: t
+        })
+      });
+      if (!e.ok) {
+        const r = await e.text();
+        let c = "Failed to send MFA email code";
+        try {
+          const o = JSON.parse(r);
+          c = o.message || o.error || r;
+        } catch {
+          c = r || "Failed to send MFA email code";
+        }
+        throw new Error(c);
+      }
+      return await e.json();
+    } finally {
+      i.value.sendingMfaEmail = !1;
+    }
+  }, ue = async (t) => {
+    if (!v.value)
+      throw new Error("No MFA session available");
+    const e = await fetch(n("mfaWebAuthnChallenge"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({
+        mfa_session_id: v.value,
+        device_id: t
+      })
+    });
+    if (!e.ok) {
+      const a = await e.text();
+      let r = "Failed to get WebAuthn challenge";
+      try {
+        const c = JSON.parse(a);
+        r = c.message || c.error || a;
+      } catch {
+        r = a || r;
+      }
+      throw new Error(r);
+    }
+    return e.json();
+  }, b = async (t) => {
+    try {
+      t.user && (s.value = x(t.user));
+      const a = {
+        accessToken: "",
+        // Token is in HttpOnly cookie
+        refreshToken: "",
+        // Token is in HttpOnly cookie
+        expiresAt: t.expires_at ? new Date(t.expires_at * 1e3) : new Date(Date.now() + 480 * 60 * 1e3),
+        userId: s.value?.id || t.user?.id
+      };
+      f.value = a, S(), I();
+    } catch {
+    }
+  }, fe = 240 * 1e3, de = () => {
+    l.heartbeatTimer && (clearInterval(l.heartbeatTimer), l.heartbeatTimer = null);
+  };
+  let N;
+  const S = () => {
+    if (l.refreshTimer && clearTimeout(l.refreshTimer), !f.value || typeof document < "u" && document.visibilityState === "hidden")
+      return;
+    const t = /* @__PURE__ */ new Date(), a = f.value.expiresAt.getTime() - t.getTime() - 60 * 1e3;
+    if (a <= 0) {
+      O();
+      return;
+    }
+    l.refreshTimer = setTimeout(async () => {
+      (typeof document > "u" || document.visibilityState === "visible") && await O() && S();
+    }, a), N();
+  }, k = () => {
+    l.refreshTimer && (clearTimeout(l.refreshTimer), l.refreshTimer = null), de();
+  };
+  N = () => {
+    l.heartbeatTimer || (l.heartbeatTimer = setInterval(async () => {
+      if (typeof document < "u" && document.visibilityState === "hidden" || !f.value) return;
+      const t = Date.now();
+      f.value.expiresAt.getTime() - t <= 300 * 1e3 && await O(), !l.refreshTimer && f.value && S();
+    }, fe));
+  }, l.refreshTokenFn = O, l.startTimerFn = S, l.stopTimerFn = k;
+  const P = async () => {
+    if (T.value) {
+      i.value.initializing = !1;
+      return;
+    }
+    if (l.promise) {
+      await l.promise;
+      return;
+    }
+    i.value.initializing = !0;
+    const t = async () => {
+      try {
+        typeof window < "u" && (await Promise.race([
+          Q(),
+          new Promise((r) => setTimeout(() => r(!1), 5e3))
+        ]) ? S() : (s.value = null, f.value = null)), T.value = !0, await new Promise((e) => setTimeout(e, 50));
+      } catch {
+      } finally {
+        i.value.initializing = !1, l.promise = null;
+      }
+    };
+    return l.promise = t(), l.promise;
+  }, he = async (t) => {
+    i.value.loadingProfile = !0;
+    try {
+      const e = await fetch(n("changeUsername"), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        credentials: "include",
+        body: JSON.stringify({
+          username: t
+        })
+      });
+      if (!e.ok) {
+        const r = await e.json().catch(() => ({}));
+        throw e.status === 409 ? new Error("Username is already taken") : r.cooldown_end ? new Error(`You can only change your username once every 30 days. You can change it again on ${new Date(r.cooldown_end).toLocaleDateString()}`) : new Error(r.message || `Username change failed: ${e.status} ${e.statusText}`);
+      }
+      const a = await e.json();
+      return s.value && (s.value = {
+        ...s.value,
+        username: t,
+        usernameLastChangedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }), a;
+    } finally {
+      i.value.loadingProfile = !1;
+    }
+  }, ge = async () => {
+    const t = await fetch(n("usernameCooldown"), {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!t.ok)
+      throw new Error(`Failed to get username cooldown: ${t.status} ${t.statusText}`);
+    return t.json();
+  }, me = async (t) => {
+    const e = n("checkUsernameAvailability").replace("{username}", encodeURIComponent(t)), a = await fetch(e, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!a.ok)
+      throw new Error(`Failed to check username availability: ${a.status} ${a.statusText}`);
+    return a.json();
+  }, ve = async () => {
+    const t = `sessions:${s.value?.id || "no-user"}`;
+    try {
+      return await m(t, async () => {
+        const e = await fetch(n("sessions"), {
+          method: "GET",
+          credentials: "include"
+        });
+        if (!e.ok)
+          throw await e.text(), new Error(`Failed to get user sessions: ${e.status} ${e.statusText}`);
+        return e.json();
+      }, 120 * 1e3);
+    } catch (e) {
+      throw e;
+    }
+  }, we = async () => {
+    const t = await fetch(n("sessionsStats"), {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!t.ok)
+      throw new Error(`Failed to get session stats: ${t.status} ${t.statusText}`);
+    return t.json();
+  }, pe = async (t) => {
+    const e = n("sessionRevoke").replace("{session_id}", encodeURIComponent(t)), a = await fetch(e, {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!a.ok)
+      throw new Error(`Failed to revoke session: ${a.status} ${a.statusText}`);
+    return a.status === 200;
+  }, ye = async () => {
+    const t = await fetch(n("sessionsRevokeAll"), {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!t.ok)
+      throw new Error(`Failed to revoke all other sessions: ${t.status} ${t.statusText}`);
+    return t.status === 200;
+  }, Te = async (t) => {
+    const e = await fetch(n("switchAccount"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({ user_id: t })
+    });
+    if (!e.ok) {
+      const r = await e.json().catch(() => ({})), c = new Error(r.message || "Failed to switch account");
+      throw c.code = r.code, c.email = r.email, c;
+    }
+    const a = await e.json();
+    return await b(a), a;
+  }, Se = async (t) => {
+    if (!(await fetch(n("removeKnownAccount"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({ user_id: t })
+    })).ok)
+      throw new Error("Failed to remove known account");
+    I(), s.value?.id === t && (s.value = null, f.value = null, k(), h());
+  };
+  if (typeof document < "u" && typeof window < "u") {
+    const t = window;
+    t.__STRANDS_VISIBILITY_LISTENER__ || (t.__STRANDS_VISIBILITY_LISTENER__ = !0, document.addEventListener("visibilitychange", async () => {
+      const e = J();
+      if (document.visibilityState === "visible" && e.currentSession.value) {
+        const a = /* @__PURE__ */ new Date();
+        e.currentSession.value.expiresAt.getTime() - a.getTime() <= 120 * 1e3 ? e.refreshTokenFn && await e.refreshTokenFn() : e.startTimerFn && e.startTimerFn();
+      } else document.visibilityState === "hidden" && e.stopTimerFn && e.stopTimerFn();
+    }));
+  }
+  const _e = () => {
+    k(), h();
+  };
+  try {
+    Ae() && ke(_e);
+  } catch {
+  }
+  return T.value || P(), {
+    // State
+    user: u(() => s.value),
+    currentUser: u(() => s.value),
+    currentSession: u(() => f.value),
+    isAuthenticated: ee,
+    isLoading: u(() => G.value || !T.value),
+    loading: C,
+    loadingMessage: W,
+    // Specific loading states
+    isInitializing: z,
+    isInitialized: u(() => T.value),
+    isSigningIn: L,
+    isSigningUp: H,
+    isSigningOut: K,
+    isRefreshingToken: V,
+    isSendingMfaEmail: q,
+    isVerifyingMfa: B,
+    // MFA State
+    mfaRequired: u(() => _.value),
+    mfaSessionId: u(() => v.value),
+    availableMfaMethods: u(() => A.value),
+    // Methods
+    signIn: te,
+    signUp: ne,
+    signOut: ae,
+    refreshToken: O,
+    fetchProfile: ie,
+    updateProfile: se,
+    updateUserSettings: re,
+    changeEmail: oe,
+    changeUsername: he,
+    getUsernameCooldown: ge,
+    checkUsernameAvailability: me,
+    // Session management
+    getUserSessions: ve,
+    getSessionStats: we,
+    revokeSession: pe,
+    revokeAllOtherSessions: ye,
+    initialize: P,
+    setAuthData: b,
+    verifyMfa: le,
+    sendMfaEmailCode: ce,
+    getMfaWebAuthnChallenge: ue,
+    registerHardwareKey: Z,
+    completeHardwareKeyRegistration: X,
+    // Multi-account
+    switchAccount: Te,
+    removeKnownAccount: Se,
+    // Token management
+    startTokenRefreshTimer: S,
+    stopTokenRefreshTimer: k,
+    getAuthHeaders: Y,
+    // Force re-initialization (useful for testing or navigation)
+    forceReInit: () => {
+      T.value = !1, i.value.initializing = !0, P();
+    }
+  };
+}
+export {
+  Fe as u
+};