@aurabase/auth 0.6.2 → 0.7.1

package/README.md

@@ -39,8 +39,13 @@ await aura.auth.signOut()
 ### Session
 
 ```ts
-// getSession() n'est PAS un AuraResponse : il lit directement le store local (synchrone en pratique).
-const { accessToken, user } = await aura.auth.getSession()
+// getSession() lit le store local (synchrone en pratique) :
+const { data: { session } } = await aura.auth.getSession()
+if (session) {
+  console.log('Session ID:', session.id)
+  console.log('Access token:', session.access_token)
+  console.log('User ID:', session.user.id)
+}
 
 const refreshed = await aura.auth.refreshSession()
 
@@ -55,6 +60,32 @@ if (first) await aura.auth.revokeSession(first.id)
 await aura.auth.revokeAllSessions()
 ```
 
+### Configuration du stockage (SSR & Node.js)
+
+```ts
+import { createClient, LocalAuthStore, BaseAuthStore } from '@aurabase/aurabase-js'
+
+// Par défaut, le client choisit automatiquement :
+// - Navigateur : `LocalAuthStore` avec clé scopée par projet (`aura-<slug>-auth`)
+// - Node.js / SSR : `BaseAuthStore` en mémoire avec exportToCookie() / loadFromCookie()
+
+// Pour personnaliser le stockage :
+const aura = createClient('https://mon-projet.aurabase.cloud', 'aura_anon_xxx', {
+  auth: {
+    storage: new LocalAuthStore('custom-auth-key'),
+    autoRefreshToken: true,
+    persistSession: true,
+  },
+})
+
+// Sérialisation cookie (SSR) :
+const setCookieHeader = aura.authStore.exportToCookie({
+  httpOnly: true,
+  secure: true,
+  sameSite: 'lax',
+})
+```
+
 ### OAuth (implicite ou PKCE)
 
 `signInWithOAuth` ne redirige plus « en dur » : il renvoie toujours `{ url }` (et redirige en plus via `window.location.href` si un `window` existe).
@@ -288,14 +319,19 @@ await admin.authAdmin.listUsers({ limit: 50 })
 import { AuthAdminService } from '@aurabase/auth'
 ```
 
-Méthodes clés : `listUsers`, `getUser`, `createUser`, `updateUser`, `deleteUser`, `banUser`, `unbanUser`, `generateLink`, `getUserStats`, `listUserIdentities`, `listSessions`, `revokeSession`, `getAuditLog`, `getSettings`, `updateSettings`, `listEmailTemplates`/`getEmailTemplate`/`updateEmailTemplate`/`deleteEmailTemplate`, `testEmailTemplate`.
+Méthodes clés : `listUsers`, `getUser`, `createUser`, `updateUser`, `deleteUser`, `banUser`, `unbanUser`, `generateLink`, `getUserStats`, `listUserIdentities`, `listSessions`, `revokeSession`, `impersonate` (RFC 8693 avec claim `act`), `importUsers` (import en masse avec conversion automatique bcrypt vers Argon2id), `listSigningKeys` (clés ES256 du projet), `getAuditLog`, `getSettings`, `updateSettings`, `listEmailTemplates`/`getEmailTemplate`/`updateEmailTemplate`/`deleteEmailTemplate`, `testEmailTemplate`.
+
+### Authentification Multi-Facteurs (MFA v0.7.0)
+
+Aurabase supporte l'authentification multifacteur complète avec niveaux d'assurance (AAL1, AAL2) et claim standard `amr` :
+- **TOTP** : `c.auth.mfa.enroll()`, `c.auth.mfa.verifySetup(token)`, `c.auth.mfa.verify({ mfa_token, code })`
+- **Facteurs disponibles** : `c.auth.mfa.factors(mfa_token)` liste les méthodes éligibles (`totp`, `webauthn`, `sms`)
+- **WebAuthn / Passkeys** : `c.auth.mfa.webauthn`
+- **SMS OTP** : `c.auth.mfa.sms`
 
-## Limitations
+### Vérification locale de jeton (JWKS / ES256)
 
-- Pas de `resend()` / `reauthenticate()` / `verifyOtp()` unifiés (style Supabase) : chaque canal (magic link, email OTP, SMS OTP) a sa propre paire `signInWith*`/`verify*`.
-- Pas de SSO/SAML.
-- MFA limité au TOTP : pas de `listFactors()`, pas de niveau d'authentification (AAL), pas de MFA par téléphone.
-- `getClaims()` en fallback (HS256 / JWKS vide) ne renvoie pas `exp`/`iat` — ne pas s'y fier après un fallback.
+Chaque projet émet des jetons signés avec sa propre clé asymétrique **ES256**. Vous pouvez vérifier les jetons hors-ligne via n'importe quelle bibliothèque standard (`jose`, Go, Python) en récupérant la clé publique sur `https://<projet>.aurabase.cloud/v1/auth/.well-known/jwks.json`.
 
 ## Documentation
 

