@instroc/auth 1.3.1 → 2.0.0-alpha.2

package/dist/chunk-4FR5RRCB.js

@@ -1,1036 +0,0 @@
-// src/forms/use-login-form.ts
-import { useState as useState3, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect3 } from "react";
-
-// src/use-auth.ts
-import { useEffect as useEffect2, useState as useState2 } from "react";
-
-// src/provider.tsx
-import {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
-  useEffect,
-  useRef
-} from "react";
-
-// src/errors.ts
-var AuthError = class _AuthError extends Error {
-  constructor(message, status, code) {
-    super(message);
-    this.name = "AuthError";
-    this.status = status;
-    this.code = code;
-    Object.setPrototypeOf(this, _AuthError.prototype);
-  }
-};
-function authErrorFromResponse(response, data, fallbackMessage) {
-  const body = data ?? {};
-  const message = body.error || fallbackMessage;
-  return new AuthError(message, response.status, body.code);
-}
-
-// src/version.ts
-var SDK_NAME = "instroc-auth";
-var SDK_VERSION = true ? "1.3.1" : "0.0.0-dev";
-function withSdkHeader(init) {
-  const headers = new Headers(init?.headers ?? {});
-  headers.set("X-Instroc-SDK", `${SDK_NAME}/${SDK_VERSION}`);
-  return { ...init, headers };
-}
-
-// src/provider.tsx
-import { jsx } from "react/jsx-runtime";
-var AuthContext = createContext(null);
-var STORAGE_KEY = "instroc_auth_session";
-var WARNING_SESSION_KEY = "instroc_auth_sdk_warning_seen";
-function noteDeprecationWarning(response) {
-  const warning = response.headers?.get?.("X-Instroc-SDK-Warning");
-  if (!warning)
-    return;
-  if (typeof window === "undefined")
-    return;
-  try {
-    if (sessionStorage.getItem(WARNING_SESSION_KEY))
-      return;
-    sessionStorage.setItem(WARNING_SESSION_KEY, "1");
-  } catch {
-  }
-  console.warn(`[instroc-auth] ${warning}`);
-}
-function AuthProvider({
-  children,
-  projectId: initialProjectId,
-  baseUrl = "/api/baas",
-  persistSession = true,
-  onAuthStateChange
-}) {
-  const [projectId, setProjectId] = useState(
-    initialProjectId || null
-  );
-  const [user, setUser] = useState(null);
-  const [session, setSession] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const [authConfig, setAuthConfig] = useState(null);
-  const [visibilityConfig, setVisibilityConfig] = useState(null);
-  const refreshTimeoutRef = useRef(null);
-  const buildUrl = useCallback(
-    (endpoint) => {
-      if (!projectId) {
-        throw new Error("Project ID is required");
-      }
-      return `${baseUrl}/${projectId}/auth/${endpoint}`;
-    },
-    [projectId, baseUrl]
-  );
-  const authFetch = useCallback(async (url, init) => {
-    const response = await fetch(url, {
-      ...withSdkHeader(init),
-      credentials: "include"
-    });
-    noteDeprecationWarning(response);
-    return response;
-  }, []);
-  const saveSession = useCallback(
-    (sessionData) => {
-      if (persistSession && typeof window !== "undefined") {
-        if (sessionData) {
-          localStorage.setItem(STORAGE_KEY, JSON.stringify(sessionData));
-        } else {
-          localStorage.removeItem(STORAGE_KEY);
-        }
-      }
-    },
-    [persistSession]
-  );
-  const loadSession = useCallback(() => {
-    if (persistSession && typeof window !== "undefined") {
-      const stored = localStorage.getItem(STORAGE_KEY);
-      if (stored) {
-        try {
-          return JSON.parse(stored);
-        } catch {
-          localStorage.removeItem(STORAGE_KEY);
-        }
-      }
-    }
-    return null;
-  }, [persistSession]);
-  const scheduleRefresh = useCallback(
-    (expiresAt) => {
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-      const expiresTime = new Date(expiresAt).getTime();
-      const now = Date.now();
-      const refreshIn = expiresTime - now - 5 * 60 * 1e3;
-      if (refreshIn > 0) {
-        refreshTimeoutRef.current = setTimeout(async () => {
-          try {
-            await refreshSession();
-          } catch (err) {
-            console.warn("Token refresh failed:", err);
-            setUser(null);
-            setSession(null);
-            saveSession(null);
-          }
-        }, refreshIn);
-      }
-    },
-    [saveSession]
-  );
-  const updateAuthState = useCallback(
-    (newUser, newSession) => {
-      setUser(newUser);
-      setSession(newSession);
-      saveSession(newSession);
-      if (newSession) {
-        scheduleRefresh(newSession.expires_at);
-      }
-      if (onAuthStateChange) {
-        onAuthStateChange(newUser);
-      }
-    },
-    [saveSession, scheduleRefresh, onAuthStateChange]
-  );
-  const fetchUser = useCallback(async () => {
-    const storedSession = loadSession();
-    if (!storedSession || !projectId) {
-      setLoading(false);
-      return;
-    }
-    try {
-      const response = await authFetch(buildUrl("me"), {
-        headers: {
-          Authorization: `Bearer ${storedSession.access_token}`
-        }
-      });
-      if (response.ok) {
-        const data = await response.json();
-        updateAuthState(data.user, storedSession);
-      } else if (response.status === 401) {
-        try {
-          const refreshResponse = await authFetch(buildUrl("refresh"), {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ refreshToken: storedSession.refresh_token })
-          });
-          if (refreshResponse.ok) {
-            const refreshData = await refreshResponse.json();
-            const newSession = {
-              ...storedSession,
-              access_token: refreshData.access_token,
-              expires_at: refreshData.expires_at
-            };
-            const userResponse = await authFetch(buildUrl("me"), {
-              headers: {
-                Authorization: `Bearer ${newSession.access_token}`
-              }
-            });
-            if (userResponse.ok) {
-              const userData = await userResponse.json();
-              updateAuthState(userData.user, newSession);
-            } else {
-              updateAuthState(null, null);
-            }
-          } else {
-            updateAuthState(null, null);
-          }
-        } catch {
-          updateAuthState(null, null);
-        }
-      } else {
-        updateAuthState(null, null);
-      }
-    } catch (err) {
-      console.error("Failed to fetch user:", err);
-      updateAuthState(null, null);
-    } finally {
-      setLoading(false);
-    }
-  }, [projectId, loadSession, buildUrl, updateAuthState]);
-  useEffect(() => {
-    if (projectId) {
-      fetchUser();
-    } else {
-      setLoading(false);
-    }
-    return () => {
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-    };
-  }, [projectId, fetchUser]);
-  const login = useCallback(
-    async (credentials) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("login"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(credentials)
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Login failed");
-        }
-        const authResponse = data;
-        updateAuthState(authResponse.user, authResponse.session);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Login failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const signup = useCallback(
-    async (credentials) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("signup"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(credentials)
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Signup failed");
-        }
-        const authResponse = data;
-        if (authResponse.needsVerification) {
-          return {
-            status: "needs_verification",
-            email: credentials.email
-          };
-        }
-        if (authResponse.needsApproval) {
-          updateAuthState(authResponse.user, authResponse.session);
-          return { status: "needs_approval", user: authResponse.user };
-        }
-        if (authResponse.session.access_token) {
-          updateAuthState(authResponse.user, authResponse.session);
-          return { status: "authenticated", user: authResponse.user };
-        }
-        return {
-          status: "needs_verification",
-          email: credentials.email
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Signup failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const logout = useCallback(async () => {
-    try {
-      if (session) {
-        await authFetch(buildUrl("logout"), {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${session.access_token}`
-          }
-        });
-      }
-    } catch (err) {
-      console.error("Logout error:", err);
-    } finally {
-      updateAuthState(null, null);
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-    }
-  }, [session, buildUrl, updateAuthState]);
-  const updateProfile = useCallback(
-    async (data) => {
-      if (!session) {
-        throw new AuthError("Not authenticated", 401);
-      }
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("me"), {
-          method: "PATCH",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${session.access_token}`
-          },
-          body: JSON.stringify(data)
-        });
-        const result = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, result, "Update failed");
-        }
-        setUser(result.user);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Update failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [session, buildUrl]
-  );
-  const refreshSession = useCallback(async () => {
-    if (!session)
-      return;
-    const response = await authFetch(buildUrl("refresh"), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refreshToken: session.refresh_token })
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw authErrorFromResponse(response, data, "Refresh failed");
-    }
-    const refreshData = data;
-    const newSession = {
-      ...session,
-      access_token: refreshData.access_token,
-      expires_at: refreshData.expires_at
-    };
-    updateAuthState(user, newSession);
-  }, [session, user, buildUrl, updateAuthState]);
-  const forgotPassword = useCallback(
-    async (email) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("forgot-password"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Request failed");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Request failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const resetPassword = useCallback(
-    async (token, newPassword) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("reset-password"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ token, password: newPassword })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Reset failed");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Reset failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const signInWithOAuth = useCallback(
-    (provider) => {
-      if (!projectId) {
-        setError("Project ID is required");
-        return;
-      }
-      const currentUrl = window.location.origin + window.location.pathname;
-      const oauthUrl = `${baseUrl}/${projectId}/auth/oauth/${provider}?redirect_uri=${encodeURIComponent(currentUrl)}`;
-      window.location.href = oauthUrl;
-    },
-    [projectId, baseUrl]
-  );
-  const verifyOTP = useCallback(
-    async (email, code) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("verify-email"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email, otp: code })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Verification failed");
-        }
-        if (data.session) {
-          updateAuthState(data.user, data.session);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Verification failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const resendOTP = useCallback(
-    async (email) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("resend-verification"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw authErrorFromResponse(response, data, "Failed to resend code");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Failed to resend code";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const fetchAuthConfig = useCallback(async () => {
-    if (!projectId)
-      return;
-    try {
-      const response = await fetch(
-        `${baseUrl}/${projectId}/auth/config`,
-        withSdkHeader()
-      );
-      noteDeprecationWarning(response);
-      if (response.ok) {
-        const data = await response.json();
-        setAuthConfig(data.config || null);
-        setVisibilityConfig(
-          data.visibility || {
-            projectName: "App",
-            visibility: "public",
-            requireLogin: false,
-            logoUrl: null,
-            welcomeMessage: null
-          }
-        );
-      }
-    } catch (err) {
-      console.error("Failed to fetch auth config:", err);
-    }
-  }, [projectId, baseUrl]);
-  const parseOAuthCallback = useCallback(() => {
-    if (typeof window === "undefined")
-      return;
-    const hash = window.location.hash;
-    if (hash && hash.startsWith("#auth=")) {
-      try {
-        const authData = decodeURIComponent(hash.substring(6));
-        const tokenData = JSON.parse(authData);
-        if (tokenData.access_token && tokenData.refresh_token) {
-          const newSession = {
-            access_token: tokenData.access_token,
-            refresh_token: tokenData.refresh_token,
-            expires_at: tokenData.expires_at
-          };
-          saveSession(newSession);
-          setSession(newSession);
-          window.history.replaceState({}, "", window.location.pathname);
-          return true;
-        }
-      } catch {
-      }
-    }
-    const params = new URLSearchParams(window.location.search);
-    const verifyEmailToken = params.get("verify_email");
-    if (verifyEmailToken && projectId) {
-      fetch(
-        buildUrl("verify-email"),
-        withSdkHeader({
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ token: verifyEmailToken })
-        })
-      ).then((res) => res.json()).then(() => {
-        window.history.replaceState({}, "", window.location.pathname);
-      }).catch(() => {
-        window.history.replaceState({}, "", window.location.pathname);
-      });
-      return true;
-    }
-    const accessToken = params.get("access_token");
-    const refreshToken = params.get("refresh_token");
-    const expiresAt = params.get("expires_at");
-    if (accessToken && refreshToken && expiresAt) {
-      const newSession = {
-        access_token: accessToken,
-        refresh_token: refreshToken,
-        expires_at: expiresAt
-      };
-      saveSession(newSession);
-      setSession(newSession);
-      window.history.replaceState({}, "", window.location.pathname);
-      return true;
-    }
-    return false;
-  }, [projectId, buildUrl, saveSession]);
-  useEffect(() => {
-    fetchAuthConfig();
-  }, [fetchAuthConfig]);
-  useEffect(() => {
-    parseOAuthCallback();
-  }, [parseOAuthCallback]);
-  const value = {
-    user,
-    session,
-    loading,
-    error,
-    login,
-    signup,
-    logout,
-    signInWithOAuth,
-    verifyOTP,
-    resendOTP,
-    updateProfile,
-    refreshSession,
-    forgotPassword,
-    resetPassword,
-    setProjectId,
-    projectId,
-    authConfig,
-    visibilityConfig
-  };
-  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
-}
-function useAuthContext() {
-  const context = useContext(AuthContext);
-  if (!context) {
-    throw new Error("useAuthContext must be used within an AuthProvider");
-  }
-  return context;
-}
-
-// src/use-auth.ts
-function useAuth() {
-  return useAuthContext();
-}
-function useUser() {
-  const { user, loading } = useAuthContext();
-  return { user, loading };
-}
-function useSession() {
-  const { session, loading } = useAuthContext();
-  return { session, loading };
-}
-function useAuthRequired() {
-  const { user, loading, session } = useAuthContext();
-  if (loading) {
-    return { user: null, session: null, loading: true };
-  }
-  if (!user) {
-    throw new Error("Authentication required");
-  }
-  return { user, session, loading: false };
-}
-function useIsOwner() {
-  const { user, session, loading } = useAuthContext();
-  if (loading || !user || !session)
-    return false;
-  if (user.is_owner === true)
-    return true;
-  const claim = decodeIsOwnerClaim(session.access_token);
-  return claim === true;
-}
-function useIsWorkspaceMember() {
-  const [isMember, setIsMember] = useState2(() => isDevHost());
-  useEffect2(() => {
-    if (typeof window === "undefined")
-      return;
-    let cancelled = false;
-    (async () => {
-      try {
-        const res = await fetch("/__instroc/workspace-status", {
-          credentials: "include",
-          cache: "no-store"
-        });
-        if (cancelled)
-          return;
-        if (!res.ok) {
-          setIsMember(isDevHost());
-          return;
-        }
-        const data = await res.json();
-        setIsMember(data.isWorkspaceMember === true);
-      } catch {
-        if (!cancelled)
-          setIsMember(isDevHost());
-      }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-  return isMember;
-}
-function isDevHost() {
-  if (typeof window === "undefined")
-    return false;
-  const h = window.location.hostname;
-  return h === "localhost" || h === "127.0.0.1" || h.endsWith(".fly.dev") || h.endsWith(".workers.dev") || h === "preview.instroc.app";
-}
-function decodeIsOwnerClaim(accessToken) {
-  try {
-    const parts = accessToken.split(".");
-    if (parts.length !== 3)
-      return void 0;
-    const payload = parts[1];
-    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
-    const json = typeof atob !== "undefined" ? atob(padded) : Buffer.from(padded, "base64").toString("utf-8");
-    const decoded = JSON.parse(json);
-    return decoded.is_owner;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/forms/use-form-action.ts
-function resolveErrorMessage(err, messages, fallback) {
-  if (err instanceof AuthError) {
-    return messages?.[err.status] ?? err.message ?? fallback;
-  }
-  if (err instanceof Error)
-    return err.message;
-  return fallback;
-}
-function applyErrorResult(err, onError, messages, fallback, setError) {
-  const override = onError?.(err);
-  if (override === null) {
-    setError(null);
-    return;
-  }
-  if (typeof override === "string") {
-    setError(override);
-    return;
-  }
-  setError(resolveErrorMessage(err, messages, fallback));
-}
-
-// src/forms/use-login-form.ts
-function useLoginForm(options = {}) {
-  const { login, user } = useAuth();
-  const { onSuccess, onNeedsVerification, onError, messages } = options;
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const mountedRef = useRef2(true);
-  useEffect3(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const safeSetError = useCallback2((msg) => {
-    if (mountedRef.current)
-      setError(msg);
-  }, []);
-  const clearError = useCallback2(() => safeSetError(null), [safeSetError]);
-  const submit = useCallback2(
-    async (credentials) => {
-      if (mountedRef.current) {
-        setLoading(true);
-        setError(null);
-      }
-      try {
-        await login(credentials);
-        onSuccess?.(user ?? { id: "", email: credentials.email });
-      } catch (err) {
-        if (err instanceof AuthError && err.status === 403 && onNeedsVerification) {
-          safeSetError(null);
-          onNeedsVerification(credentials.email);
-          return;
-        }
-        applyErrorResult(
-          err,
-          onError,
-          messages,
-          "Login failed. Please try again.",
-          safeSetError
-        );
-      } finally {
-        if (mountedRef.current)
-          setLoading(false);
-      }
-    },
-    [
-      login,
-      user,
-      onSuccess,
-      onNeedsVerification,
-      onError,
-      messages,
-      safeSetError
-    ]
-  );
-  return { submit, loading, error, setError: safeSetError, clearError };
-}
-
-// src/forms/use-signup-form.ts
-import { useState as useState4, useCallback as useCallback3, useRef as useRef3, useEffect as useEffect4 } from "react";
-function useSignupForm(options = {}) {
-  const { signup } = useAuth();
-  const { onSuccess, onNeedsVerification, onNeedsApproval, onError, messages } = options;
-  const [loading, setLoading] = useState4(false);
-  const [error, setError] = useState4(null);
-  const mountedRef = useRef3(true);
-  useEffect4(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const safeSetError = useCallback3((msg) => {
-    if (mountedRef.current)
-      setError(msg);
-  }, []);
-  const clearError = useCallback3(() => safeSetError(null), [safeSetError]);
-  const submit = useCallback3(
-    async (credentials) => {
-      if (mountedRef.current) {
-        setLoading(true);
-        setError(null);
-      }
-      try {
-        const result = await signup(credentials);
-        switch (result.status) {
-          case "authenticated":
-            onSuccess?.(result.user);
-            return;
-          case "needs_verification":
-            onNeedsVerification?.(result.email);
-            return;
-          case "needs_approval":
-            onNeedsApproval?.(result.user);
-            return;
-        }
-      } catch (err) {
-        applyErrorResult(
-          err,
-          onError,
-          messages,
-          "Signup failed. Please try again.",
-          safeSetError
-        );
-      } finally {
-        if (mountedRef.current)
-          setLoading(false);
-      }
-    },
-    [
-      signup,
-      onSuccess,
-      onNeedsVerification,
-      onNeedsApproval,
-      onError,
-      messages,
-      safeSetError
-    ]
-  );
-  return { submit, loading, error, setError: safeSetError, clearError };
-}
-
-// src/forms/use-otp-form.ts
-import { useState as useState5, useCallback as useCallback4, useRef as useRef4, useEffect as useEffect5 } from "react";
-function useOtpForm(options) {
-  const { verifyOTP, resendOTP } = useAuth();
-  const {
-    email,
-    onSuccess,
-    onResendSuccess,
-    onError,
-    messages,
-    resendCooldownSeconds = 60
-  } = options;
-  const [loading, setLoading] = useState5(false);
-  const [resending, setResending] = useState5(false);
-  const [resendCooldown, setResendCooldown] = useState5(0);
-  const [error, setError] = useState5(null);
-  const mountedRef = useRef4(true);
-  useEffect5(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  useEffect5(() => {
-    if (resendCooldown <= 0)
-      return;
-    const id = setTimeout(() => setResendCooldown((s) => s - 1), 1e3);
-    return () => clearTimeout(id);
-  }, [resendCooldown]);
-  const safeSetError = useCallback4((msg) => {
-    if (mountedRef.current)
-      setError(msg);
-  }, []);
-  const clearError = useCallback4(() => safeSetError(null), [safeSetError]);
-  const submit = useCallback4(
-    async (code) => {
-      if (mountedRef.current) {
-        setLoading(true);
-        setError(null);
-      }
-      try {
-        await verifyOTP(email, code);
-        onSuccess?.();
-      } catch (err) {
-        applyErrorResult(
-          err,
-          onError,
-          messages,
-          "Verification failed. Please try again.",
-          safeSetError
-        );
-      } finally {
-        if (mountedRef.current)
-          setLoading(false);
-      }
-    },
-    [verifyOTP, email, onSuccess, onError, messages, safeSetError]
-  );
-  const resend = useCallback4(async () => {
-    if (resendCooldown > 0)
-      return;
-    if (mountedRef.current) {
-      setResending(true);
-      setError(null);
-    }
-    try {
-      await resendOTP(email);
-      if (mountedRef.current)
-        setResendCooldown(resendCooldownSeconds);
-      onResendSuccess?.();
-    } catch (err) {
-      applyErrorResult(
-        err,
-        onError,
-        messages,
-        "Could not resend code. Please try again.",
-        safeSetError
-      );
-    } finally {
-      if (mountedRef.current)
-        setResending(false);
-    }
-  }, [
-    resendCooldown,
-    resendOTP,
-    email,
-    resendCooldownSeconds,
-    onResendSuccess,
-    onError,
-    messages,
-    safeSetError
-  ]);
-  return {
-    submit,
-    resend,
-    loading,
-    resending,
-    resendCooldown,
-    error,
-    setError: safeSetError,
-    clearError
-  };
-}
-
-// src/forms/use-forgot-password-form.ts
-import { useState as useState6, useCallback as useCallback5, useRef as useRef5, useEffect as useEffect6 } from "react";
-function useForgotPasswordForm(options = {}) {
-  const { forgotPassword } = useAuth();
-  const { onSuccess, onError, messages } = options;
-  const [loading, setLoading] = useState6(false);
-  const [submitted, setSubmitted] = useState6(false);
-  const [error, setError] = useState6(null);
-  const mountedRef = useRef5(true);
-  useEffect6(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const safeSetError = useCallback5((msg) => {
-    if (mountedRef.current)
-      setError(msg);
-  }, []);
-  const clearError = useCallback5(() => safeSetError(null), [safeSetError]);
-  const reset = useCallback5(() => {
-    if (mountedRef.current) {
-      setSubmitted(false);
-      setError(null);
-    }
-  }, []);
-  const submit = useCallback5(
-    async (email) => {
-      if (mountedRef.current) {
-        setLoading(true);
-        setError(null);
-      }
-      try {
-        await forgotPassword(email);
-        if (mountedRef.current)
-          setSubmitted(true);
-        onSuccess?.(email);
-      } catch (err) {
-        applyErrorResult(
-          err,
-          onError,
-          messages,
-          "Could not send reset link. Please try again.",
-          safeSetError
-        );
-      } finally {
-        if (mountedRef.current)
-          setLoading(false);
-      }
-    },
-    [forgotPassword, onSuccess, onError, messages, safeSetError]
-  );
-  return {
-    submit,
-    loading,
-    submitted,
-    error,
-    setError: safeSetError,
-    clearError,
-    reset
-  };
-}
-
-// src/forms/use-reset-password-form.ts
-import { useState as useState7, useCallback as useCallback6, useRef as useRef6, useEffect as useEffect7 } from "react";
-function useResetPasswordForm(options) {
-  const { resetPassword } = useAuth();
-  const { token, onSuccess, onError, messages } = options;
-  const [loading, setLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const mountedRef = useRef6(true);
-  useEffect7(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const safeSetError = useCallback6((msg) => {
-    if (mountedRef.current)
-      setError(msg);
-  }, []);
-  const clearError = useCallback6(() => safeSetError(null), [safeSetError]);
-  const submit = useCallback6(
-    async (newPassword) => {
-      if (mountedRef.current) {
-        setLoading(true);
-        setError(null);
-      }
-      try {
-        await resetPassword(token, newPassword);
-        onSuccess?.();
-      } catch (err) {
-        applyErrorResult(
-          err,
-          onError,
-          messages,
-          "Could not reset password. Please try again.",
-          safeSetError
-        );
-      } finally {
-        if (mountedRef.current)
-          setLoading(false);
-      }
-    },
-    [resetPassword, token, onSuccess, onError, messages, safeSetError]
-  );
-  return { submit, loading, error, setError: safeSetError, clearError };
-}
-
-export {
-  AuthError,
-  AuthProvider,
-  useAuthContext,
-  useAuth,
-  useUser,
-  useSession,
-  useAuthRequired,
-  useIsOwner,
-  useIsWorkspaceMember,
-  useLoginForm,
-  useSignupForm,
-  useOtpForm,
-  useForgotPasswordForm,
-  useResetPasswordForm
-};