vybekiit 0.4.0 → 0.6.0

package/dist/global-skills/firebase-auth-basics/references/flutter_setup.md

@@ -0,0 +1,149 @@
+# Firebase Auth & Google Sign-In for Flutter
+
+When integrating Firebase Authentication and Google Sign-In into Flutter apps
+targeting cross-platform environments (like Mobile + Web), you must navigate
+several breaking changes introduced in `google_sign_in` 7.x+ and some
+platform-specific quirks.
+
+## 1. `google_sign_in` 7.2.0 API Changes
+
+- **Method Renamed**: The `signIn()` method is deprecated/removed and has been
+  replaced with `authenticate()`.
+- **Token Separation**: The `GoogleSignInAuthentication` object no longer
+  packages both identity and authorization tokens together. Initial
+  authentication now only provides the `idToken`. If an `accessToken` is
+  required for Google APIs, you must explicitly request server authorization
+  separately.
+
+## 2. Initialization & Web Hang/Crash Pitfalls
+
+- **Initialization Requirement**: In 7.x, you must call
+  `await GoogleSignIn.instance.initialize();` globally before using the plugin.
+- **Web Client ID Constraint**: On Flutter Web, if you call `initialize()`
+  without passing a `clientId` argument OR specifying the
+  `<meta name="google-signin-client_id" ... />` tag in `web/index.html`, the
+  Dart Web Debug Service (DWDS) and the app will throw an assertion error and
+  **hang infinitely**, resulting in a blank screen.
+- **Common Workaround**: If you intend to use Firebase Auth's
+  `signInWithPopup(GoogleAuthProvider())` for the web, you can conditionally
+  skip the local `GoogleSignIn` package initialization entirely:
+  ```dart
+  import 'package:flutter/foundation.dart' show kIsWeb;
+
+  if (!kIsWeb) {
+    await GoogleSignIn.instance.initialize();
+  }
+  ```
+
+## 3. Web Logout Crashes
+
+- If you bypassed `GoogleSignIn` initialization on the web (as demonstrated
+  above), you cannot call its `signOut()` method later. Attempting to execute
+  `await GoogleSignIn.instance.signOut();` during the user's logout flow on the
+  Web platform evaluates against an uninitialized context or unsupported
+  environment, crashing the app.
+- **Solution**: Conditionally separate the logout logic for Web to rely entirely
+  on `FirebaseAuth`:
+  ```dart
+  if (!kIsWeb) {
+      await GoogleSignIn.instance.signOut();
+  }
+  await FirebaseAuth.instance.signOut();
+  ```
+
+## 4. Prototyping Workaround: Bypassing Firestore Composite Indices
+
+*Note: This is a Firestore consideration frequently encountered while fetching
+user-specific auth data.*
+
+When querying data via `FirebaseFirestore.instance`, using
+`.where('userId', isEqualTo: uid)` combined with a sort on a different field
+like `.orderBy('createdAt', descending: true)` mandates a custom composite
+index.
+
+- **Quick Alternative**: During local development, you can avoid defining
+  indexes by pulling the data using only `.where()` and applying the `.sort()`
+  operation client-side on the resulting `List` in Dart.
+
+## 5. Robust `AuthService` Boilerplate
+
+Here is a comprehensive `AuthService` implementation that properly handles the
+initialization and platform differences between Flutter Web and Mobile:
+
+```dart
+import 'package:firebase_auth/firebase_auth.dart';
+import 'package:flutter/foundation.dart';
+import 'package:google_sign_in/google_sign_in.dart';
+
+class AuthService {
+  final FirebaseAuth _auth = FirebaseAuth.instance;
+
+  AuthService() {
+    if (!kIsWeb) {
+      GoogleSignIn.instance.initialize();
+    }
+  }
+
+  // Stream to listen to auth state changes
+  Stream<User?> get authStateChanges => _auth.authStateChanges();
+
+  // Get current user
+  User? get currentUser => _auth.currentUser;
+
+  // Google Sign-In
+  Future<UserCredential?> signInWithGoogle() async {
+    try {
+      if (kIsWeb) {
+        // Web uses popup to avoid DWDS hangs and manual client ID config
+        GoogleAuthProvider authProvider = GoogleAuthProvider();
+        return await _auth.signInWithPopup(authProvider);
+      } else {
+        // Mobile uses standard flow
+        final GoogleSignInAccount? googleUser = await GoogleSignIn.instance.authenticate();
+        if (googleUser == null) return null; // Cancelled
+
+        final GoogleSignInAuthentication googleAuth = await googleUser.authentication;
+        
+        final AuthCredential credential = GoogleAuthProvider.credential(
+          idToken: googleAuth.idToken,
+        );
+        
+        return await _auth.signInWithCredential(credential);
+      }
+    } catch (e) {
+      print("Error during Google Sign-In: \$e");
+      return null;
+    }
+  }
+
+  // Sign out
+  Future<void> signOut() async {
+    try {
+      if (!kIsWeb) {
+        await GoogleSignIn.instance.signOut();
+      }
+      await _auth.signOut();
+    } catch (e) {
+      print("Error signing out: \$e");
+    }
+  }
+}
+```
+
+## 6. Troubleshooting `auth/unauthorized-domain` on Flutter Web
+
+When running Flutter Web locally and using `signInWithPopup`, you might
+encounter a situation where the Google Sign-In popup opens and immediately
+closes.
+
+- **Symptom**: The console shows
+  `Sign-in failed: [firebase_auth/unauthorized-domain] This domain is not authorized for OAuth operation for your Firebase project.`
+- **Cause**: The domain (usually `localhost` during local testing) is not listed
+  in the Authorized Domains in the Firebase Console.
+- **Solution**: Add `localhost` to the Authorized Domains list in the Firebase
+  Console (Authentication > Settings > Authorized domains) or in your
+  `firebase.json` auth config.
+- **CRITICAL**: Do NOT include the protocol or port number when adding the
+  domain (e.g., use `localhost`, NOT `http://localhost:9090`). Flutter Web often
+  runs on random ports or specific ports, but Firebase Auth only cares about the
+  domain.

