@adonis-agora/authkit-server 0.58.3 → 0.60.0

package/build/index.d.ts

@@ -23,8 +23,8 @@ export { lucidAccountStore, appKeyEncrypter } from './src/accounts/lucid_account
 export { lucidStores } from './src/accounts/lucid_stores.js';
 export type { LucidStoresModels, LucidStoresOptions, LucidStoresResult, } from './src/accounts/lucid_stores.js';
 export type { LucidAccountStoreOptions, AccountSecretEncrypter, } from './src/accounts/lucid_account_store.js';
-export type { AccountStore, CoreAccountStore, AdminCapability, MfaCapability, WebauthnCapability, ProviderIdentityCapability, ProviderIdentitySummary, AccountSecurityCapability, AccountStatusCapability, ProfileCapability, MagicLinkCapability, OtpLoginCapability, OtpLoginVerifyResult, EmailVerificationStatusCapability, AccountDeletionCapability, AccountImportCapability, ImportAccountInput, AuthAccount, CreateAccountInput, LinkProviderIdentityInput, ListAccountsParams, Paginated, PasskeySummary, } from './src/accounts/account_store.js';
-export { supportsMfa, supportsPasskeys, supportsProviderIdentity, supportsAccountSecurity, supportsAccountStatus, supportsProfile, supportsMagicLink, supportsOtpLogin, supportsEmailVerificationStatus, supportsAccountDeletion, supportsAccountImport, } from './src/accounts/account_store.js';
+export type { AccountStore, CoreAccountStore, AdminCapability, MfaCapability, WebauthnCapability, ProviderIdentityCapability, ProviderIdentitySummary, AccountSecurityCapability, AccountStatusCapability, ProfileCapability, MagicLinkCapability, OtpLoginCapability, OtpLoginVerifyResult, EmailVerificationStatusCapability, AccountDeletionCapability, AccountImportCapability, ImportAccountInput, AuthAccount, CreateAccountInput, LinkProviderIdentityInput, ListAccountsParams, Paginated, PasskeySummary, LoginMethodsPreferenceCapability, } from './src/accounts/account_store.js';
+export { supportsMfa, supportsPasskeys, supportsProviderIdentity, supportsAccountSecurity, supportsAccountStatus, supportsProfile, supportsMagicLink, supportsOtpLogin, supportsEmailVerificationStatus, supportsAccountDeletion, supportsAccountImport, supportsLoginMethodsPreference, } from './src/accounts/account_store.js';
 export { type OtpLoginConfigInput, type ResolvedOtpLoginConfig, type OtpVerifyOutcome, resolveOtpLoginConfig, generateOtpCode, evaluateLoginOtp, OTP_LOGIN_DEFAULTS, } from './src/host/otp_login.js';
 export { PasswordManager, PasswordPolicyError, } from './src/password/password_manager.js';
 export type { PasswordConfigInput, LegacyPasswordVerifier, PasswordVerifyResult, } from './src/password/password_manager.js';
@@ -125,6 +125,8 @@ export { resolveEffectiveBotProtection } from './src/host/bot_protection.js';
 export type { BotProtectionSetting } from './src/host/bot_protection.js';
 export { SETTING_KEYS, resolveEffectiveRegistration, resolveEffectiveRequireVerifiedEmail, resolveEffectiveMaintenanceMode, resolveEffectiveAuthMethods, configLockedAuthMethods, } from './src/host/runtime_toggles.js';
 export type { SettingKey, RegistrationSetting, RequireVerifiedEmailSetting, MaintenanceModeSetting, ResolvedMaintenanceMode, AuthMethodsSetting, ResolvedAuthMethods, AuthMethodsCapabilities, AuthMethodsConfigOverride, } from './src/host/runtime_toggles.js';
+export { USER_LOGIN_METHOD_KEYS, normalizeUserLoginMethods, parseUserLoginMethodsPayload, resolveEffectiveUserLoginMethods, } from './src/host/user_login_methods.js';
+export type { UserLoginMethodKey, UserLoginMethods, ResolvedUserLoginMethods, } from './src/host/user_login_methods.js';
 export { resolveRegistration } from './src/define_config.js';
 export type { RegistrationConfigInput, ResolvedRegistrationConfig, } from './src/define_config.js';
 export { getAccountId, realAccountId, hasAccountSession, consoleLoginUrl, } from './src/host/console_session.js';

