@adonis-agora/authkit-server 0.70.0 → 0.72.0

package/build/commands/commands.json

@@ -153,6 +153,24 @@
       "options": { "startApp": true },
       "filePath": "import_users.js"
     },
+    {
+      "commandName": "authkit:users:normalize-emails",
+      "description": "Migra os e-mails gravados para a forma normalizada da identidade (trim + lowercase). Sem --apply apenas relata.",
+      "namespace": "authkit",
+      "aliases": [],
+      "flags": [
+        {
+          "name": "apply",
+          "flagName": "apply",
+          "required": false,
+          "type": "boolean",
+          "description": "Grava a normalização (sem ele, apenas relata)."
+        }
+      ],
+      "args": [],
+      "options": { "startApp": true },
+      "filePath": "normalize_emails.js"
+    },
     {
       "commandName": "authkit:settings:list",
       "description": "Lista todas as runtime settings presentes em `auth_settings`.",

package/build/commands/import_users.js

@@ -53,12 +53,7 @@ export default class AuthkitImportUsers extends BaseCommand {
             return;
         }
         const { records, parseErrors } = parseImportFile(content);
-        const report = await importUsers(store, records, {
-            dryRun: this.dryRun,
-            // Ponte legada do config (default ligada) — a checagem de duplicado
-            // enxerga as contas gravadas com o endereço mutilado pelo cadastro antigo.
-            legacyFallback: authkitConfig?.login?.legacyEmailFallback ?? true,
-        });
+        const report = await importUsers(store, records, { dryRun: this.dryRun });
         // Erros de parsing entram no relatório agregado.
         report.errors.unshift(...parseErrors);
         if (this.dryRun) {

package/build/commands/normalize_emails.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Migra os endereços GRAVADOS para a forma normalizada da identidade (`trim` +
+ * `toLowerCase`) — a MESMA que o cadastro grava e que o login busca.
+ *
+ * É PASSO OBRIGATÓRIO do upgrade para quem tem contas criadas antes da v0.69:
+ * o cadastro antigo gravava o endereço mutilado (`.normalizeEmail()` do VineJS
+ * removia pontos e `+tag` no gmail) e import/convite/provider social gravavam a
+ * grafia crua, com maiúsculas. O login busca UMA forma só; qualquer outra grafia
+ * gravada deixa a conta INALCANÇÁVEL, sem mensagem de erro (a tela é à prova de
+ * enumeração).
+ */
+export default class AuthkitNormalizeEmails extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    apply?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/normalize_emails.js

@@ -0,0 +1,106 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+import { normalizeAccountEmails } from '../src/commands/normalize_emails.js';
+import { resolveAuthkitConfig } from '../src/commands/resolve_config.js';
+/**
+ * Migra os endereços GRAVADOS para a forma normalizada da identidade (`trim` +
+ * `toLowerCase`) — a MESMA que o cadastro grava e que o login busca.
+ *
+ * É PASSO OBRIGATÓRIO do upgrade para quem tem contas criadas antes da v0.69:
+ * o cadastro antigo gravava o endereço mutilado (`.normalizeEmail()` do VineJS
+ * removia pontos e `+tag` no gmail) e import/convite/provider social gravavam a
+ * grafia crua, com maiúsculas. O login busca UMA forma só; qualquer outra grafia
+ * gravada deixa a conta INALCANÇÁVEL, sem mensagem de erro (a tela é à prova de
+ * enumeração).
+ */
+export default class AuthkitNormalizeEmails extends BaseCommand {
+    static commandName = 'authkit:users:normalize-emails';
+    static description = 'Migra os e-mails gravados para a forma normalizada da identidade (trim + lowercase). Sem --apply apenas relata.';
+    static help = [
+        'Sem --apply o comando NÃO escreve nada: varre as contas e relata quantas mudariam,',
+        'quais, e as COLISÕES (duas contas que colapsam no mesmo endereço).',
+        'Com --apply grava, recusando-se a tocar em qualquer conta envolvida numa colisão —',
+        'a migração nunca funde contas nem escolhe vencedor: as colididas saem listadas para',
+        'decisão humana.',
+        '',
+        'Sai com código != 0 quando há colisões (ou erro de escrita): é a sua deixa de que',
+        'a base ainda precisa de decisão humana.',
+        '',
+        'Exemplos:',
+        '  node ace authkit:users:normalize-emails',
+        '  node ace authkit:users:normalize-emails --apply',
+    ];
+    static options = { startApp: true };
+    async run() {
+        const config = await this.app.container.make('config');
+        // Resolve o config provider exportado por defineConfig (provider cru não tem accountStore).
+        const authkitConfig = await resolveAuthkitConfig(this.app, config.get('authkit', null));
+        const store = authkitConfig?.accountStore;
+        if (!store) {
+            this.logger.logError("❌ config('authkit').accountStore ausente.");
+            this.exitCode = 1;
+            return;
+        }
+        let report;
+        try {
+            report = await normalizeAccountEmails(store, { apply: this.apply });
+        }
+        catch (error) {
+            this.logger.logError(`❌ ${error.message}`);
+            this.exitCode = 1;
+            return;
+        }
+        if (!this.apply) {
+            this.logger.info('🧪 Relatório — nenhum dado foi alterado (use --apply para gravar).');
+        }
+        this.logger.info(`🔎 ${report.scanned} conta(s) varrida(s); ${report.alreadyNormalized} já normalizada(s).`);
+        if (report.changes.length === 0) {
+            this.logger.success('✅ Nenhum endereço a normalizar.');
+        }
+        else if (this.apply) {
+            this.logger.success(`✅ ${report.applied} endereço(s) normalizado(s).`);
+        }
+        else {
+            this.logger.warning(`⚠️  ${report.changes.length} endereço(s) seriam normalizado(s):`);
+        }
+        for (const change of report.changes) {
+            if (change.error)
+                continue;
+            this.logger.info(`   ${change.from} → ${change.to}`);
+        }
+        const failures = report.changes.filter((change) => !!change.error);
+        if (failures.length > 0) {
+            this.logger.logError(`❌ ${failures.length} não gravada(s):`);
+            for (const change of failures) {
+                this.logger.logError(`   ${change.from} → ${change.to}: ${change.error}`);
+            }
+            this.exitCode = 1;
+        }
+        if (report.unusable.length > 0) {
+            // Não entram em "já normalizada": o relatório não dá por boa uma linha que
+            // deixou para trás.
+            this.logger.warning(`⚠️  ${report.unusable.length} conta(s) com e-mail vazio/inutilizável — NÃO migrada(s):`);
+            for (const account of report.unusable) {
+                this.logger.warning(`   id ${account.accountId}: ${JSON.stringify(account.email)}`);
+            }
+        }
+        if (report.collisions.length > 0) {
+            this.logger.logError(`❌ ${report.collisions.length} colisão(ões) — ${report.skippedByCollision} conta(s) NÃO tocada(s). Decida à mão (a migração não funde contas):`);
+            for (const collision of report.collisions) {
+                this.logger.logError(`   ${collision.email}:`);
+                for (const account of collision.accounts) {
+                    this.logger.logError(`     - ${account.email} (id ${account.accountId})`);
+                }
+            }
+            this.exitCode = 1;
+        }
+    }
+}
+__decorate([
+    flags.boolean({ description: 'Grava a normalização (sem ele, apenas relata).' })
+], AuthkitNormalizeEmails.prototype, "apply", void 0);

package/build/host/views/mfa-challenge.edge

@@ -17,8 +17,11 @@
       @end
 
       {{-- Step-up sem MFA enrolado: bloqueia o login e instrui a configurar o MFA;
-           não renderiza o campo de código (não há 2º fator a desafiar). --}}
-      @if(!noEnrollment)
+           não renderiza o campo de código (não há 2º fator a desafiar).
+           `totpAvailable === false` = a conta só tem passkey, sem app autenticador
+           confirmado: pedir um código de 6 dígitos seria pedir o impossível. Ausente
+           (stores que não reportam o estado) mantém o campo visível. --}}
+      @if(!noEnrollment && totpAvailable !== false)
         <div class="mt-6">
           <label for="code" class="mb-1 block text-sm font-medium text-gray-700">{{ t('mfa_challenge.code_label') }}</label>
           <input id="code" name="code" inputmode="numeric" autocomplete="one-time-code"
