@adonis-agora/authkit-server 0.68.4 → 0.70.0

package/build/src/host/controllers/account_orgs_controller.js

@@ -5,9 +5,13 @@ import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { ACTIVE_ORG_COOKIE, ACTIVE_ORG_COOKIE_TTL, encodeActiveOrgCookie, } from '../active_org_cookie.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
+import { ensureConsoleSession } from '../idp_session_bridge.js';
+// Política efetiva compartilhada com o espelho JSON (`account_orgs_api_controller`):
+// ponto de verdade único, para as duas superfícies nunca divergirem.
+import { effectiveOrgPolicy, orgPolicyDefaults } from '../org_policy.js';
 import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
-import { isRoleInCatalog } from '../runtime_toggles.js';
+import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy } from '../runtime_toggles.js';
 /**
  * Console de conta — Organizations. Server-rendered, padrão dos outros controllers
  * de conta (account_tokens_controller, account_security_controller, etc.).
@@ -51,12 +55,13 @@ export default class AccountOrgsController {
             const members = canManage ? await store.listOrgMembers(org.id) : [];
             return { ...org, members, canManage, isActive: org.id === activeOrgId };
         }));
+        const policy = await effectiveOrgPolicy(ctx, cfg);
         const props = {
             supported: true,
             orgs: orgsWithMembers,
             pendingInvitations: invitationsWithOrg,
-            allowSelfCreate: cfg.organizations.allowSelfCreate,
-            availableRoles: cfg.organizations.roles,
+            allowSelfCreate: policy.allowSelfCreate,
+            availableRoles: policy.roles,
             messages,
             csrfToken: ctx.request.csrfToken,
         };
@@ -69,9 +74,10 @@ export default class AccountOrgsController {
         const cfg = service.config;
         const store = cfg.accountStore;
         const accountId = session.get(ACCOUNT_SESSION_KEY);
-        if (!supportsOrganizations(store) || !cfg.organizations.allowSelfCreate) {
+        if (!supportsOrganizations(store))
+            return response.forbidden();
+        if (!(await effectiveOrgPolicy(ctx, cfg)).allowSelfCreate)
             return response.forbidden();
-        }
         const name = request.input('name', '').trim();
         const slug = request.input('slug', '').trim();
         if (!name || !slug)
@@ -179,11 +185,7 @@ export default class AccountOrgsController {
         // config → defaults). Role fora do catálogo é rejeitada (não cria convite).
         // Usa o helper PURO `isRoleInCatalog` (mesmo ponto de verdade do caminho admin).
         const settings = await resolveRuntimeSettings(ctx);
-        const roleValid = await isRoleInCatalog(role, settings, {
-            roles: cfg.organizations.roles,
-            allowSelfCreate: cfg.organizations.allowSelfCreate,
-            invitationTtlHours: cfg.organizations.invitationTtlHours,
-        }, params.id);
+        const roleValid = await isRoleInCatalog(role, settings, orgPolicyDefaults(cfg), params.id);
         if (!roleValid) {
             return response.unprocessableEntity({
                 error: { code: 'invalid_role', message: 'Role inválida.' },
@@ -194,12 +196,14 @@ export default class AccountOrgsController {
         if (role === 'owner' && membership.role !== 'owner') {
             return response.forbidden();
         }
+        // TTL da política efetiva da org (setting org → global → config), não só do config.
+        const policy = await resolveEffectiveOrganizationsPolicy(settings, orgPolicyDefaults(cfg), params.id);
         const { invitation, token } = await store.createOrgInvitation({
             organizationId: params.id,
             email,
             role,
             invitedBy: accountId,
-            ttlHours: cfg.organizations.invitationTtlHours,
+            ttlHours: policy.invitationTtlHours,
         });
         // Sends the invitation email (best-effort). The host hook wins when present;
         // otherwise the host-kit sends its own branded/translated email, like every
@@ -243,6 +247,8 @@ export default class AccountOrgsController {
         const { createHash } = await import('node:crypto');
         if (!supportsOrganizations(store))
             return response.notFound();
+        // Rota fora do guard: a sessão do IdP (SSO) também vale, se configurado.
+        await ensureConsoleSession(ctx);
         const accountId = session.get(ACCOUNT_SESSION_KEY);
         if (!accountId) {
             // Não logado: redireciona para login (configurável) com return URL
@@ -272,6 +278,8 @@ export default class AccountOrgsController {
         const { createHash } = await import('node:crypto');
         if (!supportsOrganizations(store))
             return response.notFound();
+        // Rota fora do guard: a sessão do IdP (SSO) também vale, se configurado.
+        await ensureConsoleSession(ctx);
         const accountId = session.get(ACCOUNT_SESSION_KEY);
         if (!accountId)
             return response.redirect(getAccountLoginUrl());

package/build/src/host/controllers/account_security_controller.js

@@ -10,6 +10,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { syncAdonisAuthLogout } from '../adonis_auth_sync.js';
 import { AvatarUploadError, isAvatarUploadSupported, storeAvatar } from '../avatar_storage.js';
 import { sendEmailChangeConfirmationEmail, sendEmailChangedCompletedEmail, sendEmailChangeNoticeEmail, } from '../default_mailer.js';
+import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
@@ -164,7 +165,8 @@ export default class AccountSecurityController {
             confirmed = !!(await store.verifyCredentials(account.email, currentPassword));
         }
         if (!confirmed && confirmEmail) {
-            confirmed = confirmEmail.trim().toLowerCase() === account.email.toLowerCase();
+            confirmed =
+                normalizeEmailIdentifier(confirmEmail) === normalizeEmailIdentifier(account.email);
         }
         if (!confirmed) {
             ctx.session.flash('deleteError', translate(cfg.messages, 'account.delete.invalid_confirmation'));

package/build/src/host/controllers/account_session_controller.js

@@ -3,7 +3,9 @@ import { accountHome } from '../account_home.js';
 import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { syncAdonisAuthLogin, syncAdonisAuthLogout } from '../adonis_auth_sync.js';
+import { resolveEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
+import { endBridgedIdpSession } from '../idp_session_bridge.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
 import { notifyLoginSuccess } from '../login_notify.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
@@ -59,10 +61,6 @@ export default class AccountSessionController {
         const cfg = service.config;
         const render = cfg.render;
         const { email: rawEmail, password } = ctx.request.only(['email', 'password']);
-        // L6: normaliza o e-mail (trim + lowercase) ANTES de usar — garante que o
-        // lookup, o lockout (keyed por email) e a auditoria usem a forma canônica,
-        // independente do casing/espaços digitados.
-        const email = typeof rawEmail === 'string' ? rawEmail.trim().toLowerCase() : rawEmail;
         const ip = ctx.request.ip?.() ?? null;
         // Lê e valida o return_to do corpo do formulário (hidden input) — nunca confiar sem revalidar.
         const rawReturnTo = ctx.request.input?.('return_to');
@@ -70,8 +68,18 @@ export default class AccountSessionController {
         // Verificação + lockout + auditoria de falha centralizados (sem clientId no console).
         // M1: passa `settings` p/ o lockout (e verified-email/expiração) runtime valerem aqui também.
         const settings = await resolveRuntimeSettings(ctx);
+        // L6: `resolveEmailIdentifier` normaliza (trim + lowercase, a MESMA função do
+        // cadastro e do passo de identificador do login OIDC) e devolve o endereço sob
+        // o qual a conta está gravada — de modo que o lookup, o lockout (keyed por
+        // e-mail) e a auditoria usem a forma canônica, independente do casing/espaços
+        // digitados. A ponte legada faz a conta que nasceu com o endereço mutilado
+        // entrar no console pelo endereço REAL, como no login OIDC. A tela de erro é a
+        // mesma (credencial inválida), ache conta ou não.
+        const { lookupEmail } = await resolveEmailIdentifier(cfg.accountStore, rawEmail, {
+            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+        });
         const result = await attemptPasswordLogin(cfg, {
-            email,
+            email: lookupEmail,
             password,
             ip,
             logger: ctx.logger,
@@ -105,7 +113,7 @@ export default class AccountSessionController {
         // Opt-in: sincroniza ctx.auth.use(cfg.adonisAuth.guard) com a mesma conta —
         // no-op sem `adonisAuth` configurado ou sem @adonisjs/auth inicializado.
         await syncAdonisAuthLogin(ctx, cfg, acc);
-        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email: acc.email, ip });
         // Redireciona pro destino original (validado), ou cai no accountHome configurado.
         return ctx.response.redirect(returnTo ?? accountHome(cfg));
     }
@@ -134,6 +142,9 @@ export default class AccountSessionController {
         // timestamp, sem dono. Passou a ser vinculada — por isso este `forget`
         // continua sendo só do `ACCOUNT_SESSION_KEY`: trocada a conta, a marca de
         // sudo remanescente já não vale para ninguém.
+        // Console aberto pela sessão do IdP (SSO): encerra também essa sessão, senão
+        // o próximo request reabriria o console pela ponte e o "Sair" não valeria.
+        await endBridgedIdpSession(ctx);
         ctx.session.forget(ACCOUNT_SESSION_KEY);
         await ctx.session.regenerate();
         // Opt-in: espelha o logout no guard de @adonisjs/auth (ver adonisAuth em define_config.ts).

package/build/src/host/controllers/interaction_controller.d.ts

@@ -7,6 +7,16 @@ export default class AuthInteractionController {
      * POST /auth/interaction/:uid/identifier
      * Step 1: receive email, store in session, redirect to step 2.
      * ENUMERATION-SAFE: always advances regardless of whether the email exists.
+     *
+     * Normaliza o e-mail com a MESMA regra do cadastro (`normalizeEmailIdentifier`:
+     * `trim` + `toLowerCase`) — antes disto o valor cru ia para a sessão e a busca
+     * no store era por igualdade exata, então nem `Davi@x.com` achava `davi@x.com`.
+     *
+     * A resolução acontece AQUI (uma vez, onde o valor digitado ainda existe) e
+     * não a cada request do passo 2. Guarda DUAS coisas: o digitado (o que a tela
+     * mostra) e, se a ponte de compatibilidade precisou de outra forma, o endereço
+     * sob o qual a conta está gravada (o que vai para o store). A resposta continua
+     * sendo o mesmo redirect incondicional, ache conta ou não.
      */
     identifier(ctx: HttpContext): Promise<void>;
     /**

package/build/src/host/controllers/interaction_controller.js

@@ -4,6 +4,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
 import { sendMagicLinkEmail, sendOtpUnlockEmail } from '../default_mailer.js';
+import { resolveEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
@@ -36,11 +37,37 @@ function accountStatusErrorKey(reason) {
             return 'login.password_expired_intro';
     }
 }
+/**
+ * E-mail DIGITADO no passo de identificador, já normalizado (`trim` +
+ * `toLowerCase`). É o que a tela SEMPRE mostra — nunca o endereço gravado —,
+ * para que a canonicalização não vire um oráculo de "esta conta existe".
+ */
 const SESSION_KEY = 'authkit_login_email';
