@dudousxd/adonis-authkit-server 0.1.0

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

@@ -0,0 +1,54 @@
+/**
+ * Tipos de eventos de auditoria relevantes para segurança emitidos pelo IdP.
+ */
+export type AuditEventType = 'login.success' | 'login.failure' | 'signup' | 'password_reset.issued' | 'password_reset.consumed' | 'pat.issued' | 'pat.revoked' | 'pat.used' | 'impersonation' | 'mfa.enabled' | 'mfa.disabled' | 'account.locked' | 'passkey.registered' | 'passkey.removed' | 'email_verification.issued' | 'email_verification.consumed';
+/**
+ * Evento de auditoria a registrar. O timestamp é definido pelo sink (não aqui).
+ */
+export interface AuditEvent {
+    type: AuditEventType;
+    accountId?: string | null;
+    email?: string | null;
+    clientId?: string | null;
+    /** Impersonation: quem agiu (o admin). */
+    actorId?: string | null;
+    ip?: string | null;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Evento de auditoria já persistido (lido de volta pelo console admin). Carrega
+ * o id e o timestamp atribuídos pelo sink.
+ */
+export interface StoredAuditEvent extends AuditEvent {
+    id: string;
+    createdAt: Date | string | null;
+}
+/** Filtros de listagem do log de auditoria (console admin). */
+export interface ListAuditParams {
+    /** Página (1-based). Default: 1. */
+    page?: number;
+    /** Itens por página. Default: 20. */
+    limit?: number;
+    /** Filtra por tipo de evento exato. */
+    type?: string;
+    /** Filtra pelo subject (accountId) do evento. */
+    subject?: string;
+}
+/** Página de eventos + total absoluto. */
+export interface AuditPage {
+    data: StoredAuditEvent[];
+    total: number;
+}
+/**
+ * Sink plugável de auditoria. Implementações devem ser best-effort: `record`
+ * NUNCA deve lançar para dentro do caminho da request.
+ *
+ * `list` é OPCIONAL: sinks customizados podem só implementar `record` (write-only).
+ * O console admin degrada graciosamente ("consulta não suportada") quando o sink
+ * configurado não fornece `list`.
+ */
+export interface AuditSink {
+    record(event: AuditEvent): Promise<void>;
+    /** Lista eventos paginados (opcional — só sinks que suportam consulta). */
+    list?(params: ListAuditParams): Promise<AuditPage>;
+}

package/build/src/audit/audit_sink.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import type { AuditSink } from './audit_sink.js';
+/**
+ * Implementação default do {@link AuditSink} sobre um model Lucid composto de
+ * `withAuditLog()`. Insere o evento na tabela `audit_logs` e suporta consulta
+ * paginada para o console admin.
+ *
+ * BEST-EFFORT: erros de inserção são logados via `console.error` e engolidos —
+ * a auditoria nunca deve lançar para dentro do caminho da request.
+ */
+export declare function lucidAuditSink(Model: any): AuditSink;

package/build/src/audit/lucid_audit_sink.js

@@ -0,0 +1,60 @@
+/**
+ * Implementação default do {@link AuditSink} sobre um model Lucid composto de
+ * `withAuditLog()`. Insere o evento na tabela `audit_logs` e suporta consulta
+ * paginada para o console admin.
+ *
+ * BEST-EFFORT: erros de inserção são logados via `console.error` e engolidos —
+ * a auditoria nunca deve lançar para dentro do caminho da request.
+ */
+export function lucidAuditSink(Model) {
+    return {
+        async record(event) {
+            try {
+                await Model.create({
+                    type: event.type,
+                    accountId: event.accountId ?? null,
+                    email: event.email ?? null,
+                    clientId: event.clientId ?? null,
+                    actorId: event.actorId ?? null,
+                    ip: event.ip ?? null,
+                    metadata: event.metadata ?? null,
+                });
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.error('[authkit] audit sink falhou ao registrar evento', event.type, error);
+            }
+        },
+        async list(params) {
+            const page = Math.max(1, params.page ?? 1);
+            const limit = Math.max(1, params.limit ?? 20);
+            const base = () => {
+                const q = Model.query();
+                if (params.type)
+                    q.where('type', params.type);
+                if (params.subject)
+                    q.where('accountId', params.subject);
+                return q;
+            };
+            const countResult = await base().count('* as total');
+            const total = Number(countResult[0]?.$extras?.total ?? 0);
+            const rows = await base()
+                .orderBy('createdAt', 'desc')
+                .offset((page - 1) * limit)
+                .limit(limit);
+            const data = rows.map((row) => ({
+                id: String(row.id),
+                type: row.type,
+                accountId: row.accountId ?? null,
+                email: row.email ?? null,
+                clientId: row.clientId ?? null,
+                actorId: row.actorId ?? null,
+                ip: row.ip ?? null,
+                metadata: row.metadata ?? undefined,
+                // createdAt é um luxon DateTime no Lucid; normaliza para ISO string.
+                createdAt: row.createdAt?.toISO?.() ?? row.createdAt ?? null,
+            }));
+            return { data, total };
+        },
+    };
+}

package/build/src/controllers/oidc_callback_controller.d.ts

@@ -0,0 +1,22 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Delega a requisição Adonis ao handler do oidc-provider (`service.callback`),
+ * que faz seu próprio roteamento e escreve direto na resposta Node.
+ *
+ * Quando o issuer tem um path (ex.: `/oidc`), o `service.callback` é um app Koa
+ * com o provider MONTADO sob esse path via koa-mount (vide OidcService). Por isso
+ * NÃO removemos o prefixo de `req.url`: o koa-mount cuida do mount e o provider
+ * gera URLs de discovery/redirect já prefixadas (ex.: /oidc/auth, /oidc/jwks).
+ *
+ * Resolvemos a Promise no `finish`/`close` para impedir que o Adonis tente
+ * tratar a resposta novamente.
+ *
+ * Body bridge: o bodyparser do AdonisJS consome o stream da requisição antes
+ * de chegar aqui. O oidc-provider usa `raw-body` para ler o stream — como ele
+ * já está esgotado, o provider cai no fallback `ctx.req.body || ctx.request.body`.
+ * Populamos `req.body` com o payload já parseado pelo AdonisJS para que o
+ * oidc-provider consiga ler os parâmetros do formulário (client_id, code, etc.).
+ */
+export default class OidcCallbackController {
+    handle(ctx: HttpContext): Promise<void>;
+}

package/build/src/controllers/oidc_callback_controller.js

@@ -0,0 +1,33 @@
+/**
+ * Delega a requisição Adonis ao handler do oidc-provider (`service.callback`),
+ * que faz seu próprio roteamento e escreve direto na resposta Node.
+ *
+ * Quando o issuer tem um path (ex.: `/oidc`), o `service.callback` é um app Koa
+ * com o provider MONTADO sob esse path via koa-mount (vide OidcService). Por isso
+ * NÃO removemos o prefixo de `req.url`: o koa-mount cuida do mount e o provider
+ * gera URLs de discovery/redirect já prefixadas (ex.: /oidc/auth, /oidc/jwks).
+ *
+ * Resolvemos a Promise no `finish`/`close` para impedir que o Adonis tente
+ * tratar a resposta novamente.
+ *
+ * Body bridge: o bodyparser do AdonisJS consome o stream da requisição antes
+ * de chegar aqui. O oidc-provider usa `raw-body` para ler o stream — como ele
+ * já está esgotado, o provider cai no fallback `ctx.req.body || ctx.request.body`.
+ * Populamos `req.body` com o payload já parseado pelo AdonisJS para que o
+ * oidc-provider consiga ler os parâmetros do formulário (client_id, code, etc.).
+ */
+export default class OidcCallbackController {
+    async handle(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const req = ctx.request.request;
+        const res = ctx.response.response;
+        // Repassa o body já parseado pelo AdonisJS para o req cru, pois o stream
+        // foi consumido pelo bodyparser_middleware antes de chegar neste controller.
+        req.body = ctx.request.all();
+        return new Promise((resolve) => {
+            res.on('finish', resolve);
+            res.on('close', resolve);
+            service.callback(req, res);
+        });
+    }
+}

package/build/src/define_config.d.ts

@@ -0,0 +1,261 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ClientConfig, JwksConfig, ObservabilityConfig, TtlConfig } from '@dudousxd/adonis-authkit-core';
+import { adapters, type AdapterFactory, type OidcAdapterClass } from './adapters/factory.js';
+import type { AccountStore, AuthAccount } from './accounts/account_store.js';
+import type { PatStore } from './pat/pat_store.js';
+import type { AuditSink } from './audit/audit_sink.js';
+import type { BrandingConfig } from './host/branding.js';
+import { type AuthMessages, type I18nConfig } from './host/i18n.js';
+export { adapters };
+export type { AuthAccount };
+export type AuthHostRenderer = (ctx: HttpContext, view: string, props: Record<string, unknown>) => unknown;
+export interface AuthSocialConfig {
+    providers: string[];
+}
+/**
+ * Hooks de e-mail plugáveis (best-effort). Quando ausentes, o host-kit cai no
+ * fallback de log em dev (sem enviar e-mail). O envio real fica a cargo do host
+ * (ex.: @adonisjs/mail), mantendo a lib agnóstica de transporte.
+ */
+export interface MailHooks {
+    /** Disparado após gerar o token de redefinição de senha. */
+    onPasswordReset?: (data: {
+        email: string;
+        resetUrl: string;
+        token: string;
+    }) => Promise<void>;
+    /** Disparado após gerar o token de verificação de e-mail. */
+    onEmailVerification?: (data: {
+        email: string;
+        verifyUrl: string;
+        token: string;
+    }) => Promise<void>;
+}
+/** Bucket de rate-limit: pontos (requests) permitidos por janela de duração. */
+export interface RateLimitBucket {
+    /** Número de requests permitidos na janela. */
+    points: number;
+    /** Duração da janela (ex.: '1 min', '15 mins', 60). */
+    duration: string;
+}
+/**
+ * Rate-limiting para as rotas sensíveis do host-kit.
+ * Backed pelo `@adonisjs/limiter` (o host precisa tê-lo configurado: config/limiter.ts).
+ * Ligado por default; se o limiter não estiver configurado, o throttle vira no-op
+ * (fail-safe, sem quebra). Passe `enabled: false` para montar as rotas SEM throttle.
+ */
+export interface RateLimitConfigInput {
+    /** Liga o rate-limit. Default: true. */
+    enabled?: boolean;
+    /** Bucket das rotas de login/signup/forgot/reset (keyed por IP). Default: 10 req / 1 min. */
+    login?: RateLimitBucket;
+    /** Bucket da rota de introspecção de PAT (keyed por IP ou bearer). Default: 60 req / 1 min. */
+    introspection?: RateLimitBucket;
+    /** Nome do store configurado em config/limiter.ts a usar. Default: store padrão do host. */
+    store?: string;
+}
+export interface ResolvedRateLimitConfig {
+    enabled: boolean;
+    login: RateLimitBucket;
+    introspection: RateLimitBucket;
+    store?: string;
+}
+export declare function resolveRateLimit(input?: RateLimitConfigInput): ResolvedRateLimitConfig;
+/**
+ * Bloqueio progressivo de conta (anti-brute-force keyed por EMAIL, complementar ao
+ * rate-limit por IP). Backed pelo mesmo `@adonisjs/limiter` do host (peer/opt-in) —
+ * SEM migração nem DB. Ligado por default; vira no-op se o limiter não existir.
+ */
+export interface LockoutConfigInput {
+    /** Liga o lockout. Default: true (no-op se o limiter não estiver configurado). */
+    enabled?: boolean;
+    /** Falhas dentro da janela antes de bloquear. Default: 5. */
+    maxAttempts?: number;
+    /** Janela deslizante (segundos) para contar falhas. Default: 900 (15 min). */
+    windowSec?: number;
+    /** Duração do 1º bloqueio (segundos). Default: 60. */
+    baseLockoutSec?: number;
+    /** Teto do backoff progressivo (segundos). Default: 3600 (1 h). */
+    maxLockoutSec?: number;
+    /** Store do `config/limiter.ts` a usar. Default: store padrão do host. */
+    store?: string;
+}
+export interface ResolvedLockoutConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    windowSec: number;
+    baseLockoutSec: number;
+    maxLockoutSec: number;
+    store?: string;
+}
+export declare function resolveLockout(input?: LockoutConfigInput): ResolvedLockoutConfig;
+/**
+ * Registro dinâmico de clients (OIDC Dynamic Client Registration — RFC 7591).
+ *
+ * Quando habilitado, o oidc-provider expõe o endpoint de registro (`/reg`) e os
+ * clients criados ali são PERSISTIDOS pelo MESMO adapter usado para os demais
+ * artefatos OIDC. Assim, clients dinâmicos coexistem com os `clients` estáticos
+ * da config e ficam disponíveis para uma futura UI admin que gerencia clients no DB.
+ */
+export interface DynamicRegistrationConfigInput {
+    /** Liga o endpoint de registro dinâmico. Default: false (comportamento atual). */
+    enabled: boolean;
+    /**
+     * Exige um Initial Access Token (IAT) como bearer para registrar (RFC 7591 §3).
+     * Quando ausente/false, o registro é ABERTO (qualquer um pode registrar um client) —
+     * isso raramente é desejável em produção; prefira sempre definir um IAT.
+     */
+    initialAccessToken?: string;
+    /**
+     * Habilita o Registration Management (RFC 7592): ler/atualizar/deletar o client
+     * registrado via o `registration_access_token` devolvido no registro. Default: false.
+     */
+    management?: boolean;
+}
+export interface ResolvedDynamicRegistrationConfig {
+    enabled: boolean;
+    initialAccessToken?: string;
+    management: boolean;
+}
+/**
+ * Console admin opt-in do IdP (B6). Quando habilitado, monta o grupo `/admin/*`
+ * (dashboard, usuários/papéis, clients, audit) atrás de um guard que exige sessão
+ * de conta E que a conta tenha pelo menos um dos `roles` nas suas roles globais.
+ * Default: DESLIGADO — hosts existentes não mudam de comportamento.
+ */
+export interface AdminConfigInput {
+    /** Liga o console admin. Default: false. */
+    enabled: boolean;
+    /** Roles globais que dão acesso ao /admin. Default: ['ADMIN']. */
+    roles?: string[];
+}
+export interface ResolvedAdminConfig {
+    enabled: boolean;
+    roles: string[];
+}
+export declare function resolveAdmin(input?: AdminConfigInput): ResolvedAdminConfig;
+/**
+ * Parâmetros do Relying Party (RP) das cerimônias WebAuthn / passkeys. Quando
+ * omitidos, são derivados do `issuer`: `rpId` = hostname (sem porta), `origin` =
+ * origem (scheme://host[:port]) do issuer, `rpName` = nome do app/branding.
+ */
+export interface WebauthnConfigInput {
+    /** Nome do RP mostrado pelo authenticator. Default: branding/app name. */
+    rpName?: string;
+    /** RP ID — hostname (sem porta) do issuer. Default: hostname do issuer. */
+    rpId?: string;
+    /** Origin(s) esperada(s) na verificação. Default: origem do issuer. */
+    origin?: string | string[];
+}
+export interface ResolvedWebauthnConfig {
+    rpName: string;
+    rpId: string;
+    origin: string | string[];
+}
+/**
+ * Resolve os parâmetros do RP de WebAuthn a partir do `issuer` quando omitidos.
+ * `rpName` cai no `fallbackName` (branding/mfaIssuer) quando ausente.
+ */
+export declare function resolveWebauthn(issuer: string, fallbackName: string, input?: WebauthnConfigInput): ResolvedWebauthnConfig;
+export interface AuthServerConfigInput {
+    issuer: string;
+    adapter: AdapterFactory;
+    clients: ClientConfig[];
+    jwks: JwksConfig;
+    ttl?: TtlConfig;
+    /** Nome da CLAIM (não do scope) onde os papéis globais são emitidos. Default: 'roles'. */
+    globalRolesClaim?: string;
+    cookieKeys?: string[];
+    observability?: ObservabilityConfig;
+    /** Contrato primário de identidade. Deriva findAccount/verifyCredentials do provider. */
+    accountStore: AccountStore;
+    /** Opcional — necessário só para fluxos de Personal Access Token. */
+    patStore?: PatStore;
+    /** Caminho base onde o host-kit monta as rotas OIDC. Default: '/oidc'. */
+    mountPath?: string;
+    /** Renderer de páginas do host (Inertia ou Edge). */
+    render?: AuthHostRenderer;
+    /** Configuração de branding por cliente. */
+    branding?: BrandingConfig;
+    /** Internacionalização das telas. Default: pt-BR embutido (zero config). */
+    i18n?: I18nConfig;
+    /** Configuração de providers sociais. */
+    social?: AuthSocialConfig;
+    /** Segredo para autenticar requests de introspecção de PAT. */
+    patIntrospectionSecret?: string;
+    /** Rate-limiting das rotas sensíveis (anti-brute-force). Default: ligado (no-op se o limiter não estiver configurado). */
+    rateLimit?: RateLimitConfigInput;
+    /** Bloqueio progressivo de conta por email em falhas repetidas. Default: ligado (no-op sem limiter). */
+    lockout?: LockoutConfigInput;
+    /** Hooks de e-mail (reset de senha / verificação). Opcional — fallback de log em dev. */
+    mail?: MailHooks;
+    /** Sink de auditoria (best-effort). Opcional — quando ausente, auditoria é no-op. */
+    audit?: AuditSink;
+    /**
+     * Label de issuer TOTP mostrado nos apps autenticadores (MFA). Default: 'AuthKit'.
+     * O `lucidAccountStore` lê isso para montar o keyuri/QR.
+     */
+    mfaIssuer?: string;
+    /**
+     * Parâmetros do RP de WebAuthn / passkeys (2º fator alternativo ao TOTP).
+     * Opcional — quando omitido, é derivado do `issuer`. As passkeys só ficam
+     * disponíveis quando o accountStore + o model de credenciais suportam.
+     */
+    webauthn?: WebauthnConfigInput;
+    /**
+     * Registro dinâmico de clients (RFC 7591/7592). Default: desligado. Quando ligado,
+     * os clients registrados são persistidos pelo mesmo adapter OIDC.
+     */
+    dynamicRegistration?: DynamicRegistrationConfigInput;
+    /**
+     * Console admin do IdP (B6). Default: desligado. Quando ligado, o host também
+     * deve passar `admin: true` em {@link AuthHostOptions} no registro de rotas
+     * (a montagem das rotas acontece antes do config resolver).
+     */
+    admin?: AdminConfigInput;
+}
+export interface ResolvedServerConfig {
+    issuer: string;
+    AdapterClass: OidcAdapterClass;
+    clients: ClientConfig[];
+    jwks: {
+        keys: Record<string, any>[];
+    };
+    ttl: {
+        accessToken: number;
+        refreshToken: number;
+        idToken: number;
+        session: number;
+    };
+    globalRolesClaim: string;
+    cookieKeys: string[];
+    observability: ObservabilityConfig;
+    findAccount: (sub: string) => Promise<AuthAccount | null>;
+    verifyCredentials: (email: string, password: string) => Promise<{
+        id: string;
+    } | null>;
+    accountStore: AccountStore;
+    patStore?: PatStore;
+    mountPath: string;
+    render?: AuthHostRenderer;
+    branding?: BrandingConfig;
+    social?: AuthSocialConfig;
+    patIntrospectionSecret?: string;
+    rateLimit: ResolvedRateLimitConfig;
+    /** Bloqueio progressivo de conta resolvido (sempre presente; default ligado). */
+    lockout: ResolvedLockoutConfig;
+    mail?: MailHooks;
+    audit?: AuditSink;
+    mfaIssuer: string;
+    /** RP de WebAuthn resolvido (sempre presente; derivado do issuer por default). */
+    webauthn: ResolvedWebauthnConfig;
+    dynamicRegistration: ResolvedDynamicRegistrationConfig;
+    /** Console admin resolvido (sempre presente; default desligado). */
+    admin: ResolvedAdminConfig;
+    /** Catálogo de mensagens ativo (locale resolvido), pronto para os renderers. */
+    messages: AuthMessages;
+    /** Locale ativo (default 'pt-BR'). */
+    locale: string;
+}
+export declare function toSeconds(value: string | number | undefined, fallback: number): number;
+export declare function defineConfig(config: AuthServerConfigInput): import("@adonisjs/core/types").ConfigProvider<ResolvedServerConfig>;