@@ -56,7 +59,9 @@
       <p id="passkey-error" class="mt-3 hidden text-sm text-red-600">{{ t('mfa_challenge.passkey_error') }}</p>
     @end
 
-    @if(!noEnrollment)
+    {{-- Códigos de recuperação só existem junto com o TOTP (são gerados no
+         enrollment); sem ele, a seção não tem o que receber. --}}
+    @if(!noEnrollment && totpAvailable !== false)
       <details class="mt-6 text-sm text-gray-600">
         <summary class="cursor-pointer hover:underline">{{ t('mfa_challenge.recovery_summary') }}</summary>
         <form method="POST" action="/auth/interaction/{{ uid }}/mfa" class="mt-3">

package/build/index.d.ts

@@ -3,8 +3,8 @@
  * O comando do AdonisJS importa o entrypoint principal e procura por estes exports.
  */
 export { configure } from './commands/configure.js';
-export type { AccountDeletionCapability, AccountImportCapability, AccountSecurityCapability, AccountStatusCapability, AccountStore, ActiveOrgInfo, AdminCapability, AuthAccount, CoreAccountStore, CreateAccountInput, EmailVerificationStatusCapability, ImportAccountInput, LinkProviderIdentityInput, ListAccountsParams, LoginMethodsPreferenceCapability, MagicLinkCapability, MfaCapability, OrganizationsCapability, OrgInvitation, OrgMember, OrgSummary, OtpLoginCapability, OtpLoginVerifyResult, Paginated, PasskeySummary, ProfileCapability, ProviderIdentityCapability, ProviderIdentitySummary, WebauthnCapability, } from './src/accounts/account_store.js';
-export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
+export type { AccountDeletionCapability, AccountEmailRewriteCapability, AccountImportCapability, AccountSecurityCapability, AccountStatusCapability, AccountStore, ActiveOrgInfo, AdminCapability, AuthAccount, CoreAccountStore, CreateAccountInput, EmailVerificationStatusCapability, ImportAccountInput, LinkProviderIdentityInput, ListAccountsParams, LoginMethodsPreferenceCapability, MagicLinkCapability, MfaCapability, OrganizationsCapability, OrgInvitation, OrgMember, OrgSummary, OtpLoginCapability, OtpLoginVerifyResult, Paginated, PasskeySummary, ProfileCapability, ProviderIdentityCapability, ProviderIdentitySummary, WebauthnCapability, } from './src/accounts/account_store.js';
+export { supportsAccountDeletion, supportsAccountEmailRewrite, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export type { AccountSecretEncrypter, LucidAccountStoreOptions, } from './src/accounts/lucid_account_store.js';
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
@@ -64,8 +64,7 @@ export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROU
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
 export type { AuthkitCsrfOptions } from './src/host/csrf.js';
 export { authkitCsrfExceptions } from './src/host/csrf.js';
-export type { EmailIdentifierLookup, ResolvedEmailIdentifier, } from './src/host/email_identifier.js';
-export { legacyNormalizeEmailIdentifier, normalizeEmailIdentifier, resolveEmailIdentifier, } from './src/host/email_identifier.js';
+export { normalizeEmailIdentifier } from './src/host/email_identifier.js';
 export type { ResolveGeo } from './src/host/geo.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export type { AuthMessages, I18nConfig } from './src/host/i18n.js';

package/build/index.js

@@ -3,7 +3,7 @@
  * O comando do AdonisJS importa o entrypoint principal e procura por estes exports.
  */
 export { configure } from './commands/configure.js';
-export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
+export { supportsAccountDeletion, supportsAccountEmailRewrite, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
 export { lucidStores } from './src/accounts/lucid_stores.js';
@@ -49,7 +49,7 @@ export { brandFor, isFirstParty, isFirstPartyClient } from './src/host/branding.
 export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROUTE_OPTIONS, resetLockedSettingKeys, SettingLockedError, setLockedSettingKeys, } from './src/host/config_locks.js';
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
 export { authkitCsrfExceptions } from './src/host/csrf.js';
-export { legacyNormalizeEmailIdentifier, normalizeEmailIdentifier, resolveEmailIdentifier, } from './src/host/email_identifier.js';
+export { normalizeEmailIdentifier } from './src/host/email_identifier.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export { BUILTIN_MESSAGES, DEFAULT_LOCALE, DEFAULT_MESSAGES, PT_BR_MESSAGES, resolveMessages, translate, } from './src/host/i18n.js';
 export { ensureConsoleSession } from './src/host/idp_session_bridge.js';

package/build/src/accounts/account_store.d.ts

@@ -250,10 +250,18 @@ export interface MfaCapability {
      * mecanismo de "trusted devices": um cookie de confiança emitido ANTES desse
      * instante é considerado inválido (re-enrolar MFA revoga a confiança). Pode ser
      * `null`/ausente quando o MFA não está ativo ou o store não rastreia o instante.
+     *
+     * `totp` diz se há um app autenticador CONFIRMADO (segredo + códigos de
+     * recuperação). É diferente de `enabled`: registrar uma passkey também liga o
+     * MFA, e remover a última passkey não o desliga — então `enabled` sozinho não
+     * responde "existe um segundo fator que esta pessoa consegue apresentar?".
+     * Quem decide mostrar (ou não) o desafio precisa de `totp`; stores antigos que
+     * o omitem continuam funcionando, só não distinguem os dois casos.
      */
     getMfaState(accountId: string): Promise<{
         enabled: boolean;
         enabledAt?: number | null;
+        totp?: boolean;
     }>;
     /**
      * Inicia o enrollment TOTP: gera um segredo PENDENTE (mfaEnabledAt continua
@@ -441,6 +449,28 @@ export interface AccountImportCapability {
      */
     importAccount(input: ImportAccountInput): Promise<AuthAccount | null>;
 }
+/**
+ * Regravação ADMINISTRATIVA do endereço da conta (comando
+ * `authkit:users:normalize-emails`). CAPACIDADE opcional, presente no store
+ * Lucid default.
+ *
+ * Distinta de {@link AccountSecurityCapability.requestEmailChange}: NÃO há
+ * cerimônia de confirmação (nenhum token viaja, nenhum e-mail é enviado) e o
+ * estado de "e-mail verificado" fica COMO ESTÁ — a migração só canonicaliza a
+ * grafia de uma caixa postal que já era a mesma (`trim` + `toLowerCase`), então
+ * marcar como verificado seria conceder uma prova que ninguém deu.
+ *
+ * Não é um caminho para trocar de titular: quem quer mudar de caixa postal passa
+ * pelo fluxo com confirmação. Um store pode simplesmente não a implementar — aí
+ * o `--apply` do comando recusa e a base é migrada por SQL do host.
+ */
+export interface AccountEmailRewriteCapability {
+    /**
+     * Regrava o e-mail da conta. Retorna `false` quando a conta não existe ou
+     * quando o endereço já pertence a OUTRA conta (a migração nunca funde contas).
+     */
+    rewriteAccountEmail(accountId: string, email: string): Promise<boolean>;
+}
 /**
  * Login sem senha por "magic link" — um token de uso único e curta duração
  * enviado por e-mail. CAPACIDADE opcional: stores sem suporte omitem os métodos e
@@ -661,7 +691,7 @@ export type AccountStore = CoreAccountStore & {
      * Undefined → `users` (back-compat com stores próprios).
      */
     readonly accountTable?: string;
-} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
+} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & AccountEmailRewriteCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
 /** Type guard: o store implementa a capacidade de MFA / TOTP. */
 export declare function supportsMfa(store: AccountStore): store is AccountStore & MfaCapability;
 /**
@@ -712,6 +742,8 @@ export declare function supportsEmailVerificationStatus(store: AccountStore): st
 export declare function supportsAccountDeletion(store: AccountStore): store is AccountStore & AccountDeletionCapability;
 /** Type guard: o store implementa o import em massa de contas. */
 export declare function supportsAccountImport(store: AccountStore): store is AccountStore & AccountImportCapability;