package/build/index.js

@@ -14,7 +14,7 @@ export { resolveTrustedDevices, isTrustedDeviceValid, buildTrustedDevicePayload,
 export { resolveBotProtection, botProtectionApplies, extractBotToken, verifyBotProtection, guardBotProtection, DEFAULT_BOT_TOKEN_FIELDS, } from './src/host/bot_protection.js';
 export { lucidAccountStore, appKeyEncrypter } from './src/accounts/lucid_account_store.js';
 export { lucidStores } from './src/accounts/lucid_stores.js';
-export { supportsMfa, supportsPasskeys, supportsProviderIdentity, supportsAccountSecurity, supportsAccountStatus, supportsProfile, supportsMagicLink, supportsOtpLogin, supportsEmailVerificationStatus, supportsAccountDeletion, supportsAccountImport, } from './src/accounts/account_store.js';
+export { supportsMfa, supportsPasskeys, supportsProviderIdentity, supportsAccountSecurity, supportsAccountStatus, supportsProfile, supportsMagicLink, supportsOtpLogin, supportsEmailVerificationStatus, supportsAccountDeletion, supportsAccountImport, supportsLoginMethodsPreference, } from './src/accounts/account_store.js';
 // Login por OTP (código digitável): config + helpers puros.
 export { resolveOtpLoginConfig, generateOtpCode, evaluateLoginOtp, OTP_LOGIN_DEFAULTS, } from './src/host/otp_login.js';
 // Gerência de senha: lazy rehash + legacy verifier, política e checagem de vazamento.
@@ -85,6 +85,8 @@ export { buildKeysStatus, rotateNow } from './src/host/key_rotation_actions.js';
 export { resolveEffectiveBotProtection } from './src/host/bot_protection.js';
 // Runtime toggles (registration, require_verified_email, maintenance_mode).
 export { SETTING_KEYS, resolveEffectiveRegistration, resolveEffectiveRequireVerifiedEmail, resolveEffectiveMaintenanceMode, resolveEffectiveAuthMethods, configLockedAuthMethods, } from './src/host/runtime_toggles.js';
+// Tipos de login POR USUÁRIO (self-service no console de conta).
+export { USER_LOGIN_METHOD_KEYS, normalizeUserLoginMethods, parseUserLoginMethodsPayload, resolveEffectiveUserLoginMethods, } from './src/host/user_login_methods.js';
 export { resolveRegistration } from './src/define_config.js';
 export { getAccountId, realAccountId, hasAccountSession, consoleLoginUrl, } from './src/host/console_session.js';
 export { ACCOUNT_SESSION_KEY } from './src/host/account_session_key.js';

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

@@ -1,4 +1,5 @@
 /** DTO público da conta — o que o provider e os controllers enxergam. Nunca um model Lucid. */
+import type { UserLoginMethods } from '../host/user_login_methods.js';
 export interface AuthAccount {
     id: string;
     email: string;
@@ -211,6 +212,22 @@ export interface ProviderIdentitySummary {
     providerUserId: string;
     email?: string | null;
 }
+/**
+ * Preferência POR USUÁRIO de tipos de login (self-service no console de conta).
+ * CAPACIDADE opcional, montada quando o model tem a coluna `login_methods`
+ * (JSONB) — hosts adotam por migração própria. `null` = sem preferência (herda
+ * os métodos globais efetivos). Ver `host/user_login_methods.ts` para o shape
+ * canônico (`UserLoginMethods`) e a semântica da interseção.
+ */
+export interface LoginMethodsPreferenceCapability {
+    /** Lê a preferência da conta; null quando não há preferência persistida. */
+    getLoginMethods(accountId: string): Promise<UserLoginMethods | null>;
+    /**
+     * Grava a preferência da conta. Objeto vazio ou null REMOVE a preferência
+     * (volta a herdar os globais). No-op se a conta não existe.
+     */
+    setLoginMethods(accountId: string, methods: UserLoginMethods | null): Promise<void>;
+}
 /**
  * MFA / TOTP. Stores sem suporte a MFA omitem a capacidade inteira; o interaction
  * flow trata a ausência como "MFA desligado".
@@ -599,7 +616,7 @@ export type AccountStore = CoreAccountStore & {
      * blocos `Partial<...>` de capacidades probáveis.
      */
     readonly connectionName?: string;
-} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability>;
+} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
 /** Type guard: o store implementa a capacidade de MFA / TOTP. */
 export declare function supportsMfa(store: AccountStore): store is AccountStore & MfaCapability;
 /**
@@ -634,3 +651,5 @@ export declare function supportsAccountImport(store: AccountStore): store is Acc
 export declare function supportsPasswordHistory(store: AccountStore): store is AccountStore & PasswordHistoryCapability;
 /** Type guard: o store implementa expiração de senha (password_changed_at coluna). */
 export declare function supportsPasswordExpiration(store: AccountStore): store is AccountStore & PasswordExpirationCapability;