+/**
+ * E-mail sob o qual a conta está GRAVADA, quando a ponte de compatibilidade
+ * precisou de uma forma diferente da digitada ({@link resolveEmailIdentifier}).
+ * É o e-mail que vai para o account store em TODA busca/emissão de token.
+ * Ausente = igual ao digitado.
+ */
+const SESSION_LOOKUP_KEY = 'authkit_login_email_lookup';
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
 /** Desafio WebAuthn pendente (autenticação) guardado entre begin/finish no login. */
 const PASSKEY_AUTH_CHALLENGE_KEY = 'authkit_passkey_auth_challenge';
+/**
+ * E-mail para BUSCAR a conta no store. Cai no e-mail digitado quando não há
+ * forma de compatibilidade gravada — inclusive nas sessões que já estavam
+ * abertas antes deste deploy.
+ */
+function lookupEmail(ctx) {
+    return (ctx.session.get(SESSION_LOOKUP_KEY) ??
+        ctx.session.get(SESSION_KEY));
+}
+/** Esquece o e-mail do login (digitado + forma de busca) de uma vez só. */
+function forgetLoginEmail(ctx) {
+    ctx.session.forget(SESSION_KEY);
+    ctx.session.forget(SESSION_LOOKUP_KEY);
+}
 export default class AuthInteractionController {
     /**
      * Métodos de login efetivos (com os pins do `cfg.authMethods`) para QUALQUER render do
@@ -161,6 +188,8 @@ export default class AuthInteractionController {
             });
         }
         const email = ctx.session.get(SESSION_KEY);
+        // O que a tela mostra é `email` (o digitado); o que busca a conta é este.
+        const storeEmail = lookupEmail(ctx);
         // Métodos de login efetivos (magic link, OTP, social) — account-independent
         // neste ponto (passkey-first depende da conta, resolvido no step 2). Reusa o
         // helper compartilhado por TODOS os renders do passo login, para que
@@ -170,7 +199,7 @@ export default class AuthInteractionController {
         // Com email na sessão (passo 2+), aplica a preferência POR USUÁRIO — os
         // métodos que o dono da conta desligou não aparecem nem aqui nem nos POSTs.
         const loginMethods = email
-            ? await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettingsForMaintenance)
+            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettingsForMaintenance)
             : await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
         const authMethods = loginMethods.authMethods;
         if (!email) {
@@ -187,7 +216,7 @@ export default class AuthInteractionController {
             });
         }
         // Step 2: password — look up user for personalisation (enumeration-safe: always show step 2)
-        const acc = await cfg.accountStore.findByEmail(email);
+        const acc = await cfg.accountStore.findByEmail(storeEmail ?? email);
         const account = acc ? { fullName: acc.name ?? null, globalRoles: acc.globalRoles ?? [] } : null;
         // Passwordless: magic link disponível vem do helper (`loginMethods`).
         // Passkey-first disponível se ligado, o store suporta, a conta tem passkeys E auth_methods permite.
@@ -215,10 +244,29 @@ export default class AuthInteractionController {
      * POST /auth/interaction/:uid/identifier
      * Step 1: receive email, store in session, redirect to step 2.
      * ENUMERATION-SAFE: always advances regardless of whether the email exists.
+     *
+     * Normaliza o e-mail com a MESMA regra do cadastro (`normalizeEmailIdentifier`:
+     * `trim` + `toLowerCase`) — antes disto o valor cru ia para a sessão e a busca
+     * no store era por igualdade exata, então nem `Davi@x.com` achava `davi@x.com`.
+     *
+     * A resolução acontece AQUI (uma vez, onde o valor digitado ainda existe) e
+     * não a cada request do passo 2. Guarda DUAS coisas: o digitado (o que a tela
+     * mostra) e, se a ponte de compatibilidade precisou de outra forma, o endereço
+     * sob o qual a conta está gravada (o que vai para o store). A resposta continua
+     * sendo o mesmo redirect incondicional, ache conta ou não.
      */
     async identifier(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
         const { email } = ctx.request.only(['email']);
-        ctx.session.put(SESSION_KEY, email);
+        const resolved = await resolveEmailIdentifier(cfg.accountStore, email, {
+            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+        });
+        ctx.session.put(SESSION_KEY, resolved.email);
+        if (resolved.viaLegacyFallback)
+            ctx.session.put(SESSION_LOOKUP_KEY, resolved.lookupEmail);
+        else
+            ctx.session.forget(SESSION_LOOKUP_KEY);
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**
@@ -236,6 +284,8 @@ export default class AuthInteractionController {
             // Session expired or tampered — send back to step 1
             return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
         }
+        // `email` é o digitado (o que a tela mostra); `storeEmail` é o que busca a conta.
+        const storeEmail = lookupEmail(ctx) ?? email;
         const { password } = ctx.request.only(['password']);
         const ip = ctx.request.ip?.() ?? null;
         const clientId = details.params.client_id ?? null;
@@ -251,13 +301,16 @@ export default class AuthInteractionController {
         // credenciais. Fail-safe: erro/timeout no verify do host PERMITE o fluxo.
         // We use a cfg-compatible object: pass effectiveBotLogin merged into cfg.
         const cfgWithEffectiveBot = effectiveBotLogin !== cfg.botProtection ? { ...cfg, botProtection: effectiveBotLogin } : cfg;
-        if (!(await guardBotProtection(ctx, cfgWithEffectiveBot, 'login', { email, clientId }))) {
-            const found = await cfg.accountStore.findByEmail(email);
+        if (!(await guardBotProtection(ctx, cfgWithEffectiveBot, 'login', {
+            email: storeEmail,
+            clientId,
+        }))) {
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings)),
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -271,9 +324,9 @@ export default class AuthInteractionController {
         // Preferência por usuário: senha desligada para ESTA conta → recusa ANTES de
         // verificar credenciais (mesma tela/erro de credencial inválida — não vaza
         // se a conta existe nem qual preferência está gravada).
-        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings);
+        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings);
         if (!userMethodsForLogin.authMethods.password) {
-            const found = await cfg.accountStore.findByEmail(email);
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -302,7 +355,7 @@ export default class AuthInteractionController {
         // ainda. A sequência verificação + lockout + auditoria de falha é centralizada
         // em attemptPasswordLogin; a renderização (lookup p/ personalização) fica aqui.
         const result = await attemptPasswordLogin(cfg, {
-            email,
+            email: storeEmail,
             password,
             ip,
             clientId,
@@ -326,7 +379,7 @@ export default class AuthInteractionController {
                     botProtection: undefined,
                 });
             }
-            const found = await cfg.accountStore.findByEmail(email);
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -407,7 +460,7 @@ export default class AuthInteractionController {
                         clientId,
                         trustedDevice: true,
                     });
-                    ctx.session.forget(SESSION_KEY);
+                    forgetLoginEmail(ctx);
                     return;
                 }
             }
@@ -447,7 +500,7 @@ export default class AuthInteractionController {
             }
         }
         await service.interactions.completeLogin(ctx, acc.id, { remember });