+/** Type guard: o store implementa a regravação administrativa do e-mail. */
+export declare function supportsAccountEmailRewrite(store: AccountStore): store is AccountStore & AccountEmailRewriteCapability;
 /** Type guard: o store implementa histórico de senhas (disallow_password_reuse). */
 export declare function supportsPasswordHistory(store: AccountStore): store is AccountStore & PasswordHistoryCapability;
 /** Type guard: o store implementa expiração de senha (password_changed_at coluna). */

package/build/src/accounts/account_store.js

@@ -75,6 +75,10 @@ export function supportsAccountDeletion(store) {
 export function supportsAccountImport(store) {
     return typeof store.importAccount === 'function';
 }
+/** Type guard: o store implementa a regravação administrativa do e-mail. */
+export function supportsAccountEmailRewrite(store) {
+    return typeof store.rewriteAccountEmail === 'function';
+}
 /** Type guard: o store implementa histórico de senhas (disallow_password_reuse). */
 export function supportsPasswordHistory(store) {
     return typeof store.isPasswordReused === 'function';

package/build/src/accounts/lucid_store/core.d.ts

@@ -1,4 +1,4 @@
-import type { AccountImportCapability, AccountSecurityCapability, CoreAccountStore, MagicLinkCapability, OtpLoginCapability } from '../account_store.js';
+import type { AccountEmailRewriteCapability, AccountImportCapability, AccountSecurityCapability, CoreAccountStore, MagicLinkCapability, OtpLoginCapability } from '../account_store.js';
 import type { LucidStoreContext } from './shared.js';
 /**
  * Núcleo SEMPRE presente do {@link CoreAccountStore} sobre um model Lucid:
@@ -6,4 +6,4 @@ import type { LucidStoreContext } from './shared.js';
  * (listagem paginada + roles globais) e o self-service de segurança
  * ({@link AccountSecurityCapability}: trocar senha/e-mail).
  */
-export declare function buildCore(ctx: LucidStoreContext): CoreAccountStore & AccountSecurityCapability & MagicLinkCapability & OtpLoginCapability & AccountImportCapability;
+export declare function buildCore(ctx: LucidStoreContext): CoreAccountStore & AccountSecurityCapability & MagicLinkCapability & OtpLoginCapability & AccountImportCapability & AccountEmailRewriteCapability;

package/build/src/accounts/lucid_store/core.js

@@ -432,6 +432,22 @@ export function buildCore(ctx) {
             await row.save();
             return { token, account: toAccount(row), newEmail };
         },
+        async rewriteAccountEmail(accountId, email) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            // Nunca funde contas: se o endereço já é de OUTRA conta, recusa. O comando
+            // já detecta a colisão antes de chegar aqui; isto é a rede de baixo, para
+            // a corrida (outra conta gravada entre o relatório e a escrita).
+            const taken = await Model.query().where('email', email).first();
+            if (taken && taken.id !== row.id)
+                return false;
+            row.email = email;
+            // `emailVerifiedAt` fica COMO ESTÁ: a caixa postal é a mesma, só a grafia
+            // gravada muda — não há prova nova para registrar.
+            await row.save();
+            return true;
+        },
         async confirmEmailChange(token) {
             if (!token || !token.startsWith(EMAIL_CHANGE_PREFIX))
                 return { ok: false };

package/build/src/accounts/lucid_store/mfa.js

@@ -25,7 +25,15 @@ export function buildMfa(ctx) {
             const state = await repo.read(accountId);
             // `enabledAt` (epoch ms) habilita o trusted-device check: um cookie de
             // confiança emitido ANTES deste instante é inválido (re-enrolar revoga).
-            return { enabled: !!state?.mfaEnabledAt, enabledAt: state?.mfaEnabledAt ?? null };
+            // `totp` é o fator REALMENTE utilizável: segredo confirmado + códigos de
+            // recuperação gravados. `enabled` também liga ao registrar passkey (ver
+            // `webauthn.ts`) e não desliga ao remover a última — sozinho, não diz se
+            // sobrou algum fator para desafiar.
+            return {
+                enabled: !!state?.mfaEnabledAt,
+                enabledAt: state?.mfaEnabledAt ?? null,
+                totp: !!(state?.mfaEnabledAt && state?.totpSecret && state?.recoveryCodes),
+            };
         },
         async startTotpEnrollment(accountId) {
             // O email/QR vem do model principal; só o ESTADO de MFA vive em auth_mfa.

package/build/src/commands/import_users.d.ts

@@ -42,17 +42,10 @@ export declare function parseImportFile(content: string): {
  *
  * Lógica PURA quanto a I/O de arquivo (recebe os registros já parseados) — fácil
  * de testar. Lança se o store não suporta import nem create.
- *
- * `legacyFallback` (default ligado, como no resto da lib) faz a checagem de
- * duplicado enxergar também a conta que o cadastro antigo gravou com o endereço
- * mutilado — importar a grafia REAL do dono dela pula como duplicado em vez de
- * criar uma SEGUNDA conta. O comando não tem acesso ao config, então o flag
- * chega por aqui.
  */
 export declare function importUsers(store: AccountStore, records: {
     line: number;
     record: ImportUserRecord;
 }[], options?: {
     dryRun?: boolean;
-    legacyFallback?: boolean;
 }): Promise<ImportReport>;

package/build/src/commands/import_users.js

@@ -1,5 +1,5 @@
 import { supportsAccountImport } from '../accounts/account_store.js';
-import { normalizeEmailIdentifier, resolveEmailIdentifier } from '../host/email_identifier.js';
+import { normalizeEmailIdentifier } from '../host/email_identifier.js';
 /**
  * Faz o parse do conteúdo do arquivo: aceita NDJSON (uma linha JSON por usuário)
  * OU um array JSON. Retorna os registros + os erros de parsing por linha. PURO
@@ -48,12 +48,6 @@ export function parseImportFile(content) {
  *
  * Lógica PURA quanto a I/O de arquivo (recebe os registros já parseados) — fácil
  * de testar. Lança se o store não suporta import nem create.
- *
- * `legacyFallback` (default ligado, como no resto da lib) faz a checagem de
- * duplicado enxergar também a conta que o cadastro antigo gravou com o endereço
- * mutilado — importar a grafia REAL do dono dela pula como duplicado em vez de
- * criar uma SEGUNDA conta. O comando não tem acesso ao config, então o flag
- * chega por aqui.
  */
 export async function importUsers(store, records, options = {}) {
     const report = { created: 0, skippedDuplicate: 0, errors: [] };
@@ -66,11 +60,10 @@ export async function importUsers(store, records, options = {}) {
             report.errors.push({ line, reason: 'missing email' });
             continue;
         }
-        // Duplicado: e-mail já existe → pula. Enxerga também a conta gravada com o
-        // endereço mutilado (ponte legada) — empate segue criando, como no cadastro.
-        const existing = (await resolveEmailIdentifier(store, record.email, {
-            legacyFallback: options.legacyFallback,
-        })).account;
+        // Duplicado pela MESMA forma que o login busca — a normalizada. Uma base com
+        // endereços gravados em outra grafia pede `authkit:users:normalize-emails`
+        // ANTES do import, senão o duplicado passa despercebido.
+        const existing = await store.findByEmail(email);
         if (existing) {
             report.skippedDuplicate++;
             continue;

package/build/src/commands/normalize_emails.d.ts

@@ -0,0 +1,78 @@
+import type { AccountStore } from '../accounts/account_store.js';
+/** Uma conta cujo endereço gravado difere da forma normalizada. */
+export interface EmailNormalizationChange {
+    accountId: string;
+    /** Endereço como está gravado hoje. */
+    from: string;
+    /** Forma normalizada (`trim` + `toLowerCase`) — o que o login busca. */
+    to: string;
+    /** `true` quando o `--apply` gravou; `false` no relatório e quando a escrita falhou. */
+    applied: boolean;
+    /** Motivo da escrita não ter acontecido (só com `--apply`). */
+    error?: string;
+}
+/**
+ * Duas ou mais contas que colapsam no MESMO endereço normalizado — por exemplo
+ * `Davi@Acme.com` e `davi@acme.com`. A migração NÃO escolhe vencedor e NÃO funde
+ * contas: lista as envolvidas e não toca em nenhuma delas.
+ */
+export interface EmailNormalizationCollision {
+    /** A forma normalizada em que as contas colidem. */
+    email: string;
+    /** As contas envolvidas, com o endereço que cada uma tem gravado hoje. */
+    accounts: {
+        accountId: string;
+        email: string;
+    }[];
+}
+export interface NormalizeEmailsReport {
+    /** Contas varridas. */
+    scanned: number;
+    /** Contas que já estão na forma normalizada (não são tocadas). */
+    alreadyNormalized: number;
+    /** As que mudariam (ou mudaram, com `--apply`), fora de colisão. */
+    changes: EmailNormalizationChange[];
+    /** Quantas foram efetivamente gravadas (0 sem `--apply`). */
+    applied: number;
+    /** Colisões encontradas — decisão humana. */
+    collisions: EmailNormalizationCollision[];
+    /** Contas que a colisão impediu de mexer (soma das contas de `collisions`). */
+    skippedByCollision: number;
+    /**
+     * Contas cujo endereço gravado NÃO normaliza para nada (coluna nula, vazia ou
+     * só espaços). Não entram em `alreadyNormalized`: gravar string vazia como
+     * identidade seria pior que deixar como está, e um operador que lê "já
+     * normalizada" não pode achar que estas linhas estão bem.
+     */
+    unusable: {
+        accountId: string;
+        email: string;
+    }[];
+}
+/**
+ * Migração dos endereços GRAVADOS para a forma normalizada da identidade
+ * (`normalizeEmailIdentifier`: `trim` + `toLowerCase`).
+ *
+ * POR QUE ELA EXISTE: até a v0.68 o cadastro gravava o endereço mutilado pelo
+ * `.normalizeEmail()` do VineJS (no gmail, sem pontos e sem `+tag`), e import,
+ * convite e provider social gravavam a grafia crua, com maiúsculas. O login
+ * busca UMA forma só — a normalizada. Uma conta gravada em qualquer outra grafia
+ * fica INALCANÇÁVEL, e, por o login ser à prova de enumeração, sem nenhuma
+ * mensagem de erro. Esta migração é o que reencontra essas contas.
+ *
+ * Em modo RELATÓRIO (default) não escreve nada: varre, calcula e devolve o que
+ * mudaria. Com `apply`, grava — RECUSANDO-SE a tocar em qualquer conta envolvida
+ * numa colisão (duas contas que colapsam no mesmo endereço). Nunca funde contas,
+ * nunca escolhe vencedor: as colididas saem listadas para decisão humana.
+ *
+ * A varredura acontece INTEIRA antes de qualquer escrita, de propósito: a
+ * listagem é ordenada por e-mail, e reescrever endereços no meio da paginação
+ * moveria linhas entre páginas — contas seriam puladas sem nenhum sinal.
+ *
+ * Lógica PURA quanto a CLI (recebe o store, devolve o relatório) — testável sem
+ * ace e sem banco.
+ */
+export declare function normalizeAccountEmails(store: AccountStore, options?: {
+    apply?: boolean;
+    pageSize?: number;
+}): Promise<NormalizeEmailsReport>;

package/build/src/commands/normalize_emails.js

@@ -0,0 +1,129 @@
+import { supportsAccountEmailRewrite } from '../accounts/account_store.js';
+import { normalizeEmailIdentifier } from '../host/email_identifier.js';
+import { ADMIN_LIST_DEFAULT_SIZE } from '../pagination.js';
+/** Comparação por code unit — mesma ordem em qualquer máquina, sem depender do ICU. */
+function byCodeUnit(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/**
+ * Migração dos endereços GRAVADOS para a forma normalizada da identidade
+ * (`normalizeEmailIdentifier`: `trim` + `toLowerCase`).
+ *
+ * POR QUE ELA EXISTE: até a v0.68 o cadastro gravava o endereço mutilado pelo
+ * `.normalizeEmail()` do VineJS (no gmail, sem pontos e sem `+tag`), e import,
+ * convite e provider social gravavam a grafia crua, com maiúsculas. O login
+ * busca UMA forma só — a normalizada. Uma conta gravada em qualquer outra grafia
+ * fica INALCANÇÁVEL, e, por o login ser à prova de enumeração, sem nenhuma
+ * mensagem de erro. Esta migração é o que reencontra essas contas.
+ *
+ * Em modo RELATÓRIO (default) não escreve nada: varre, calcula e devolve o que
+ * mudaria. Com `apply`, grava — RECUSANDO-SE a tocar em qualquer conta envolvida
+ * numa colisão (duas contas que colapsam no mesmo endereço). Nunca funde contas,
+ * nunca escolhe vencedor: as colididas saem listadas para decisão humana.
+ *
+ * A varredura acontece INTEIRA antes de qualquer escrita, de propósito: a
+ * listagem é ordenada por e-mail, e reescrever endereços no meio da paginação
+ * moveria linhas entre páginas — contas seriam puladas sem nenhum sinal.
+ *
+ * Lógica PURA quanto a CLI (recebe o store, devolve o relatório) — testável sem
+ * ace e sem banco.
+ */
+export async function normalizeAccountEmails(store, options = {}) {
+    const pageSize = options.pageSize ?? ADMIN_LIST_DEFAULT_SIZE;
+    const report = {
+        scanned: 0,
+        alreadyNormalized: 0,
+        changes: [],
+        applied: 0,
+        collisions: [],
+        skippedByCollision: 0,
+        unusable: [],
+    };
+    // 1) Varredura completa. Guarda só id + e-mail (strings), agrupados pela forma
+    //    normalizada — é o agrupamento que revela as colisões.
+    const buckets = new Map();
+    for (let page = 1;; page++) {
+        const { data, total } = await store.listAccounts({ page, size: pageSize });
+        if (!data.length)
+            break;
+        for (const account of data) {
+            report.scanned++;
+            const normalized = normalizeEmailIdentifier(account.email);
+            const bucket = buckets.get(normalized);
+            if (bucket)
+                bucket.push({ accountId: account.id, email: account.email });
+            else
+                buckets.set(normalized, [{ accountId: account.id, email: account.email }]);
+        }
+        if (report.scanned >= total)
+            break;
+    }
+    // 2) Classificação: colisão, mudança ou já normalizada.
+    const pending = [];
+    for (const [normalized, accounts] of buckets) {
+        // `normalized` vazio (coluna nula/vazia/só espaços) não é migrável. Sai
+        // LISTADO, não somado às "já normalizadas": o relatório não pode dar
+        // atestado de saúde para a linha que ele deliberadamente deixou para trás.
+        // ANTES da checagem de colisão: duas linhas em branco caem no mesmo balde
+        // `""` e sairiam como "colisão no endereço ''", que não descreve nada.
+        if (!normalized) {
+            report.unusable.push(...accounts);
+            continue;
+        }
+        if (accounts.length > 1) {
+            // Duas contas distintas no mesmo endereço normalizado. NENHUMA é tocada —
+            // nem a que já está normalizada, porque a decisão (fundir? renomear? qual
+            // delas é a pessoa?) é humana e envolve as duas.
+            report.collisions.push({ email: normalized, accounts });
+            report.skippedByCollision += accounts.length;
+            continue;
+        }
+        const [account] = accounts;
+        if (account.email === normalized) {
+            report.alreadyNormalized++;
+            continue;
+        }
+        pending.push({
+            accountId: account.accountId,
+            from: account.email,
+            to: normalized,
+            applied: false,
+        });
+    }
+    // Ordem estável (por endereço gravado) para o relatório ser diffável entre
+    // runs. Comparação por code unit, NÃO `localeCompare`: a ordem desta depende
+    // do ICU da máquina, e aí "diffável" valeria só dentro de um host.
+    pending.sort((a, b) => byCodeUnit(a.from, b.from));
+    report.collisions.sort((a, b) => byCodeUnit(a.email, b.email));
+    // `unusable` também: sem isto a lista sairia na ordem da varredura, que é a
+    // ordem do store — a mesma garantia não valeria para ela.
+    report.unusable.sort((a, b) => byCodeUnit(a.accountId, b.accountId));
+    report.changes = pending;
+    if (!options.apply)
+        return report;
+    // 3) Escrita. Capacidade probada: um store sem ela não tem como regravar o
+    //    endereço, e inventar um caminho por fora do store não é da lib.
+    if (!supportsAccountEmailRewrite(store)) {
+        throw new Error('accountStore não implementa rewriteAccountEmail: a migração não tem como gravar (relatório segue funcionando).');
+    }
+    for (const change of pending) {
+        try {
+            const ok = await store.rewriteAccountEmail(change.accountId, change.to);
+            if (ok) {
+                change.applied = true;
+                report.applied++;
+            }
+            else {
+                // O store recusou: conta sumiu ou o endereço passou a ser de OUTRA conta
+                // entre a varredura e a escrita (colisão que nasceu no meio do caminho).
+                change.error = 'o store recusou a regravação (conta inexistente ou endereço já tomado)';
+            }
+        }
+        catch (error) {
+            change.error = error.message;
+        }
+    }
+    return report;
+}