@adonis-agora/authkit-server 0.70.0 → 0.71.0

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

@@ -3,7 +3,7 @@ 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 { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { endBridgedIdpSession } from '../idp_session_bridge.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
@@ -68,18 +68,13 @@ 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
+        // L6: normaliza (trim + lowercase, a MESMA função do cadastro e do passo de
+        // identificador do login OIDC) para 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,
-        });
+        // digitados. A tela de erro é a mesma (credencial inválida), ache conta ou não.
+        const email = normalizeEmailIdentifier(rawEmail);
         const result = await attemptPasswordLogin(cfg, {
-            email: lookupEmail,
+            email,
             password,
             ip,
             logger: ctx.logger,

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

@@ -12,11 +12,11 @@ export default class AuthInteractionController {
      * `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.
+     * À PROVA DE ENUMERAÇÃO: o passo NÃO toca no account store — só normaliza e
+     * guarda. A resposta é o MESMO redirect incondicional, exista a conta ou não,
+     * e não há busca alguma aqui para diferenciar os dois casos nem no tempo de
+     * resposta. Quem decide se a conta existe é o passo 2, que renderiza a mesma
+     * tela nos dois casos.
      */
     identifier(ctx: HttpContext): Promise<void>;
     /**

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

@@ -4,7 +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 { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
@@ -43,30 +43,19 @@ function accountStatusErrorKey(reason) {
  * 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.
+ * Esquece o e-mail do login.
+ *
+ * Helper de UMA linha de propósito: os fluxos que encerram o passo de login
+ * (sucesso, "usar outro e-mail", expiração) chamam ISTO em vez de `forget` da
+ * chave crua, para que nenhum caminho deixe o e-mail pendurado na sessão.
  */
-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 {
     /**
@@ -188,8 +177,6 @@ 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
@@ -199,7 +186,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, storeEmail, runtimeSettingsForMaintenance)
+            ? await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettingsForMaintenance)
             : await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
         const authMethods = loginMethods.authMethods;
         if (!email) {
@@ -216,7 +203,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(storeEmail ?? email);
+        const acc = await cfg.accountStore.findByEmail(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.
@@ -249,24 +236,17 @@ export default class AuthInteractionController {
      * `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.
+     * À PROVA DE ENUMERAÇÃO: o passo NÃO toca no account store — só normaliza e
+     * guarda. A resposta é o MESMO redirect incondicional, exista a conta ou não,
+     * e não há busca alguma aqui para diferenciar os dois casos nem no tempo de
+     * resposta. Quem decide se a conta existe é o passo 2, que renderiza a mesma
+     * tela nos dois casos.
      */
     async identifier(ctx) {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const cfg = service.config;
         const { email } = ctx.request.only(['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);
+        // `request.only` não valida tipo (`email[]=x` chega array): a normalização
+        // devolve string vazia para não-string, e o passo segue com o redirect.
+        ctx.session.put(SESSION_KEY, normalizeEmailIdentifier(email));
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**
@@ -284,8 +264,6 @@ 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;
@@ -302,15 +280,15 @@ export default class AuthInteractionController {
         // 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: storeEmail,
+            email,
             clientId,
         }))) {
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings)),
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -324,9 +302,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, storeEmail, runtimeSettings);
+        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings);
         if (!userMethodsForLogin.authMethods.password) {
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -355,7 +333,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: storeEmail,
+            email,
             password,
             ip,
             clientId,
@@ -379,7 +357,7 @@ export default class AuthInteractionController {
                     botProtection: undefined,
                 });
             }
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -728,7 +706,7 @@ export default class AuthInteractionController {
             return pending;
         if (!cfg.passwordless?.passkeyFirst)
             return undefined;
-        const email = lookupEmail(ctx);
+        const email = ctx.session.get(SESSION_KEY);
         if (!email)
             return undefined;
         const acc = await cfg.accountStore.findByEmail(email);
@@ -749,9 +727,6 @@ 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.
@@ -763,7 +738,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, storeEmail)
+            ? await this.#userScopedLoginMethods(ctx, cfg, email)
             : null;
         if (userScopedMethods && !userScopedMethods.authMethods.magicLink) {
             return render(ctx, 'login', {
@@ -778,17 +753,17 @@ export default class AuthInteractionController {
                 magicChannel: 'none',
             });
         }
-        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && storeEmail) {
+        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
             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(storeEmail, uid, {
+                ? await cfg.accountStore.issueMagicLinkWithCode(email, uid, {
                     digits: cfg.login.otp.digits,
                     ttlMinutes: cfg.login.otp.ttlMinutes,
                 })
-                : await cfg.accountStore.issueMagicLinkToken(storeEmail);
+                : await cfg.accountStore.issueMagicLinkToken(email);
             if (issued) {
                 const code = 'code' in issued ? issued.code : undefined;
                 await cfg.audit?.record({
@@ -823,7 +798,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, storeEmail)
+                ? await this.#userScopedLoginMethods(ctx, cfg, email)
                 : await this.#loginMethods(ctx, cfg)),
             uid,
             csrfToken: ctx.request.csrfToken,
@@ -973,11 +948,9 @@ 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 || !storeEmail) {
+        if (!otpEnabled || !email) {
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
         const code = String(ctx.request.input('code', '') ?? '').trim();
@@ -985,14 +958,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(storeEmail, uid, code, {
+        const result = await cfg.accountStore.verifyLoginCode(email, 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, storeEmail)),
+            ...(await this.#userScopedLoginMethods(ctx, cfg, email)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -1072,13 +1045,13 @@ export default class AuthInteractionController {
         }
         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: storeEmail, ip, clientId });
+            await cfg.audit?.record({ type: 'login.otp_invalidated', email, ip, clientId });
             return renderOtpError('login.otp_locked');
         }
         if (result.status === 'expired') {
             await cfg.audit?.record({
                 type: 'login.otp_failed',
-                email: storeEmail,
+                email,
                 ip,
                 clientId,
                 metadata: { reason: 'expired' },
@@ -1088,7 +1061,7 @@ export default class AuthInteractionController {
         // 'invalid' (tentativa contabilizada) ou 'no_code'.
         await cfg.audit?.record({
             type: 'login.otp_failed',
-            email: storeEmail,
+            email,
             ip,
             clientId,
             metadata: { reason: result.status },

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

@@ -5,7 +5,6 @@ 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';
@@ -119,13 +118,9 @@ export default class AuthRegistrationController {
         }
         const data = await ctx.request.validateUsing(signupValidator);
         const accountStore = cfg.accountStore;
-        // 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;
+        // Duplicado pela MESMA forma que o login busca (`data.email` já saiu
+        // normalizado do validator).
+        const existing = await accountStore.findByEmail(data.email);
         if (existing) {
             return render(ctx, 'signup', {
                 uid: ctx.request.param('uid'),
@@ -224,10 +219,7 @@ 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).
-        // 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;
+        const existing = await accountStore.findByEmail(data.email);
         if (!existing) {
             const created = await accountStore.create({
                 email: data.email,
@@ -243,10 +235,9 @@ export default class AuthRegistrationController {
             });
         }
         // Emite + envia o magic link (mesma construção do login por magic link).
-        // 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);
+        // `data.email` já é a forma normalizada — a mesma sob a qual a conta foi
+        // encontrada acima ou acabou de ser criada.
+        const issued = await accountStore.issueMagicLinkToken(data.email);
         if (issued) {
             const origin = authkitOrigin(cfg);
             const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
@@ -336,17 +327,10 @@ export default class AuthRegistrationController {
         }
         const { email } = await ctx.request.validateUsing(forgotPasswordValidator);
         const accountStore = cfg.accountStore;
-        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);
-            }
-        }
+        // `email` já saiu normalizado do validator (a MESMA normalização do
+        // cadastro e do login). Resposta uniforme: a tela abaixo é a mesma, ache
+        // conta ou não.
+        const result = await accountStore.issuePasswordResetToken(email);
         if (result) {
             await cfg.audit?.record({
                 type: 'password_reset.issued',

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

@@ -1,7 +1,7 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
 import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, supportsProviderIdentity, } from '../../accounts/account_store.js';
-import { normalizeEmailIdentifier, resolveEmailIdentifier } from '../email_identifier.js';
+import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
@@ -71,12 +71,10 @@ export default class AuthSocialController {
         //  3. Senão → cria conta nova e liga a identidade.
         let user = await store.findByProviderIdentity(provider, profile.id);
         if (!user && email) {
-            // Ponte legada: sem ela, quem tem a conta gravada com o endereço mutilado
-            // pelo cadastro antigo ganharia uma SEGUNDA conta ao "Continuar com o
-            // Google" em vez de ligar a identidade à conta que já tem.
-            const byEmail = (await resolveEmailIdentifier(store, profile.email, {
-                legacyFallback: cfg.login?.legacyEmailFallback ?? true,
-            })).account;
+            // Busca pela MESMA forma normalizada que o login usa. Uma conta gravada
+            // com outra grafia não é encontrada aqui e a pessoa ganharia uma SEGUNDA
+            // conta — por isso `authkit:users:normalize-emails` é passo de upgrade.
+            const byEmail = await store.findByEmail(email);
             if (byEmail) {
                 await store.linkProviderIdentity({
                     accountId: byEmail.id,

package/build/src/host/email_identifier.d.ts

@@ -1,4 +1,3 @@
-import type { AuthAccount } from '../accounts/account_store.js';
 /**
  * Normalização ÚNICA e CONSERVADORA do e-mail usado como identidade da conta.
  *
@@ -19,74 +18,12 @@ import type { AuthAccount } from '../accounts/account_store.js';
  * Use em TODO ponto que grava ou busca a identidade: cadastro (com e sem senha),
  * "esqueci a senha", troca de e-mail, criação por admin, convite de organização,
  * import de usuários, cadastro social e o passo de identificador do login.
- */
-export declare function normalizeEmailIdentifier(raw: unknown): string;
-/**
- * Réplica da normalização LEGADA — `normalizeEmail()` do validator.js com os
- * defaults, que é o que o `.normalizeEmail()` do VineJS aplicava no cadastro até
- * a v0.68. Existe SÓ para reencontrar as contas que nasceram com o endereço
- * mutilado; nada novo deve ser gravado com ela.
  *
- * É uma PONTE TEMPORÁRIA: quando as contas antigas tiverem sido migradas para o
- * endereço real (ou o suficiente delas), esta função, a opção
- * `login.legacyEmailFallback` e {@link resolveEmailIdentifier} podem sair.
- *
- * Retorna `null` para entradas que o validator.js também recusaria (local part
- * vazio depois do colapso) ou que não são um endereço com `@`.
+ * As contas GRAVADAS antes disto (com o endereço mutilado, ou com maiúsculas
+ * vindas de import/convite/provider social) ficam inalcançáveis pelo login, que
+ * busca a forma normalizada. Elas pedem MIGRAÇÃO do endereço gravado — é o que o
+ * comando `authkit:users:normalize-emails` faz (ver `commands/normalize_emails.ts`).
+ * A lib não tenta adivinhar grafias no caminho do login: cada tentativa extra é
+ * uma query a mais por e-mail desconhecido, que é justamente o caminho de ataque.
  */
-export declare function legacyNormalizeEmailIdentifier(raw: unknown): string | null;
-/** Só o que {@link resolveEmailIdentifier} precisa do account store. */
-export interface EmailIdentifierLookup {
-    findByEmail(email: string): Promise<AuthAccount | null>;
-}
-export interface ResolvedEmailIdentifier {
-    /** O que a pessoa digitou, normalizado. É o que a tela SEMPRE mostra. */
-    email: string;
-    /**
-     * E-mail sob o qual a conta está GRAVADA — o que deve ir para o store em
-     * qualquer busca/emissão de token. Igual a {@link email} quando a conta foi
-     * achada direto (ou quando não foi achada nenhuma).
-     */
-    lookupEmail: string;
-    /** A conta, quando alguma foi encontrada. */
-    account: AuthAccount | null;
-    /** `true` quando a conta só foi alcançada pela ponte legada. */
-    viaLegacyFallback: boolean;
-}
-/**
- * Resolve o e-mail digitado na conta correspondente.
- *
- * Passe o valor **CRU** (como veio do formulário, do provider ou do arquivo): a
- * normalização acontece aqui dentro, e a forma crua é uma das candidatas da
- * ponte. Passar um valor já normalizado apaga essa candidata e reduz o alcance
- * da ponte às contas gravadas com o endereço mutilado.
- *
- * 1. Busca pela forma normalizada NOVA (trim + lowercase) — o caminho de sempre,
- *    uma única query por igualdade (indexada).
- * 2. Não achando, e com a ponte ligada (`login.legacyEmailFallback`, default
- *    `true`), tenta as formas de compatibilidade:
- *    - o endereço EXATAMENTE como digitado (só com `trim`), para as contas que
- *      foram gravadas com maiúsculas antes desta normalização existir (import,
- *      convite, criação por admin, provider social);
- *    - a {@link legacyNormalizeEmailIdentifier normalização legada}, para as
- *      contas que nasceram com o endereço mutilado.
- *    O resultado só é aceito quando as formas de compatibilidade apontam para
- *    EXATAMENTE UMA conta. Duas contas distintas (ex.: `Davi.C@Gmail.com` criada
- *    pelo social E `davic@gmail.com` criada pelo cadastro legado) são um empate:
- *    a lib não adivinha qual é a pessoa e trata como "não achei".
- *
- * LIMITE CONHECIDO: a ponte só alcança grafias que dá para derivar do que foi
- * digitado. Uma conta gravada `Davi@Acme.com` é alcançada por quem digita
- * `Davi@Acme.com` (a forma crua), mas NÃO por quem digita `davi@acme.com` — aí as
- * três formas coincidem e só uma busca case-insensitive no store resolveria, o
- * que exigiria varrer a tabela a cada login com e-mail desconhecido (justamente o
- * caminho de ataque). Essas contas pedem migração do endereço gravado, não ponte.
- *
- * À PROVA DE ENUMERAÇÃO: nunca lança, nunca sinaliza nada para fora — quem chama
- * segue com `account: null` exatamente como seguia antes. As buscas extras só
- * acontecem quando as formas de compatibilidade DIFEREM da normalizada (e-mail
- * digitado em minúsculas e sem ponto/tag → uma query só, como hoje).
- */
-export declare function resolveEmailIdentifier(store: EmailIdentifierLookup, raw: unknown, options?: {
-    legacyFallback?: boolean;
-}): Promise<ResolvedEmailIdentifier>;
+export declare function normalizeEmailIdentifier(raw: unknown): string;