package/build/src/define_config.js

@@ -0,0 +1,115 @@
+import { configProvider } from '@adonisjs/core';
+import { generateJwks } from './keys/jwks_manager.js';
+import { adapters } from './adapters/factory.js';
+import { resolveMessages } from './host/i18n.js';
+export { adapters };
+const RATE_LIMIT_DEFAULTS = {
+    login: { points: 10, duration: '1 min' },
+    introspection: { points: 60, duration: '1 min' },
+};
+export function resolveRateLimit(input) {
+    const enabled = input?.enabled ?? true;
+    return {
+        enabled,
+        login: input?.login ?? RATE_LIMIT_DEFAULTS.login,
+        introspection: input?.introspection ?? RATE_LIMIT_DEFAULTS.introspection,
+        store: input?.store,
+    };
+}
+export function resolveLockout(input) {
+    return {
+        enabled: input?.enabled ?? true,
+        maxAttempts: input?.maxAttempts ?? 5,
+        windowSec: input?.windowSec ?? 900,
+        baseLockoutSec: input?.baseLockoutSec ?? 60,
+        maxLockoutSec: input?.maxLockoutSec ?? 3600,
+        store: input?.store,
+    };
+}
+export function resolveAdmin(input) {
+    return {
+        enabled: input?.enabled ?? false,
+        roles: input?.roles && input.roles.length > 0 ? input.roles : ['ADMIN'],
+    };
+}
+/**
+ * Resolve os parâmetros do RP de WebAuthn a partir do `issuer` quando omitidos.
+ * `rpName` cai no `fallbackName` (branding/mfaIssuer) quando ausente.
+ */
+export function resolveWebauthn(issuer, fallbackName, input) {
+    let host = 'localhost';
+    let origin = 'http://localhost';
+    try {
+        const url = new URL(issuer);
+        host = url.hostname;
+        origin = url.origin;
+    }
+    catch {
+        // issuer inválido → mantém defaults de localhost (dev).
+    }
+    return {
+        rpName: input?.rpName ?? fallbackName,
+        rpId: input?.rpId ?? host,
+        origin: input?.origin ?? origin,
+    };
+}
+const UNITS = { s: 1, m: 60, h: 3600, d: 86400 };
+export function toSeconds(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value === 'number')
+        return value;
+    const m = /^(\d+)\s*([smhd])$/.exec(value.trim());
+    if (!m)
+        throw new Error(`TTL inválido: ${value}`);
+    return Number(m[1]) * UNITS[m[2]];
+}
+export function defineConfig(config) {
+    return configProvider.create(async (app) => {
+        const AdapterClass = await config.adapter.resolver(app);
+        const jwks = config.jwks.source === 'managed'
+            ? await generateJwks(config.jwks.algorithm ?? 'RS256')
+            : { keys: config.jwks.keys ?? [] };
+        return {
+            issuer: config.issuer,
+            AdapterClass,
+            clients: config.clients,
+            jwks: jwks,
+            ttl: {
+                accessToken: toSeconds(config.ttl?.accessToken, 900),
+                refreshToken: toSeconds(config.ttl?.refreshToken, 2592000),
+                idToken: toSeconds(config.ttl?.idToken, 900),
+                session: toSeconds(config.ttl?.session, 604800),
+            },
+            globalRolesClaim: config.globalRolesClaim ?? 'roles',
+            cookieKeys: config.cookieKeys ?? [],
+            observability: config.observability ?? {},
+            findAccount: (sub) => config.accountStore.findById(sub),
+            verifyCredentials: async (email, password) => {
+                const acc = await config.accountStore.verifyCredentials(email, password);
+                return acc ? { id: acc.id } : null;
+            },
+            accountStore: config.accountStore,
+            patStore: config.patStore,
+            mountPath: config.mountPath ?? '/oidc',
+            render: config.render,
+            branding: config.branding,
+            social: config.social,
+            patIntrospectionSecret: config.patIntrospectionSecret,
+            rateLimit: resolveRateLimit(config.rateLimit),
+            lockout: resolveLockout(config.lockout),
+            mail: config.mail,
+            audit: config.audit,
+            mfaIssuer: config.mfaIssuer ?? 'AuthKit',
+            webauthn: resolveWebauthn(config.issuer, config.mfaIssuer ?? 'AuthKit', config.webauthn),
+            dynamicRegistration: {
+                enabled: config.dynamicRegistration?.enabled ?? false,
+                initialAccessToken: config.dynamicRegistration?.initialAccessToken,
+                management: config.dynamicRegistration?.management ?? false,
+            },
+            admin: resolveAdmin(config.admin),
+            messages: resolveMessages(config.i18n),
+            locale: config.i18n?.locale ?? 'pt-BR',
+        };
+    });
+}

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

