@adonis-agora/authkit-server 0.61.3 → 0.62.0

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

@@ -98,7 +98,7 @@ export interface BotProtectionWidget {
  *   - `g-recaptcha-response`  (Google reCAPTCHA)
  *   - `authkit-bot-token`     (genérico, p/ widgets custom)
  */
-export declare const DEFAULT_BOT_TOKEN_FIELDS: readonly ["cf-turnstile-response", "h-captcha-response", "g-recaptcha-response", "authkit-bot-token"];
+export declare const DEFAULT_BOT_TOKEN_FIELDS: readonly ['cf-turnstile-response', 'h-captcha-response', 'g-recaptcha-response', 'authkit-bot-token'];
 /** Config de entrada do bot protection (em `config/authkit.ts`). */
 export interface BotProtectionConfigInput {
     /**

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

@@ -27,7 +27,7 @@ export declare function deriveLockedSettingKeys(config: Record<string, any>): st
  * (onde as rotas moram). Ver `AuthHostOptions` e o docblock de
  * `registerAuthHost`.
  */
-export declare const POLICY_ROUTE_OPTIONS: readonly ["social", "rateLimit", "sudoMethods", "admin", "adminApi"];
+export declare const POLICY_ROUTE_OPTIONS: readonly ['social', 'rateLimit', 'sudoMethods', 'admin', 'adminApi'];
 /** Uma opção de política de `AuthHostOptions`. */
 export type PolicyRouteOption = (typeof POLICY_ROUTE_OPTIONS)[number];
 /**

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

@@ -8,7 +8,7 @@
  * A tela está atrás do `accountGuard` (requer sessão de conta ativa).
  */
 import '../augmentations.js';
-import { LAST_METHOD_SESSION_KEY, configuredSudoMethods, isSudoMethodMounted, resolveAvailableMethods, sudoContextFrom, } from '../sudo/runtime.js';
+import { configuredSudoMethods, isSudoMethodMounted, LAST_METHOD_SESSION_KEY, resolveAvailableMethods, sudoContextFrom, } from '../sudo/runtime.js';
 /**
  * Reexport de compatibilidade. O construtor canônico do `SudoContext` vive em
  * `sudo/runtime.ts` (é runtime do SPI, não detalhe da tela); este caminho

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

@@ -9,7 +9,7 @@ import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { syncAdonisAuthLogout } from '../adonis_auth_sync.js';
 import { AvatarUploadError, isAvatarUploadSupported, storeAvatar } from '../avatar_storage.js';
-import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail, sendEmailChangedCompletedEmail, } from '../default_mailer.js';
+import { sendEmailChangeConfirmationEmail, sendEmailChangedCompletedEmail, sendEmailChangeNoticeEmail, } from '../default_mailer.js';
 import { translate } from '../i18n.js';
 import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';

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

@@ -3,8 +3,7 @@ import { supportsLoginMethodsPreference, supportsMagicLink, supportsOtpLogin, su
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
-import { sendMagicLinkEmail } from '../default_mailer.js';
-import { sendOtpUnlockEmail } from '../default_mailer.js';
+import { sendMagicLinkEmail, sendOtpUnlockEmail } from '../default_mailer.js';
 import { translate } from '../i18n.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
@@ -13,7 +12,7 @@ import { authkitOrigin } from '../origin.js';
 import { createOtpLockout, generateOtpUnlockToken, rawToDbOtpUnlockToken, resolveEffectiveOtpLockout, } from '../otp_lockout.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, resolveEffectiveSessionPolicy, } from '../runtime_toggles.js';
-import { TRUSTED_DEVICE_COOKIE, buildTrustedDevicePayload, isTrustedDeviceValid, } from '../trusted_device.js';
+import { buildTrustedDevicePayload, isTrustedDeviceValid, TRUSTED_DEVICE_COOKIE, } from '../trusted_device.js';
 import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
 /**
  * Chave i18n do erro de status de conta (disabled/expired) compartilhada pelos

package/build/src/host/durable/index.d.ts

@@ -29,8 +29,8 @@
 import type { DeletionActor } from '../account_deletion_service.js';
 import { type AccountDeleteWorkflowInput } from './account_deletion_workflow.js';
 import { type AccountExportWorkflowInput } from './account_export_workflow.js';
-export { defineAccountDeletionWorkflow, ACCOUNT_DELETE_WORKFLOW, type AccountDeleteWorkflowInput, type AccountDeletionWorkflowDeps, type DurableStepCtx, type WorkflowBody, } from './account_deletion_workflow.js';
-export { defineAccountExportWorkflow, ACCOUNT_EXPORT_WORKFLOW, type AccountExportWorkflowInput, type AccountExportWorkflowResult, type AccountExportWorkflowDeps, type PersistArtifact, type DeliverArtifact, } from './account_export_workflow.js';
+export { ACCOUNT_DELETE_WORKFLOW, type AccountDeleteWorkflowInput, type AccountDeletionWorkflowDeps, type DurableStepCtx, defineAccountDeletionWorkflow, type WorkflowBody, } from './account_deletion_workflow.js';
+export { ACCOUNT_EXPORT_WORKFLOW, type AccountExportWorkflowDeps, type AccountExportWorkflowInput, type AccountExportWorkflowResult, type DeliverArtifact, defineAccountExportWorkflow, type PersistArtifact, } from './account_export_workflow.js';
 /**
  * Superfície mínima do `WorkflowEngine` que o enqueue usa (`start` idempotente por
  * run-id). Tipada estruturalmente p/ NÃO acoplar o build ao peer opcional.

package/build/src/host/durable/index.js

@@ -28,8 +28,8 @@
  */
 import { ACCOUNT_DELETE_WORKFLOW, } from './account_deletion_workflow.js';
 import { ACCOUNT_EXPORT_WORKFLOW, } from './account_export_workflow.js';
-export { defineAccountDeletionWorkflow, ACCOUNT_DELETE_WORKFLOW, } from './account_deletion_workflow.js';
-export { defineAccountExportWorkflow, ACCOUNT_EXPORT_WORKFLOW, } from './account_export_workflow.js';
+export { ACCOUNT_DELETE_WORKFLOW, defineAccountDeletionWorkflow, } from './account_deletion_workflow.js';
+export { ACCOUNT_EXPORT_WORKFLOW, defineAccountExportWorkflow, } from './account_export_workflow.js';
 /**
  * Resolve o `WorkflowEngine` do container — SÓ no caminho durável. Importa
  * `@adonis-agora/durable` dinamicamente (peer opcional), então o barrel principal

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

@@ -1,4 +1,5 @@
 import type { HttpContext } from '@adonisjs/core/http';
+import type { AuditSink } from '../audit/audit_sink.js';
 /**
  * Guarda o access token do admin na sessão (chame no callback OIDC do RP, logo
  * após o login). Necessário porque o token-exchange exige o access token do admin
@@ -25,6 +26,18 @@ export interface StartImpersonationParams {
     tokenEndpoint?: string;
     scope?: string;
     fetchImpl?: typeof fetch;
+    /**
+     * Vida máxima da impersonation em SEGUNDOS, contada do start. Quando
+     * definido, `impersonationState().active` passa a `false` após o prazo
+     * (expiração preguiçosa — nenhum timer roda; a leitura decide) e o stop
+     * continua restaurando o admin normalmente.
+     *
+     * OPCIONAL e ausente por default: sem ele a impersonation dura até o stop
+     * explícito / logout / fim da sessão (comportamento histórico — um default
+     * com prazo faria a impersonation "parar sozinha" para quem não configurou
+     * nada). Deve ser > 0.
+     */
+    maxAge?: number;
 }
 export interface ImpersonationState {
     active: boolean;
@@ -32,6 +45,29 @@ export interface ImpersonationState {
     targetId?: string;
     /** O admin real (impersonator), quando `active`. */
     impersonatorId?: string;
+    /** Id único desta impersonation (gerado no start). */
+    impersonationId?: string;
+    /** Epoch ms do start. */
+    startedAt?: number;
+    /** Epoch ms da expiração — só quando `maxAge` foi configurado. */
+    expiresAt?: number;
+    /**
+     * `act.sub` devolvido pelo token-exchange (o ator PROVADO pelo IdP, que
+     * deve coincidir com `impersonatorId`).
+     */
+    actSub?: string;
+    /**
+     * `expires_in` (segundos) do token trocado — INFORMATIVO: é a vida do token
+     * do lado do IdP, NÃO impõe expiração na sessão (só `maxAge` faz isso).
+     */
+    exchangeExpiresIn?: number;
+}
+/** Metadados aproveitados da resposta do token-exchange (só o que não é segredo). */
+export interface TokenExchangeResult {
+    /** `expires_in` (s) do token trocado, quando o IdP informa. */
+    expiresIn?: number;
+    /** `act.sub` (ator provado pelo IdP), quando o IdP informa. */
+    actSub?: string;
 }
 /**
  * Renova o access token do admin via refresh grant (RFC 6749 §6), usando o
@@ -53,20 +89,48 @@ export declare function refreshAccessToken(ctx: HttpContext, params: Pick<StartI
  * impersonator (= `account_user_id` atual), regenera a sessão (anti-fixation) e
  * seta `account_user_id = targetId`.
  *
+ * Além da troca de identidade, registra a impersonation: um id único
+ * (`impersonationId`), o instante do start e — só com `maxAge` configurado —
+ * a expiração, mais os metadados não-secretos do exchange (`actSub`,
+ * `exchangeExpiresIn`). Devolve o estado criado (o mesmo shape de
+ * `impersonationState`).
+ *
  * - Se o exchange falhar, LANÇA e NÃO troca NADA na sessão.
- * - Recusa (lança) se já houver impersonation ativa (pare a atual antes).
+ * - Recusa (lança) se já houver impersonation ativa (pare a atual antes) —
+ *   inclusive expirada pelo prazo: expirar só apaga o `active` da leitura,
+ *   encerrar continua explícito via `stopImpersonation`.
  * - Recusa (lança) se não houver access token do admin na sessão.
+ * - Recusa (lança) `maxAge` não-positivo (fail-fast de misconfiguração).
  */
-export declare function startImpersonation(ctx: HttpContext, params: StartImpersonationParams): Promise<void>;
+export declare function startImpersonation(ctx: HttpContext, params: StartImpersonationParams): Promise<ImpersonationState>;
 /**
  * Estado da impersonation pra UI (ex.: banner). `active` quando há um impersonator
- * guardado na sessão.
+ * guardado na sessão E a impersonation não expirou (expiração preguiçosa: com
+ * `maxAge` configurado no start, passado o prazo a leitura devolve
+ * `active: false` — mas os dados seguem na sessão até o `stopImpersonation`
+ * explícito, que continua restaurando o admin normalmente).
+ *
+ * O shape evita keys com valor `undefined` (construção condicional): `{ active:
+ * false }` puro quando nunca houve impersonation.
  */
 export declare function impersonationState(ctx: HttpContext): ImpersonationState;
+/** Opções do `stopImpersonation`. */
+export interface StopImpersonationOptions {
+    /**
+     * Sink para auditar o encerramento (`impersonation.stopped`, com o
+     * `impersonationId`). Sem ele, o stop só mexe na sessão — o start segue
+     * auditado pelo IdP, mas o fim da impersonation não aparece na trilha.
+     */
+    audit?: AuditSink;
+    /** IP a registrar no evento de auditoria (o helper não lê o request). */
+    ip?: string | null;
+}
 /**
- * Encerra a impersonation: restaura `account_user_id = impersonator`, remove a
- * key de impersonation e regenera a sessão (anti-fixation). No-op quando não há
- * impersonation ativa.
+ * Encerra a impersonation: restaura `account_user_id = impersonator`, remove
+ * TODAS as keys de sessão de impersonation (id, tempos, prova do exchange) e
+ * regenera a sessão (anti-fixation). Devolve o estado encerrado (com o
+ * `impersonationId`, mesmo que já expirado pelo prazo) ou `null` quando não
+ * havia nenhuma ativa (no-op — sem audit, sem regenerate).
  *
  * O `admin_access_token` (a credencial do ADMIN usada como `subject_token` do
  * token-exchange) é PRESERVADO: ele é do admin — não do alvo — e o admin segue
@@ -75,4 +139,4 @@ export declare function impersonationState(ctx: HttpContext): ImpersonationState
  * session). O token segue curto (TTL do access token do RP) e o logout do app
  * (`ctx.session.clear()` em `AuthRpController.logout`) continua limpando tudo.
  */
-export declare function stopImpersonation(ctx: HttpContext): Promise<void>;
+export declare function stopImpersonation(ctx: HttpContext, options?: StopImpersonationOptions): Promise<ImpersonationState | null>;

package/build/src/host/impersonation_session.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
 /**
  * Ergonômico de SESSÃO de browser no RP para "personificar" (impersonate) um
@@ -22,6 +23,16 @@ const ACCESS_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token';
  * implementação, leia via `impersonationState`.
  */
 const IMPERSONATOR_SESSION_KEY = 'impersonator_user_id';
+/**
+ * Keys de sessão do registro da impersonation (id + tempos + prova do
+ * exchange). Internas pelo mesmo motivo da key do impersonator: o contrato
+ * público é `impersonationState` / o retorno de `startImpersonation`.
+ */
+const IMPERSONATION_ID_SESSION_KEY = 'impersonation_id';
+const IMPERSONATION_STARTED_AT_SESSION_KEY = 'impersonation_started_at';
+const IMPERSONATION_EXPIRES_AT_SESSION_KEY = 'impersonation_expires_at';
+const IMPERSONATION_ACT_SESSION_KEY = 'impersonation_act_sub';
+const IMPERSONATION_EXCHANGE_EXPIRES_IN_SESSION_KEY = 'impersonation_exchange_expires_in';
 /**
  * Key de sessão que guarda o access token do admin, necessário como
  * `subject_token` do token-exchange. Interna: NÃO exporte o literal.
@@ -59,6 +70,13 @@ export function rememberRefreshToken(ctx, refreshToken) {
  * adicioná-la inverteria a direção do grafo de pacotes (server = IdP toolkit). São
  * ~12 linhas; testável via `fetchImpl`. Lança se o IdP não responder 2xx (é o
  * gatekeeper: não-admin / token expirado ⇒ erro ⇒ a sessão não é tocada).
+ *
+ * Em sucesso devolve os metadados NÃO-secretos da resposta (`expires_in` e
+ * `act.sub`) — o access token trocado é DESCARTADO de propósito: é uma
+ * credencial bearer do alvo e nada no fluxo o consome depois do start
+ * (o app age como o alvo via troca de sessão, não via bearer). NUNCA guarde
+ * esse token na sessão. O parse do corpo é tolerante: IdP que responde 2xx
+ * sem JSON válido ainda conta como exchange OK, só sem metadados.
  */
 async function requestTokenExchange(params, subjectToken) {
     const body = new URLSearchParams({
@@ -82,6 +100,21 @@ async function requestTokenExchange(params, subjectToken) {
         // NUNCA logamos tokens nem o corpo (pode ecoar segredos). Só o status.
         throw new Error(`Token exchange failed: ${res.status}`);
     }
+    const result = {};
+    try {
+        const data = (await res.json());
+        if (typeof data?.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+            result.expiresIn = data.expires_in;
+        }
+        const act = data?.act;
+        if (act && typeof act.sub === 'string' && act.sub.length > 0) {
+            result.actSub = act.sub;
+        }
+    }
+    catch {
+        // Corpo fora do JSON esperado: exchange valeu, metadados ficam ausentes.
+    }
+    return result;
 }
 /**
  * Renova o access token do admin via refresh grant (RFC 6749 §6), usando o
@@ -126,14 +159,26 @@ export async function refreshAccessToken(ctx, params) {
  * impersonator (= `account_user_id` atual), regenera a sessão (anti-fixation) e
  * seta `account_user_id = targetId`.
  *
+ * Além da troca de identidade, registra a impersonation: um id único
+ * (`impersonationId`), o instante do start e — só com `maxAge` configurado —
+ * a expiração, mais os metadados não-secretos do exchange (`actSub`,
+ * `exchangeExpiresIn`). Devolve o estado criado (o mesmo shape de
+ * `impersonationState`).
+ *
  * - Se o exchange falhar, LANÇA e NÃO troca NADA na sessão.
- * - Recusa (lança) se já houver impersonation ativa (pare a atual antes).
+ * - Recusa (lança) se já houver impersonation ativa (pare a atual antes) —
+ *   inclusive expirada pelo prazo: expirar só apaga o `active` da leitura,
+ *   encerrar continua explícito via `stopImpersonation`.
  * - Recusa (lança) se não houver access token do admin na sessão.
+ * - Recusa (lança) `maxAge` não-positivo (fail-fast de misconfiguração).
  */
 export async function startImpersonation(ctx, params) {
     if (ctx.session.get(IMPERSONATOR_SESSION_KEY)) {
         throw new Error('Impersonation already active; stop the current one before starting another');
     }
+    if (params.maxAge !== undefined && !(params.maxAge > 0)) {
+        throw new Error('Invalid maxAge: must be a positive number of seconds');
+    }
     const adminAccessToken = ctx.session.get(ADMIN_ACCESS_TOKEN_SESSION_KEY);
     if (!adminAccessToken) {
         throw new Error('No admin access token in session; call rememberAccessToken after login');
@@ -146,8 +191,9 @@ export async function startImpersonation(ctx, params) {
     }
     // O IdP é o gatekeeper: lança se o admin não puder personificar. Chamado ANTES
     // de qualquer mutação de sessão — em caso de erro nada é trocado.
+    let exchange;
     try {
-        await requestTokenExchange(params, adminAccessToken);
+        exchange = await requestTokenExchange(params, adminAccessToken);
     }
     catch (err) {
         // Access token expirado (4xx do exchange): renova via refresh token e tenta
@@ -160,11 +206,14 @@ export async function startImpersonation(ctx, params) {
         rememberAccessToken(ctx, refreshed.accessToken);
         if (refreshed.refreshToken)
             rememberRefreshToken(ctx, refreshed.refreshToken);
-        await requestTokenExchange(params, refreshed.accessToken);
+        exchange = await requestTokenExchange(params, refreshed.accessToken);
     }
     // Anti-fixation: rotaciona o id da sessão (mantém os dados) antes de gravar a
     // nova identidade. Mesmo padrão do consumidor real no RP.
     await ctx.session.regenerate();
+    const impersonationId = randomUUID();
+    const startedAt = Date.now();
+    const expiresAt = params.maxAge !== undefined ? startedAt + params.maxAge * 1000 : undefined;
     // ESCALAÇÃO DE PRIVILÉGIO (fechada por vinculação): trocar a conta aqui NÃO
     // pode carregar junto o sudo que o admin confirmou sobre a PRÓPRIA conta —
     // senão ele entraria personificando já com a graça aberta sobre a conta
@@ -173,24 +222,61 @@ export async function startImpersonation(ctx, params) {
     // `isSudoActive` a recusa sozinho assim que `ACCOUNT_SESSION_KEY` muda. A
     // garantia é estrutural — vale para qualquer troca de conta futura, sem
     // depender de um `forget` lembrado em cada nova transição.
+    ctx.session.put(IMPERSONATION_ID_SESSION_KEY, impersonationId);
+    ctx.session.put(IMPERSONATION_STARTED_AT_SESSION_KEY, startedAt);
+    if (expiresAt !== undefined)
+        ctx.session.put(IMPERSONATION_EXPIRES_AT_SESSION_KEY, expiresAt);
+    if (exchange.actSub)
+        ctx.session.put(IMPERSONATION_ACT_SESSION_KEY, exchange.actSub);
+    if (exchange.expiresIn !== undefined) {
+        ctx.session.put(IMPERSONATION_EXCHANGE_EXPIRES_IN_SESSION_KEY, exchange.expiresIn);
+    }
     ctx.session.put(IMPERSONATOR_SESSION_KEY, impersonatorId);
     ctx.session.put(ACCOUNT_SESSION_KEY, params.targetId);
+    return impersonationState(ctx);
 }
 /**
  * Estado da impersonation pra UI (ex.: banner). `active` quando há um impersonator
- * guardado na sessão.
+ * guardado na sessão E a impersonation não expirou (expiração preguiçosa: com
+ * `maxAge` configurado no start, passado o prazo a leitura devolve
+ * `active: false` — mas os dados seguem na sessão até o `stopImpersonation`
+ * explícito, que continua restaurando o admin normalmente).
+ *
+ * O shape evita keys com valor `undefined` (construção condicional): `{ active:
+ * false }` puro quando nunca houve impersonation.
  */
 export function impersonationState(ctx) {
     const impersonatorId = ctx.session.get(IMPERSONATOR_SESSION_KEY);
     if (!impersonatorId)
         return { active: false };
     const targetId = ctx.session.get(ACCOUNT_SESSION_KEY);
-    return { active: true, targetId, impersonatorId };
+    const state = { active: true, targetId, impersonatorId };
+    const impersonationId = ctx.session.get(IMPERSONATION_ID_SESSION_KEY);
+    if (impersonationId)
+        state.impersonationId = impersonationId;
+    const startedAt = ctx.session.get(IMPERSONATION_STARTED_AT_SESSION_KEY);
+    if (typeof startedAt === 'number')
+        state.startedAt = startedAt;
+    const expiresAt = ctx.session.get(IMPERSONATION_EXPIRES_AT_SESSION_KEY);
+    if (typeof expiresAt === 'number')
+        state.expiresAt = expiresAt;
+    const actSub = ctx.session.get(IMPERSONATION_ACT_SESSION_KEY);
+    if (actSub)
+        state.actSub = actSub;
+    const exchangeExpiresIn = ctx.session.get(IMPERSONATION_EXCHANGE_EXPIRES_IN_SESSION_KEY);
+    if (typeof exchangeExpiresIn === 'number')
+        state.exchangeExpiresIn = exchangeExpiresIn;
+    if (state.expiresAt !== undefined && Date.now() > state.expiresAt) {
+        state.active = false;
+    }
+    return state;
 }
 /**
- * Encerra a impersonation: restaura `account_user_id = impersonator`, remove a
- * key de impersonation e regenera a sessão (anti-fixation). No-op quando não há
- * impersonation ativa.
+ * Encerra a impersonation: restaura `account_user_id = impersonator`, remove
+ * TODAS as keys de sessão de impersonation (id, tempos, prova do exchange) e
+ * regenera a sessão (anti-fixation). Devolve o estado encerrado (com o
+ * `impersonationId`, mesmo que já expirado pelo prazo) ou `null` quando não
+ * havia nenhuma ativa (no-op — sem audit, sem regenerate).
  *
  * O `admin_access_token` (a credencial do ADMIN usada como `subject_token` do
  * token-exchange) é PRESERVADO: ele é do admin — não do alvo — e o admin segue
@@ -199,10 +285,10 @@ export function impersonationState(ctx) {
  * session). O token segue curto (TTL do access token do RP) e o logout do app
  * (`ctx.session.clear()` em `AuthRpController.logout`) continua limpando tudo.
  */
-export async function stopImpersonation(ctx) {
-    const impersonatorId = ctx.session.get(IMPERSONATOR_SESSION_KEY);
-    if (!impersonatorId)
-        return;
+export async function stopImpersonation(ctx, options) {
+    const stopped = impersonationState(ctx);
+    if (!stopped.impersonatorId)
+        return null;
     await ctx.session.regenerate();
     // Simétrico ao `startImpersonation`: o sudo obtido ENQUANTO personificava
     // ficaria valendo sobre a conta do admin ao voltar. A vinculação corta isso —
@@ -211,6 +297,24 @@ export async function stopImpersonation(ctx) {
     // Nota: se o admin tinha sudo sobre a própria conta ANTES de personificar e a
     // graça ainda não venceu, ele volta valendo. Correto e intencional: é a
     // confirmação dele, sobre a conta dele, dentro da janela dele.
-    ctx.session.put(ACCOUNT_SESSION_KEY, impersonatorId);
+    ctx.session.put(ACCOUNT_SESSION_KEY, stopped.impersonatorId);
     ctx.session.forget(IMPERSONATOR_SESSION_KEY);
+    ctx.session.forget(IMPERSONATION_ID_SESSION_KEY);
+    ctx.session.forget(IMPERSONATION_STARTED_AT_SESSION_KEY);
+    ctx.session.forget(IMPERSONATION_EXPIRES_AT_SESSION_KEY);
+    ctx.session.forget(IMPERSONATION_ACT_SESSION_KEY);
+    ctx.session.forget(IMPERSONATION_EXCHANGE_EXPIRES_IN_SESSION_KEY);
+    await options?.audit?.record({
+        type: 'impersonation.stopped',
+        accountId: stopped.targetId ?? null,
+        actorId: stopped.impersonatorId,
+        ip: options?.ip ?? null,
+        metadata: {
+            impersonationId: stopped.impersonationId ?? null,
+            startedAt: stopped.startedAt ?? null,
+            stoppedAt: Date.now(),
+            expired: !stopped.active,
+        },
+    });
+    return stopped;
 }

package/build/src/host/login_methods_state.js

@@ -1,8 +1,5 @@
-import { supportsMagicLink } from '../accounts/account_store.js';
-import { supportsPasskeys } from '../accounts/account_store.js';
-import { supportsLoginMethodsPreference } from '../accounts/account_store.js';
-import { resolveEffectiveAuthMethods } from './runtime_toggles.js';
-import { configLockedAuthMethods } from './runtime_toggles.js';
+import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, } from '../accounts/account_store.js';
+import { configLockedAuthMethods, resolveEffectiveAuthMethods } from './runtime_toggles.js';
 import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from './user_login_methods.js';
 /**
  * Métodos globais efetivos + pins de config — resolução compartilhada entre o

package/build/src/host/login_notify.js

@@ -1,5 +1,5 @@
 import { sendNewDeviceLoginEmail, sendNewLoginEmail } from './default_mailer.js';
-import { TRUSTED_DEVICE_COOKIE, isTrustedDeviceValid } from './trusted_device.js';
+import { isTrustedDeviceValid, TRUSTED_DEVICE_COOKIE } from './trusted_device.js';
 /**
  * Centraliza o pós-login bem-sucedido: registra o evento `login.success` e dispara
  * (best-effort) o alerta de NOVO acesso quando o IP nunca foi visto para a conta.

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

@@ -75,7 +75,7 @@ export type OidcRpGuardEvents<User> = {
 export declare class OidcRpGuard<UserProvider extends SessionUserProviderContract<unknown>> implements GuardContract<RealUser<UserProvider>> {
     #private;
     [symbols.GUARD_KNOWN_EVENTS]: OidcRpGuardEvents<RealUser<UserProvider>>;
-    driverName: "oidc_rp";
+    driverName: 'oidc_rp';
     authenticationAttempted: boolean;
     isAuthenticated: boolean;
     isLoggedOut: boolean;

package/build/src/host/runtime_settings.js

@@ -50,7 +50,7 @@
  * );
  * ```
  */
-import { SettingLockedError, isSettingLocked } from './config_locks.js';
+import { isSettingLocked, SettingLockedError } from './config_locks.js';
 /**
  * Type guard: o objeto (store ou serviço) expõe SettingsCapability?
  */

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

@@ -17,29 +17,29 @@ import type { SettingsCapability } from './runtime_settings.js';
  * que qualquer code-path possa importar a constante e não depender de strings.
  */
 export declare const SETTING_KEYS: {
-    readonly BOT_PROTECTION: "bot_protection";
-    readonly REGISTRATION: "registration";
-    readonly REQUIRE_VERIFIED_EMAIL: "require_verified_email";
-    readonly MAINTENANCE_MODE: "maintenance_mode";
-    readonly AUTH_METHODS: "auth_methods";
-    readonly EMAIL_CHANGE: "email_change";
-    readonly SECURITY_NOTIFICATIONS: "security_notifications";
-    readonly PASSWORD_HISTORY: "password_history";
-    readonly PASSWORD_EXPIRATION: "password_expiration";
-    readonly SESSION_POLICY: "session_policy";
-    readonly LOCKOUT: "lockout";
-    readonly RATE_LIMIT: "rate_limit";
-    readonly PASSWORD_POLICY: "password_policy";
-    readonly NOTIFICATIONS: "notifications";
-    readonly TRUSTED_DEVICES: "trusted_devices";
-    readonly TOKEN_TTL: "token_ttl";
-    readonly ADMIN_IMPERSONATION: "admin_impersonation";
-    readonly ORGANIZATIONS_POLICY: "organizations_policy";
-    readonly ROLES_CATALOG: "roles_catalog";
-    readonly OTP_LOCKOUT: "otp_lockout";
-    readonly SUDO_MODE: "sudo_mode";
-    readonly ACCOUNT_EXPIRATION: "account_expiration";
-    readonly KEY_ROTATION: "key_rotation";
+    readonly BOT_PROTECTION: 'bot_protection';
+    readonly REGISTRATION: 'registration';
+    readonly REQUIRE_VERIFIED_EMAIL: 'require_verified_email';
+    readonly MAINTENANCE_MODE: 'maintenance_mode';
+    readonly AUTH_METHODS: 'auth_methods';
+    readonly EMAIL_CHANGE: 'email_change';
+    readonly SECURITY_NOTIFICATIONS: 'security_notifications';
+    readonly PASSWORD_HISTORY: 'password_history';
+    readonly PASSWORD_EXPIRATION: 'password_expiration';
+    readonly SESSION_POLICY: 'session_policy';
+    readonly LOCKOUT: 'lockout';
+    readonly RATE_LIMIT: 'rate_limit';
+    readonly PASSWORD_POLICY: 'password_policy';
+    readonly NOTIFICATIONS: 'notifications';
+    readonly TRUSTED_DEVICES: 'trusted_devices';
+    readonly TOKEN_TTL: 'token_ttl';
+    readonly ADMIN_IMPERSONATION: 'admin_impersonation';
+    readonly ORGANIZATIONS_POLICY: 'organizations_policy';
+    readonly ROLES_CATALOG: 'roles_catalog';
+    readonly OTP_LOCKOUT: 'otp_lockout';
+    readonly SUDO_MODE: 'sudo_mode';
+    readonly ACCOUNT_EXPIRATION: 'account_expiration';
+    readonly KEY_ROTATION: 'key_rotation';
 };
 export type SettingKey = (typeof SETTING_KEYS)[keyof typeof SETTING_KEYS];
 /**

package/build/src/host/sudo/index.d.ts

@@ -46,10 +46,10 @@ export declare const sudoMethods: {
     oidcStepUp: typeof oidcStepUp;
     magicLink: typeof magicLink;
 };
-export type { SudoMethod, SudoContext, SudoMethodDescriptor, SudoRouteHelpers } from './types.js';
 /**
  * Montagem do `SudoContext` a partir do `HttpContext`. Reexportado aqui por
  * simetria com `sudoMethods` e os tipos: quem escreve um método (ou a rota de
  * callback do `oidcStepUp`) precisa dos três.
  */
 export { sudoContextFrom } from './runtime.js';
+export type { SudoContext, SudoMethod, SudoMethodDescriptor, SudoRouteHelpers } from './types.js';