package/dist/global-skills/firebase-auth-basics/references/ios_setup.md

@@ -0,0 +1,87 @@
+# Firebase Auth iOS Setup Guide
+
+# ⛔️ CRITICAL RULE: NO INLINE INITIALIZATION ⛔️
+
+NEVER write `let auth = Auth.auth()` as an inline class or struct property if
+there is ANY chance the object is instantiated before `FirebaseApp.configure()`
+executes in the app root.
+
+- **FATAL CRASH:** `@Observable class AuthManager { let auth = Auth.auth() }`
+  initialized as a `@State` in the App root.
+- **SAFE PATTERN:** Initialize `Auth.auth()` lazily
+  (`lazy var auth = Auth.auth()`) OR explicitly initialize the manager *after*
+  `FirebaseApp.configure()` finishes.
+
+## 1. Import and Initialize
+
+Ensure you have installed the `FirebaseAuth` SDK. Use the `xcode-project-setup`
+skill to automate adding the SPM dependency to the Xcode project.
+
+> **Note:** Ensure `FirebaseApp.configure()` has been executed in your app's
+> entry point before calling any `Auth.auth()` methods, otherwise your app will
+> crash. Do not initialize Auth objects in SwiftUI `@State` properties at the
+> App root level.
+
+```swift
+import FirebaseAuth
+```
+
+## 2. Authentication State
+
+To listen for authentication state changes (recommended way to check if a user
+is signed in):
+
+```swift
+var handle: AuthStateDidChangeListenerHandle?
+
+handle = Auth.auth().addStateDidChangeListener { auth, user in
+  if let user = user {
+    print("User is signed in with uid: \(user.uid)")
+  } else {
+    print("User is signed out")
+  }
+}
+
+// To remove the listener when no longer needed:
+if let handle = handle {
+  Auth.auth().removeStateDidChangeListener(handle)
+}
+```
+
+## 3. Email and Password Authentication (Modern Concurrency)
+
+Modern Swift projects should prioritize `async/await` for authentication calls
+to avoid nested completion handlers and improve readability.
+
+### Sign Up
+
+```swift
+do {
+    let authResult = try await Auth.auth().createUser(withEmail: "user@example.com", password: "password")
+    print("User created successfully with uid: \(authResult.user.uid)")
+} catch {
+    print("Error creating user: \(error.localizedDescription)")
+}
+```
+
+### Sign In
+
+```swift
+do {
+    let authResult = try await Auth.auth().signIn(withEmail: "user@example.com", password: "password")
+    print("User signed in successfully with uid: \(authResult.user.uid)")
+} catch {
+    print("Error signing in: \(error.localizedDescription)")
+}
+```
+
+## 4. Sign Out
+
+```swift
+do {
+  try Auth.auth().signOut()
+  print("Successfully signed out")
+} catch let signOutError as NSError {
+  print("Error signing out: \(signOutError)")
+}
+```

