> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.generaltranslation.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Ajouter une connexion à votre application iOS ou macOS

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              processedNode = processedNode.replace(new RegExp(key, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

<div id="get-started">
  ## Premiers pas
</div>

<Steps>
  <Step title="Créer un projet" stepNumber={1}>
    Créez un nouveau projet iOS ou macOS pour ce démarrage rapide.

    **Dans Xcode :**

    1. **File** → **New** → **Project** (ou **⌘+Shift+N**)
    2. Sélectionnez l’une des options suivantes :
       * Onglet **iOS** → modèle **App**
       * Onglet **macOS** → modèle **App**
    3. Configurez votre projet :
       * **Product Name** : `Auth0-Sample`
       * **Interface** : SwiftUI
       * **Language** : Swift
       * **Use Core Data** : décoché
       * **Include Tests** : coché (recommandé)
    4. Choisissez un emplacement et cliquez sur **Create**

    <Tip>
      Cela crée une application standard avec prise en charge de SwiftUI et de Swift Package Manager, idéale pour l’intégration à Auth0.
    </Tip>
  </Step>

  <Step title="Ajouter la trousse de développement logiciel (SDK) d’Auth0" stepNumber={2}>
    Ajoutez la trousse de développement logiciel (SDK) Auth0 à votre projet à l’aide du gestionnaire de paquets de votre choix.

    <Tabs>
      <Tab title="Swift Package Manager">
        **Dans Xcode :**

        1. **File** → **Add Package Dependencies...** (ou **⌘+Shift+K**)
        2. Entrez l’URL du SDK Auth0 :
           ```
           https://github.com/auth0/Auth0.swift
           ```
        3. **Add Package** → Sélectionnez la cible de votre application → **Add Package**
      </Tab>

      <Tab title="CocoaPods">
        1. Créez un `Podfile` dans le répertoire de votre projet :
           ```ruby Podfile theme={null}
           platform :ios, '14.0' # Or platform :osx, '11.0' for macOS
           use_frameworks!

           target 'YourApp' do
             pod 'Auth0', '~> 2.0'
           end
           ```
        2. Installez les dépendances :
           ```bash theme={null}
           pod install
           ```
        3. Ouvrez le fichier `.xcworkspace` généré (et non `.xcodeproj`)
      </Tab>

      <Tab title="Carthage">
        1. Créez un `Cartfile` dans le répertoire de votre projet :
           ```text Cartfile theme={null}
           github "auth0/Auth0.swift" ~> 2.0
           ```
        2. Exécutez Carthage :
           ```bash theme={null}
           carthage update --platform iOS --use-xcframeworks
           ```
           Pour macOS, utilisez `--platform macOS`
        3. Glissez-déposez le fichier `Auth0.xcframework` généré à partir de `Carthage/Build` dans votre projet Xcode
        4. Dans les paramètres **General** de votre cible, ajoutez `Auth0.xcframework` à **Frameworks, Libraries, and Embedded Content**
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurer Auth0" stepNumber={3}>
    Créez une nouvelle Application Auth0 et configurez les URL de redirection (callback).

    1. Accédez à [Auth0 Dashboard](https://manage.auth0.com/dashboard/)
    2. **Applications** > **Create Application** > Donnez-lui un nom, sélectionnez **Native**, puis **Create**
    3. Dans l’onglet **Settings**, notez votre **Client ID** et votre **Domaine**
    4. Ajoutez les URL suivantes à **URL de redirection autorisées** :

    <Tabs>
      <Tab title="iOS">
        ```
        https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
        ```
      </Tab>

      <Tab title="macOS">
        ```
        https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
        ```
      </Tab>
    </Tabs>

    5. Ajoutez les URL suivantes à **URL de déconnexion autorisées** :

    <Tabs>
      <Tab title="iOS">
        ```
        https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
        ```
      </Tab>

      <Tab title="macOS">
        ```
        https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
        ```
      </Tab>
    </Tabs>

    6. Cliquez sur **Save Changes**
  </Step>

  <Step title="Configurer les identifiants de l’application" stepNumber={4}>
    Créez `Auth0.plist` dans le dossier de votre projet :

    ```xml Auth0.plist theme={null}
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
    <dict>
        <key>ClientId</key>
        <string>YOUR_AUTH0_CLIENT_ID</string>
        <key>Domain</key>
        <string>{yourDomain}</string>
    </dict>
    </plist>
    ```

    Faites glisser `Auth0.plist` dans Xcode et assurez-vous que l’option « Add to target » est cochée.
  </Step>

  <Step title="Créer le service d’authentification" stepNumber={5}>
    Créez le fichier `AuthenticationService.swift` :

    1. Cliquez avec le bouton droit sur votre projet → **New File...** → **Swift File**
    2. Nommez-le `AuthenticationService`
    3. Remplacez-en le contenu par :

    ```swift AuthenticationService.swift expandable lines theme={null}
    import Foundation
    import Auth0
    import Combine

    @MainActor
    class AuthenticationService: ObservableObject {
        @Published var isAuthenticated = false
        @Published var user: User?
        @Published var isLoading = false
        @Published var errorMessage: String?
        
        private let credentialsManager = CredentialsManager(authentication: Auth0.authentication())
        
        init() {
            Task {
                await checkAuthenticationStatus()
            }
        }
        
        private func checkAuthenticationStatus() async {
            isLoading = true
            defer { isLoading = false }
            
            guard let credentials = try? await credentialsManager.credentials() else {
                isAuthenticated = false
                return
            }
            
            isAuthenticated = true
            // Obtenir les informations de l'utilisateur à partir du jeton d'identité
            user = credentials.user
        }
        
        func login() async {
            isLoading = true
            errorMessage = nil
            defer { isLoading = false }
            
            do {
                let credentials = try await Auth0
                    .webAuth()
                    .scope("openid profile email offline_access")
                    .start()
                
                _ = credentialsManager.store(credentials: credentials)
                isAuthenticated = true
                // Obtenir les informations de l'utilisateur à partir du jeton d'identité
                user = credentials.user
            } catch {
                errorMessage = "Échec de la connexion : \(error.localizedDescription)"
            }
        }
        
        func logout() async {
            isLoading = true
            defer { isLoading = false }
            
            do {
                try await Auth0.webAuth().clearSession()
                _ = credentialsManager.clear()
                isAuthenticated = false
                user = nil
            } catch {
                errorMessage = "Échec de la déconnexion : \(error.localizedDescription)"
            }
        }
    }
    ```
  </Step>

  <Step title="Créer des composants d’interface utilisateur" stepNumber={6}>
    Créez les fichiers d’interface utilisateur et ajoutez du code :

    ```bash theme={null}
    touch AuthenticatedView.swift UnauthenticatedView.swift ProfileCard.swift LoadingView.swift
    ```

    <AuthCodeGroup>
      ```swift ContentView.swift expandable lines theme={null}
      import SwiftUI

      struct ContentView: View {
          @StateObject private var authService = AuthenticationService()
          
          var body: some View {
              VStack(spacing: 30) {
                  Image(systemName: "shield.checkered")
                      .font(.system(size: 80))
                      .foregroundStyle(.blue)
                  
                  Text("Exemple Auth0")
                      .font(.largeTitle)
                      .fontWeight(.bold)
                  
                  if authService.isLoading {
                      LoadingView()
                  } else if authService.isAuthenticated {
                      AuthenticatedView(authService: authService)
                  } else {
                      UnauthenticatedView(authService: authService)
                  }
                  
                  Spacer()
              }
              .padding()
              .alert("Erreur", isPresented: .constant(authService.errorMessage != nil)) {
                  Button("OK") { authService.errorMessage = nil }
              } message: {
                  Text(authService.errorMessage ?? "")
              }
          }
      }
      ```

      ```swift AuthenticatedView.swift expandable lines theme={null}
      import SwiftUI

      struct AuthenticatedView: View {
          @ObservedObject var authService: AuthenticationService
          
          var body: some View {
              VStack(spacing: 24) {
                  HStack {
                      Image(systemName: "checkmark.circle.fill")
                          .foregroundColor(.green)
                      Text("Authentification réussie!")
                          .font(.headline)
                          .foregroundColor(.green)
                  }
                  .padding()
                  .background(Color.green.opacity(0.1))
                  .cornerRadius(12)
                  
                  Text("Votre profil")
                      .font(.title2)
                      .fontWeight(.semibold)
                  
                  ProfileCard(user: authService.user)
                  
                  Button("Se déconnecter") {
                      Task {
                          await authService.logout()
                      }
                  }
                  .buttonStyle(.borderedProminent)
                  .controlSize(.large)
                  .disabled(authService.isLoading)
              }
          }
      }
      ```

      ```swift UnauthenticatedView.swift expandable lines theme={null}
      import SwiftUI

      struct UnauthenticatedView: View {
          @ObservedObject var authService: AuthenticationService
          
          var body: some View {
              VStack(spacing: 24) {
                  Text("Commencez en ouvrant une session dans votre compte")
                      .font(.title3)
                      .multilineTextAlignment(.center)
                      .foregroundColor(.secondary)
                      .padding()
                      .background(Color(.secondarySystemBackground))
                      .cornerRadius(16)
                  
                  Button("Se connecter") {
                      Task {
                          await authService.login()
                      }
                  }
                  .buttonStyle(.borderedProminent)
                  .controlSize(.large)
                  .disabled(authService.isLoading)
              }
          }
      }
      ```

      ```swift ProfileCard.swift expandable lines theme={null}
      import SwiftUI
      import Auth0

      struct ProfileCard: View {
          let user: User?
          
          var body: some View {
              VStack(spacing: 16) {
                  if let user = user {
                      AsyncImage(url: URL(string: user.picture ?? "")) { image in
                          image.resizable().aspectRatio(contentMode: .fill)
                      } placeholder: {
                          Image(systemName: "person.circle.fill")
                              .font(.system(size: 80))
                              .foregroundColor(.gray)
                      }
                      .frame(width: 100, height: 100)
                      .clipShape(Circle())
                      
                      VStack(spacing: 8) {
                          if let name = user.name {
                              Text(name).font(.title2).fontWeight(.semibold)
                          }
                          if let email = user.email {
                              Text(email).foregroundColor(.secondary)
                          }
                      }
                  } else {
                      ProgressView()
                      Text("Chargement du profil...").foregroundColor(.secondary)
                  }
              }
              .padding()
              .background(Color(.tertiarySystemBackground))
              .cornerRadius(16)
          }
      }
      ```

      ```swift LoadingView.swift expandable lines theme={null}
      import SwiftUI

      struct LoadingView: View {
          var body: some View {
              VStack(spacing: 16) {
                  ProgressView().scaleEffect(1.2)
                  Text("Chargement...").font(.headline).foregroundColor(.secondary)
              }
          }
      }
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Configurer le flux d’authentification (facultatif)" stepNumber={7}>
    Pour améliorer l’expérience utilisateur, vous pouvez réduire les alertes système de différentes façons :

    1. Utilisez les Universal Links : cela élimine l’invite « Ouvrir dans "AppName" ? » qui apparaît pendant la redirection. Remarque : l’alerte d’autorisation ASWebAuthenticationSession s’affichera tout de même.
    2. Utilisez des sessions éphémères : cela élimine toutes les alertes d’autorisation. Remarque : cela désactive l’authentification unique (SSO) et les cookies partagés.

    <Tip>
      **Passez cette étape** pour utiliser le comportement par défaut avec une alerte d’autorisation. Vous pourrez configurer cela plus tard.
    </Tip>

    <Tabs>
      <Tab title="Universal Links">
        1. Auth0 Dashboard → **Applications** → Votre application → **Settings** → **Advanced Settings** → **Device Settings**
        2. Ajoutez **Apple Team ID** et **bundle identifier** → **Save**
        3. Xcode : Target → **Signing & Capabilities** → **+ Capability** → **Associated Domains**
        4. Ajoutez : `webcredentials:{yourDomain}`

        <Warning>Prérequis : compte Apple Developer payant, iOS 17.4+ / macOS 14.4+</Warning>

        <Tip>
          Idéal pour les applications de production.
        </Tip>
      </Tab>

      <Tab title="Session éphémère">
        Ajoutez `.useEphemeralSession()` à l’appel de connexion dans `AuthenticationService.swift` :

        ```swift theme={null}
        // Dans la fonction login()
        let credentials = try await Auth0
            .webAuth()
            .scope("openid profile email offline_access")
            .useEphemeralSession()
            .start()
        ```

        <Info>
          Lorsque vous utilisez des sessions éphémères, vous n’avez pas besoin d’appeler `clearSession()` lors de la déconnexion. Supprimez simplement les informations d’identification de votre application : il n’y a aucun cookie partagé à supprimer.
        </Info>

        <Tip>
          Configuration rapide, pas d’alerte, mais les utilisateurs doivent se connecter à chaque fois (aucun SSO).
        </Tip>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Lancez votre application" stepNumber={8}>
    Appuyez sur **⌘+R** dans Xcode.

    1. Touchez « Se connecter » → Alerte d’autorisation (si vous utilisez les paramètres par défaut) → Touchez « Continuer »
    2. Terminez la connexion dans le navigateur
    3. Affichez votre profil!
  </Step>
</Steps>

<Check>
  **Point de contrôle**

  Vous avez maintenant une connexion Auth0 entièrement fonctionnelle dans votre application iOS ou macOS !
</Check>

***

<div id="troubleshooting-advanced">
  ## Dépannage et fonctions avancées
</div>

<Accordion title="Problèmes courants et solutions">
  <div id="build-errors-auth0-module-not-found">
    ### Erreurs de compilation : module 'Auth0' introuvable
  </div>

  **Solutions** :

  1. **Swift Package Manager** : Vérifiez **Package Dependencies** → Assurez-vous que `Auth0.swift` y figure
  2. **CocoaPods** : Assurez-vous d’ouvrir le fichier `.xcworkspace`, et non `.xcodeproj`
  3. **Carthage** : Vérifiez que `Auth0.xcframework` est ajouté à **Frameworks, Libraries, and Embedded Content**
  4. Nettoyez et reconstruisez : **⌘+Shift+K** puis **⌘+R**
  5. Redémarrez Xcode au besoin

  <div id="app-crashes-auth0plist-not-found">
    ### L’app plante : 'Auth0.plist not found'
  </div>

  **Correctif** :

  1. Vérifiez que `Auth0.plist` se trouve dans l’explorateur de projet Xcode
  2. Sélectionnez le fichier → Inspector → Assurez-vous que la cible de votre app est cochée
  3. Confirmez qu’il contient les clés `ClientId` et `Domain` avec vos valeurs
  4. **Autre option** : utilisez une configuration par programmation (voir la section Intégration avancée ci‑dessous)

  <div id="browser-opens-but-never-returns-to-app">
    ### Le navigateur s’ouvre mais ne revient jamais à l’app
  </div>

  **Correctif** :

  1. Vérifiez que les URL de rappel dans Auth0 Dashboard correspondent exactement à votre identifiant de bundle et à votre plateforme
  2. Pour iOS : les URL doivent contenir `/ios/`, pour macOS : `/macos/`
  3. Vérifiez que l’identifiant de bundle dans Xcode correspond aux paramètres Auth0
  4. Assurez-vous qu’il n’y a pas de fautes de frappe dans les URL (fréquent : deux-points manquants, format de domaine incorrect)
  5. **Utilisateurs de domaine personnalisé** : vérifiez que vous utilisez votre domaine personnalisé, et non le domaine Auth0

  <div id="permission-alert-appears-every-time">
    ### L’alerte d’autorisation apparaît à chaque fois
  </div>

  Il s’agit du comportement de sécurité standard d’iOS/macOS lorsque vous utilisez des schémas d’URL personnalisés. Consultez **l’étape 6** pour éliminer cette alerte en utilisant Universal Links ou des sessions éphémères.
</Accordion>

<Accordion title="Configuration de domaine personnalisé">
  Si vous utilisez un [domaine personnalisé](/customize/custom-domains), utilisez sa valeur partout à la place de votre domaine Auth0.

  **Exemple :** Utilisez `login.example.com` au lieu de `tenant.auth0.com`

  Ceci est **obligatoire** pour que certaines fonctionnalités fonctionnent correctement :

  * Mettez à jour `Auth0.plist` avec votre domaine personnalisé
  * Utilisez le domaine personnalisé dans les URL de rappel/de déconnexion
  * Pour les Universal Links, utilisez : `webcredentials:login.example.com`
</Accordion>

<Accordion title="Déploiement en production">
  <div id="app-store-preparation">
    ### Préparation pour l’App Store
  </div>

  * Configurez les Universal Links pour éliminer l’alerte d’autorisation
  * Testez sur plusieurs versions de plateforme et tailles d’appareils
  * Mettez en œuvre une gestion adéquate des erreurs pour les pannes réseau
  * Ajoutez des descriptions d’utilisation de la confidentialité si vous utilisez le trousseau (Keychain) avec les données biométriques
  * Suivez les App Store Review Guidelines pour les flux d’authentification

  <div id="security-best-practices">
    ### Bonnes pratiques de sécurité
  </div>

  * Ne journalisez jamais de données d’authentification sensibles en production
  * Mettez en œuvre la conformité App Transport Security (ATS)
  * Utilisez HTTPS pour toutes les requêtes réseau
  * **NE PAS** épingler les certificats d’API Auth0 – [Auth0 ne recommande pas cette pratique](/troubleshoot/product-lifecycle/past-migrations#avoid-pinning-or-fingerprinting-tls-certificates-for-auth0-endpoints)

  <div id="performance-optimization">
    ### Optimisation des performances
  </div>

  * Toutes les opérations asynchrones utilisent correctement `@MainActor` pour les mises à jour de l’interface
  * Les propriétés `@Published` utilisent une gestion de mémoire appropriée
  * Les informations d’identification sont mises en cache de façon sécurisée dans le trousseau (Keychain) pour l’accès hors ligne
  * Le profil de l’utilisateur est récupéré à partir du jeton ID (aucune requête réseau supplémentaire)
</Accordion>

<Accordion title="Intégration avancée">
  <div id="programmatic-configuration">
    ### Configuration programmatique
  </div>

  Au lieu d’utiliser `Auth0.plist`, vous pouvez transmettre les informations d’identification directement dans votre code. C’est utile lorsque les informations d’identification doivent être dynamiques ou propres à un environnement (par exemple, différents tenants Auth0 pour le développement, la préproduction et la production).

  **Remplacez les appels à `Auth0.webAuth()` par `Auth0.webAuth(clientId:domain:)` :**

  ```swift theme={null}
  // Dans AuthenticationService.swift - fonction de connexion
  func login() async {
      isLoading = true
      errorMessage = nil
      defer { isLoading = false }
      
      do {
          let credentials = try await Auth0
              .webAuth(clientId: "{yourClientId}", domain: "{yourDomain}")
              .scope("openid profile email offline_access")
              .start()
          
          _ = credentialsManager.store(credentials: credentials)
          isAuthenticated = true
          user = credentials.user
      } catch {
          errorMessage = "Login failed: \(error.localizedDescription)"
      }
  }

  // Dans AuthenticationService.swift - fonction de déconnexion
  func logout() async {
      isLoading = true
      defer { isLoading = false }
      
      do {
          try await Auth0.webAuth(clientId: "{yourClientId}", domain: "{yourDomain}").clearSession()
          _ = credentialsManager.clear()
          isAuthenticated = false
          user = nil
      } catch {
          errorMessage = "Logout failed: \(error.localizedDescription)"
      }
  }
  ```

  <div id="enhanced-keychain-security-with-biometrics">
    ### Sécurité renforcée du trousseau avec les données biométriques
  </div>

  Exigez Face ID ou Touch ID pour accéder aux informations d’identification stockées :

  ```swift theme={null}
  private let credentialsManager: CredentialsManager = {
      let manager = CredentialsManager(authentication: Auth0.authentication())
      manager.enableBiometrics(
          withTitle: "Unlock with Face ID", 
          cancelTitle: "Cancel", 
          fallbackTitle: "Use Passcode"
      )
      return manager
  }()
  ```

  Une fois activée, l’authentification biométrique est requise avant que le SDK puisse récupérer les informations d’identification stockées.

  <div id="automatic-token-refresh">
    ### Actualisation automatique du jeton d’accès
  </div>

  `CredentialsManager` actualise automatiquement les jetons d’accès expirés :

  ```swift theme={null}
  // Obtenir les informations d’identification - actualise automatiquement si expirées
  func getAccessToken() async throws -> String {
      let credentials = try await credentialsManager.credentials()
      return credentials.accessToken
  }
  ```

  Utilisez ce modèle lorsque vous effectuez des appels d’API qui exigent un jeton d’accès.

  <div id="shared-credentials-across-app-extensions">
    ### Informations d’identification partagées entre les extensions d’app
  </div>

  Pour les widgets, extensions d’app ou tâches en arrière-plan qui ont besoin de jetons d’accès :

  ```swift theme={null}
  // Créer un gestionnaire d’informations d’identification partagé avec un groupe d’apps
  let credentialsManager = CredentialsManager(
      authentication: Auth0.authentication(),
      storeKey: "credentials",
      storage: .shared(withIdentifier: "group.com.example.myapp")
  )
  ```

  **Exigences :**

  1. Activer la fonctionnalité **App Groups** dans Xcode pour toutes les cibles
  2. Utiliser le même identifiant de groupe d’apps pour toutes les cibles
  3. Configurer le `CredentialsManager` partagé dans chaque cible

  <div id="authentication-flow-options-comparison">
    ### Comparaison des options de flux d’authentification
  </div>

  | Fonctionnalité                          | Universal Links                         | Session éphémère | Valeur par défaut (alerte) |
  | --------------------------------------- | --------------------------------------- | ---------------- | -------------------------- |
  | Alertes d’autorisation                  | Réduites (aucune invite de redirection) | Aucune           | Affiche toutes les alertes |
  | Prise en charge de la SSO               | Oui                                     | Non              | Oui                        |
  | Compte Apple Developer                  | Requis                                  | Non requis       | Non requis                 |
  | Expérience utilisateur                  | Meilleure                               | Bonne            | Acceptable                 |
  | Complexité de configuration             | Moyenne                                 | Simple           | Simple                     |
  | Prise en charge de la navigation privée | Oui                                     | Oui              | Non                        |

  **Recommandations :**

  * **Applications de production avec SSO** : Universal Links (meilleure UX, prise en charge de la SSO, nécessite un compte Apple Developer)
  * **Applications de production sans SSO** : sessions éphémères (aucune alerte, configuration plus simple)
  * **Tests/Développement** : sessions éphémères (configuration rapide, UX la plus épurée)
  * **Démarrage rapide/Prototypage** : valeur par défaut avec alertes (aucune configuration, migration possible plus tard)
</Accordion>