-        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip, clientId });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email: acc.email, ip, clientId });
         // single-session: após o completeLogin, revoga sessões que existiam ANTES.
         // A sessão nova foi criada pelo provider no resume — ela NÃO está em prevSessionIds.
         if (sessionPolicy.singleSession && prevSessionIds.size > 0) {
@@ -467,7 +520,7 @@ export default class AuthInteractionController {
             }
         }
         // Clean up the session key after a successful login.
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
     }
     /**
      * POST /auth/interaction/:uid/mfa
@@ -554,7 +607,7 @@ export default class AuthInteractionController {
         await this.maybeTrustDevice(ctx, cfg, accountId);
         // Finaliza a interaction para o accountId pendente.
         ctx.session.forget(MFA_PENDING_KEY);
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
@@ -675,7 +728,7 @@ export default class AuthInteractionController {
             return pending;
         if (!cfg.passwordless?.passkeyFirst)
             return undefined;
-        const email = ctx.session.get(SESSION_KEY);
+        const email = lookupEmail(ctx);
         if (!email)
             return undefined;
         const acc = await cfg.accountStore.findByEmail(email);
@@ -696,6 +749,9 @@ export default class AuthInteractionController {
         const details = await service.interactions.details(ctx);
         const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
         const email = ctx.session.get(SESSION_KEY);
+        // `email` é o digitado (o que a tela mostra); `storeEmail` emite e ENDEREÇA o
+        // magic link — precisa ser a caixa postal sob a qual a conta está gravada.
+        const storeEmail = lookupEmail(ctx);
         const uid = ctx.request.param('uid');
         // Login por OTP: liga o campo de código na tela "link enviado" quando a config
         // está ligada E o store suporta a capacidade.
@@ -707,7 +763,7 @@ export default class AuthInteractionController {
         // Preferência por usuário: magic link desligado para ESTA conta → não emite
         // token (resposta uniforme "enviado", sem vazar a preferência).
         const userScopedMethods = email && cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore)
-            ? await this.#userScopedLoginMethods(ctx, cfg, email)
+            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
             : null;
         if (userScopedMethods && !userScopedMethods.authMethods.magicLink) {
             return render(ctx, 'login', {
@@ -722,23 +778,23 @@ export default class AuthInteractionController {
                 magicChannel: 'none',
             });
         }
-        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
+        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && storeEmail) {
             const ip = ctx.request.ip?.() ?? null;
             const clientId = details.params.client_id ?? null;
             // Com OTP ligado, emite link E código no MESMO disparo (issueMagicLinkWithCode);
             // senão, o magic link puro de sempre.
             const issued = otpEnabled
-                ? await cfg.accountStore.issueMagicLinkWithCode(email, uid, {
+                ? await cfg.accountStore.issueMagicLinkWithCode(storeEmail, uid, {
                     digits: cfg.login.otp.digits,
                     ttlMinutes: cfg.login.otp.ttlMinutes,
                 })
-                : await cfg.accountStore.issueMagicLinkToken(email);
+                : await cfg.accountStore.issueMagicLinkToken(storeEmail);
             if (issued) {
                 const code = 'code' in issued ? issued.code : undefined;
                 await cfg.audit?.record({
                     type: 'login.magic_link_sent',
                     accountId: issued.account.id,
-                    email,
+                    email: issued.account.email,
                     ip,
                     clientId,
                 });
@@ -746,18 +802,19 @@ export default class AuthInteractionController {
                     await cfg.audit?.record({
                         type: 'login.otp_sent',
                         accountId: issued.account.id,
-                        email,
+                        email: issued.account.email,
                         ip,
                         clientId,
                     });
                 }
                 const origin = authkitOrigin(cfg);
                 const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+                const to = issued.account.email;
                 if (cfg.mail?.onMagicLink) {
-                    await cfg.mail.onMagicLink({ email, magicUrl, token: issued.token, code, channel });
+                    await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token, code, channel });
                 }
                 else {
-                    await sendMagicLinkEmail(ctx, { email, magicUrl, code, channel });
+                    await sendMagicLinkEmail(ctx, { email: to, magicUrl, code, channel });
                 }
             }
         }
@@ -766,7 +823,7 @@ export default class AuthInteractionController {
         // local usado acima para decidir a emissão) — não re-declarado aqui.
         return render(ctx, 'login', {
             ...(email
-                ? await this.#userScopedLoginMethods(ctx, cfg, email)
+                ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
                 : await this.#loginMethods(ctx, cfg)),
             uid,
             csrfToken: ctx.request.csrfToken,
@@ -895,7 +952,7 @@ export default class AuthInteractionController {
             clientId: clientId ?? null,
             metadata: { method: 'magic_link' },
         });
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await service.interactions.completeLogin(ctx, acc.id, { amr: ['email'] });
     }
     /**
@@ -916,9 +973,11 @@ export default class AuthInteractionController {
         const ip = ctx.request.ip?.() ?? null;
         const clientId = (await service.interactions.details(ctx)).params.client_id;
         const email = ctx.session.get(SESSION_KEY);
+        // `email` é o digitado (o que a tela mostra); `storeEmail` verifica o código.
+        const storeEmail = lookupEmail(ctx);
         // Guardas: OTP desligado, store sem suporte ou sem e-mail na sessão → volta ao login.
         const otpEnabled = cfg.login.otp.enabled && supportsOtpLogin(cfg.accountStore);
-        if (!otpEnabled || !email) {
+        if (!otpEnabled || !email || !storeEmail) {
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
         const code = String(ctx.request.input('code', '') ?? '').trim();
@@ -926,14 +985,14 @@ export default class AuthInteractionController {
         // Mantém a sub-view do seletor no re-render de erro (o form de código pode
         // POSTar `channel=code`). Ausente = both (histórico).
         const channel = normalizeLoginChannel(ctx.request.input('channel'));
-        const result = await cfg.accountStore.verifyLoginCode(email, uid, code, {
+        const result = await cfg.accountStore.verifyLoginCode(storeEmail, uid, code, {
             maxAttempts: cfg.login.otp.maxAttempts,
         });
         // Re-render da tela "link enviado" com o campo de código + erro localizado.
         // `otpEnabled` vem do spread (scoped — OTP é extensão do magic link, e a
         // preferência do usuário que desligou magic link já foi barrada acima).
         const renderOtpError = async (messageKey) => render(ctx, 'login', {
-            ...(await this.#userScopedLoginMethods(ctx, cfg, email)),
+            ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -1008,18 +1067,18 @@ export default class AuthInteractionController {
                 clientId: clientId ?? null,
                 metadata: { method: 'otp' },
             });
-            ctx.session.forget(SESSION_KEY);
+            forgetLoginEmail(ctx);
             return service.interactions.completeLogin(ctx, result.account.id, { amr: ['email'] });
         }
         if (result.status === 'locked') {
             // 5ª falha (ou já travado): código invalidado, o LINK continua válido.
-            await cfg.audit?.record({ type: 'login.otp_invalidated', email, ip, clientId });
+            await cfg.audit?.record({ type: 'login.otp_invalidated', email: storeEmail, ip, clientId });
             return renderOtpError('login.otp_locked');
         }
         if (result.status === 'expired') {
             await cfg.audit?.record({
                 type: 'login.otp_failed',
-                email,
+                email: storeEmail,
                 ip,
                 clientId,
                 metadata: { reason: 'expired' },
@@ -1029,7 +1088,7 @@ export default class AuthInteractionController {
         // 'invalid' (tentativa contabilizada) ou 'no_code'.
         await cfg.audit?.record({
             type: 'login.otp_failed',
-            email,
+            email: storeEmail,
             ip,
             clientId,
             metadata: { reason: result.status },
@@ -1252,7 +1311,7 @@ export default class AuthInteractionController {
         // Passkey OK: opcionalmente confia neste dispositivo (checkbox no challenge).
         await this.maybeTrustDevice(ctx, cfg, accountId);
         ctx.session.forget(MFA_PENDING_KEY);
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
@@ -1268,7 +1327,7 @@ export default class AuthInteractionController {
      * Clears the stored email and redirects back to step 1.
      */
     async switchIdentifier(ctx) {
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**

package/build/src/host/controllers/registration_controller.js

@@ -5,6 +5,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor } from '../branding.js';
 import { sendEmailVerificationEmail, sendMagicLinkEmail, sendPasswordResetEmail, } from '../default_mailer.js';