package/dist/global-skills/firebase-auth-basics/references/security_rules.md

@@ -0,0 +1,49 @@
+# Authentication in Security Rules
+
+Firebase Security Rules work with Firebase Authentication to provide rule-based
+access control. For better advice on writing safe security rules, enable the
+`firebase-firestore-basics` or `firebase-storage-basics` skills.
+
+The `request.auth` variable contains authentication information for the user
+requesting data.
+
+## Basic Checks
+
+### Check if user is signed in
+
+```
+allow read, write: if request.auth != null;
+```
+
+### Check if user owns the data
+
+Access data only if the document ID matches the user's UID.
+
+```
+allow read, write: if request.auth != null && request.auth.uid == userId;
+```
+
+(Where `userId` is a path variable, e.g., `match /users/{userId}`)
+
+### Check if user owns the document (field-based)
+
+Access data only if the document has a `owner_uid` field matching the user's
+UID.
+
+```
+allow read, write: if request.auth != null && request.auth.uid == resource.data.owner_uid;
+```
+
+## Token Properties
+
+`request.auth.token` contains standard JWT claims and custom claims.
+
+- `request.auth.token.email`: The user's email address.
+- `request.auth.token.email_verified`: If the email is verified.
+- `request.auth.token.name`: The user's display name.
+
+### Example: Email Verification Check
+
+```
+allow create: if request.auth.token.email_verified == true;
+```