package/dist/index.cjs

@@ -52,9 +52,81 @@ var AuthAdminService = class extends core.BaseService {
   }
   /**
    * Génère un lien à usage unique pour un utilisateur (`'magic'`, `'recovery'` ou `'invite'`) et renvoie `{ link, token }`.
+   * Accepte soit `generateLink(userId, type)` soit `generateLink({ userId, type })`.
    */
-  async generateLink(userId, type) {
-    return this.request("POST", `${this.prefix}/users/${userId}/generate-link`, { type });
+  async generateLink(userIdOrParams, type) {
+    let resolvedUserId;
+    let resolvedType;
+    if (typeof userIdOrParams === "object" && userIdOrParams !== null) {
+      resolvedUserId = userIdOrParams.userId ?? userIdOrParams.user_id;
+      resolvedType = userIdOrParams.type ?? type;
+    } else if (typeof userIdOrParams === "string") {
+      resolvedUserId = userIdOrParams;
+      resolvedType = type;
+    }
+    if (!resolvedUserId || typeof resolvedUserId !== "string" || resolvedUserId.trim() === "" || resolvedUserId.includes("[object")) {
+      return {
+        data: null,
+        error: new core.AuraError(400, {
+          error: {
+            code: "INVALID_ARGUMENT",
+            message: "userId must be a non-empty string (UUID). Usage: generateLink(userId, type) or generateLink({ userId, type })."
+          }
+        })
+      };
+    }
+    if (!resolvedType) {
+      return {
+        data: null,
+        error: new core.AuraError(400, {
+          error: {
+            code: "INVALID_ARGUMENT",
+            message: 'type is required for generateLink ("magic" | "recovery" | "invite").'
+          }
+        })
+      };
+    }
+    return this.request("POST", `${this.prefix}/users/${encodeURIComponent(resolvedUserId)}/generate-link`, { type: resolvedType });
+  }
+  /**
+   * Impersonation (AUTH-037) : jeton COURT (10 minutes au plus) pour agir en tant que l'utilisateur,
+   * avec le claim `act: { sub }`. Pas de refresh token, journalisé (`admin_impersonation`).
+   * Un compte `owner`/`admin` exige `allowPrivileged: true` ET une `reason`.
+   */
+  async impersonate(userId, options) {
+    return this.request("POST", `${this.prefix}/users/${userId}/impersonate`, {
+      reason: options?.reason,
+      ttl_seconds: options?.ttlSeconds,
+      allow_privileged: options?.allowPrivileged ?? false
+    });
+  }
+  /**
+   * Import en masse (AUTH-037) : jusqu'a 1000 utilisateurs par appel, avec hash bcrypt ou argon2id.
+   * Rapport ligne par ligne ; une ligne en erreur n'arrete pas les autres.
+   */
+  async importUsers(users) {
+    return this.request("POST", `${this.prefix}/users/import`, {
+      users: users.map((u) => ({
+        email: u.email,
+        email_verified: u.emailVerified ?? false,
+        password_hash: u.passwordHash,
+        name: u.name,
+        user_metadata: u.userMetadata,
+        app_metadata: u.appMetadata
+      }))
+    });
+  }
+  /** Cles de signature du projet (active + previous), URL du JWKS et emetteur (`iss`). */
+  async listSigningKeys() {
+    return this.request("GET", `${this.prefix}/signing-keys`);
+  }
+  /** Rotation : une nouvelle cle signe les nouveaux jetons, l'ancienne reste publiee 24 h. */
+  async rotateSigningKey() {
+    return this.request("POST", `${this.prefix}/signing-keys/rotate`, {});
+  }
+  /** Revoque une ancienne cle compromise (retiree du JWKS, jetons refuses). */
+  async revokeSigningKey(kid) {
+    return this.request("DELETE", `${this.prefix}/signing-keys/${encodeURIComponent(kid)}`);
   }
   /**
    * Statistiques des utilisateurs : total, vérifiés, bannis, avec MFA et nouveaux sur 7 jours.
@@ -353,6 +425,77 @@ async function codeChallengeS256(verifier) {
   return b64url(new Uint8Array(digest));
 }
 
+// src/webauthn.ts
+function base64urlToBytes(valeur) {
+  const b64 = valeur.replace(/-/g, "+").replace(/_/g, "/");
+  const bin = atob(b64 + "=".repeat((4 - b64.length % 4) % 4));
+  const octets = new Uint8Array(new ArrayBuffer(bin.length));
+  for (let i = 0; i < bin.length; i++) octets[i] = bin.charCodeAt(i);
+  return octets;
+}
+function bytesToBase64url(octets) {
+  const vue = octets instanceof ArrayBuffer ? new Uint8Array(octets) : new Uint8Array(octets.buffer, octets.byteOffset, octets.byteLength);
+  let bin = "";
+  for (const o of vue) bin += String.fromCharCode(o);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function creationOptionsFromJson(json) {
+  const pk = json.publicKey;
+  return {
+    publicKey: {
+      ...pk,
+      challenge: base64urlToBytes(pk.challenge),
+      user: { ...pk.user, id: base64urlToBytes(pk.user.id) },
+      excludeCredentials: (pk.excludeCredentials ?? []).map((c) => ({
+        ...c,
+        id: base64urlToBytes(c.id)
+      }))
+    }
+  };
+}
+function requestOptionsFromJson(json) {
+  const pk = json.publicKey;
+  return {
+    publicKey: {
+      ...pk,
+      challenge: base64urlToBytes(pk.challenge),
+      allowCredentials: (pk.allowCredentials ?? []).map((c) => ({
+        ...c,
+        id: base64urlToBytes(c.id)
+      }))
+    }
+  };
+}
+function attestationToJson(cred) {
+  const r = cred.response;
+  return {
+    id: cred.id,
+    rawId: bytesToBase64url(cred.rawId),
+    type: cred.type,
+    response: {
+      attestationObject: bytesToBase64url(r.attestationObject),
+      clientDataJSON: bytesToBase64url(r.clientDataJSON),
+      transports: typeof r.getTransports === "function" ? r.getTransports() : void 0
+    },
+    extensions: cred.getClientExtensionResults?.() ?? {}
+  };
+}
+function assertionToJson(cred) {
+  const r = cred.response;
+  return {
+    id: cred.id,
+    rawId: bytesToBase64url(cred.rawId),
+    type: cred.type,
+    response: {
+      authenticatorData: bytesToBase64url(r.authenticatorData),
+      clientDataJSON: bytesToBase64url(r.clientDataJSON),
+      signature: bytesToBase64url(r.signature),
+      userHandle: r.userHandle ? bytesToBase64url(r.userHandle) : null
+    },
+    extensions: cred.getClientExtensionResults?.() ?? {}
+  };
+}
+
 // src/SessionManager.ts
 var SessionManager = class {
   opts;
@@ -425,6 +568,15 @@ var SessionManager = class {
 };
 
 // src/AuthService.ts
+function extractSessionId(token) {
+  if (!token) return void 0;
+  try {
+    const payload = decodeJwt(token).payload;
+    return payload?.session_id ?? payload?.sid ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
 function isMfaChallenge(v) {
   return typeof v === "object" && v !== null && v.mfa_required === true;
 }
@@ -454,10 +606,16 @@ var AuthService = class extends core.BaseService {
   _stateListeners = /* @__PURE__ */ new Set();
   _sessionManager;
   _applyingRemote = false;
+  /** AUTH-011 — séquence des effacements de session et dernier effacement annoncé par SIGNED_OUT. */
+  _clearSeq = 0;
+  _signedOutSeq = 0;
   _unsubStore = null;
   _disposed = false;
+  /** AUTH-015 — flux OAuth par défaut du client. */
+  _defaultFlowType;
   constructor(client, options) {
     super(client);
+    this._defaultFlowType = options?.flowType;
     const browser = typeof window !== "undefined";
     const enabled = !!options?.forceEnabled || (options?.autoRefresh ?? true) && browser && (options?.persistSession ?? true);
     this._sessionManager = new SessionManager({
@@ -473,8 +631,18 @@ var AuthService = class extends core.BaseService {
       onRemoteMessage: (data) => this._applyRemoteState(data)
     });
     this._sessionManager.start();
+    let hadToken = !!this.client.authStore.token;
     this._unsubStore = this.client.authStore.onChange((token) => {
       this._sessionManager.setActive(!!token);
+      if (!token && hadToken && !this._applyingRemote) {
+        const seq = ++this._clearSeq;
+        queueMicrotask(() => {
+          if (this._signedOutSeq < seq && !this.client.authStore.token) {
+            this._emitEvent("SIGNED_OUT", null, null);
+          }
+        });
+      }
+      hadToken = !!token;
       if (!this._applyingRemote) {
         const state = this._broadcastState();
         if (!token || state !== null) {
@@ -687,10 +855,9 @@ var AuthService = class extends core.BaseService {
     queueMicrotask(() => {
       if (this._stateListeners.has(callback)) {
         const session = store.token && store.user ? {
+          id: extractSessionId(store.token),
           access_token: store.token,
           refresh_token: store.refreshToken ?? "",
-          accessToken: store.token,
-          refreshToken: store.refreshToken ?? "",
           token_type: "Bearer",
           expires_in: 900,
           user: store.user
@@ -701,11 +868,11 @@ var AuthService = class extends core.BaseService {
     return result;
   }
   _emitEvent(event, user, accessToken, extra) {
+    if (event === "SIGNED_OUT") this._signedOutSeq = this._clearSeq;
     const session = accessToken && user ? {
+      id: extractSessionId(accessToken),
       access_token: accessToken,
       refresh_token: this.client.authStore.refreshToken ?? "",
-      accessToken,
-      refreshToken: this.client.authStore.refreshToken ?? "",
       token_type: "Bearer",
       expires_in: 900,
       user
@@ -735,16 +902,18 @@ var AuthService = class extends core.BaseService {
     }
     if (req.options?.data) payload.data = req.options.data;
     if (req.options?.emailRedirectTo) payload.email_redirect_to = req.options.emailRedirectTo;
+    if (req.options?.preventEmailEnumeration) payload.prevent_email_enumeration = true;
     const res = await this.request("POST", `${this.prefix}/register`, payload);
+    if (res.data && !isMfaChallenge(res.data) && !res.data.access_token) {
+      res.data.session = null;
+      return res;
+    }
     if (res.data && !isMfaChallenge(res.data)) {
       const tp = res.data;
-      tp.accessToken = tp.access_token;
-      tp.refreshToken = tp.refresh_token;
       tp.session = {
+        id: extractSessionId(tp.access_token),
         access_token: tp.access_token,
         refresh_token: tp.refresh_token,
-        accessToken: tp.access_token,
-        refreshToken: tp.refresh_token,
         token_type: tp.token_type,
         expires_in: tp.expires_in,
         user: tp.user,
@@ -756,11 +925,6 @@ var AuthService = class extends core.BaseService {
     }
     if (res.data && isMfaChallenge(res.data)) {
       const mfa = res.data;
-      mfa.mfaChallenge = {
-        mfaRequired: mfa.mfa_required,
-        mfaToken: mfa.mfa_token,
-        mfaSetupRequired: mfa.mfa_setup_required
-      };
       this._emitEvent("MFA_CHALLENGE", null, null, {
         mfaToken: mfa.mfa_token,
         mfaSetupRequired: mfa.mfa_setup_required
@@ -782,13 +946,10 @@ var AuthService = class extends core.BaseService {
     const res = await this.request("POST", `${this.prefix}/login`, payload);
     if (res.data && !isMfaChallenge(res.data)) {
       const tp = res.data;
-      tp.accessToken = tp.access_token;
-      tp.refreshToken = tp.refresh_token;
       tp.session = {
+        id: extractSessionId(tp.access_token),
         access_token: tp.access_token,
         refresh_token: tp.refresh_token,
-        accessToken: tp.access_token,
-        refreshToken: tp.refresh_token,
         token_type: tp.token_type,
         expires_in: tp.expires_in,
         user: tp.user,
@@ -800,11 +961,6 @@ var AuthService = class extends core.BaseService {
     }
     if (res.data && isMfaChallenge(res.data)) {
       const mfa = res.data;
-      mfa.mfaChallenge = {
-        mfaRequired: mfa.mfa_required,
-        mfaToken: mfa.mfa_token,
-        mfaSetupRequired: mfa.mfa_setup_required
-      };
       this._emitEvent("MFA_CHALLENGE", null, null, {
         mfaToken: mfa.mfa_token,
         mfaSetupRequired: mfa.mfa_setup_required
@@ -833,7 +989,7 @@ var AuthService = class extends core.BaseService {
         error: new core.AuraError(0, {
           error: {
             code: "invalid_provider",
-            message: "signInWithOAuth: le fournisseur doit \xEAtre une cha\xEEne non vide, par exemple signInWithOAuth('google', { redirectTo }) ou signInWithOAuth({ provider: 'google', redirectTo })"
+            message: "signInWithOAuth: the provider must be a non-empty string, e.g. signInWithOAuth('google', { redirectTo }) or signInWithOAuth({ provider: 'google', redirectTo })"
           }
         })
       };
@@ -847,22 +1003,22 @@ var AuthService = class extends core.BaseService {
           params.set(k, v);
           continue;
         }
-        const raison = OAUTH_SDK_OWNED_QUERY_PARAMS.has(k) ? `il est construit par signInWithOAuth (utilisez l'option d\xE9di\xE9e : ${k === "redirect_uri" || k === "redirect_to" ? "redirectTo" : k === "scopes" ? "scopes" : k === "project_id" ? "l'URL du projet pass\xE9e \xE0 createClient()" : "flowType:'pkce'"})` : `il n'est pas transmis au provider. Seuls ces param\xE8tres d'exp\xE9rience de connexion le sont : ${[...OAUTH_FORWARDABLE_QUERY_PARAMS].join(", ")}`;
+        const raison = OAUTH_SDK_OWNED_QUERY_PARAMS.has(k) ? `it is built by signInWithOAuth (use the dedicated option: ${k === "redirect_uri" || k === "redirect_to" ? "redirectTo" : k === "scopes" ? "scopes" : k === "project_id" ? "the project URL passed to createClient()" : "flowType:'pkce'"})` : `it is not forwarded to the provider. Only these sign-in experience parameters are: ${[...OAUTH_FORWARDABLE_QUERY_PARAMS].join(", ")}`;
         return {
           data: null,
           error: new core.AuraError(400, {
             error: {
               code: "invalid_oauth_query_param",
-              message: `signInWithOAuth: queryParams.${k} refus\xE9 \u2014 ${raison}.`
+              message: `signInWithOAuth: queryParams.${k} rejected \u2014 ${raison}.`
             }
           })
         };
       }
     }
-    if (options?.flowType === "pkce") {
+    if ((options?.flowType ?? this._defaultFlowType) === "pkce") {
       if (typeof window !== "undefined" && !this.client.authStore.persistent) {
         console.warn(
-          `[aurabase] PKCE (flowType:"pkce") requiert un store persistant (LocalAuthStore) pour que le code_verifier survive au redirect OAuth ; le store courant est en m\xE9moire \u2014 l'\xE9change \xE9chouera au retour.`
+          '[aurabase] PKCE (flowType:"pkce") requires a persistent store (LocalAuthStore) so that the code_verifier survives the OAuth redirect; the current store is in-memory, so the exchange will fail on return.'
         );
       }
       try {
@@ -877,7 +1033,7 @@ var AuthService = class extends core.BaseService {
           error: new core.AuraError(0, {
             error: {
               code: "pkce_generation_failed",
-              message: "PKCE: g\xE9n\xE9ration du code_verifier/challenge impossible (WebCrypto indisponible)"
+              message: "PKCE: cannot generate the code_verifier/challenge (WebCrypto unavailable)"
             }
           })
         };
@@ -885,7 +1041,7 @@ var AuthService = class extends core.BaseService {
     } else {
       if (typeof window !== "undefined" && !this.client.authStore.persistent) {
         console.warn(
-          '[aurabase] S\xC9CURIT\xC9 : signInWithOAuth en flux implicit avec un store NON persistant (m\xE9moire) \u2014 le marqueur anti session-fixation ne survivra pas au redirect OAuth et la session ne sera pas adopt\xE9e au retour. Utilisez un LocalAuthStore, et pr\xE9f\xE9rez flowType:"pkce" (recommand\xE9, immunis\xE9 contre la session fixation).'
+          '[aurabase] SECURITY: signInWithOAuth in implicit flow with a NON-persistent store (in-memory): the anti session-fixation marker will not survive the OAuth redirect and the session will not be adopted on return. Use a LocalAuthStore, and prefer flowType:"pkce" (recommended, immune to session fixation).'
         );
       }
       try {
@@ -894,7 +1050,7 @@ var AuthService = class extends core.BaseService {
       }
     }
     const url = `${this.client.baseUrl}/v1/auth/oauth/${encodeURIComponent(provider)}/start?${params.toString()}`;
-    if (typeof window !== "undefined") {
+    if (typeof window !== "undefined" && window.location) {
       window.location.href = url;
     }
     return { data: { url }, error: null };
@@ -951,31 +1107,22 @@ var AuthService = class extends core.BaseService {
     return res;
   }
   /**
-   * Session courante lue depuis le store (synchrone en pratique, pas d'appel réseau).
-   *
-   * DOUBLE COMPATIBILITÉ DX (Parité Supabase & compatibilité existante Aurabase) :
-   * - Permet `const { data: { session }, error } = await aura.auth.getSession()` (forme canonique)
-   * - Permet `const { accessToken, user } = await aura.auth.getSession()` (forme plate historique)
+   * Session courante lue depuis le store (pas d'appel réseau). Forme unique (AUTH-019) :
+   * `const { data: { session } } = await aura.auth.getSession()`.
+   * Côté serveur, cette session n'est PAS vérifiée : autorisez avec `getUser()` (AUTH-004).
    */
   getSession() {
     const token = this.client.authStore.token;
     const user = this.client.authStore.user;
     const session = token && user ? {
+      id: extractSessionId(token),
       access_token: token,
       refresh_token: this.client.authStore.refreshToken ?? "",
-      accessToken: token,
-      refreshToken: this.client.authStore.refreshToken ?? "",
       token_type: "Bearer",
       expires_in: 900,
       user
     } : null;
-    return Promise.resolve({
-      data: { session },
-      error: null,
-      accessToken: token,
-      access_token: token,
-      user
-    });
+    return Promise.resolve({ data: { session }, error: null });
   }
   /**
    * Installe une session à partir d'un jeton d'accès et d'un jeton de rafraîchissement existants (par exemple reçus d'un serveur).
@@ -1243,7 +1390,7 @@ var AuthService = class extends core.BaseService {
           error: new core.AuraError(0, {
             error: {
               code: "allow_expired_unsupported_on_fallback",
-              message: "getClaims: allowExpired ne peut pas \xEAtre honor\xE9 sur le chemin de validation serveur (fallback HS256/JWKS)"
+              message: "getClaims: allowExpired cannot be honored on the server validation path (HS256/JWKS fallback)"
             }
           })
         };
@@ -1271,7 +1418,7 @@ var AuthService = class extends core.BaseService {
           error: new core.AuraError(0, {
             error: {
               code: "invalid_response",
-              message: "getClaims: la validation serveur du token (getUser) a r\xE9pondu sans contenu \u2014 claims ind\xE9terminables"
+              message: "getClaims: the server token validation (getUser) answered with no content, so the claims cannot be determined"
             }
           })
         };
@@ -1287,6 +1434,17 @@ var AuthService = class extends core.BaseService {
    * Supprime le compte de l'utilisateur connecté après confirmation par son mot de passe, puis vide la session locale.
    */
   async deleteUser(password) {
+    if (!password || typeof password !== "string" || password.trim() === "") {
+      return {
+        data: null,
+        error: new core.AuraError(400, {
+          error: {
+            code: "PASSWORD_REQUIRED",
+            message: "Password is required to delete account"
+          }
+        })
+      };
+    }
     const res = await this.request("DELETE", `${this.prefix}/user`, { password });
     if (!res.error) {
       this.client.authStore.clear();
@@ -1348,9 +1506,107 @@ var AuthService = class extends core.BaseService {
       regenerateRecoveryCodes: (codeOrParams) => {
         const code = typeof codeOrParams === "string" ? codeOrParams : codeOrParams.code;
         return this.regenerateRecoveryCodes(code);
+      },
+      factors: (mfaToken) => this.request("POST", `${this.prefix}/mfa/factors`, { mfa_token: mfaToken }),
+      sms: {
+        setup: (phone) => this.request("POST", `${this.prefix}/mfa/sms/setup`, { phone }),
+        verifySetup: (code) => this.request("POST", `${this.prefix}/mfa/sms/setup/verify`, { code }),
+        send: (mfaToken) => this.request("POST", `${this.prefix}/mfa/sms/send`, {
+          mfa_token: mfaToken
+        }),
+        remove: (password) => this.request("DELETE", `${this.prefix}/mfa/sms`, { password })
+      },
+      webauthn: {
+        register: (params) => this.webauthnRegister(params),
+        verify: (params) => this.webauthnVerify(params),
+        list: () => this.request("GET", `${this.prefix}/mfa/webauthn`),
+        remove: (id, password) => this.request(
+          "DELETE",
+          `${this.prefix}/mfa/webauthn/${encodeURIComponent(id)}`,
+          { password }
+        )
       }
     };
   }
+  webauthnIndisponible() {
+    return {
+      data: null,
+      error: new core.AuraError(0, {
+        error: {
+          code: "webauthn_unavailable",
+          message: "WebAuthn is not available here: navigator.credentials is missing. Use a browser in a secure context (https or localhost), or pass `credentials` explicitly."
+        }
+      })
+    };
+  }
+  /**
+   * Enrôle une passkey WebAuthn pour l'utilisateur connecté (cérémonie complète : options du serveur,
+   * `navigator.credentials.create`, confirmation). Le premier facteur du compte active le MFA et
+   * renvoie les codes de récupération (`recovery_codes`) — à afficher une seule fois.
+   */
+  async webauthnRegister(params) {
+    const conteneur = params?.credentials ?? (typeof navigator !== "undefined" ? navigator.credentials : void 0);
+    if (!conteneur) return this.webauthnIndisponible();
+    const debut = await this.request(
+      "POST",
+      `${this.prefix}/mfa/webauthn/register/start`,
+      { friendly_name: params?.friendlyName }
+    );
+    if (!debut.data) return debut;
+    let cred;
+    try {
+      cred = await conteneur.create(creationOptionsFromJson(debut.data.options));
+    } catch (e) {
+      return this.webauthnAnnule(e);
+    }
+    if (!cred) return this.webauthnAnnule(new Error("no credential returned"));
+    return this.request("POST", `${this.prefix}/mfa/webauthn/register/finish`, {
+      credential: attestationToJson(cred),
+      friendly_name: params?.friendlyName
+    });
+  }
+  /**
+   * Relève un défi MFA (`mfaToken`, reçu d'un `signIn`) avec une passkey : options du serveur,
+   * `navigator.credentials.get`, vérification. Enregistre la session et émet `SIGNED_IN`.
+   */
+  async webauthnVerify(params) {
+    const conteneur = params.credentials ?? (typeof navigator !== "undefined" ? navigator.credentials : void 0);
+    if (!conteneur) return this.webauthnIndisponible();
+    const debut = await this.request(
+      "POST",
+      `${this.prefix}/mfa/webauthn/verify/start`,
+      { mfa_token: params.mfaToken }
+    );
+    if (!debut.data) return debut;
+    let cred;
+    try {
+      cred = await conteneur.get(requestOptionsFromJson(debut.data.options));
+    } catch (e) {
+      return this.webauthnAnnule(e);
+    }
+    if (!cred) return this.webauthnAnnule(new Error("no credential returned"));
+    const res = await this.request("POST", `${this.prefix}/mfa/webauthn/verify/finish`, {
+      mfa_token: params.mfaToken,
+      credential: assertionToJson(cred)
+    });
+    if (res.data) {
+      this.client.authStore.save(res.data.access_token, res.data.refresh_token, res.data.user);
+      this._emitEvent("SIGNED_IN", res.data.user, res.data.access_token);
+    }
+    return res;
+  }
+  webauthnAnnule(cause) {
+    const nom = cause instanceof Error ? cause.name : "Error";
+    return {
+      data: null,
+      error: new core.AuraError(0, {
+        error: {
+          code: nom === "NotAllowedError" ? "webauthn_cancelled" : "webauthn_failed",
+          message: nom === "NotAllowedError" ? "The passkey prompt was cancelled or timed out." : `The passkey ceremony failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        }
+      })
+    };
+  }
   /** MFA : démarre l'enrôlement TOTP et renvoie le `secret` et l'URL `otpauth_url` à afficher en QR code. */
   async mfaEnroll() {
     return this.request("POST", `${this.prefix}/mfa/setup`);
@@ -1363,10 +1619,31 @@ var AuthService = class extends core.BaseService {
    * MFA : termine une connexion qui a renvoyé un défi (`mfa_token` et code TOTP). Enregistre la session et émet `SIGNED_IN`.
    */
   async mfaVerify(req) {
-    const res = await this.request("POST", `${this.prefix}/mfa/verify-login`, req);
+    const raw = req;
+    const mfa_token = raw.mfa_token ?? raw.mfaToken ?? raw.challenge_id ?? raw.challengeId;
+    const code = raw.code;
+    const recovery_code = raw.recovery_code ?? raw.recoveryCode;
+    const sms_code = raw.sms_code ?? raw.smsCode;
+    const body = {};
+    if (mfa_token) body.mfa_token = mfa_token;
+    if (code !== void 0) body.code = code;
+    if (recovery_code !== void 0) body.recovery_code = recovery_code;
+    if (sms_code !== void 0) body.sms_code = sms_code;
+    const res = await this.request("POST", `${this.prefix}/mfa/verify-login`, body);
     if (res.data) {
-      this.client.authStore.save(res.data.access_token, res.data.refresh_token, res.data.user);
-      this._emitEvent("SIGNED_IN", res.data.user, res.data.access_token);
+      const tp = res.data;
+      tp.session = {
+        id: extractSessionId(tp.access_token),
+        access_token: tp.access_token,
+        refresh_token: tp.refresh_token,
+        token_type: tp.token_type,
+        expires_in: tp.expires_in,
+        user: tp.user,
+        provider_token: tp.provider_token,
+        provider_refresh_token: tp.provider_refresh_token
+      };
+      this.client.authStore.save(tp.access_token, tp.refresh_token, tp.user);
+      this._emitEvent("SIGNED_IN", tp.user, tp.access_token);
     }
     return res;
   }
@@ -1520,10 +1797,10 @@ var AuthService = class extends core.BaseService {
   async getSettings() {
     return this.request("GET", `${this.prefix}/settings`);
   }
-  /** Clé publiable (anon key) du projet — GET /anon-key (public, à l'image du modèle Supabase). */
-  async getAnonKey() {
-    return this.request("GET", `${this.prefix}/anon-key`);
-  }
+  // AUTH-023 — `getAnonKey()` retirée : la route `/anon-key` n'est servie qu'aux projets qui
+  // activent l'auth hébergée (garde C1, aucun BaaS n'expose la clé d'un projet à un anonyme), et
+  // un client qui l'appelle possède déjà la clé anon (passée à createClient). La méthode
+  // répondait donc 404 pour presque tous les projets.
   // -- Password recovery (token consumption) ----------------------------------
   /**
    * Consomme le token de récupération de mot de passe et applique le nouveau mot de passe.
@@ -1563,4 +1840,10 @@ var AuthService = class extends core.BaseService {
 exports.AuthAdminService = AuthAdminService;
 exports.AuthService = AuthService;
 exports.SessionManager = SessionManager;
+exports.assertionToJson = assertionToJson;
+exports.attestationToJson = attestationToJson;
+exports.base64urlToBytes = base64urlToBytes;
+exports.bytesToBase64url = bytesToBase64url;
+exports.creationOptionsFromJson = creationOptionsFromJson;
 exports.isMfaChallenge = isMfaChallenge;
+exports.requestOptionsFromJson = requestOptionsFromJson;