@@ -0,0 +1,86 @@
+import type { AuditSink } from '../audit/audit_sink.js';
+import type { ResolvedLockoutConfig } from '../define_config.js';
+/**
+ * Bloqueio progressivo de conta (anti-brute-force keyed por EMAIL, não por IP).
+ *
+ * Construído sobre o `@adonisjs/limiter` do HOST (peer/opt-in), exatamente como o
+ * `rate_limit.ts`: o service do limiter é importado de forma preguiçosa e fail-safe.
+ * Se o `@adonisjs/limiter` não estiver instalado/configurado, TODOS os métodos viram
+ * no-op (lockout desligado) e `isLocked` devolve `{ locked: false }` — NUNCA lança no
+ * caminho da request, e NÃO há migração/DB envolvido (usa o store do limiter do host).
+ *
+ * Esquema de chaves (todas namespaced + email normalizado):
+ * - `authkit_lockout_fail:{email}` — contador de falhas dentro da janela deslizante.
+ * - `authkit_lockout:{email}`      — chave bloqueada (TTL = duração progressiva do lock).
+ * - `authkit_lockout_count:{email}`— quantos locks já ocorreram (alimenta o backoff).
+ */
+/** Service do `@adonisjs/limiter` resolvido preguiçosamente. `any` de propósito (peer/opt-in). */
+type LimiterService = any;
+/**
+ * Permite reapontar/limpar o loader do limiter (usado em testes).
+ * @internal
+ */
+export declare function __setLockoutLimiterLoaderForTests(fn: (() => Promise<LimiterService | null>) | undefined): void;
+/**
+ * Backoff progressivo PURO (sem I/O — fácil de testar): a duração do lock cresce
+ * com o número de locks já ocorridos para a chave: `base * 2^(lockCount-1)`,
+ * limitada a `maxLockoutSec`. `lockCount` é 1-based (1 = primeiro lock).
+ */
+export declare function computeLockoutSec(lockCount: number, cfg: ResolvedLockoutConfig): number;
+/** Resultado de uma checagem de bloqueio. */
+export interface LockState {
+    locked: boolean;
+    /** Segundos até a conta destravar (presente quando `locked`). */
+    retryAfterSec?: number;
+}
+/** Contexto opcional de auditoria para o evento `account.locked`. */
+export interface LockoutAuditContext {
+    sink?: AuditSink;
+    ip?: string | null;
+}
+/**
+ * Helper de lockout amarrado a uma config resolvida. Cada método é fail-safe:
+ * resolve o limiter preguiçosamente e degrada para no-op quando ele está ausente
+ * ou quando `cfg.enabled === false`.
+ */
+export declare class AccountLockout {
+    private cfg;
+    constructor(cfg: ResolvedLockoutConfig);
+    private failKey;
+    private lockKey;
+    private countKey;
+    /**
+     * Resolve o limiter (ou `null`). Retorna `null` também quando lockout está
+     * desligado por config — assim o caminho de no-op é o mesmo.
+     */
+    private limiter;
+    /** Store de contagem de falhas (janela deslizante de `windowSec`). */
+    private failStore;
+    /**
+     * Store da contagem de locks. A janela é longa (mantém o histórico de locks por
+     * um tempo para o backoff progressivo crescer entre locks sucessivos).
+     */
+    private countStore;
+    /**
+     * Store dedicado a marcar a chave como bloqueada. `requests: 1` + `block(...)`
+     * com a duração progressiva; `isBlocked`/`availableIn` consultam o estado.
+     */
+    private lockStore;
+    /** `true`/retryAfter quando a conta está bloqueada. Fail-safe: `{ locked: false }`. */
+    isLocked(email: string): Promise<LockState>;
+    /**
+     * Registra uma falha de login. Ao cruzar `maxAttempts` dentro da janela, marca
+     * a chave como bloqueada com TTL progressivo e incrementa a contagem de locks.
+     * Emite `account.locked` UMA vez (na transição), não a cada tentativa bloqueada.
+     */
+    recordFailure(email: string, audit?: LockoutAuditContext): Promise<void>;
+    /**
+     * Limpa o estado de falhas após um login bem-sucedido. Remove o contador de
+     * falhas e o lock; mantém a contagem de locks (histórico para o backoff) — ela
+     * expira naturalmente pela janela longa do `countStore`.
+     */
+    clearFailures(email: string): Promise<void>;
+}
+/** Fabrica o helper de lockout a partir da config resolvida. */
+export declare function createAccountLockout(cfg: ResolvedLockoutConfig): AccountLockout;
+export {};