package/dist/global-skills/firebase-basics/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: firebase-basics
+description: >-
+  Provides foundational setup, authentication, and project management workflows
+  for Firebase using the Firebase CLI. Use when checking Firebase CLI version
+  (must use 'npx -y firebase-tools@latest --version'), initializing a Firebase
+  environment, authenticating, setting active projects, or setting up `google-services.json`
+  or `GoogleService-Info.plist` files.
+---
+
+# Prerequisites
+
+Complete these setup steps before proceeding:
+
+1. **Local Environment Setup:** Verify the environment is properly set up so we
+   can use Firebase tools:
+
+   - Run `npx -y firebase-tools@latest --version` to check if the Firebase CLI
+     is installed.
+   - Verify if the Firebase MCP server is installed using your existing tools.
+   - **CRITICAL**: Before configuring any extensions or agent environments
+     below, you MUST read
+     [references/local-env-setup.md](references/local-env-setup.md).
+   - **DO NOT SKIP** this step: if 'firebase-basics' is the only Firebase skill
+     available to you, you must follow the reference for your agent environment
+     to set up the full suite of Firebase skills:
+     - **Gemini CLI**: Review
+       [references/setup/gemini_cli.md](references/setup/gemini_cli.md)
+     - **Antigravity**: Review
+       [references/setup/antigravity.md](references/setup/antigravity.md)
+     - **Android Studio**: Review
+       [references/setup/android_studio.md](references/setup/android_studio.md)
+     - **Claude Code**: Review
+       [references/setup/claude_code.md](references/setup/claude_code.md)
+     - **Cursor**: Review
+       [references/setup/cursor.md](references/setup/cursor.md)
+     - **GitHub Copilot**: Review
+       [references/setup/github_copilot.md](references/setup/github_copilot.md)
+     - **Other Agents**: Review
+       [references/setup/other_agents.md](references/setup/other_agents.md)
+
+1. **Authentication:** Ensure you are logged in to Firebase so that commands
+   have the correct permissions. Run `npx -y firebase-tools@latest login`. For
+   environments without a browser (e.g., remote shells), use
+   `npx -y firebase-tools@latest login --no-localhost`.
+
+   - The command should output the current user.
+   - If you are not logged in, follow the interactive instructions from this
+     command to authenticate.
+
+1. **Active Project:** Most Firebase tasks require an active project context.
+
+   > [!IMPORTANT] **For Agents:** Before proceeding with project configuration,
+   > you MUST pause and ask the developer if they prefer to:
+   >
+   > 1. **Provide an existing Firebase Project ID**, or
+   > 1. **Create a new Firebase project**.
+
+   - **If using an existing Project ID:**
+
+     1. Check the current project by running `npx -y firebase-tools@latest use`.
+     1. If the command outputs `Active Project: <project-id>`, confirm with the
+        user if this is the intended project.
+     1. If not, or if no project is active, set the project provided by the
+        user:
+        ```bash
+        npx -y firebase-tools@latest use <PROJECT_ID>
+        ```
+
+   - **If creating a new project:** Run the following command to create it:
+
+     ```bash
+     npx -y firebase-tools@latest projects:create <project-id> --display-name "<display-name>"
+     ```
+
+     *Note: The `<project-id>` must be 6-30 characters, lowercase, and can
+     contain digits and hyphens. It must be globally unique.*
+
+# Firebase Usage Principles
+
+Adhere to these principles:
+
+1. **Use npx for CLI commands:** To ensure you always use the latest version of
+   the Firebase CLI, always prepend commands with `npx -y firebase-tools@latest`
+   instead of just `firebase`. For example, use
+   `npx -y firebase-tools@latest --version`. NEVER suggest the naked `firebase`
+   command as an alternative.
+1. **Prioritize official knowledge:** For any Firebase-related knowledge,
+   consult the `developerknowledge_search_documents` MCP tool before falling
+   back to Google Search or your internal knowledge base. Including "Firebase"
+   in your search query significantly improves relevance.
+1. **Follow Agent Skills for implementation guidance:** Skills provide
+   opinionated workflows (CUJs), security rules, and best practices. Always
+   consult them to understand *how* to implement Firebase features correctly
+   instead of relying on general knowledge.
+1. **Use Firebase MCP Server tools instead of direct API calls:** Whenever you
+   need to interact with remote Firebase APIs (such as fetching Crashlytics logs
+   or executing Data Connect queries), use the tools provided by the Firebase
+   MCP Server instead of attempting manual API calls.
+1. **Keep Plugin / Agent Skills updated:** Since Firebase best practices evolve
+   quickly, regularly check for and install updates to their Firebase plugin or
+   Agent Skills. Similarly, if you encounter issues with outdated tools or
+   commands, follow the steps below based on your agent environment:
+   - **Antigravity**: Follow
+     [references/refresh/antigravity.md](references/refresh/antigravity.md)
+   - **Gemini CLI**: Follow
+     [references/refresh/gemini-cli.md](references/refresh/gemini-cli.md)
+   - **Claude Code**: Follow
+     [references/refresh/claude.md](references/refresh/claude.md)
+   - **Cursor**: Follow
+     [references/refresh/other-agents.md](references/refresh/other-agents.md)
+   - **Android Studio**: Follow
+     [references/refresh/android_studio.md](references/refresh/android_studio.md)
+   - **Others**: Follow
+     [references/refresh/other-agents.md](references/refresh/other-agents.md)
+1. **Automate Config File Retrieval:** When setting up iOS or Android apps, do
+   NOT direct users to the Firebase Console to download `google-services.json`
+   or `GoogleService-Info.plist`. Instead, use the Firebase CLI to fetch the
+   config programmatically:
+   - For Android:
+     `npx -y firebase-tools@latest apps:sdkconfig ANDROID <APP_ID> --project <PROJECT_ID>`
+   - For iOS:
+     `npx -y firebase-tools@latest apps:sdkconfig IOS <APP_ID> --project <PROJECT_ID>`
+     Save the output to the appropriate location (e.g.,
+     `app/google-services.json` for Android, or a path to be linked by
+     `xcode-project-setup` for iOS).
+
+# References
+
+- **Initialize Firebase:** See
+  [references/firebase-service-init.md](references/firebase-service-init.md)
+  when you need to initialize new Firebase services using the CLI.
+- **Exploring Commands:** See
+  [references/firebase-cli-guide.md](references/firebase-cli-guide.md) to
+  discover and understand CLI functionality.
+- **SDK Setup:** For detailed guides on adding Firebase to your app:
+  - **Web**: See [references/web_setup.md](references/web_setup.md)
+  - **Android**: See [references/android_setup.md](references/android_setup.md)
+  - **iOS**: See [references/ios_setup.md](references/ios_setup.md)
+
+# Common Issues
+
+- **Login Issues:** If the browser fails to open during the login step, use
+  `npx -y firebase-tools@latest login --no-localhost` instead.
+- **Genkit:** If using Genkit, install the skills:
+  ```bash
+  npx skills add genkit-ai/skills
+  ```

