@strands.gg/accui 2.15.16 → 2.17.9

package/dist/useStrandsAuth-BCnUxo-R.es.js

@@ -1,915 +0,0 @@
-import { computed, ref, getCurrentInstance, onUnmounted } from "vue";
-import { u as useStrandsConfig } from "./useStrandsConfig-fRu-OG08.es.js";
-class RequestCache {
-  cache = /* @__PURE__ */ new Map();
-  DEFAULT_TTL = 5 * 60 * 1e3;
-  // 5 minutes
-  /**
-   * Memoized fetch - prevents duplicate requests and caches results
-   */
-  async fetch(key, fetcher, ttl = this.DEFAULT_TTL) {
-    const now = Date.now();
-    const entry = this.cache.get(key);
-    if (entry && now - entry.timestamp < entry.ttl) {
-      return entry.promise;
-    }
-    this.cleanExpired();
-    const promise = fetcher().finally(() => {
-      setTimeout(() => {
-        this.cache.delete(key);
-      }, ttl);
-    });
-    this.cache.set(key, {
-      promise,
-      timestamp: now,
-      ttl
-    });
-    return promise;
-  }
-  /**
-   * Clear all cached entries
-   */
-  clear() {
-    this.cache.clear();
-  }
-  /**
-   * Remove a specific cache entry
-   */
-  invalidate(key) {
-    this.cache.delete(key);
-  }
-  /**
-   * Clean expired cache entries
-   */
-  cleanExpired() {
-    const now = Date.now();
-    for (const [key, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > entry.ttl) {
-        this.cache.delete(key);
-      }
-    }
-  }
-  /**
-   * Get cache statistics (for debugging)
-   */
-  getStats() {
-    return {
-      size: this.cache.size,
-      entries: Array.from(this.cache.keys())
-    };
-  }
-}
-const requestCache = new RequestCache();
-function useRequestCache() {
-  return {
-    fetch: requestCache.fetch.bind(requestCache),
-    clear: requestCache.clear.bind(requestCache),
-    invalidate: requestCache.invalidate.bind(requestCache),
-    getStats: requestCache.getStats.bind(requestCache)
-  };
-}
-function debounce(func, wait) {
-  let timeout = null;
-  return (...args) => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => {
-      func(...args);
-    }, wait);
-  };
-}
-const debouncedSetItem = debounce((key, value) => {
-  if (typeof window !== "undefined") {
-    localStorage.setItem(key, value);
-  }
-}, 300);
-const mapApiUserToFrontend = (apiUser) => {
-  return {
-    id: apiUser.id,
-    email: apiUser.email,
-    firstName: apiUser.first_name || apiUser.firstName || "",
-    lastName: apiUser.last_name || apiUser.lastName || "",
-    avatar: apiUser.avatar_url || apiUser.avatar,
-    mfaEnabled: apiUser.mfa_enabled ?? apiUser.mfaEnabled ?? false,
-    emailVerified: apiUser.email_verified ?? apiUser.emailVerified ?? false,
-    passwordUpdatedAt: apiUser.password_updated_at || apiUser.passwordUpdatedAt,
-    settings: apiUser.settings || {},
-    xp: apiUser.xp || 0,
-    level: apiUser.level || 1,
-    next_level_xp: apiUser.next_level_xp || apiUser.next_level_xp || 4,
-    username: apiUser.username,
-    usernameLastChangedAt: apiUser.username_last_changed_at || apiUser.usernameLastChangedAt,
-    createdAt: apiUser.created_at || apiUser.createdAt,
-    updatedAt: apiUser.updated_at || apiUser.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
-  };
-};
-const globalState = {
-  currentUser: ref(null),
-  currentSession: ref(null),
-  loadingStates: ref({
-    initializing: true,
-    signingIn: false,
-    signingUp: false,
-    signingOut: false,
-    refreshingToken: false,
-    sendingMfaEmail: false,
-    verifyingMfa: false,
-    loadingProfile: false
-  }),
-  isInitialized: ref(false),
-  mfaRequired: ref(false),
-  mfaSessionId: ref(null),
-  availableMfaMethods: ref([])
-};
-let refreshTimer = null;
-let refreshPromise = null;
-function useStrandsAuth() {
-  const { getUrl, config } = useStrandsConfig();
-  const { fetch: cachedFetch, clear: clearCache, invalidate } = useRequestCache();
-  const { currentUser, currentSession, loadingStates, isInitialized, mfaRequired, mfaSessionId, availableMfaMethods } = globalState;
-  const handleAuthLoss = () => {
-    currentUser.value = null;
-    currentSession.value = null;
-    mfaRequired.value = false;
-    mfaSessionId.value = null;
-    availableMfaMethods.value = [];
-    if (typeof window !== "undefined") {
-      localStorage.removeItem("strands_auth_session");
-      localStorage.removeItem("strands_auth_user");
-    }
-    stopTokenRefreshTimer();
-    refreshPromise = null;
-    clearCache();
-    if (typeof window !== "undefined" && config.value?.onSignOutUrl) {
-      const currentPath = window.location.pathname + window.location.search;
-      const signOutUrl = config.value.onSignOutUrl;
-      if (currentPath !== signOutUrl) {
-        window.location.href = signOutUrl;
-      }
-    }
-  };
-  const isInitializing = computed(() => loadingStates.value.initializing);
-  const isSigningIn = computed(() => loadingStates.value.signingIn);
-  const isSigningUp = computed(() => loadingStates.value.signingUp);
-  const isSigningOut = computed(() => loadingStates.value.signingOut);
-  const isRefreshingToken = computed(() => loadingStates.value.refreshingToken);
-  const isSendingMfaEmail = computed(() => loadingStates.value.sendingMfaEmail);
-  const isVerifyingMfa = computed(() => loadingStates.value.verifyingMfa);
-  computed(() => loadingStates.value.loadingProfile);
-  const loading = computed(
-    () => loadingStates.value.signingIn || loadingStates.value.signingUp || loadingStates.value.signingOut || loadingStates.value.refreshingToken || loadingStates.value.sendingMfaEmail || loadingStates.value.verifyingMfa || loadingStates.value.loadingProfile
-  );
-  const isLoading = computed(() => loadingStates.value.initializing || loading.value);
-  const loadingMessage = computed(() => {
-    const states = loadingStates.value;
-    if (states.initializing) return "Checking authentication...";
-    if (states.signingIn) return "Signing you in...";
-    if (states.signingUp) return "Creating your account...";
-    if (states.signingOut) return "Signing you out...";
-    if (states.refreshingToken) return "Refreshing session...";
-    if (states.sendingMfaEmail) return "Sending verification code...";
-    if (states.verifyingMfa) return "Verifying code...";
-    if (states.loadingProfile) return "Loading profile...";
-    return "Loading...";
-  });
-  const getAuthHeaders = () => {
-    const headers = {};
-    if (currentSession.value?.accessToken) {
-      headers["Authorization"] = `Bearer ${currentSession.value.accessToken}`;
-    }
-    if (currentSession.value?.refreshToken) {
-      headers["x-refresh-token"] = currentSession.value.refreshToken;
-    }
-    return headers;
-  };
-  const completeHardwareKeyRegistration = async (deviceId, credential, accessToken) => {
-    const response = await fetch(getUrl("mfaHardwareCompleteRegistration"), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${currentSession.value.accessToken}`
-      },
-      body: JSON.stringify({
-        device_id: deviceId,
-        credential
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      let errorMessage = "Failed to complete hardware key registration";
-      try {
-        const errorData = JSON.parse(errorText);
-        errorMessage = errorData.message || errorData.error || errorText;
-      } catch {
-        errorMessage = errorText || "Failed to complete hardware key registration";
-      }
-      throw new Error(errorMessage);
-    }
-    return response.json();
-  };
-  const registerHardwareKey = async (deviceName, accessToken, deviceType = "hardware") => {
-    const response = await fetch(getUrl("mfaHardwareStartRegistration"), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${currentSession.value.accessToken}`
-      },
-      body: JSON.stringify({
-        device_name: deviceName,
-        device_type: deviceType
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      let errorMessage = "Failed to start hardware key registration";
-      try {
-        const errorData = JSON.parse(errorText);
-        errorMessage = errorData.message || errorData.error || errorText;
-      } catch {
-        errorMessage = errorText || "Failed to start hardware key registration";
-      }
-      throw new Error(errorMessage);
-    }
-    return response.json();
-  };
-  const isAuthenticated = computed(() => currentUser.value !== null);
-  const signIn = async (credentials) => {
-    loadingStates.value.signingIn = true;
-    try {
-      mfaRequired.value = false;
-      mfaSessionId.value = null;
-      availableMfaMethods.value = [];
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (typeof window !== "undefined" && window.location) {
-        headers["Origin"] = window.location.origin;
-      }
-      const response = await fetch(getUrl("signIn"), {
-        method: "POST",
-        headers,
-        body: JSON.stringify(credentials)
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error("Invalid email or password");
-        } else if (response.status === 403) {
-          throw new Error("Please verify your email address before signing in");
-        } else {
-          throw new Error(`Sign in failed: ${response.status} ${response.statusText}`);
-        }
-      }
-      const authData = await response.json();
-      if (authData.mfa_required) {
-        mfaRequired.value = true;
-        mfaSessionId.value = authData.mfa_session_id || null;
-        const methods = (authData.available_mfa_methods || []).map((method) => {
-          let fallbackName = `${method.device_type.charAt(0).toUpperCase() + method.device_type.slice(1)} Authentication`;
-          if (method.device_type === "hardware") {
-            fallbackName = method.device_name || "Security Key";
-          } else if (method.device_type === "totp") {
-            fallbackName = method.device_name || "Authenticator App";
-          } else if (method.device_type === "email") {
-            fallbackName = method.device_name || "Email Verification";
-          }
-          return {
-            id: method.device_id,
-            device_type: method.device_type,
-            device_name: method.device_name || fallbackName,
-            is_active: true,
-            created_at: (/* @__PURE__ */ new Date()).toISOString(),
-            last_used_at: method.last_used_at,
-            // Pass through additional metadata if available
-            credential_id: method.credential_id,
-            device_info: method.device_info
-          };
-        });
-        availableMfaMethods.value = methods;
-        loadingStates.value.signingIn = false;
-        return authData;
-      }
-      await setAuthData(authData);
-      return authData;
-    } catch (error) {
-      throw error;
-    } finally {
-      loadingStates.value.signingIn = false;
-    }
-  };
-  const signUp = async (userData) => {
-    loadingStates.value.signingUp = true;
-    try {
-      throw new Error("Sign up not implemented - please integrate with auth SDK");
-    } finally {
-      loadingStates.value.signingUp = false;
-    }
-  };
-  const signOut = async () => {
-    loadingStates.value.signingOut = true;
-    try {
-      stopTokenRefreshTimer();
-      refreshPromise = null;
-      clearCache();
-      currentUser.value = null;
-      currentSession.value = null;
-      mfaRequired.value = false;
-      mfaSessionId.value = null;
-      availableMfaMethods.value = [];
-      if (typeof window !== "undefined") {
-        localStorage.removeItem("strands_auth_session");
-        localStorage.removeItem("strands_auth_user");
-      }
-    } finally {
-      loadingStates.value.signingOut = false;
-    }
-  };
-  const refreshToken = async () => {
-    if (!currentSession.value?.refreshToken) {
-      return false;
-    }
-    if (refreshPromise) {
-      return await refreshPromise;
-    }
-    refreshPromise = (async () => {
-      loadingStates.value.refreshingToken = true;
-      try {
-        const response = await fetch(getUrl("refresh"), {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            refresh_token: currentSession.value.refreshToken
-          })
-        });
-        if (!response.ok) {
-          if (response.status === 401) {
-            handleAuthLoss();
-            return false;
-          }
-          throw new Error(`Token refresh failed: ${response.status} ${response.statusText}`);
-        }
-        const tokenData = await response.json();
-        if (tokenData.user) {
-          currentUser.value = mapApiUserToFrontend(tokenData.user);
-          if (currentUser.value && typeof window !== "undefined") {
-            localStorage.setItem("strands_auth_user", JSON.stringify(currentUser.value));
-          }
-        }
-        const newSession = {
-          accessToken: tokenData.access_token,
-          refreshToken: tokenData.refresh_token,
-          expiresAt: new Date(Date.now() + 5 * 60 * 1e3),
-          // 5 minutes from now
-          userId: tokenData.user?.id || currentUser.value?.id
-        };
-        currentSession.value = newSession;
-        if (typeof window !== "undefined") {
-          localStorage.setItem("strands_auth_session", JSON.stringify(newSession));
-        }
-        startTokenRefreshTimer();
-        invalidate(`sessions:${currentSession.value.accessToken.slice(0, 20)}`);
-        return true;
-      } catch (error) {
-        handleAuthLoss();
-        return false;
-      } finally {
-        loadingStates.value.refreshingToken = false;
-      }
-    })();
-    const result = await refreshPromise;
-    refreshPromise = null;
-    return result;
-  };
-  const fetchProfile = async () => {
-    const cacheKey = `profile:${currentSession.value.accessToken.slice(0, 20)}`;
-    loadingStates.value.loadingProfile = true;
-    try {
-      return await cachedFetch(cacheKey, async () => {
-        const response = await fetch(getUrl("profile"), {
-          method: "GET",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${currentSession.value?.accessToken}`
-          }
-        });
-        if (!response.ok) {
-          if (response.status === 401) {
-            throw new Error("Authentication expired. Please sign in again.");
-          } else {
-            throw new Error(`Failed to fetch profile: ${response.status} ${response.statusText}`);
-          }
-        }
-        const userData = await response.json();
-        currentUser.value = mapApiUserToFrontend(userData);
-        if (currentUser.value && typeof window !== "undefined") {
-          localStorage.setItem("strands_auth_user", JSON.stringify(currentUser.value));
-        }
-        return currentUser.value;
-      });
-    } finally {
-      loadingStates.value.loadingProfile = false;
-    }
-  };
-  const updateProfile = async (profileData) => {
-    loadingStates.value.loadingProfile = true;
-    try {
-      const response = await fetch(getUrl("profile"), {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${currentSession.value.accessToken}`
-        },
-        body: JSON.stringify({
-          first_name: profileData.firstName,
-          last_name: profileData.lastName
-        })
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error("Authentication expired. Please sign in again.");
-        } else {
-          throw new Error(`Profile update failed: ${response.status} ${response.statusText}`);
-        }
-      }
-      const updatedUserData = await response.json();
-      currentUser.value = mapApiUserToFrontend(updatedUserData);
-      if (currentUser.value) {
-        debouncedSetItem("strands_auth_user", JSON.stringify(currentUser.value));
-      }
-      return currentUser.value;
-    } finally {
-      loadingStates.value.loadingProfile = false;
-    }
-  };
-  const updateUserSettings = async (settings) => {
-    loadingStates.value.loadingProfile = true;
-    try {
-      const response = await fetch(getUrl("settings"), {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${currentSession.value.accessToken}`
-        },
-        body: JSON.stringify({
-          settings
-        })
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error("Authentication expired. Please sign in again.");
-        } else {
-          throw new Error(`Settings update failed: ${response.status} ${response.statusText}`);
-        }
-      }
-      const updatedUserData = await response.json();
-      currentUser.value = mapApiUserToFrontend(updatedUserData);
-      if (currentUser.value) {
-        debouncedSetItem("strands_auth_user", JSON.stringify(currentUser.value));
-      }
-      return currentUser.value;
-    } finally {
-      loadingStates.value.loadingProfile = false;
-    }
-  };
-  const changeEmail = async (newEmail, password) => {
-    loadingStates.value.loadingProfile = true;
-    try {
-      const response = await fetch(getUrl("changeEmail"), {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${currentSession.value.accessToken}`
-        },
-        body: JSON.stringify({
-          new_email: newEmail,
-          password
-        })
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error("Authentication expired. Please sign in again.");
-        } else {
-          const errorData = await response.json().catch(() => ({}));
-          throw new Error(errorData.message || `Email change failed: ${response.status} ${response.statusText}`);
-        }
-      }
-      const result = await response.json();
-      if (currentUser.value) {
-        currentUser.value = {
-          ...currentUser.value,
-          email: newEmail,
-          emailVerified: false,
-          // Email needs to be verified again
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (typeof window !== "undefined") {
-          localStorage.setItem("strands_auth_user", JSON.stringify(currentUser.value));
-        }
-      }
-      return result;
-    } finally {
-      loadingStates.value.loadingProfile = false;
-    }
-  };
-  const verifyMfa = async (deviceId, code, isBackupCode = false) => {
-    if (!mfaSessionId.value) {
-      throw new Error("No MFA session available");
-    }
-    loadingStates.value.verifyingMfa = true;
-    try {
-      const endpoint = isBackupCode ? getUrl("mfaBackupCodeVerify") : getUrl("mfaSigninVerify");
-      const body = isBackupCode ? { mfa_session_id: mfaSessionId.value, backup_code: code } : { mfa_session_id: mfaSessionId.value, device_id: deviceId, code };
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = "MFA verification failed";
-        try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
-        } catch {
-          errorMessage = errorText || "MFA verification failed";
-        }
-        throw new Error(errorMessage);
-      }
-      const authData = await response.json();
-      mfaRequired.value = false;
-      mfaSessionId.value = null;
-      availableMfaMethods.value = [];
-      await setAuthData(authData);
-      return authData;
-    } finally {
-      loadingStates.value.verifyingMfa = false;
-    }
-  };
-  const sendMfaEmailCode = async (deviceId) => {
-    if (!mfaSessionId.value) {
-      throw new Error("No MFA session available");
-    }
-    loadingStates.value.sendingMfaEmail = true;
-    try {
-      const response = await fetch(getUrl("mfaSigninSendEmail"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          mfa_session_id: mfaSessionId.value,
-          device_id: deviceId
-        })
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = "Failed to send MFA email code";
-        try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
-        } catch {
-          errorMessage = errorText || "Failed to send MFA email code";
-        }
-        throw new Error(errorMessage);
-      }
-      const result = await response.json();
-      return result;
-    } finally {
-      loadingStates.value.sendingMfaEmail = false;
-    }
-  };
-  const getMfaWebAuthnChallenge = async (deviceId) => {
-    if (!mfaSessionId.value) {
-      throw new Error("No MFA session available");
-    }
-    const response = await fetch(getUrl("mfaWebAuthnChallenge"), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        mfa_session_id: mfaSessionId.value,
-        device_id: deviceId
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      let errorMessage = "Failed to get WebAuthn challenge";
-      try {
-        const errorData = JSON.parse(errorText);
-        errorMessage = errorData.message || errorData.error || errorText;
-      } catch {
-        errorMessage = errorText || errorMessage;
-      }
-      throw new Error(errorMessage);
-    }
-    return response.json();
-  };
-  const setAuthData = async (authResponse) => {
-    try {
-      if (authResponse.user) {
-        currentUser.value = mapApiUserToFrontend(authResponse.user);
-      }
-      const session = {
-        accessToken: authResponse.access_token,
-        refreshToken: authResponse.refresh_token,
-        expiresAt: new Date(Date.now() + 5 * 60 * 1e3),
-        // 5 minutes from now (matching API token expiry)
-        userId: currentUser.value?.id || authResponse.user?.id
-      };
-      currentSession.value = session;
-      if (typeof window !== "undefined") {
-        localStorage.setItem("strands_auth_session", JSON.stringify(session));
-        if (currentUser.value) {
-          localStorage.setItem("strands_auth_user", JSON.stringify(currentUser.value));
-        }
-      }
-      startTokenRefreshTimer();
-    } catch (error) {
-    }
-  };
-  const startTokenRefreshTimer = () => {
-    if (refreshTimer) {
-      clearTimeout(refreshTimer);
-    }
-    if (!currentSession.value) return;
-    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
-      return;
-    }
-    const now = /* @__PURE__ */ new Date();
-    const expiresAt = currentSession.value.expiresAt;
-    const timeUntilRefresh = expiresAt.getTime() - now.getTime() - 1 * 60 * 1e3;
-    if (timeUntilRefresh <= 0) {
-      refreshToken();
-      return;
-    }
-    refreshTimer = setTimeout(async () => {
-      if (typeof document === "undefined" || document.visibilityState === "visible") {
-        const success = await refreshToken();
-        if (success) {
-          startTokenRefreshTimer();
-        }
-      }
-    }, timeUntilRefresh);
-  };
-  const stopTokenRefreshTimer = () => {
-    if (refreshTimer) {
-      clearTimeout(refreshTimer);
-      refreshTimer = null;
-    }
-  };
-  const initialize = async () => {
-    if (isInitialized.value) return;
-    loadingStates.value.initializing = true;
-    try {
-      if (typeof window !== "undefined") {
-        const storedSession = localStorage.getItem("strands_auth_session");
-        const storedUser = localStorage.getItem("strands_auth_user");
-        if (storedSession && storedUser) {
-          try {
-            const session = JSON.parse(storedSession);
-            const user = JSON.parse(storedUser);
-            session.expiresAt = new Date(session.expiresAt);
-            if (session.expiresAt <= /* @__PURE__ */ new Date() && session.refreshToken) {
-              currentSession.value = session;
-              currentUser.value = user;
-              const refreshSuccess = await refreshToken();
-              if (!refreshSuccess) {
-                handleAuthLoss();
-              }
-            } else if (session.expiresAt > /* @__PURE__ */ new Date()) {
-              currentSession.value = session;
-              currentUser.value = user;
-              startTokenRefreshTimer();
-            } else {
-              localStorage.removeItem("strands_auth_session");
-              localStorage.removeItem("strands_auth_user");
-            }
-          } catch (error) {
-            localStorage.removeItem("strands_auth_session");
-            localStorage.removeItem("strands_auth_user");
-          }
-        }
-      }
-      isInitialized.value = true;
-      await new Promise((resolve) => setTimeout(resolve, 50));
-    } catch (error) {
-    } finally {
-      loadingStates.value.initializing = false;
-    }
-  };
-  const changeUsername = async (newUsername) => {
-    loadingStates.value.loadingProfile = true;
-    try {
-      const response = await fetch(getUrl("changeUsername"), {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${currentSession.value.accessToken}`
-        },
-        body: JSON.stringify({
-          username: newUsername
-        })
-      });
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        if (response.status === 409) {
-          throw new Error("Username is already taken");
-        } else if (errorData.cooldown_end) {
-          throw new Error(`You can only change your username once every 30 days. You can change it again on ${new Date(errorData.cooldown_end).toLocaleDateString()}`);
-        }
-        throw new Error(errorData.message || `Username change failed: ${response.status} ${response.statusText}`);
-      }
-      const result = await response.json();
-      if (currentUser.value) {
-        currentUser.value = {
-          ...currentUser.value,
-          username: newUsername,
-          usernameLastChangedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (typeof window !== "undefined") {
-          localStorage.setItem("strands_auth_user", JSON.stringify(currentUser.value));
-        }
-      }
-      return result;
-    } finally {
-      loadingStates.value.loadingProfile = false;
-    }
-  };
-  const getUsernameCooldown = async () => {
-    const response = await fetch(getUrl("usernameCooldown"), {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${currentSession.value.accessToken}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get username cooldown: ${response.status} ${response.statusText}`);
-    }
-    return response.json();
-  };
-  const checkUsernameAvailability = async (username) => {
-    const url = getUrl("checkUsernameAvailability").replace("{username}", encodeURIComponent(username));
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to check username availability: ${response.status} ${response.statusText}`);
-    }
-    return response.json();
-  };
-  const getUserSessions = async () => {
-    const cacheKey = `sessions:${currentSession.value?.accessToken?.slice(0, 20) || "no-token"}`;
-    try {
-      return await cachedFetch(cacheKey, async () => {
-        const headers = getAuthHeaders();
-        const response = await fetch(getUrl("sessions"), {
-          method: "GET",
-          headers
-        });
-        if (!response.ok) {
-          await response.text();
-          throw new Error(`Failed to get user sessions: ${response.status} ${response.statusText}`);
-        }
-        return response.json();
-      }, 2 * 60 * 1e3);
-    } catch (error) {
-      throw error;
-    }
-  };
-  const getSessionStats = async () => {
-    const response = await fetch(getUrl("sessionsStats"), {
-      method: "GET",
-      headers: getAuthHeaders()
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get session stats: ${response.status} ${response.statusText}`);
-    }
-    return response.json();
-  };
-  const revokeSession = async (sessionId) => {
-    const url = getUrl("sessionRevoke").replace("{session_id}", encodeURIComponent(sessionId));
-    const response = await fetch(url, {
-      method: "POST",
-      headers: getAuthHeaders()
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to revoke session: ${response.status} ${response.statusText}`);
-    }
-    return response.status === 200;
-  };
-  const revokeAllOtherSessions = async () => {
-    const response = await fetch(getUrl("sessionsRevokeAll"), {
-      method: "POST",
-      headers: getAuthHeaders()
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to revoke all other sessions: ${response.status} ${response.statusText}`);
-    }
-    return response.status === 200;
-  };
-  if (typeof document !== "undefined") {
-    document.addEventListener("visibilitychange", () => {
-      if (document.visibilityState === "visible" && currentSession.value) {
-        startTokenRefreshTimer();
-        checkAuthState();
-      } else if (document.visibilityState === "hidden") {
-        stopTokenRefreshTimer();
-      }
-    });
-  }
-  if (typeof window !== "undefined") {
-    window.addEventListener("storage", (event) => {
-      if (event.key === "strands_auth_session" || event.key === "strands_auth_user") {
-        if (!event.newValue && currentUser.value) {
-          handleAuthLoss();
-        }
-      }
-    });
-  }
-  const checkAuthState = () => {
-    if (typeof window === "undefined") return;
-    if (currentUser.value && currentSession.value) {
-      const storedSession = localStorage.getItem("strands_auth_session");
-      const storedUser = localStorage.getItem("strands_auth_user");
-      if (!storedSession || !storedUser) {
-        handleAuthLoss();
-      }
-    }
-  };
-  const cleanup = () => {
-    stopTokenRefreshTimer();
-    clearCache();
-  };
-  try {
-    const currentInstance = getCurrentInstance();
-    if (currentInstance) {
-      onUnmounted(cleanup);
-    }
-  } catch (e) {
-  }
-  if (!isInitialized.value) {
-    initialize();
-  }
-  return {
-    // State
-    user: computed(() => currentUser.value),
-    currentUser: computed(() => currentUser.value),
-    currentSession: computed(() => currentSession.value),
-    isAuthenticated,
-    isLoading: computed(() => isLoading.value || !isInitialized.value),
-    loading,
-    loadingMessage,
-    // Specific loading states
-    isInitializing,
-    isSigningIn,
-    isSigningUp,
-    isSigningOut,
-    isRefreshingToken,
-    isSendingMfaEmail,
-    isVerifyingMfa,
-    // MFA State
-    mfaRequired: computed(() => mfaRequired.value),
-    mfaSessionId: computed(() => mfaSessionId.value),
-    availableMfaMethods: computed(() => availableMfaMethods.value),
-    // Methods
-    signIn,
-    signUp,
-    signOut,
-    refreshToken,
-    fetchProfile,
-    updateProfile,
-    updateUserSettings,
-    changeEmail,
-    changeUsername,
-    getUsernameCooldown,
-    checkUsernameAvailability,
-    // Session management
-    getUserSessions,
-    getSessionStats,
-    revokeSession,
-    revokeAllOtherSessions,
-    initialize,
-    setAuthData,
-    verifyMfa,
-    sendMfaEmailCode,
-    getMfaWebAuthnChallenge,
-    registerHardwareKey,
-    completeHardwareKeyRegistration,
-    // Token management
-    startTokenRefreshTimer,
-    stopTokenRefreshTimer,
-    getAuthHeaders,
-    // Force re-initialization (useful for testing or navigation)
-    forceReInit: () => {
-      isInitialized.value = false;
-      loadingStates.value.initializing = true;
-      initialize();
-    }
-  };
-}
-export {
-  useStrandsAuth as u
-};