+import { resolveEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { authkitOrigin } from '../origin.js';
 import { RuntimeSettings, resolveRuntimeSettings } from '../runtime_settings.js';
@@ -118,7 +119,13 @@ export default class AuthRegistrationController {
         }
         const data = await ctx.request.validateUsing(signupValidator);
         const accountStore = cfg.accountStore;
-        const existing = await accountStore.findByEmail(data.email);
+        // Duplicado: além do endereço normalizado, enxerga a conta que o cadastro
+        // antigo gravou mutilada — senão a mesma pessoa ganharia uma SEGUNDA conta.
+        // Usa o valor CRU do formulário (o validator já normalizou `data.email`, e a
+        // ponte precisa da grafia original entre as candidatas).
+        const existing = (await resolveEmailIdentifier(accountStore, ctx.request.input('email'), {
+            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+        })).account;
         if (existing) {
             return render(ctx, 'signup', {
                 uid: ctx.request.param('uid'),
@@ -217,7 +224,10 @@ export default class AuthRegistrationController {
         const data = await ctx.request.validateUsing(passwordlessSignupValidator);
         // Cria a conta se ainda não existe. Senha random inutilizável: o login é 100%
         // passwordless (mesmo precedente das contas criadas por identidade social).
-        const existing = await accountStore.findByEmail(data.email);
+        // Valor CRU do formulário pelo mesmo motivo do cadastro com senha.
+        const existing = (await resolveEmailIdentifier(accountStore, ctx.request.input('email'), {
+            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+        })).account;
         if (!existing) {
             const created = await accountStore.create({
                 email: data.email,
@@ -233,15 +243,19 @@ export default class AuthRegistrationController {
             });
         }
         // Emite + envia o magic link (mesma construção do login por magic link).
-        const issued = await accountStore.issueMagicLinkToken(data.email);
+        // Conta já existente entra pelo endereço sob o qual está GRAVADA (pode ser a
+        // forma mutilada pelo cadastro antigo); conta nova, pelo endereço digitado.
+        const issueFor = existing?.email ?? data.email;
+        const issued = await accountStore.issueMagicLinkToken(issueFor);
         if (issued) {
             const origin = authkitOrigin(cfg);
             const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+            const to = issued.account.email;
             if (cfg.mail?.onMagicLink) {
-                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token: issued.token });
+                await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token });
             }
             else {
-                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl });
+                await sendMagicLinkEmail(ctx, { email: to, magicUrl });
             }
         }
         // Resposta uniforme: "enviamos um link" (não vaza existência da conta).