package/dist/global-skills/firebase-basics/references/android_setup.md

@@ -0,0 +1,41 @@
+# 🛠️ Firebase Android Setup Guide
+
+______________________________________________________________________
+
+## 📋 Prerequisites
+
+## Before running these commands, ensure you are authenticated: `npx -y firebase-tools@latest login` (or `npx -y firebase-tools@latest login --no-localhost` on remote servers)
+
+## 0. Create an Android application
+
+if you haven't already created an android application, create one.
+
+## 1. Create a Firebase Project
+
+If you haven't already created a project, create a new cloud project with a
+unique ID:
+`npx -y firebase-tools@latest projects:create <UNIQUE_PROJECT_ID> --display-name '<DISPLAY_NAME>'`
+*Example:*
+`npx -y firebase-tools@latest projects:create my-cool-app-20260330 --display-name 'MyCoolApp'`
+
+### 2. Register Your Android App
+
+Link your Android app module (package name) to your project. Notice that the
+display name is passed as a positional argument at the end:
+`npx -y firebase-tools@latest apps:create ANDROID '<APP_DISPLAY_NAME>' --package-name '<PACKAGE_NAME>' --project <PROJECT_ID>`
+*Example:*
+`npx -y firebase-tools@latest apps:create ANDROID 'MyApplication' --package-name 'com.example.myapplication' --project my-cool-app-20260330`
+
+### 3. Download `google-services.json`
+
+## Fetch the configuration file using the App ID (which is printed in the output of the previous command): `npx -y firebase-tools@latest apps:sdkconfig ANDROID <APP_ID> --project <PROJECT_ID>` *Example output extraction to file:* ` # (Output must be saved as app/google-services.json)`
+
+## ✅ Verification Plan
+
+### Manual Verification
+
+Validate that the project was created and registered successfully:
+`npx -y firebase-tools@latest projects:list`
+`npx -y firebase-tools@latest apps:list --project <PROJECT_ID>`
+
+______________________________________________________________________

package/dist/global-skills/firebase-basics/references/firebase-cli-guide.md

@@ -0,0 +1,18 @@
+# Exploring Commands
+
+The Firebase CLI documents itself. Use help commands to discover functionality.
+
+- **Global Help**: List all available commands and categories.
+
+  ```bash
+  npx -y firebase-tools@latest --help
+  ```
+
+- **Command Help**: Get detailed usage for a specific command.
+
+  ```bash
+  npx -y firebase-tools@latest [command] --help
+  # Example:
+  npx -y firebase-tools@latest deploy --help
+  npx -y firebase-tools@latest firestore:indexes --help
+  ```

package/dist/global-skills/firebase-basics/references/firebase-service-init.md

@@ -0,0 +1,20 @@
+# Initialization
+
+Before initializing, check if you are already in a Firebase project directory by
+looking for `firebase.json`.
+
+1. **Project Directory:** Navigate to the root directory of the codebase. *(Only
+   if starting a completely new project from scratch without an existing
+   codebase, create a directory first: `mkdir my-project && cd my-project`)*
+
+1. **Initialize Services:** Run the initialization command:
+
+   ```bash
+   npx -y firebase-tools@latest init
+   ```
+
+The CLI will guide you through:
+
+- Selecting features (Firestore, Functions, Hosting, etc.).
+- Associating with an existing project or creating a new one.
+- Configuring files (e.g. `firebase.json`, `.firebaserc`).

package/dist/global-skills/firebase-basics/references/flutter_setup.md

