@adonis-agora/authkit-client 0.14.0 → 0.16.0

package/build/commands/configure.js

@@ -4,13 +4,15 @@ export async function configure(command) {
     await codemods.makeUsingStub(stubsRoot, 'config/authkit_client.stub', {});
     await codemods.makeUsingStub(stubsRoot, 'controllers/oidc_session_controller.stub', {});
     await codemods.updateRcFile((rc) => rc.addProvider('@adonis-agora/authkit-client/authkit_client_provider'));
-    await codemods.registerMiddleware('router', [{ path: '@adonis-agora/authkit-client/authkit_middleware' }]);
+    await codemods.registerMiddleware('router', [
+        { path: '@adonis-agora/authkit-client/authkit_middleware' },
+    ]);
     await codemods.defineEnvValidations({
         leadingComment: 'Variáveis do @adonis-agora/authkit-client (OIDC client)',
         variables: {
             AUTHKIT_ISSUER: `Env.schema.string({ format: 'url', tld: false })`,
-            AUTHKIT_CLIENT_ID: `Env.schema.string()`,
-            AUTHKIT_CLIENT_SECRET: `Env.schema.string.optional()`,
+            AUTHKIT_CLIENT_ID: 'Env.schema.string()',
+            AUTHKIT_CLIENT_SECRET: 'Env.schema.string.optional()',
             AUTHKIT_REDIRECT_URI: `Env.schema.string({ format: 'url', tld: false })`,
         },
     });

package/build/index.d.ts

@@ -1,28 +1,32 @@
-export { defineConfig, resolvers } from "./src/define_config.js";
-export { Authenticator } from "./src/authenticator.js";
-export { identityToUser, createUserinfoResolver, } from "./src/user_resolvers.js";
-export type { ClaimsUser, ResolveUserContext, UserinfoResolverOptions, } from "./src/user_resolvers.js";
-export { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, exchangeToken, refreshTokens, generatePkce, } from "./src/oidc_login.js";
-export type { EndSessionParams, RefreshParams } from "./src/oidc_login.js";
-export { discoverEndpoints, conventionEndpoints } from "./src/discovery.js";
-export type { OidcEndpoints, DiscoverOptions } from "./src/discovery.js";
-export { resilientFetch } from "./src/http/resilient_fetch.js";
-export type { ResiliencePolicy } from "./src/http/resilient_fetch.js";
-export { AuthkitClientManager } from "./providers/authkit_client_provider.js";
-export type { ResolvedClientConfig, ClientConfigInput, BackchannelLogoutCallback, BackchannelLogoutInput, } from "./src/define_config.js";
-export { lucidRevocationStore, DEFAULT_REVOCATION_TABLE, } from "./src/revocation/revocation_store.js";
-export type { RevocationStore, LucidRevocationStoreOptions, } from "./src/revocation/revocation_store.js";
-export { default as BackchannelRevocationMiddleware } from "./src/middleware/backchannel_revocation_middleware.js";
-export { lucidMirror } from "./src/lucid_mirror.js";
-export type { LucidMirrorOptions } from "./src/lucid_mirror.js";
-export { registerOidcClient } from "./src/register_oidc_client.js";
-export type { RegisterOidcClientOptions, PostLoginRedirects, } from "./src/register_oidc_client.js";
-export { validateLogoutToken, InvalidLogoutTokenError, InMemorySessionIndex, BACKCHANNEL_LOGOUT_EVENT, } from "./src/backchannel_logout.js";
-export type { ValidateLogoutTokenOptions, ValidatedLogoutToken, SessionIndex, SessionIndexEntry, } from "./src/backchannel_logout.js";
-export { generateDpopKeyPair, createDpopProof, dpopJwkThumbprint, } from "./src/dpop.js";
-export type { DpopKeyPair, CreateDpopProofInput } from "./src/dpop.js";
-export { verifyJwtAccessToken, clearJwksCache, } from "./src/verify_access_token.js";
-export type { VerifyJwtAccessTokenOptions, JwtAccessTokenClaims, } from "./src/verify_access_token.js";
-export type { TokenSet } from "./src/types.js";
-export type { Identity } from "@adonis-agora/authkit-core";
-export { configure } from "./commands/configure.js";
+export { defineConfig, resolvers } from './src/define_config.js';
+export { Authenticator } from './src/authenticator.js';
+export { identityToUser, createUserinfoResolver, } from './src/user_resolvers.js';
+export type { ClaimsUser, ResolveUserContext, UserinfoResolverOptions, } from './src/user_resolvers.js';
+export { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, exchangeToken, refreshTokens, generatePkce, } from './src/oidc_login.js';
+export type { EndSessionParams, RefreshParams } from './src/oidc_login.js';
+export { discoverEndpoints, conventionEndpoints } from './src/discovery.js';
+export type { OidcEndpoints, DiscoverOptions } from './src/discovery.js';
+export { resilientFetch } from './src/http/resilient_fetch.js';
+export type { ResiliencePolicy } from './src/http/resilient_fetch.js';
+export { AuthkitClientManager } from './providers/authkit_client_provider.js';
+export type { ResolvedClientConfig, ClientConfigInput, BackchannelLogoutCallback, BackchannelLogoutInput, } from './src/define_config.js';
+export { lucidRevocationStore, DEFAULT_REVOCATION_TABLE, } from './src/revocation/revocation_store.js';
+export type { RevocationStore, LucidRevocationStoreOptions, } from './src/revocation/revocation_store.js';
+export { default as BackchannelRevocationMiddleware } from './src/middleware/backchannel_revocation_middleware.js';
+export { authkitClientGuard, AuthkitClientGuard } from './src/host/authkit_client_guard.js';
+export type { UnauthorizedAccessConstructor } from './src/host/authkit_client_guard.js';
+export { getAuthkit } from './src/host/request_authenticator.js';
+export { default as AuthkitContextMiddleware } from './src/middleware/authkit_context_middleware.js';
+export { lucidMirror } from './src/lucid_mirror.js';
+export type { LucidMirrorOptions } from './src/lucid_mirror.js';
+export { registerOidcClient } from './src/register_oidc_client.js';
+export type { RegisterOidcClientOptions, PostLoginRedirects, } from './src/register_oidc_client.js';
+export { validateLogoutToken, InvalidLogoutTokenError, InMemorySessionIndex, BACKCHANNEL_LOGOUT_EVENT, } from './src/backchannel_logout.js';
+export type { ValidateLogoutTokenOptions, ValidatedLogoutToken, SessionIndex, SessionIndexEntry, } from './src/backchannel_logout.js';
+export { generateDpopKeyPair, createDpopProof, dpopJwkThumbprint, } from './src/dpop.js';
+export type { DpopKeyPair, CreateDpopProofInput } from './src/dpop.js';
+export { verifyJwtAccessToken, clearJwksCache, } from './src/verify_access_token.js';
+export type { VerifyJwtAccessTokenOptions, JwtAccessTokenClaims, } from './src/verify_access_token.js';
+export type { TokenSet } from './src/types.js';
+export type { Identity } from '@adonis-agora/authkit-core';
+export { configure } from './commands/configure.js';

package/build/index.js

@@ -1,15 +1,18 @@
-export { defineConfig, resolvers } from "./src/define_config.js";
-export { Authenticator } from "./src/authenticator.js";
-export { identityToUser, createUserinfoResolver, } from "./src/user_resolvers.js";
-export { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, exchangeToken, refreshTokens, generatePkce, } from "./src/oidc_login.js";
-export { discoverEndpoints, conventionEndpoints } from "./src/discovery.js";
-export { resilientFetch } from "./src/http/resilient_fetch.js";
-export { AuthkitClientManager } from "./providers/authkit_client_provider.js";
-export { lucidRevocationStore, DEFAULT_REVOCATION_TABLE, } from "./src/revocation/revocation_store.js";
-export { default as BackchannelRevocationMiddleware } from "./src/middleware/backchannel_revocation_middleware.js";
-export { lucidMirror } from "./src/lucid_mirror.js";
-export { registerOidcClient } from "./src/register_oidc_client.js";
-export { validateLogoutToken, InvalidLogoutTokenError, InMemorySessionIndex, BACKCHANNEL_LOGOUT_EVENT, } from "./src/backchannel_logout.js";
-export { generateDpopKeyPair, createDpopProof, dpopJwkThumbprint, } from "./src/dpop.js";
-export { verifyJwtAccessToken, clearJwksCache, } from "./src/verify_access_token.js";
-export { configure } from "./commands/configure.js";
+export { defineConfig, resolvers } from './src/define_config.js';
+export { Authenticator } from './src/authenticator.js';
+export { identityToUser, createUserinfoResolver, } from './src/user_resolvers.js';
+export { buildAuthorizeUrl, buildEndSessionUrl, exchangeCode, exchangeToken, refreshTokens, generatePkce, } from './src/oidc_login.js';
+export { discoverEndpoints, conventionEndpoints } from './src/discovery.js';
+export { resilientFetch } from './src/http/resilient_fetch.js';
+export { AuthkitClientManager } from './providers/authkit_client_provider.js';
+export { lucidRevocationStore, DEFAULT_REVOCATION_TABLE, } from './src/revocation/revocation_store.js';
+export { default as BackchannelRevocationMiddleware } from './src/middleware/backchannel_revocation_middleware.js';
+export { authkitClientGuard, AuthkitClientGuard } from './src/host/authkit_client_guard.js';
+export { getAuthkit } from './src/host/request_authenticator.js';
+export { default as AuthkitContextMiddleware } from './src/middleware/authkit_context_middleware.js';
+export { lucidMirror } from './src/lucid_mirror.js';
+export { registerOidcClient } from './src/register_oidc_client.js';
+export { validateLogoutToken, InvalidLogoutTokenError, InMemorySessionIndex, BACKCHANNEL_LOGOUT_EVENT, } from './src/backchannel_logout.js';
+export { generateDpopKeyPair, createDpopProof, dpopJwkThumbprint, } from './src/dpop.js';
+export { verifyJwtAccessToken, clearJwksCache, } from './src/verify_access_token.js';
+export { configure } from './commands/configure.js';

package/build/providers/authkit_client_provider.d.ts

@@ -1,7 +1,8 @@
-import type { HttpContext } from "@adonisjs/core/http";
-import type { ApplicationService } from "@adonisjs/core/types";
-import { Authenticator } from "../src/authenticator.js";
-import type { ResolvedClientConfig } from "../src/define_config.js";
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ApplicationService } from '@adonisjs/core/types';
+import { Authenticator } from '../src/authenticator.js';
+import type { ResolvedClientConfig } from '../src/define_config.js';
+import type { TokenSet } from '../src/types.js';
 /** Deps injetáveis (relógio/fetch) para testar `maybeRefresh` sem rede/tempo real. */
 export interface RefreshDeps {
     now?: () => number;
@@ -23,6 +24,9 @@ export declare class AuthkitClientManager {
      * renovado — incluindo o refresh_token ROTACIONADO — de volta na sessão. Preserva
      * o id_token / refresh_token anteriores quando o IdP não os reemite.
      *
+     * Preserva TAMBÉM o `impersonationBinding`: renovar o token do alvo não muda a
+     * sessão, então não pode invalidar o vínculo e trancar o ator na impersonação.
+     *
      * Best-effort: qualquer falha (token revogado, IdP fora) é silenciosa — o resolver
      * lida com a sessão expirada no fluxo normal. Chamado pelo middleware por request.
      */
@@ -43,15 +47,69 @@ export declare class AuthkitClientManager {
      * do chamador (ex.: Bouncer) ANTES de chamar este método.
      */
     impersonate(ctx: HttpContext, requestedSubject: string): Promise<void>;
-    /** Encerra a impersonação restaurando o token set original. Retorna false se não havia impersonação. */
+    /**
+     * Encerra a impersonação restaurando o token set do ator — SE a sessão que pede
+     * ainda for aquela para a qual a credencial foi guardada.
+     *
+     * A credencial parqueada é um refresh token vivo; sem essa conferência o restore
+     * a entrega a quem estiver de posse do cookie jar depois (logout do ator + login
+     * de outra identidade). A prova é o `impersonationBinding`: um nonce escrito ao
+     * mesmo tempo dentro do token set ATIVO e do registro parqueado. Só `impersonate()`
+     * o escreve e só o `maybeRefresh` o propaga — qualquer troca de identidade
+     * reescreve o slot da sessão e o vínculo some.
+     *
+     * As conferências ÓBVIAS não servem, e é por isso que o vínculo existe:
+     *  - `sub === sub do ator`: durante uma impersonação legítima a sessão é a do
+     *    ALVO, então isso nunca é verdade — trancaria o ator dentro da impersonação;
+     *  - "o token parqueado é de um admin?": sempre verdade; o atacante não alega
+     *    ser o ator, ele pede a credencial do ator;
+     *  - gate por papel: o ator impersonando carrega os papéis do ALVO nesse momento.
+     *
+     * Recusa é FAIL-CLOSED: a credencial órfã é DESCARTADA (nunca devolvida) e o
+     * token set da sessão também cai — uma recusa não é uma tentativa a repetir, e
+     * ninguém fica preso impersonando.
+     *
+     * LIMITE HONESTO: quem controla o cookie jar DURANTE uma impersonação ativa é
+     * indistinguível do ator — é literalmente a mesma sessão, e o vínculo viaja nela.
+     * Isso é o modelo de sessão, não esta conferência. O que fecha é a janela em que
+     * a credencial sobrevive à sessão que a guardou.
+     *
+     * @returns `true` só quando o ator foi restaurado.
+     */
     stopImpersonating(ctx: HttpContext): Promise<boolean>;
-    /** Indica se a request corrente está impersonando (p/ exibir banner na UI). */
+    /**
+     * Indica se a request corrente está impersonando (p/ exibir banner na UI). Exige o
+     * mesmo vínculo do `stopImpersonating` — uma credencial órfã de outra sessão não
+     * faz o banner aparecer para quem não está impersonando ninguém.
+     */
     isImpersonating(ctx: HttpContext): boolean;
+    /**
+     * Encerra a sessão do AuthKit: remove o token set E qualquer credencial de
+     * impersonação parqueada. Todo caminho da lib que derruba a sessão passa por aqui
+     * — logout RP-initiated (`registerOidcClient`) e revogação back-channel.
+     *
+     * Existe porque um `session.forget(sessionKey)` solto deixava o refresh token do
+     * ATOR parqueado no browser depois de uma revogação central — o mecanismo que o
+     * operador usa justamente para matar a sessão.
+     */
+    endSession(ctx: HttpContext): void;
+    /**
+     * Instala o token set de um login recém-concluído, descartando o que sobrou da
+     * sessão anterior no mesmo cookie jar.
+     *
+     * O `stopImpersonating` já recusa uma credencial órfã — o token set novo nasce sem
+     * `impersonationBinding`, então o vínculo não fecha. Mas recusar é só não DEVOLVER:
+     * sem esta limpeza o refresh token do ator continua serializado no cookie de sessão
+     * de outra identidade até a sessão expirar. Não devolver e não guardar são coisas
+     * diferentes, e a segunda é a que mantém a invariante — a credencial parqueada nunca
+     * sobrevive à sessão que a parqueou.
+     */
+    startSession(ctx: HttpContext, tokenSet: TokenSet): void;
     createAuthenticator(ctx: HttpContext): Promise<Authenticator>;
 }
-declare module "@adonisjs/core/types" {
+declare module '@adonisjs/core/types' {
     interface ContainerBindings {
-        "authkit.client": AuthkitClientManager;
+        'authkit.client': AuthkitClientManager;
     }
 }
 export default class AuthkitClientProvider {

package/build/providers/authkit_client_provider.js

@@ -1,10 +1,22 @@
-import { configProvider } from "@adonisjs/core";
-import { RuntimeException } from "@adonisjs/core/exceptions";
-import { Authenticator } from "../src/authenticator.js";
-import { validateLogoutToken } from "../src/backchannel_logout.js";
-import { exchangeToken, refreshTokens } from "../src/oidc_login.js";
+import { randomUUID } from 'node:crypto';
+import { configProvider } from '@adonisjs/core';
+import { RuntimeException } from '@adonisjs/core/exceptions';
+import { Authenticator } from '../src/authenticator.js';
+import { validateLogoutToken } from '../src/backchannel_logout.js';
+import { exchangeToken, refreshTokens } from '../src/oidc_login.js';
 /** Margem (ms) antes do `expiresAt` em que o access token é renovado proativamente. */
 const REFRESH_SKEW_MS = 60_000;
+/** Aceita só o formato COM vínculo; o formato legado (TokenSet cru) vira `null`. */
+function readParked(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    if (typeof candidate.binding !== 'string' || !candidate.binding)
+        return null;
+    if (!candidate.tokenSet || typeof candidate.tokenSet !== 'object')
+        return null;
+    return candidate;
+}
 export class AuthkitClientManager {
     config;
     #resolverCache;
@@ -40,6 +52,9 @@ export class AuthkitClientManager {
      * renovado — incluindo o refresh_token ROTACIONADO — de volta na sessão. Preserva
      * o id_token / refresh_token anteriores quando o IdP não os reemite.
      *
+     * Preserva TAMBÉM o `impersonationBinding`: renovar o token do alvo não muda a
+     * sessão, então não pode invalidar o vínculo e trancar o ator na impersonação.
+     *
      * Best-effort: qualquer falha (token revogado, IdP fora) é silenciosa — o resolver
      * lida com a sessão expirada no fluxo normal. Chamado pelo middleware por request.
      */
@@ -68,6 +83,7 @@ export class AuthkitClientManager {
                 accessToken: next.accessToken,
                 refreshToken: next.refreshToken ?? tokenSet.refreshToken,
                 expiresAt: next.expiresAt,
+                impersonationBinding: tokenSet.impersonationBinding,
             });
         }
         catch {
@@ -84,10 +100,10 @@ export class AuthkitClientManager {
      */
     async handleBackchannelLogout(ctx) {
         const { request, response } = ctx;
-        response.header("Cache-Control", "no-store");
-        const token = request.input("logout_token");
-        if (!token || typeof token !== "string") {
-            return response.badRequest({ error: "invalid_request" });
+        response.header('Cache-Control', 'no-store');
+        const token = request.input('logout_token');
+        if (!token || typeof token !== 'string') {
+            return response.badRequest({ error: 'invalid_request' });
         }
         let validated;
         try {
@@ -97,7 +113,7 @@ export class AuthkitClientManager {
             });
         }
         catch {
-            return response.badRequest({ error: "invalid_request" });
+            return response.badRequest({ error: 'invalid_request' });
         }
         // Atualiza o índice local (se configurado) — revoga as sessões mapeadas.
         const index = this.config.sessionIndex;
@@ -126,9 +142,11 @@ export class AuthkitClientManager {
      */
     async impersonate(ctx, requestedSubject) {
         const session = ctx.session;
-        const current = session?.get(this.config.sessionKey);
+        if (!session)
+            throw new Error('Sem sessão ativa para impersonar a partir dela');
+        const current = session.get(this.config.sessionKey);
         if (!current?.accessToken) {
-            throw new Error("Sem sessão ativa para impersonar a partir dela");
+            throw new Error('Sem sessão ativa para impersonar a partir dela');
         }
         const impersonated = await exchangeToken({
             issuer: this.config.issuer,
@@ -138,22 +156,113 @@ export class AuthkitClientManager {
             requestedSubject,
             resilience: this.config.resilience,
         });
-        session.put(this.#impersonatorKey, current);
-        session.put(this.config.sessionKey, impersonated);
+        // Vínculo: o mesmo nonce nos dois lados. O lado ATIVO mora dentro do token set
+        // da sessão, o único slot que todo caminho de fim-de-sessão já limpa.
+        const binding = randomUUID();
+        session.put(this.#impersonatorKey, {
+            tokenSet: current,
+            binding,
+        });
+        session.put(this.config.sessionKey, { ...impersonated, impersonationBinding: binding });
     }
-    /** Encerra a impersonação restaurando o token set original. Retorna false se não havia impersonação. */
+    /**
+     * Encerra a impersonação restaurando o token set do ator — SE a sessão que pede
+     * ainda for aquela para a qual a credencial foi guardada.
+     *
+     * A credencial parqueada é um refresh token vivo; sem essa conferência o restore
+     * a entrega a quem estiver de posse do cookie jar depois (logout do ator + login
+     * de outra identidade). A prova é o `impersonationBinding`: um nonce escrito ao
+     * mesmo tempo dentro do token set ATIVO e do registro parqueado. Só `impersonate()`
+     * o escreve e só o `maybeRefresh` o propaga — qualquer troca de identidade
+     * reescreve o slot da sessão e o vínculo some.
+     *
+     * As conferências ÓBVIAS não servem, e é por isso que o vínculo existe:
+     *  - `sub === sub do ator`: durante uma impersonação legítima a sessão é a do
+     *    ALVO, então isso nunca é verdade — trancaria o ator dentro da impersonação;
+     *  - "o token parqueado é de um admin?": sempre verdade; o atacante não alega
+     *    ser o ator, ele pede a credencial do ator;
+     *  - gate por papel: o ator impersonando carrega os papéis do ALVO nesse momento.
+     *
+     * Recusa é FAIL-CLOSED: a credencial órfã é DESCARTADA (nunca devolvida) e o
+     * token set da sessão também cai — uma recusa não é uma tentativa a repetir, e
+     * ninguém fica preso impersonando.
+     *
+     * LIMITE HONESTO: quem controla o cookie jar DURANTE uma impersonação ativa é
+     * indistinguível do ator — é literalmente a mesma sessão, e o vínculo viaja nela.
+     * Isso é o modelo de sessão, não esta conferência. O que fecha é a janela em que
+     * a credencial sobrevive à sessão que a guardou.
+     *
+     * @returns `true` só quando o ator foi restaurado.
+     */
     async stopImpersonating(ctx) {
         const session = ctx.session;
-        const original = session?.get(this.#impersonatorKey);
-        if (!original)
+        if (!session)
+            return false;
+        const raw = session.get(this.#impersonatorKey);
+        if (raw === undefined || raw === null)
             return false;
+        const parked = readParked(raw);
+        const live = session.get(this.config.sessionKey);
+        // `parked === null` cobre o formato pré-0.15 (TokenSet cru, sem vínculo nenhum):
+        // é justamente a credencial que não dá pra atribuir. Recusada como qualquer outra.
+        if (!parked || !live?.impersonationBinding || live.impersonationBinding !== parked.binding) {
+            session.forget(this.#impersonatorKey);
+            session.forget(this.config.sessionKey);
+            return false;
+        }
+        const { impersonationBinding: _binding, ...original } = parked.tokenSet;
         session.put(this.config.sessionKey, original);
         session.forget(this.#impersonatorKey);
         return true;
     }
-    /** Indica se a request corrente está impersonando (p/ exibir banner na UI). */
+    /**
+     * Indica se a request corrente está impersonando (p/ exibir banner na UI). Exige o
+     * mesmo vínculo do `stopImpersonating` — uma credencial órfã de outra sessão não
+     * faz o banner aparecer para quem não está impersonando ninguém.
+     */
     isImpersonating(ctx) {
-        return Boolean(ctx.session?.get(this.#impersonatorKey));
+        const session = ctx.session;
+        if (!session)
+            return false;
+        const parked = readParked(session.get(this.#impersonatorKey));
+        if (!parked)
+            return false;
+        const live = session.get(this.config.sessionKey);
+        return live?.impersonationBinding === parked.binding;
+    }
+    /**
+     * Encerra a sessão do AuthKit: remove o token set E qualquer credencial de
+     * impersonação parqueada. Todo caminho da lib que derruba a sessão passa por aqui
+     * — logout RP-initiated (`registerOidcClient`) e revogação back-channel.
+     *
+     * Existe porque um `session.forget(sessionKey)` solto deixava o refresh token do
+     * ATOR parqueado no browser depois de uma revogação central — o mecanismo que o
+     * operador usa justamente para matar a sessão.
+     */
+    endSession(ctx) {
+        const session = ctx.session;
+        if (!session)
+            return;
+        session.forget(this.config.sessionKey);
+        session.forget(this.#impersonatorKey);
+    }
+    /**
+     * Instala o token set de um login recém-concluído, descartando o que sobrou da
+     * sessão anterior no mesmo cookie jar.
+     *
+     * O `stopImpersonating` já recusa uma credencial órfã — o token set novo nasce sem
+     * `impersonationBinding`, então o vínculo não fecha. Mas recusar é só não DEVOLVER:
+     * sem esta limpeza o refresh token do ator continua serializado no cookie de sessão
+     * de outra identidade até a sessão expirar. Não devolver e não guardar são coisas
+     * diferentes, e a segunda é a que mantém a invariante — a credencial parqueada nunca
+     * sobrevive à sessão que a parqueou.
+     */
+    startSession(ctx, tokenSet) {
+        const session = ctx.session;
+        if (!session)
+            return;
+        session.forget(this.#impersonatorKey);
+        session.put(this.config.sessionKey, tokenSet);
     }
     async createAuthenticator(ctx) {
         const resolver = await this.#getResolver();
@@ -174,8 +283,8 @@ export default class AuthkitClientProvider {
         this.app = app;
     }
     register() {
-        this.app.container.singleton("authkit.client", async () => {
-            const value = this.app.config.get("authkit_client");
+        this.app.container.singleton('authkit.client', async () => {
+            const value = this.app.config.get('authkit_client');
             const config = (await configProvider.resolve(this.app, value));
             if (!config) {
                 throw new RuntimeException('Config inválido em "config/authkit_client.ts". Use defineConfig de @adonis-agora/authkit-client.');

package/build/services/main.d.ts

@@ -1,4 +1,4 @@
-import type { AuthkitClientManager } from "../providers/authkit_client_provider.js";
+import type { AuthkitClientManager } from '../providers/authkit_client_provider.js';
 /**
  * Singleton accessor for the {@link AuthkitClientManager}, following the Adonis `services/main`
  * convention (like `db`, `mail`, `drive`). Lets an app write

package/build/services/main.js

@@ -1,4 +1,4 @@
-import app from "@adonisjs/core/services/app";
+import app from '@adonisjs/core/services/app';
 /**
  * Singleton accessor for the {@link AuthkitClientManager}, following the Adonis `services/main`
  * convention (like `db`, `mail`, `drive`). Lets an app write
@@ -8,6 +8,6 @@ import app from "@adonisjs/core/services/app";
  */
 let manager;
 await app.booted(async () => {
-    manager = await app.container.make("authkit.client");
+    manager = await app.container.make('authkit.client');
 });
 export { manager as default };

package/build/src/authenticator.d.ts

@@ -1,6 +1,6 @@
-import type { Identity, SessionResolver } from "@adonis-agora/authkit-core";
-import { type MetricsRecorder } from "@adonis-agora/authkit-core";
-import type { HttpContext } from "@adonisjs/core/http";
+import type { Identity, SessionResolver } from '@adonis-agora/authkit-core';
+import { type MetricsRecorder } from '@adonis-agora/authkit-core';
+import type { HttpContext } from '@adonisjs/core/http';
 /** Contexto opcional repassado a `resolveUser` (extensão backward-compatible). */
 export interface ResolveUserContext {
     accessToken?: string;

package/build/src/authenticator.js

@@ -1,5 +1,5 @@
-import { AUTHKIT_METRICS, NoopRecorder, } from "@adonis-agora/authkit-core";
-import { populateContext } from "./observability/context_bridge.js";
+import { AUTHKIT_METRICS, NoopRecorder } from '@adonis-agora/authkit-core';
+import { populateContext } from './observability/context_bridge.js';
 /**
  * Autenticador do request. O parâmetro `TUser` é o tipo do usuário do app que `resolveUser`
  * devolve — o app o fixa via augmentation de `HttpContext.auth` (`auth: Authenticator<AppUser>`),
@@ -47,7 +47,7 @@ export class Authenticator {
     async authenticate() {
         const identity = await this.getIdentity();
         if (!identity)
-            throw new Error("Not authenticated");
+            throw new Error('Not authenticated');
         return identity;
     }
     async check() {
@@ -84,7 +84,7 @@ export class Authenticator {
     async getUserOrFail() {
         const user = await this.getUser();
         if (user === null) {
-            throw new Error("Not authenticated: no user for the current session");
+            throw new Error('Not authenticated: no user for the current session');
         }
         return user;
     }

package/build/src/define_config.d.ts

@@ -1,8 +1,8 @@
-import type { Identity } from "@adonis-agora/authkit-core";
-import type { SessionIndex } from "./backchannel_logout.js";
-import type { ResiliencePolicy } from "./http/resilient_fetch.js";
-import { type ResolverFactory, resolvers } from "./resolvers/factory.js";
-import type { RevocationStore } from "./revocation/revocation_store.js";
+import type { Identity } from '@adonis-agora/authkit-core';
+import type { SessionIndex } from './backchannel_logout.js';
+import type { ResiliencePolicy } from './http/resilient_fetch.js';
+import { type ResolverFactory, resolvers } from './resolvers/factory.js';
+import type { RevocationStore } from './revocation/revocation_store.js';
 export { resolvers };
 /** Callback invocado quando um logout_token válido chega via Back-Channel Logout. */
 export type BackchannelLogoutCallback = (event: {

package/build/src/define_config.js

@@ -1,5 +1,5 @@
-import { configProvider } from "@adonisjs/core";
-import { resolvers } from "./resolvers/factory.js";
+import { configProvider } from '@adonisjs/core';
+import { resolvers } from './resolvers/factory.js';
 export { resolvers };
 export function defineConfig(config) {
     return configProvider.create(async () => {
@@ -22,9 +22,9 @@ export function defineConfig(config) {
             redirectUri: config.redirectUri,
             resolverFactory: config.resolver,
             resolveUser: config.resolveUser,
-            sessionKey: config.sessionKey ?? "authkit",
-            scopes: config.scopes ?? ["openid", "profile", "email", "offline_access", "roles"],
-            globalRolesClaim: config.globalRolesClaim ?? "roles",
+            sessionKey: config.sessionKey ?? 'authkit',
+            scopes: config.scopes ?? ['openid', 'profile', 'email', 'offline_access', 'roles'],
+            globalRolesClaim: config.globalRolesClaim ?? 'roles',
             onBackchannelLogout,
             sessionIndex: config.sessionIndex,
             backchannelStore: store,

package/build/src/discovery.d.ts

@@ -16,7 +16,7 @@
  * const tokens = await exchangeCode({ issuer, tokenEndpoint: endpoints.tokenEndpoint, ... })
  * ```
  */
-import { type ResiliencePolicy } from "./http/resilient_fetch.js";
+import { type ResiliencePolicy } from './http/resilient_fetch.js';
 export interface OidcEndpoints {
     authorizationEndpoint: string;
     tokenEndpoint: string;

package/build/src/discovery.js

@@ -16,13 +16,13 @@
  * const tokens = await exchangeCode({ issuer, tokenEndpoint: endpoints.tokenEndpoint, ... })
  * ```
  */
-import { resilientFetch, } from "./http/resilient_fetch.js";
+import { resilientFetch } from './http/resilient_fetch.js';
 /**
  * Convenção do oidc-provider (authkit-server) — usada como fallback quando o
  * documento de discovery não está acessível.
  */
 export function conventionEndpoints(issuer) {
-    const base = issuer.replace(/\/$/, "");
+    const base = issuer.replace(/\/$/, '');
     return {
         authorizationEndpoint: `${base}/auth`,
         tokenEndpoint: `${base}/token`,
@@ -43,7 +43,7 @@ const cache = new Map();
  * - `overrides` sempre vencem, campo a campo.
  */
 export async function discoverEndpoints(issuer, options = {}) {
-    const base = issuer.replace(/\/$/, "");
+    const base = issuer.replace(/\/$/, '');
     const ttl = options.cacheTtlMs ?? DEFAULT_TTL_MS;
     const cached = cache.get(base);
     let endpoints;
@@ -66,11 +66,11 @@ export async function discoverEndpoints(issuer, options = {}) {
 async function fetchDiscovery(base, fetchImpl, resilience) {
     const fallback = conventionEndpoints(base);
     try {
-        const res = await resilientFetch(`${base}/.well-known/openid-configuration`, { headers: { accept: "application/json" } }, resilience, fetchImpl);
+        const res = await resilientFetch(`${base}/.well-known/openid-configuration`, { headers: { accept: 'application/json' } }, resilience, fetchImpl);
         if (!res.ok)
             return fallback;
         const doc = (await res.json());
-        const str = (v) => typeof v === "string" && v ? v : undefined;
+        const str = (v) => (typeof v === 'string' && v ? v : undefined);
         return {
             authorizationEndpoint: str(doc.authorization_endpoint) ?? fallback.authorizationEndpoint,
             tokenEndpoint: str(doc.token_endpoint) ?? fallback.tokenEndpoint,

package/build/src/dpop.js

@@ -1,5 +1,5 @@
-import { SignJWT, exportJWK, generateKeyPair, calculateJwkThumbprint, base64url, } from 'jose';
 import { createHash, randomUUID } from 'node:crypto';
+import { SignJWT, base64url, calculateJwkThumbprint, exportJWK, generateKeyPair, } from 'jose';
 /**
  * Gera um par de chaves DPoP ES256 (P-256), exportável como JWK. ES256 é o alg
  * recomendado pelo RFC 9449 e o que o oidc-provider do authkit-server aceita.