@@ -322,21 +336,33 @@ export default class AuthRegistrationController {
         }
         const { email } = await ctx.request.validateUsing(forgotPasswordValidator);
         const accountStore = cfg.accountStore;
-        const result = await accountStore.issuePasswordResetToken(email);
+        let result = await accountStore.issuePasswordResetToken(email);
+        // Ponte legada: quem teve o endereço mutilado pelo cadastro antigo precisa
+        // conseguir resetar a senha digitando o endereço REAL. Só entra quando o
+        // endereço normalizado não achou nada — o caminho feliz segue com UMA
+        // chamada só. Resposta uniforme (a tela abaixo é a mesma, ache ou não).
+        if (!result && (cfg.login?.legacyEmailFallback ?? true)) {
+            const resolved = await resolveEmailIdentifier(accountStore, ctx.request.input('email'));
+            if (resolved.viaLegacyFallback) {
+                result = await accountStore.issuePasswordResetToken(resolved.lookupEmail);
+            }
+        }
         if (result) {
             await cfg.audit?.record({
                 type: 'password_reset.issued',
-                email,
+                email: result.account.email,
                 ip: ctx.request.ip?.() ?? null,
             });
             const origin = authkitOrigin(cfg);
             const url = `${origin}/auth/reset-password?token=${result.token}`;
             // Hook do config tem prioridade (override); senão usa o mailer default do host.
+            // O link vai para a caixa postal sob a qual a conta está gravada.
+            const to = result.account.email;
             if (cfg.mail?.onPasswordReset) {
-                await cfg.mail.onPasswordReset({ email, resetUrl: url, token: result.token });
+                await cfg.mail.onPasswordReset({ email: to, resetUrl: url, token: result.token });
             }
             else {
-                await sendPasswordResetEmail(ctx, { email, resetUrl: url });
+                await sendPasswordResetEmail(ctx, { email: to, resetUrl: url });
             }
         }
         return render(ctx, 'forgot', {