@@ -0,0 +1,143 @@
+# Flutter & Firebase Setup Guide
+
+This guide covers the initial setup of Flutter and its integration with Firebase
+using the FlutterFire CLI.
+
+## Prerequisites
+
+1. **Flutter SDK**: Ensure Flutter is installed and available in the PATH.
+
+   **Standard Setup (Manual):**
+
+   1. **Determine Architecture**: Check if you are on Intel (`x64`) or Apple
+      Silicon (`arm64`) using `uname -m`.
+   1. **Download SDK**: Fetch the latest stable SDK from the
+      [Flutter Archive](https://docs.flutter.dev/install/archive?tab=macos).
+   1. **Extract**: Unzip the SDK to a permanent directory (e.g.,
+      `~/development/flutter`).
+   1. **Update PATH**: Add the `bin` folder to your shell configuration (e.g.,
+      `~/.zshrc`).
+      ```bash
+      echo 'export PATH="$PATH:$HOME/development/flutter/bin"' >> ~/.zshrc
+      source ~/.zshrc
+      ```
+   1. **Verify**: Run `flutter doctor` to ensure the SDK is correctly linked and
+      initialized.
+
+1. **Firebase CLI**: Ensure the Firebase CLI is available.
+
+   - Run `npx -y firebase-tools@latest --version`.
+   - Login with `npx -y firebase-tools@latest login`.
+
+1. **FlutterFire CLI**: Install the official FlutterFire CLI globally.
+
+   - Run `dart pub global activate flutterfire_cli`.
+   - **Note**: Ensure `~/.pub-cache/bin` is also in your PATH if `flutterfire`
+     is not found.
+
+## Step 1: Create a Flutter Project
+
+If you don't have a project yet, create one:
+
+```bash
+flutter create my_awesome_app
+cd my_awesome_app
+```
+
+## Step 2: Configure Firebase
+
+> [!IMPORTANT] **For Agents:** Before running the configuration command, you
+> MUST pause and ask the developer if they prefer to:
+>
+> 1. Create a new Firebase project, or
+> 1. Provide an existing Firebase Project ID.
+
+- If the developer provides an existing Project ID, run:
+  ```bash
+  flutterfire configure --project=<project_id>
+  ```
+- If the developer prefers to create a new project interactively, run:
+  ```bash
+  flutterfire configure
+  ```
+
+This tool automates:
+
+- Registering your apps (iOS, Android, Web, etc.) with a Firebase project.
+- Generating the `lib/firebase_options.dart` file.
+
+## Step 3: Initialize Firebase in Code
+
+Add the `firebase_core` package and initialize it in your `main.dart`.
+
+1. Add the dependency:
+
+```bash
+flutter pub add firebase_core
+```
+
+2. Update `lib/main.dart`:
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:firebase_core/firebase_core.dart';
+import 'firebase_options.dart';
+
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await Firebase.initializeApp(
+    options: DefaultFirebaseOptions.currentPlatform,
+  );
+  runApp(const MyApp());
+}
+```
+
+## Step 4: Add Firebase Services
+
+To add specific services (Firestore, Auth, etc.), follow the "Pub Add &
+Configure" pattern:
+
+1. Add the service: `flutter pub add cloud_firestore`
+1. **Crucial**: Re-run `flutterfire configure` to sync platform configurations.
+1. Import and use the package in your code.
+
+## Step 5: Important Gotchas & Platform Specifics
+
+### 1. Re-running `flutterfire configure` Upon Renaming
+
+When creating a new project, developers often change the bundle identifier (iOS)
+or `applicationId` (Android) after the fact. If the package names change,
+`flutterfire configure` **must** be re-run to update the respective Google
+service files and `firebase_options.dart`.
+
+### 2. Platform-Specific Build Requirements
+
+- **Android**: Adding Firebase often requires a higher `minSdkVersion` (commonly
+  `21` or `23`) than the platform default. Be prepared to update
+  `android/app/build.gradle` automatically when installing certain plugins.
+- **iOS**: Always check if there is a `Podfile` in the `/ios` directory whenever
+  native services (like `cloud_firestore`) are added. If there is, run
+  `pod install`. Failing to do this will cause Xcode build errors. Note that
+  Flutter is moving towards Swift Package Manager (SPM), and FlutterFire
+  supports SPM, so a `Podfile` may not exist if the project only uses SPM
+  dependencies.
+
+### 3. Web CORS Best Practices
+
+When testing Firebase features locally on Chrome, requests to Google servers can
+sometimes get blocked by CORS policies. Avoid relying on
+`--disable-web-security` flags as it promotes bad security practices. Instead,
+run the app on localhost with a specific port, and ensure `localhost` is added
+to your Firebase Auth "Authorized Domains".
+
+```bash
+flutter run -d chrome --web-hostname=localhost --web-port=5000
+```
+
+### 4. Elaborating on `WidgetsFlutterBinding.ensureInitialized()`
+
+In your `main.dart`, this call is mandatory before `Firebase.initializeApp()`.
+*Why?* Because Firebase initialization requires communication across Flutter's
+native iOS/Android method channels. `ensureInitialized()` guarantees the Fluter
+engine is fully booted up and ready to handle these native platform calls before
+`runApp()` executes.