+/** Type guard: o store implementa a preferência por usuário de tipos de login. */
+export declare function supportsLoginMethodsPreference(store: AccountStore): store is AccountStore & LoginMethodsPreferenceCapability;

package/build/src/accounts/account_store.js

@@ -63,3 +63,7 @@ export function supportsPasswordHistory(store) {
 export function supportsPasswordExpiration(store) {
     return typeof store.getPasswordChangedAt === 'function';
 }
+/** Type guard: o store implementa a preferência por usuário de tipos de login. */
+export function supportsLoginMethodsPreference(store) {
+    return typeof store.getLoginMethods === 'function';
+}

package/build/src/accounts/lucid_account_store.js

@@ -1,6 +1,7 @@
 import { generateAuthenticationOptions, generateRegistrationOptions, verifyAuthenticationResponse, verifyRegistrationResponse, } from '@simplewebauthn/server';
 import { PasswordManager } from '../password/password_manager.js';
 import { buildCore } from './lucid_store/core.js';
+import { buildLoginMethods, supportsLoginMethodsColumn } from './lucid_store/login_methods.js';
 import { buildMfa } from './lucid_store/mfa.js';
 import { buildOrganizations } from './lucid_store/organizations.js';
 import { buildPasswordExpiration, buildPasswordHistory } from './lucid_store/password_hygiene.js';
@@ -165,7 +166,11 @@ export function lucidAccountStore(Model, options = {}) {
             return encrypter.decrypt(stored);
         },
         toAccount: (row) => ({
-            id: row.id,
+            // `String(...)`: o `id` do AuthAccount vira o claim `sub`, que a spec OIDC
+            // exige que seja string. Tabelas adotadas em brownfield quase sempre têm
+            // `id` INTEGER auto-increment, e sem a coerção o número vazava para o
+            // token (e para todo call-site tipado como string).
+            id: String(row.id),
             email: row.email,
             globalRoles: row.globalRoles ?? [],
             name: row.fullName ?? undefined,
@@ -208,6 +213,9 @@ export function lucidAccountStore(Model, options = {}) {
         ...buildDeletion(ctx),
         // Expiração de senha: só quando o model tem a coluna `password_changed_at`.
         ...(hasColumn(Model, 'passwordChangedAt') ? buildPasswordExpiration(ctx) : {}),
+        // Preferência por usuário de tipos de login: só quando o model tem a coluna
+        // `login_methods` (JSONB). Sem a coluna → capacidade ausente (feature no-op).
+        ...(supportsLoginMethodsColumn(Model) ? buildLoginMethods(ctx) : {}),
         // Organizations (multi-tenancy): só quando os três models foram fornecidos.
         ...(OrgModels
             ? buildOrganizations({
@@ -251,6 +259,16 @@ export function lucidAccountStore(Model, options = {}) {
          */
         __mfaIssuer: mfaIssuer,
         __webauthn: options.webauthn,
+        /**
+         * O model Lucid por trás deste store — exposto para o `authkit:doctor`
+         * inspecionar `$columnsDefinitions` e avisar sobre colunas ausentes ANTES
+         * que o fluxo correspondente quebre em produção (ver
+         * `doctor/checks.ts#checkAccountStoreColumns`). Importa sobretudo em
+         * adoção brownfield, onde o model aponta para uma tabela `users` que já
+         * existia e não passou pelas migrations do authkit.
+         * NÃO faz parte do contrato AccountStore.
+         */
+        __model: Model,
     };
     // Histórico de senhas: capability-probed via tabela `auth_password_history`.
     // A versão síncrona não pode fazer o probe de DB, então a capability fica
@@ -287,7 +305,8 @@ export async function lucidAccountStoreAsync(Model, options = {}) {
                 sealSecret: (s) => s,
                 openSecret: (s) => s ?? null,
                 toAccount: (row) => ({
-                    id: row.id,
+                    // Ver a nota em `toAccount` acima: `sub` precisa ser string.
+                    id: String(row.id),
                     email: row.email,
                     globalRoles: row.globalRoles ?? [],
                     name: row.fullName ?? undefined,

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

@@ -0,0 +1,11 @@
+import type { LoginMethodsPreferenceCapability } from '../account_store.js';
+import type { LucidStoreContext } from './shared.js';
+/**
+ * Preferência por usuário de tipos de login sobre a coluna `login_methods`
+ * (JSONB) do model. Só deve ser montada quando a coluna existe
+ * ({@link hasColumn}) — caso contrário a capacidade fica ausente e a feature
+ * degrada para no-op (hosts adotam por migração própria).
+ */
+export declare function buildLoginMethods(ctx: LucidStoreContext): LoginMethodsPreferenceCapability;
+/** Indica se o model suporta a preferência de tipos de login (coluna presente). */
+export declare function supportsLoginMethodsColumn(Model: any): boolean;

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

@@ -0,0 +1,32 @@
+import { normalizeUserLoginMethods } from '../../host/user_login_methods.js';
+import { hasColumn } from './status_profile.js';
+/**
+ * Preferência por usuário de tipos de login sobre a coluna `login_methods`
+ * (JSONB) do model. Só deve ser montada quando a coluna existe
+ * ({@link hasColumn}) — caso contrário a capacidade fica ausente e a feature
+ * degrada para no-op (hosts adotam por migração própria).
+ */
+export function buildLoginMethods(ctx) {
+    const { Model } = ctx;
+    return {
+        async getLoginMethods(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            return normalizeUserLoginMethods(row.loginMethods);
+        },
+        async setLoginMethods(accountId, methods) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return;
+            // Objeto vazio/null → grava null (sem preferência = herda globais).
+            const value = methods && Object.keys(methods).length > 0 ? normalizeUserLoginMethods(methods) : null;
+            row.loginMethods = value;
+            await row.save();
+        },
+    };
+}
+/** Indica se o model suporta a preferência de tipos de login (coluna presente). */
+export function supportsLoginMethodsColumn(Model) {
+    return hasColumn(Model, 'loginMethods');
+}

package/build/src/audit/audit_sink.d.ts

@@ -21,6 +21,16 @@ export interface AuditEvent {
     clientId?: string | null;
     /** Impersonation: quem agiu (o admin). */
     actorId?: string | null;
+    /**
+     * Organização (tenant) a que o evento pertence, quando houver. Campo de
+     * PRIMEIRA CLASSE — e não uma chave de `metadata` — de propósito: `metadata`
+     * é livre e por isso é DROPADO na projeção que vai para o barramento de
+     * diagnostics (ver `redactAuditEventForDiagnostics`), enquanto os ids internos
+     * opacos (`accountId`/`actorId`/`clientId`/`orgId`) são preservados. É esse
+     * campo que permite a um consumidor do barramento — p.ex. o provisioning do
+     * `@adonis-agora/authz` — saber QUAL tenant provisionar sem receber PII.
+     */
+    orgId?: string | null;
     ip?: string | null;
     metadata?: Record<string, unknown>;
 }

package/build/src/doctor/checks.d.ts

@@ -57,6 +57,19 @@ export declare function checkClients(input: DoctorInput): Finding;
 export declare function checkAdapterVolatility(input: DoctorInput): Finding | null;
 /** accountStore presente + quais capacidades implementa. */
 export declare function checkAccountStore(input: DoctorInput): Finding[];
+/**
+ * Valida que o model por trás do account store tem as colunas que o store
+ * escreve. Existe por causa da adoção brownfield: quando o host aponta o
+ * AuthKit para a tabela `users` que ele JÁ tinha, as colunas dos mixins
+ * (`password_reset_token`, `email_verification_token`, …) não existem, o app
+ * sobe normalmente, e a falha só aparece quando alguém clica em "esqueci minha
+ * senha" — em produção. Este check antecipa isso para o boot.
+ *
+ * Silencioso quando não há o que inspecionar: um store custom (não-Lucid) não
+ * expõe `__model`, e nesse caso o contrato é responsabilidade de quem o
+ * implementou.
+ */
+export declare function checkAccountStoreColumns(input: DoctorInput): Finding[];
 /** session provider configurado + warn se cookie store com tokenSets grandes. */
 export declare function checkSession(input: DoctorInput): Finding[];
 /** Hint de exceções de CSRF do shield para o mountPath. */

package/build/src/doctor/checks.js

@@ -134,6 +134,84 @@ export function checkAccountStore(input) {
     });
     return findings;
 }
+/**
+ * Propriedades do model que o account store Lucid escreve/lê, agrupadas pelo
+ * FLUXO que deixa de funcionar quando a coluna não existe. Agrupar por fluxo (e
+ * não listar colunas soltas) é o que torna o achado acionável: "falta
+ * `password_reset_token`" não diz nada a quem não conhece o interior da lib;
+ * "o reset de senha vai quebrar" diz.
+ */
+const REQUIRED_COLUMN_GROUPS = [
+    { flow: 'identity (every flow)', properties: ['email'] },
+    { flow: 'password login', properties: ['password'] },
+    { flow: 'role claims / admin', properties: ['globalRoles'] },
+    {
+        flow: 'password reset',
+        properties: ['passwordResetToken', 'passwordResetExpiresAt'],
+    },
+    {
+        flow: 'email verification',
+        properties: ['emailVerifiedAt', 'emailVerificationToken'],
+    },
+];
+/**
+ * Propriedades OPCIONAIS: a capability correspondente é detectada pela presença
+ * da coluna, então ausência é configuração válida (feature desligada) e nunca
+ * um erro — só vale reportar para que a ausência seja uma escolha, e não uma
+ * surpresa.
+ */
+const OPTIONAL_COLUMN_GROUPS = [
+    { capability: 'profile (name/avatar)', properties: ['fullName', 'avatarUrl'] },
+    { capability: 'disable/enable account', properties: ['disabledAt'] },
+    { capability: 'password expiration', properties: ['passwordChangedAt'] },
+];
+/**
+ * Valida que o model por trás do account store tem as colunas que o store
+ * escreve. Existe por causa da adoção brownfield: quando o host aponta o
+ * AuthKit para a tabela `users` que ele JÁ tinha, as colunas dos mixins
+ * (`password_reset_token`, `email_verification_token`, …) não existem, o app
+ * sobe normalmente, e a falha só aparece quando alguém clica em "esqueci minha
+ * senha" — em produção. Este check antecipa isso para o boot.
+ *
+ * Silencioso quando não há o que inspecionar: um store custom (não-Lucid) não
+ * expõe `__model`, e nesse caso o contrato é responsabilidade de quem o
+ * implementou.
+ */
+export function checkAccountStoreColumns(input) {
+    const store = input.authkitConfig?.accountStore;
+    const model = store?.__model;
+    const definitions = model?.$columnsDefinitions;
+    if (!definitions || typeof definitions.get !== 'function')
+        return [];
+    /** Nome da coluna real (o que o DBA procura), com fallback à propriedade. */
+    const columnOf = (property) => definitions.get(property)?.columnName ?? property;
+    const missing = (properties) => properties.filter((p) => !definitions.has(p));
+    const findings = [];
+    for (const { flow, properties } of REQUIRED_COLUMN_GROUPS) {
+        const absent = missing(properties);
+        if (absent.length === 0)
+            continue;
+        const named = absent.map((p) => `\`${p}\` (column \`${columnOf(p)}\`)`).join(', ');
+        findings.push({
+            level: 'error',
+            message: `accountStore model (${model.name ?? 'model'}) is missing ${named} — ${flow} will fail at runtime. Add the column(s) with a migration, or map an existing one with @column({ columnName: '…' }).`,
+        });
+    }
+    const off = OPTIONAL_COLUMN_GROUPS.filter((g) => missing(g.properties).length > 0);
+    if (off.length > 0) {
+        findings.push({
+            level: 'ok',
+            message: `Capabilities off (column absent): ${off.map((g) => g.capability).join(', ')}.`,
+        });
+    }
+    if (findings.every((f) => f.level === 'ok')) {
+        findings.unshift({
+            level: 'ok',
+            message: `accountStore model (${model.name ?? 'model'}) has every required column.`,
+        });
+    }
+    return findings;
+}
 /** session provider configurado + warn se cookie store com tokenSets grandes. */
 export function checkSession(input) {
     if (!input.peers.session) {
@@ -845,6 +923,7 @@ export function runAllChecks(input) {
     if (volatility)
         findings.push(volatility);
     findings.push(...checkAccountStore(input));
+    findings.push(...checkAccountStoreColumns(input));
     findings.push(...checkSession(input));
     findings.push(checkShield(input));
     findings.push(checkAlly(input));

package/build/src/events/dispatcher.d.ts

@@ -56,9 +56,13 @@ export declare function signWebhookBody(body: string, secret: string): string;
  *     e-mail). Nenhum data provider do dashboard lê `metadata`, então dropá-lo é
  *     seguro;
  *   - MANTÉM `type` (a família do evento — o que os providers agregam) e os ids
- *     internos opacos `accountId`/`actorId`/`clientId` (correlação de subject/actor
- *     no dashboard; NÃO são PII direta e, sem `email`/`ip`/`metadata` e com a linha
- *     da conta já deletada, não são reidentificáveis).
+ *     internos opacos `accountId`/`actorId`/`clientId`/`orgId` (correlação de
+ *     subject/actor/tenant no dashboard; NÃO são PII direta e, sem `email`/`ip`/
+ *     `metadata` e com a linha da conta já deletada, não são reidentificáveis).
+ *     O `orgId` está aqui porque é o que torna o barramento UTILIZÁVEL para
+ *     provisioning multi-tenant (o `@adonis-agora/authz` escuta
+ *     `agora:authkit:organization.*` e precisa saber qual tenant escopar) —
+ *     sem ele o consumidor recebia o tipo do evento e mais nada.
  *
  * Assim o Telescope nunca armazena PII bruta e a deleção de conta não precisa de uma
  * etapa de purge cross-lib. Os ramos `onEvent`/`webhook` (integrações que o host

package/build/src/events/dispatcher.js

@@ -20,6 +20,7 @@ export function buildWebhookBody(event) {
         accountId: event.accountId ?? null,
         email: event.email ?? null,
         clientId: event.clientId ?? null,
+        orgId: event.orgId ?? null,
         ip: event.ip ?? null,
         metadata: event.metadata ?? {},
         ts: new Date().toISOString(),
@@ -50,9 +51,13 @@ export function signWebhookBody(body, secret) {
  *     e-mail). Nenhum data provider do dashboard lê `metadata`, então dropá-lo é
  *     seguro;
  *   - MANTÉM `type` (a família do evento — o que os providers agregam) e os ids
- *     internos opacos `accountId`/`actorId`/`clientId` (correlação de subject/actor
- *     no dashboard; NÃO são PII direta e, sem `email`/`ip`/`metadata` e com a linha
- *     da conta já deletada, não são reidentificáveis).
+ *     internos opacos `accountId`/`actorId`/`clientId`/`orgId` (correlação de
+ *     subject/actor/tenant no dashboard; NÃO são PII direta e, sem `email`/`ip`/
+ *     `metadata` e com a linha da conta já deletada, não são reidentificáveis).
+ *     O `orgId` está aqui porque é o que torna o barramento UTILIZÁVEL para
+ *     provisioning multi-tenant (o `@adonis-agora/authz` escuta
+ *     `agora:authkit:organization.*` e precisa saber qual tenant escopar) —
+ *     sem ele o consumidor recebia o tipo do evento e mais nada.
  *
  * Assim o Telescope nunca armazena PII bruta e a deleção de conta não precisa de uma
  * etapa de purge cross-lib. Os ramos `onEvent`/`webhook` (integrações que o host
@@ -65,6 +70,7 @@ export function redactAuditEventForDiagnostics(event) {
         accountId: event.accountId ?? null,
         actorId: event.actorId ?? null,
         clientId: event.clientId ?? null,
+        orgId: event.orgId ?? null,
     };
 }
 /**

package/build/src/host/account_api/account_api_controller.d.ts

@@ -30,6 +30,7 @@
 import '../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
 export default class AccountApiController {
+    #private;
     /** Perfil + flags do usuário logado. */
     me(ctx: HttpContext): Promise<void | {
         id: any;
@@ -171,6 +172,43 @@ export default class AccountApiController {
             available: any;
         };
     }>;
+    /**
+     * Preferência POR USUÁRIO de tipos de login + o catálogo do que está
+     * disponível/travado. A interseção com os métodos globais efetivos é feita
+     * AQUI (a UI mostra o estado final; o enforcement no login reusa o resolver).
+     */
+    getLoginMethods(ctx: HttpContext): Promise<{
+        supported: false;
+        methods: null;
+        available: null;
+        locked: null;
+    } | {
+        supported: true;
+        methods: any;
+        available: {
+            password: boolean;
+            magicLink: boolean;
+            passkey: boolean;
+            social: string[];
+            forgotPassword: boolean;
+        };
+        locked: {
+            password: boolean;
+            magicLink: boolean;
+            passkey: boolean;
+            social: boolean;
+        };
+    }>;
+    /** Grava a preferência de tipos de login do usuário logado. */
+    updateLoginMethods(ctx: HttpContext): Promise<void | {
+        ok: boolean;
+        methods: {
+            password?: boolean;
+            magicLink?: boolean;
+            passkey?: boolean;
+            social?: boolean;
+        };
+    }>;
     /** Lista passkeys do usuário logado. */
     listPasskeys(ctx: HttpContext): Promise<{
         supported: boolean;

package/build/src/host/account_api/account_api_controller.js

@@ -28,7 +28,7 @@
  *   GET  /account/api/orgs/invitations     → convites pendentes
  */
 import '../augmentations.js';
-import { supportsAccountSecurity, supportsOrganizations, supportsPasskeys, supportsProfile, } from '../../accounts/account_store.js';
+import { supportsAccountSecurity, supportsLoginMethodsPreference, supportsMagicLink, supportsOrganizations, supportsPasskeys, supportsProfile, } from '../../accounts/account_store.js';
 import { PasswordPolicyError } from '../../password/password_manager.js';
 import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
@@ -39,11 +39,12 @@ import { AvatarUploadError, isAvatarUploadSupported, storeAvatar } from '../avat
 import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail } from '../default_mailer.js';
 import { translate } from '../i18n.js';
 import { authkitOrigin } from '../origin.js';
-import { resolveRuntimeSettings } from '../runtime_settings.js';
-import { resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from '../runtime_toggles.js';
+import { resolveRuntimeSettings, resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
+import { configLockedAuthMethods, resolveEffectiveAuthMethods, resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from '../runtime_toggles.js';
 import { dispatchSecurityNotice } from '../security_notice_service.js';
 import { enrichSessionsWithContext } from '../session_context.js';
 import { SUDO_MODE_DEFAULTS, isSudoActive, requireSudo, resolveEffectiveSudoMode, } from '../sudo_mode.js';
+import { parseUserLoginMethodsPayload, resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
 import { changeEmailValidator, changePasswordValidator, updateProfileValidator, } from '../validators.js';
 // ---------------------------------------------------------------------------
 // Helpers (shared with existing controllers — kept local to avoid coupling)
@@ -641,6 +642,86 @@ export default class AccountApiController {
             recovery: { available: enabled },
         };
     }
+    // ─── GET /account/api/login-methods ─────────────────────────────────────
+    /**
+     * Preferência POR USUÁRIO de tipos de login + o catálogo do que está
+     * disponível/travado. A interseção com os métodos globais efetivos é feita
+     * AQUI (a UI mostra o estado final; o enforcement no login reusa o resolver).
+     */
+    async getLoginMethods(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const supported = supportsLoginMethodsPreference(cfg.accountStore);
+        if (!supported) {
+            return { supported: false, methods: null, available: null, locked: null };
+        }
+        const pref = await cfg.accountStore.getLoginMethods(userId);
+        const { resolved: global, locked: cfgLocked } = await this.#resolveGlobalAuthMethods(ctx, cfg);
+        const effective = resolveEffectiveUserLoginMethods(global, pref);
+        return {
+            supported: true,
+            // Preferência crua do usuário (o que ELE escolheu; null = sem preferência).
+            methods: pref ?? {},
+            // Estado final por método (global ∩ preferência) — o que a tela de login mostra.
+            available: {
+                password: effective.password,
+                magicLink: effective.magicLink,
+                passkey: effective.passkey,
+                social: effective.social,
+                forgotPassword: effective.forgotPassword,
+            },
+            // Métodos que o usuário NÃO pode controlar (globalmente off ou pin de config).
+            // Pin de config: `cfgLocked` lista as chaves fixadas no arquivo de config.
+            locked: {
+                password: !global.password || cfgLocked.includes('password'),
+                magicLink: !global.magicLink || cfgLocked.includes('magicLink'),
+                passkey: !global.passkey || cfgLocked.includes('passkey'),
+                social: global.social.length === 0,
+            },
+        };
+    }
+    // ─── PUT /account/api/login-methods ─────────────────────────────────────
+    /** Grava a preferência de tipos de login do usuário logado. */
+    async updateLoginMethods(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        if (!supportsLoginMethodsPreference(cfg.accountStore)) {
+            return ctx.response.notFound(apiErr('not_supported', 'Login methods preference not supported.'));
+        }
+        const parsed = parseUserLoginMethodsPayload(ctx.request.body());
+        if (!parsed.ok) {
+            return ctx.response.badRequest(apiErr(parsed.error, 'Invalid login methods payload.'));
+        }
+        // All-off guard server-side: a preferência não pode zerar todos os métodos
+        // GLOBAIS disponíveis. Um `false` que deixaria zero métodos é recusado.
+        const { resolved: global } = await this.#resolveGlobalAuthMethods(ctx, cfg);
+        const value = { ...parsed.value };
+        const wouldBeAllOff = (value.password === false || !global.password) &&
+            (value.magicLink === false || !global.magicLink) &&
+            (value.passkey === false || !global.passkey) &&
+            (value.social === false || global.social.length === 0);
+        if (wouldBeAllOff) {
+            return ctx.response.badRequest(apiErr('all_methods_off', 'Cannot disable every login method.'));
+        }
+        await cfg.accountStore.setLoginMethods(userId, Object.keys(value).length > 0 ? value : null);
+        return { ok: true, methods: value };
+    }
+    /**
+     * Métodos globais efetivos + pins de config, compartilhados pelos handlers
+     * acima. Fail-safe: erro → defaults conservadores.
+     */
+    async #resolveGlobalAuthMethods(ctx, cfg) {
+        const settings = await resolveRuntimeSettingsOrNoop(ctx);
+        const resolved = await resolveEffectiveAuthMethods(settings, {
+            configuredSocialProviders: cfg.social?.providers ?? [],
+            magicLinkCapable: cfg.passwordless?.magicLink && supportsMagicLink(cfg.accountStore),
+            passkeyCapable: supportsPasskeys(cfg.accountStore),
+            configOverrides: cfg.authMethods,
+        });
+        return { resolved, locked: configLockedAuthMethods(cfg.authMethods) };
+    }
     // ─── GET /account/api/passkeys ──────────────────────────────────────────
     /** Lista passkeys do usuário logado. */
     async listPasskeys(ctx) {

package/build/src/host/admin_api/admin_orgs_service.js

@@ -110,6 +110,7 @@ export class AdminOrgsService {
                 accountId: input.ownerAccountId,
                 actorId: actor.actorId,
                 ip: actor.ip,
+                orgId: org.id,
                 metadata: { slug: org.slug, ...(actor.source ? { actor: actor.source } : {}) },
             });
             return org;
@@ -137,6 +138,7 @@ export class AdminOrgsService {
                 type: 'organization.updated',
                 actorId: actor.actorId,
                 ip: actor.ip,
+                orgId,
                 metadata: { orgId, ...(actor.source ? { actor: actor.source } : {}) },
             });
             return updated;
@@ -158,6 +160,7 @@ export class AdminOrgsService {
             type: 'organization.deleted',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: { orgId, slug: existing.slug, ...(actor.source ? { actor: actor.source } : {}) },
         });
         return { ok: true };
@@ -182,6 +185,7 @@ export class AdminOrgsService {
             type: 'organization.member_added',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: {
                 orgId,
                 accountId: input.accountId,
@@ -209,6 +213,7 @@ export class AdminOrgsService {
             type: 'organization.member_removed',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: {
                 orgId,
                 targetAccountId: accountId,
@@ -239,6 +244,7 @@ export class AdminOrgsService {
             type: 'organization.member_role_changed',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: {
                 orgId,
                 targetAccountId: accountId,
@@ -301,6 +307,7 @@ export class AdminOrgsService {
             type: 'organization.invitation_sent',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: {
                 orgId,
                 email: input.email,
@@ -327,6 +334,7 @@ export class AdminOrgsService {
             type: 'organization.invitation_revoked',
             actorId: actor.actorId,
             ip: actor.ip,
+            orgId,
             metadata: {
                 orgId,
                 invitationId,