svelte-firekit 0.1.0 → 0.1.2

package/dist/components/auth-guard.svelte

@@ -36,8 +36,14 @@
 		fallback?: Snippet<[]>;
 	} = $props();
 
-	// Get Firebase Auth instance
-	const auth = firebaseService.getAuthInstance();
+	// Get Firebase Auth instance with error handling
+	let auth: Auth | null = null;
+	try {
+		auth = firebaseService.getAuthInstance();
+	} catch (error) {
+		console.warn('Firebase Auth not available:', error);
+	}
+
 	if (!auth) {
 		throw new Error('Firebase Auth instance not available');
 	}

package/dist/firebase.js

@@ -129,9 +129,21 @@ class FirebaseService {
      */
     getDbInstance() {
         if (!this.db) {
-            this.getFirebaseApp();
-            if (!this.db) {
-                throw new FirebaseServiceError('Firestore instance not available', 'firestore');
+            try {
+                this.getFirebaseApp();
+                if (!this.db) {
+                    // If we're not in a browser environment, Firestore won't be available
+                    if (!this.isBrowser) {
+                        throw new FirebaseServiceError('Firestore is not available in server environment', 'firestore');
+                    }
+                    throw new FirebaseServiceError('Firestore instance not available', 'firestore');
+                }
+            }
+            catch (error) {
+                if (error instanceof FirebaseServiceError) {
+                    throw error;
+                }
+                throw new FirebaseServiceError('Failed to initialize Firestore', 'firestore');
             }
         }
         return this.db;

package/dist/services/auth.d.ts

@@ -31,6 +31,7 @@ declare class FirekitAuth {
     private static instance;
     private auth;
     private firestore;
+    private _servicesInitialized;
     private authState;
     private stateListeners;
     private recaptchaVerifiers;
@@ -40,6 +41,11 @@ declare class FirekitAuth {
      * @returns {FirekitAuth} The FirekitAuth instance
      */
     static getInstance(): FirekitAuth;
+    /**
+     * Initializes Firebase services and auth state listener
+     * @private
+     */
+    private initializeServices;
     /**
      * Initializes the authentication state listener
      * @private
@@ -263,14 +269,18 @@ declare class FirekitAuth {
      * @example
      * ```typescript
      * await firekitAuth.sendEmailVerification();
-     * console.log("Verification email sent");
      * ```
      */
     sendEmailVerification(): Promise<void>;
     /**
-     * Reloads current user to get updated email verification status
+     * Reloads user to get updated data
      * @returns {Promise<void>} Promise that resolves when user is reloaded
      * @throws {FirekitAuthError} If reload fails
+     *
+     * @example
+     * ```typescript
+     * await firekitAuth.reloadUser();
+     * ```
      */
     reloadUser(): Promise<void>;
     /**
@@ -282,21 +292,17 @@ declare class FirekitAuth {
      * @example
      * ```typescript
      * const token = await firekitAuth.getIdToken();
-     * // Use token for authenticated API calls
      * ```
      */
     getIdToken(forceRefresh?: boolean): Promise<string>;
     /**
-     * Reauthenticates current user with email/password
-     * @param {string} currentPassword Current password
-     * @returns {Promise<void>} Promise that resolves when reauthentication succeeds
-     * @throws {FirekitAuthError} If reauthentication fails
+     * Reauthenticates user with current password
      * @private
      */
     private reauthenticateUser;
     /**
-     * Deletes user account and associated data
-     * @param {string} [currentPassword] Current password for reauthentication (required for email/password accounts)
+     * Deletes user account
+     * @param {string} [currentPassword] Current password for reauthentication
      * @returns {Promise<AccountDeletionResult>} Promise resolving to deletion result
      *
      * @example
@@ -304,12 +310,14 @@ declare class FirekitAuth {
      * const result = await firekitAuth.deleteAccount("currentPassword123");
      * if (result.success) {
      *   console.log("Account deleted successfully");
+     * } else {
+     *   console.error("Deletion failed:", result.message);
      * }
      * ```
      */
     deleteAccount(currentPassword?: string): Promise<AccountDeletionResult>;
     /**
-     * Signs out current user
+     * Signs out the current user
      * @returns {Promise<void>} Promise that resolves when sign-out completes
      * @throws {FirekitAuthError} If sign-out fails
      *
@@ -336,7 +344,7 @@ declare class FirekitAuth {
      */
     isEmailVerified(): boolean;
     /**
-     * Gets user's primary email address
+     * Gets user's email address
      * @returns {string | null} User's email or null
      */
     getUserEmail(): string | null;
@@ -351,13 +359,13 @@ declare class FirekitAuth {
      */
     getUserPhotoURL(): string | null;
     /**
-     * Gets user's UID
+     * Gets user's unique ID
      * @returns {string | null} User's UID or null
      */
     getUserId(): string | null;
     /**
-     * Cleans up all resources
-     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     * Cleans up resources and listeners
+     * @returns {Promise<void>} Promise that resolves when cleanup completes
      */
     cleanup(): Promise<void>;
 }

package/dist/services/auth.js

@@ -32,8 +32,9 @@ import { mapFirebaseUserToProfile, updateUserInFirestore, createGoogleProvider,
  */
 class FirekitAuth {
     static instance;
-    auth = firebaseService.getAuthInstance();
-    firestore = firebaseService.getDbInstance();
+    auth = null;
+    firestore = null;
+    _servicesInitialized = false;
     authState = {
         user: null,
         loading: true,
@@ -42,13 +43,8 @@ class FirekitAuth {
     stateListeners = new Set();
     recaptchaVerifiers = new Map();
     constructor() {
-        if (!this.auth) {
-            throw new Error('Firebase Auth instance not available');
-        }
-        if (!this.firestore) {
-            throw new Error('Firestore instance not available');
-        }
-        this.initializeAuthStateListener();
+        // Don't initialize Firebase services in constructor
+        // They will be initialized lazily when needed
     }
     /**
      * Gets singleton instance of FirekitAuth
@@ -60,11 +56,45 @@ class FirekitAuth {
         }
         return FirekitAuth.instance;
     }
+    /**
+     * Initializes Firebase services and auth state listener
+     * @private
+     */
+    initializeServices() {
+        if (this._servicesInitialized)
+            return;
+        try {
+            this.auth = firebaseService.getAuthInstance();
+            // Try to get Firestore instance, but don't fail if it's not available
+            try {
+                this.firestore = firebaseService.getDbInstance();
+            }
+            catch (firestoreError) {
+                console.warn('Firestore not available, continuing without Firestore integration:', firestoreError);
+                this.firestore = null;
+            }
+            this._servicesInitialized = true;
+            this.initializeAuthStateListener();
+        }
+        catch (error) {
+            console.error('Failed to initialize Firebase services:', error);
+            this.authState = {
+                user: null,
+                loading: false,
+                initialized: true
+            };
+            this.notifyStateListeners();
+        }
+    }
     /**
      * Initializes the authentication state listener
      * @private
      */
     initializeAuthStateListener() {
+        if (!this.auth) {
+            console.error('Auth instance not available');
+            return;
+        }
         onAuthStateChanged(this.auth, (user) => {
             this.authState = {
                 user: user ? this.mapFirebaseUserToProfile(user) : null,
@@ -101,6 +131,10 @@ class FirekitAuth {
      * @private
      */
     async updateUserInFirestore(user) {
+        if (!this.firestore) {
+            console.warn('Firestore not available, skipping user update in Firestore');
+            return;
+        }
         await updateUserInFirestore(this.firestore, user);
     }
     /**
@@ -115,6 +149,7 @@ class FirekitAuth {
      * @returns {AuthState} Current authentication state
      */
     getState() {
+        this.initializeServices();
         return { ...this.authState };
     }
     /**
@@ -122,13 +157,15 @@ class FirekitAuth {
      * @returns {User | null} Current Firebase user or null
      */
     getCurrentUser() {
-        return this.auth.currentUser;
+        this.initializeServices();
+        return this.auth?.currentUser ?? null;
     }
     /**
      * Gets the current user profile
      * @returns {UserProfile | null} Current user profile or null
      */
     getCurrentUserProfile() {
+        this.initializeServices();
         return this.authState.user;
     }
     /**
@@ -136,6 +173,7 @@ class FirekitAuth {
      * @returns {Promise<UserProfile | null>} Promise that resolves when auth is initialized
      */
     async waitForAuth() {
+        this.initializeServices();
         return new Promise((resolve) => {
             if (this.authState.initialized) {
                 resolve(this.authState.user);
@@ -155,6 +193,7 @@ class FirekitAuth {
      * @returns {Function} Unsubscribe function
      */
     onAuthStateChanged(callback) {
+        this.initializeServices();
         this.stateListeners.add(callback);
         // Immediately call with current state
         callback(this.authState);
@@ -183,6 +222,10 @@ class FirekitAuth {
      * ```
      */
     async signInWithEmail(email, password) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -216,6 +259,10 @@ class FirekitAuth {
      * ```
      */
     async signInWithGoogle() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -238,6 +285,10 @@ class FirekitAuth {
      * @throws {FirekitAuthError} If sign-in fails
      */
     async signInWithFacebook() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -260,6 +311,10 @@ class FirekitAuth {
      * @throws {FirekitAuthError} If sign-in fails
      */
     async signInWithApple() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -288,6 +343,10 @@ class FirekitAuth {
      * ```
      */
     async signInAnonymously() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -317,6 +376,10 @@ class FirekitAuth {
      * ```
      */
     async signInWithPhoneNumber(phoneNumber, recaptchaContainerId) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -339,11 +402,11 @@ class FirekitAuth {
             const confirmationResult = await firebaseSignInWithPhoneNumber(this.auth, phoneNumber, recaptchaVerifier);
             return {
                 verificationId: confirmationResult.verificationId,
-                confirm: async (code) => {
+                confirm: async (verificationCode) => {
                     try {
-                        const result = await confirmationResult.confirm(code);
-                        await this.updateUserInFirestore(result.user);
-                        return this.mapFirebaseUserToProfile(result.user);
+                        const userCredential = await confirmationResult.confirm(verificationCode);
+                        await this.updateUserInFirestore(userCredential.user);
+                        return this.mapFirebaseUserToProfile(userCredential.user);
                     }
                     catch (error) {
                         this.handleAuthError(error);
@@ -387,6 +450,10 @@ class FirekitAuth {
      * ```
      */
     async registerWithEmail(email, password, displayName, sendVerification = true) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             this.authState.loading = true;
             this.notifyStateListeners();
@@ -427,6 +494,10 @@ class FirekitAuth {
      * ```
      */
     async sendPasswordReset(email) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             await sendPasswordResetEmail(this.auth, email);
         }
@@ -442,6 +513,10 @@ class FirekitAuth {
      * @throws {FirekitAuthError} If reset fails
      */
     async confirmPasswordReset(code, newPassword) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
             await confirmPasswordReset(this.auth, code, newPassword);
         }
@@ -466,7 +541,8 @@ class FirekitAuth {
      * ```
      */
     async updatePassword(newPassword, currentPassword) {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             return {
                 success: false,
                 message: 'No authenticated user found.',
@@ -517,7 +593,8 @@ class FirekitAuth {
      * ```
      */
     async updateUserProfile(profile) {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             throw new FirekitAuthError('auth/no-current-user', 'No authenticated user found.');
         }
         try {
@@ -540,7 +617,8 @@ class FirekitAuth {
      * ```
      */
     async updateEmail(newEmail) {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             throw new FirekitAuthError('auth/no-current-user', 'No authenticated user found.');
         }
         try {
@@ -551,9 +629,6 @@ class FirekitAuth {
             this.handleAuthError(error);
         }
     }
-    // ========================================
-    // EMAIL VERIFICATION METHODS
-    // ========================================
     /**
      * Sends email verification to current user
      * @returns {Promise<void>} Promise that resolves when verification email is sent
@@ -562,11 +637,11 @@ class FirekitAuth {
      * @example
      * ```typescript
      * await firekitAuth.sendEmailVerification();
-     * console.log("Verification email sent");
      * ```
      */
     async sendEmailVerification() {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             throw new FirekitAuthError('auth/no-current-user', 'No authenticated user found.');
         }
         try {
@@ -577,12 +652,18 @@ class FirekitAuth {
         }
     }
     /**
-     * Reloads current user to get updated email verification status
+     * Reloads user to get updated data
      * @returns {Promise<void>} Promise that resolves when user is reloaded
      * @throws {FirekitAuthError} If reload fails
+     *
+     * @example
+     * ```typescript
+     * await firekitAuth.reloadUser();
+     * ```
      */
     async reloadUser() {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             throw new FirekitAuthError('auth/no-current-user', 'No authenticated user found.');
         }
         try {
@@ -593,9 +674,6 @@ class FirekitAuth {
             this.handleAuthError(error);
         }
     }
-    // ========================================
-    // TOKEN METHODS
-    // ========================================
     /**
      * Gets the current user's ID token
      * @param {boolean} [forceRefresh=false] Whether to force token refresh
@@ -605,11 +683,11 @@ class FirekitAuth {
      * @example
      * ```typescript
      * const token = await firekitAuth.getIdToken();
-     * // Use token for authenticated API calls
      * ```
      */
     async getIdToken(forceRefresh = false) {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             throw new FirekitAuthError('auth/no-current-user', 'No authenticated user found.');
         }
         try {
@@ -619,31 +697,26 @@ class FirekitAuth {
             this.handleAuthError(error);
         }
     }
-    // ========================================
-    // ACCOUNT MANAGEMENT
-    // ========================================
     /**
-     * Reauthenticates current user with email/password
-     * @param {string} currentPassword Current password
-     * @returns {Promise<void>} Promise that resolves when reauthentication succeeds
-     * @throws {FirekitAuthError} If reauthentication fails
+     * Reauthenticates user with current password
      * @private
      */
     async reauthenticateUser(currentPassword) {
-        if (!this.auth.currentUser || !this.auth.currentUser.email) {
-            throw new FirekitAuthError('auth/no-current-user', 'No authenticated user or email unavailable.');
+        this.initializeServices();
+        if (!this.auth?.currentUser || !this.auth.currentUser.email) {
+            throw new FirekitAuthError('auth/no-current-user', 'No authenticated user with email found.');
         }
         try {
             const credential = EmailAuthProvider.credential(this.auth.currentUser.email, currentPassword);
             await reauthenticateWithCredential(this.auth.currentUser, credential);
         }
         catch (error) {
-            throw new FirekitAuthError(error.code || 'auth/reauthentication-failed', `Reauthentication failed: ${error.message || 'Unknown error occurred.'}`);
+            this.handleAuthError(error);
         }
     }
     /**
-     * Deletes user account and associated data
-     * @param {string} [currentPassword] Current password for reauthentication (required for email/password accounts)
+     * Deletes user account
+     * @param {string} [currentPassword] Current password for reauthentication
      * @returns {Promise<AccountDeletionResult>} Promise resolving to deletion result
      *
      * @example
@@ -651,11 +724,14 @@ class FirekitAuth {
      * const result = await firekitAuth.deleteAccount("currentPassword123");
      * if (result.success) {
      *   console.log("Account deleted successfully");
+     * } else {
+     *   console.error("Deletion failed:", result.message);
      * }
      * ```
      */
     async deleteAccount(currentPassword) {
-        if (!this.auth.currentUser) {
+        this.initializeServices();
+        if (!this.auth?.currentUser) {
             return {
                 success: false,
                 message: 'No authenticated user found.'
@@ -663,19 +739,21 @@ class FirekitAuth {
         }
         try {
             const user = this.auth.currentUser;
-            // Reauthenticate if password provided (required for email/password accounts)
+            // Reauthenticate if password provided
             if (currentPassword) {
                 await this.reauthenticateUser(currentPassword);
             }
-            // Delete user data from Firestore first
-            try {
-                const userRef = doc(this.firestore, 'users', user.uid);
-                await setDoc(userRef, { deleted: true, deletedAt: serverTimestamp() }, { merge: true });
-            }
-            catch (firestoreError) {
-                console.error('Failed to mark user as deleted in Firestore:', firestoreError);
+            // Delete user data from Firestore first (if available)
+            if (this.firestore) {
+                try {
+                    const userRef = doc(this.firestore, 'users', user.uid);
+                    await setDoc(userRef, { deleted: true, deletedAt: serverTimestamp() }, { merge: true });
+                }
+                catch (firestoreError) {
+                    console.warn('Failed to update Firestore before account deletion:', firestoreError);
+                }
             }
-            // Delete the Firebase Auth account
+            // Delete the user account
             await deleteUser(user);
             return {
                 success: true,
@@ -683,24 +761,14 @@ class FirekitAuth {
             };
         }
         catch (error) {
-            const code = error.code;
-            if (code === AuthErrorCode.REQUIRES_RECENT_LOGIN) {
-                return {
-                    success: false,
-                    message: 'Please sign in again before deleting your account.'
-                };
-            }
             return {
                 success: false,
                 message: error.message || 'Failed to delete account.'
             };
         }
     }
-    // ========================================
-    // SIGN OUT
-    // ========================================
     /**
-     * Signs out current user
+     * Signs out the current user
      * @returns {Promise<void>} Promise that resolves when sign-out completes
      * @throws {FirekitAuthError} If sign-out fails
      *
@@ -711,10 +779,12 @@ class FirekitAuth {
      * ```
      */
     async signOut() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         try {
-            this.authState.loading = true;
-            this.notifyStateListeners();
-            // Clear all reCAPTCHA verifiers
+            // Clear reCAPTCHA verifiers
             this.recaptchaVerifiers.forEach((verifier) => verifier.clear());
             this.recaptchaVerifiers.clear();
             await signOut(this.auth);
@@ -722,10 +792,6 @@ class FirekitAuth {
         catch (error) {
             this.handleAuthError(error);
         }
-        finally {
-            this.authState.loading = false;
-            this.notifyStateListeners();
-        }
     }
     // ========================================
     // UTILITY METHODS
@@ -735,66 +801,68 @@ class FirekitAuth {
      * @returns {boolean} True if user is authenticated
      */
     isAuthenticated() {
-        return !!this.authState.user && !this.authState.user.isAnonymous;
+        this.initializeServices();
+        return this.authState.user !== null && !this.authState.user.isAnonymous;
     }
     /**
      * Checks if user is anonymous
      * @returns {boolean} True if user is anonymous
      */
     isAnonymous() {
-        return !!this.authState.user?.isAnonymous;
+        this.initializeServices();
+        return this.authState.user?.isAnonymous ?? false;
     }
     /**
      * Checks if user's email is verified
      * @returns {boolean} True if email is verified
      */
     isEmailVerified() {
-        return !!this.authState.user?.emailVerified;
+        this.initializeServices();
+        return this.authState.user?.emailVerified ?? false;
     }
     /**
-     * Gets user's primary email address
+     * Gets user's email address
      * @returns {string | null} User's email or null
      */
     getUserEmail() {
-        return this.authState.user?.email || null;
+        this.initializeServices();
+        return this.authState.user?.email ?? null;
     }
     /**
      * Gets user's display name
      * @returns {string | null} User's display name or null
      */
     getUserDisplayName() {
-        return this.authState.user?.displayName || null;
+        this.initializeServices();
+        return this.authState.user?.displayName ?? null;
     }
     /**
      * Gets user's photo URL
      * @returns {string | null} User's photo URL or null
      */
     getUserPhotoURL() {
-        return this.authState.user?.photoURL || null;
+        this.initializeServices();
+        return this.authState.user?.photoURL ?? null;
     }
     /**
-     * Gets user's UID
+     * Gets user's unique ID
      * @returns {string | null} User's UID or null
      */
     getUserId() {
-        return this.authState.user?.uid || null;
+        this.initializeServices();
+        return this.authState.user?.uid ?? null;
     }
     /**
-     * Cleans up all resources
-     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     * Cleans up resources and listeners
+     * @returns {Promise<void>} Promise that resolves when cleanup completes
      */
     async cleanup() {
-        // Clear all listeners
-        this.stateListeners.clear();
-        // Clear all reCAPTCHA verifiers
+        this.initializeServices();
+        // Clear reCAPTCHA verifiers
         this.recaptchaVerifiers.forEach((verifier) => verifier.clear());
         this.recaptchaVerifiers.clear();
-        // Reset state
-        this.authState = {
-            user: null,
-            loading: false,
-            initialized: false
-        };
+        // Clear state listeners
+        this.stateListeners.clear();
     }
 }
 /**

package/dist/services/user.svelte.d.ts

@@ -48,6 +48,7 @@ declare class FirekitUserStore {
     private static instance;
     private auth;
     private firestore;
+    private _servicesInitialized;
     /** Current user profile state */
     private _user;
     /** Loading state indicator */
@@ -78,6 +79,11 @@ declare class FirekitUserStore {
      * @returns {FirekitUserStore} The FirekitUserStore instance
      */
     static getInstance(): FirekitUserStore;
+    /**
+     * Initializes Firebase services and auth state listener
+     * @private
+     */
+    private initializeServices;
     /**
      * Initializes the authentication state listener
      * @private

package/dist/services/user.svelte.js

@@ -31,8 +31,9 @@ import { mapFirebaseUserToProfile, updateUserInFirestore, createAuthError, valid
  */
 class FirekitUserStore {
     static instance;
-    auth = firebaseService.getAuthInstance();
-    firestore = firebaseService.getDbInstance();
+    auth = null;
+    firestore = null;
+    _servicesInitialized = false;
     // ========================================
     // REACTIVE STATE (Svelte 5 Runes)
     // ========================================
@@ -64,13 +65,8 @@ class FirekitUserStore {
     /** Derived: User's phone number */
     _userPhoneNumber = $derived(this._user?.phoneNumber ?? null);
     constructor() {
-        if (!this.auth) {
-            throw new Error('Firebase Auth instance not available');
-        }
-        if (!this.firestore) {
-            throw new Error('Firestore instance not available');
-        }
-        this.initializeAuthStateListener();
+        // Don't initialize Firebase services in constructor
+        // They will be initialized lazily when needed
     }
     /**
      * Gets singleton instance of FirekitUserStore
@@ -82,11 +78,35 @@ class FirekitUserStore {
         }
         return FirekitUserStore.instance;
     }
+    /**
+     * Initializes Firebase services and auth state listener
+     * @private
+     */
+    initializeServices() {
+        if (this._servicesInitialized)
+            return;
+        try {
+            this.auth = firebaseService.getAuthInstance();
+            this.firestore = firebaseService.getDbInstance();
+            this._servicesInitialized = true;
+            this.initializeAuthStateListener();
+        }
+        catch (error) {
+            console.error('Failed to initialize Firebase services:', error);
+            this._error = error instanceof Error ? error : new Error(String(error));
+            this._loading = false;
+            this._initialized = true;
+        }
+    }
     /**
      * Initializes the authentication state listener
      * @private
      */
     initializeAuthStateListener() {
+        if (!this.auth) {
+            console.error('Auth instance not available');
+            return;
+        }
         onAuthStateChanged(this.auth, (firebaseUser) => {
             this._user = firebaseUser ? this.mapFirebaseUserToProfile(firebaseUser) : null;
             this._loading = false;
@@ -111,6 +131,9 @@ class FirekitUserStore {
      * @private
      */
     async updateUserInFirestore(user) {
+        if (!this.firestore) {
+            throw new Error('Firestore instance not available');
+        }
         await updateUserInFirestore(this.firestore, user);
     }
     // ========================================
@@ -118,50 +141,62 @@ class FirekitUserStore {
     // ========================================
     /** Current user profile */
     get user() {
+        this.initializeServices();
         return this._user;
     }
     /** Current loading state */
     get loading() {
+        this.initializeServices();
         return this._loading;
     }
     /** Whether auth has been initialized */
     get initialized() {
+        this.initializeServices();
         return this._initialized;
     }
     /** Current error state */
     get error() {
+        this.initializeServices();
         return this._error;
     }
     /** Whether user is authenticated (not anonymous) */
     get isAuthenticated() {
+        this.initializeServices();
         return this._isAuthenticated;
     }
     /** Whether user is anonymous */
     get isAnonymous() {
+        this.initializeServices();
         return this._isAnonymous;
     }
     /** Whether user's email is verified */
     get isEmailVerified() {
+        this.initializeServices();
         return this._isEmailVerified;
     }
     /** User's email address */
     get email() {
+        this.initializeServices();
         return this._userEmail;
     }
     /** User's display name */
     get displayName() {
+        this.initializeServices();
         return this._userDisplayName;
     }
     /** User's photo URL */
     get photoURL() {
+        this.initializeServices();
         return this._userPhotoURL;
     }
     /** User's unique ID */
     get uid() {
+        this.initializeServices();
         return this._userId;
     }
     /** User's phone number */
     get phoneNumber() {
+        this.initializeServices();
         return this._userPhoneNumber;
     }
     // ========================================
@@ -179,6 +214,10 @@ class FirekitUserStore {
      * ```
      */
     async updateDisplayName(displayName) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -209,6 +248,10 @@ class FirekitUserStore {
      * ```
      */
     async updatePhotoURL(photoURL) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -242,6 +285,10 @@ class FirekitUserStore {
      * ```
      */
     async updateProfile(profileData) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -276,6 +323,10 @@ class FirekitUserStore {
      * ```
      */
     async updateEmail(newEmail) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -306,6 +357,10 @@ class FirekitUserStore {
      * ```
      */
     async updatePassword(newPassword) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -333,6 +388,10 @@ class FirekitUserStore {
      * ```
      */
     async sendEmailVerification() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             await sendEmailVerification(currentUser);
@@ -353,6 +412,10 @@ class FirekitUserStore {
      * ```
      */
     async reloadUser() {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             this._loading = true;
@@ -384,6 +447,10 @@ class FirekitUserStore {
      * ```
      */
     async getIdToken(forceRefresh = false) {
+        this.initializeServices();
+        if (!this.auth) {
+            throw new Error('Auth instance not available');
+        }
         const currentUser = validateCurrentUser(this.auth);
         try {
             return await getIdToken(currentUser, forceRefresh);
@@ -407,7 +474,8 @@ class FirekitUserStore {
      * ```
      */
     async getExtendedUserData() {
-        if (!this._user?.uid) {
+        this.initializeServices();
+        if (!this._user?.uid || !this.firestore) {
             return null;
         }
         try {
@@ -438,9 +506,13 @@ class FirekitUserStore {
      * ```
      */
     async updateExtendedUserData(data) {
+        this.initializeServices();
         if (!this._user?.uid) {
             throw new FirekitAuthError(AuthErrorCode.USER_NOT_FOUND, 'No authenticated user found.');
         }
+        if (!this.firestore) {
+            throw new Error('Firestore instance not available');
+        }
         try {
             const userRef = doc(this.firestore, 'users', this._user.uid);
             await setDoc(userRef, {
@@ -469,6 +541,7 @@ class FirekitUserStore {
      * ```
      */
     async waitForAuth() {
+        this.initializeServices();
         return new Promise((resolve) => {
             if (this._initialized) {
                 resolve(this._user);
@@ -508,6 +581,9 @@ class FirekitUserStore {
         this._loading = true;
         this._initialized = false;
         this._error = null;
+        this._servicesInitialized = false;
+        this.auth = null;
+        this.firestore = null;
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-firekit",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite dev",