@adonis-agora/authkit-server 0.65.0 → 0.65.2

package/build/host/views/account/confirm.edge

@@ -98,40 +98,9 @@
     é emitido quando existe ao menos um bloco desses na tela.
   --}}
   @if(methods && methods.some((m) => m.kind === 'webauthn'))
-    <script type="module">
-      import { startAuthentication } from '/authkit/assets/webauthn.js'
-
-      for (const block of document.querySelectorAll('[data-authkit-webauthn]')) {
-        const form = block.querySelector('[data-webauthn-form]')
-        const field = block.querySelector('[data-webauthn-response]')
-        const errorBox = block.querySelector('[data-webauthn-error]')
-
-        block.querySelector('[data-webauthn-start]')?.addEventListener('click', async () => {
-          try {
-            // Endpoint de options DERIVADO do descritor, não hardcoded.
-            const optionsResponse = await fetch(form.getAttribute('action') + '/options', {
-              method: 'POST',
-              headers: { 'x-csrf-token': form.querySelector('input[name="_csrf"]').value },
-            })
-            if (!optionsResponse.ok) throw new Error('authkit: options recusadas')
-
-            const optionsJSON = await optionsResponse.json()
-            const assertion = await startAuthentication({ optionsJSON })
-            // O handler lê `request.input('response')` como STRING e faz
-            // JSON.parse — daí o stringify aqui.
-            field.value = JSON.stringify(assertion)
-            form.submit()
-          } catch (error) {
-            // Falha no handshake (usuário cancelou, options recusadas, sem
-            // autenticador). Sem esta mensagem o botão simplesmente não faz
-            // nada e o usuário não tem como saber que deve tentar outro método.
-            console.error(error)
-            errorBox.textContent = errorBox.getAttribute('data-message')
-            errorBox.classList.remove('hidden')
-          }
-        })
-      }
-    </script>
+    {{-- M12: script inline sem nonce é bloqueado por CSP `script-src 'self'` — extraído
+         para asset same-origin (mesmo tratamento do bundle WebAuthn/splash de logout). --}}
+    <script type="module" src="/authkit/assets/webauthn_confirm.js"></script>
   @end
 </body>
 </html>

package/build/host/views/account/mfa.edge

@@ -106,6 +106,9 @@
         @end
 
         <button type="button" id="passkey-add"
+          data-csrf="{{ csrfToken }}"
+          data-options-url="{{ accountPaths?.mfa ?? '/account/mfa' }}/passkeys/options"
+          data-verify-url="{{ accountPaths?.mfa ?? '/account/mfa' }}/passkeys/verify"
           class="mt-4 rounded-lg border border-gray-300 px-4 py-2 text-sm font-semibold text-gray-700 hover:bg-gray-50">
           {{ t('mfa.passkey.add') }}
         </button>
@@ -115,39 +118,10 @@
   </div>
 
   @if(passkeysSupported)
-    <script type="module">
-      import { startRegistration } from '/authkit/assets/webauthn.js'
-      const btn = document.getElementById('passkey-add')
-      const errEl = document.getElementById('passkey-error')
-      const csrf = '{{ csrfToken }}'
-      btn?.addEventListener('click', async () => {
-        errEl.classList.add('hidden')
-        btn.disabled = true
-        try {
-          // 1) Opções de registro (challenge guardado na sessão server-side).
-          const optsRes = await fetch('{{ accountPaths?.mfa ?? '/account/mfa' }}/passkeys/options', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
-            body: JSON.stringify({}),
-          })
-          if (!optsRes.ok) throw new Error('options')
-          const optionsJSON = await optsRes.json()
-          // 2) Cerimônia de registro no authenticator.
-          const attResp = await startRegistration({ optionsJSON })
-          // 3) Verifica/persiste no servidor.
-          const verifyRes = await fetch('{{ accountPaths?.mfa ?? '/account/mfa' }}/passkeys/verify', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
-            body: JSON.stringify({ response: attResp }),
-          })
-          if (!verifyRes.ok) throw new Error('verify')
-          // 4) Recarrega para mostrar a nova passkey.
-          window.location.reload()
-        } catch (e) {
-          errEl.classList.remove('hidden')
-          btn.disabled = false
-        }
-      })
-    </script>
+    {{-- M12: script inline sem nonce é bloqueado por CSP `script-src 'self'` — extraído
+         para asset same-origin (mesmo tratamento do bundle WebAuthn/splash de logout).
+         csrf/URLs vão em `data-*` no botão acima (atributo HTML, escapado pelo Edge)
+         em vez de interpolados como string literal dentro do `<script>`. --}}
+    <script type="module" src="/authkit/assets/passkey_register.js"></script>
   @end
 </body></html>

package/build/host/views/login.edge

@@ -70,49 +70,14 @@
            Sucesso → submete o verify e completa o login sem precisar da senha.
            Fail-safe total: browser sem suporte, abort ou erro = silêncio, login normal segue. --}}
       @if(authMethods && authMethods.passkeyAutofill && authMethods.passkey)
-        <form id="autofill-passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify" class="hidden">
+        <form id="autofill-passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify"
+          data-options-url="/auth/interaction/{{ uid }}/passkey/options" class="hidden">
           <input type="hidden" name="_csrf" value="{{ csrfToken }}">
           <input type="hidden" name="response" id="autofill-passkey-response">
         </form>
-        <script type="module">
-          (async () => {
-            try {
-              // SSR-safe: só roda no browser.
-              if (typeof window === 'undefined' || typeof navigator === 'undefined') return
-              if (!window.PublicKeyCredential) return
-              // Detecta suporte a conditional mediation.
-              const supported = await PublicKeyCredential.isConditionalMediationAvailable?.()
-              if (!supported) return
-
-              const { startAuthentication } = await import('/authkit/assets/webauthn.js')
-              const csrf = document.querySelector('input[name="_csrf"]')?.value ?? ''
-              const optRes = await fetch('/auth/interaction/{{ uid }}/passkey/options', {
-                method: 'POST',
-                headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
-                body: JSON.stringify({}),
-              })
-              if (!optRes.ok) return
-              const optionsJSON = await optRes.json()
-              // Remove flag interna antes de passar ao browser.
-              delete optionsJSON._discoverable
-
-              // AbortController: cancela ao navegar/desmontar.
-              const ac = new AbortController()
-              window.addEventListener('beforeunload', () => ac.abort(), { once: true })
-
-              const assertion = await startAuthentication({
-                optionsJSON,
-                useBrowserAutofill: true,
-                verifyBrowserAutofillInput: true,
-              }, ac.signal)
-
-              document.getElementById('autofill-passkey-response').value = JSON.stringify(assertion)
-              document.getElementById('autofill-passkey-form').submit()
-            } catch {
-              // Fail-safe: abort, suporte ausente ou qualquer erro = login normal.
-            }
-          })()
-        </script>
+        {{-- M12: script inline sem nonce é bloqueado por CSP `script-src 'self'` — extraído
+             para asset same-origin (mesmo tratamento do bundle WebAuthn/splash de logout). --}}
+        <script type="module" src="/authkit/assets/passkey_autofill.js"></script>
       @end
     </div>
   @else
@@ -233,7 +198,8 @@
       {{-- Passwordless: "entrar com passkey" ANTES da senha. Reusa as cerimônias
            de passkey do MFA (begin/finish) liberadas no estágio de senha. --}}
       @if(passkeyFirstAvailable)
-        <form id="passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify" class="mt-4">
+        <form id="passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify"
+          data-options-url="/auth/interaction/{{ uid }}/passkey/options" class="mt-4">
           <input type="hidden" name="_csrf" value="{{ csrfToken }}">
           <input type="hidden" name="response" id="passkey-response">
         </form>
@@ -242,31 +208,9 @@
           {{ t('login.passkey_button') }}
         </button>
         <p id="passkey-error" class="mt-3 hidden text-sm text-red-600">{{ t('mfa_challenge.passkey_error') }}</p>
-        <script type="module">
-          import { startAuthentication } from '/authkit/assets/webauthn.js'
-          const btn = document.getElementById('passkey-button')
-          const errEl = document.getElementById('passkey-error')
-          const csrf = document.querySelector('#passkey-form input[name="_csrf"]').value
-          btn?.addEventListener('click', async () => {
-            errEl.classList.add('hidden')
-            btn.disabled = true
-            try {
-              const res = await fetch('/auth/interaction/{{ uid }}/passkey/options', {
-                method: 'POST',
-                headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
-                body: JSON.stringify({}),
-              })
-              if (!res.ok) throw new Error('options')
-              const optionsJSON = await res.json()
-              const assertion = await startAuthentication({ optionsJSON })
-              document.getElementById('passkey-response').value = JSON.stringify(assertion)
-              document.getElementById('passkey-form').submit()
-            } catch (e) {
-              errEl.classList.remove('hidden')
-              btn.disabled = false
-            }
-          })
-        </script>
+        {{-- M12: script inline sem nonce é bloqueado por CSP `script-src 'self'` — extraído
+             para asset same-origin (compartilhado com mfa-challenge.edge). --}}
+        <script type="module" src="/authkit/assets/passkey_button.js"></script>
       @end
     </div>
   @end

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

@@ -43,7 +43,8 @@
     @if(passkeyAvailable && !noEnrollment)
       {{-- Passkey como alternativa ao código TOTP. O form é submetido por página
            inteira (não fetch) para que o 303 de volta ao client navegue o browser. --}}
-      <form id="passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify" class="mt-4">
+      <form id="passkey-form" method="POST" action="/auth/interaction/{{ uid }}/passkey/verify"
+        data-options-url="/auth/interaction/{{ uid }}/passkey/options" class="mt-4">
         <input type="hidden" name="_csrf" value="{{ csrfToken }}">
         <input type="hidden" name="response" id="passkey-response">
         <input type="hidden" name="trustDevice" id="passkey-trust" value="">
@@ -72,37 +73,8 @@
   </div>
 
   @if(passkeyAvailable)
-    <script type="module">
-      import { startAuthentication } from '/authkit/assets/webauthn.js'
-      const btn = document.getElementById('passkey-button')
-      const errEl = document.getElementById('passkey-error')
-      const csrf = document.querySelector('#passkey-form input[name="_csrf"]').value
-      btn?.addEventListener('click', async () => {
-        errEl.classList.add('hidden')
-        btn.disabled = true
-        try {
-          // 1) Busca as opções de autenticação (challenge guardado na sessão server-side).
-          const res = await fetch('/auth/interaction/{{ uid }}/passkey/options', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
-            body: JSON.stringify({}),
-          })
-          if (!res.ok) throw new Error('options')
-          const optionsJSON = await res.json()
-          // 2) Cerimônia no authenticator.
-          const assertion = await startAuthentication({ optionsJSON })
-          // 3) Submete a assertion como POST de página inteira (segue o 303).
-          document.getElementById('passkey-response').value = JSON.stringify(assertion)
-          // Carrega a escolha de "confiar neste dispositivo" para o form da passkey.
-          const trustChk = document.querySelector('input[name="trustDevice"][type="checkbox"]')
-          const trustHidden = document.getElementById('passkey-trust')
-          if (trustHidden) trustHidden.value = trustChk && trustChk.checked ? 'on' : ''
-          document.getElementById('passkey-form').submit()
-        } catch (e) {
-          errEl.classList.remove('hidden')
-          btn.disabled = false
-        }
-      })
-    </script>
+    {{-- M12: script inline sem nonce é bloqueado por CSP `script-src 'self'` — extraído
+         para asset same-origin (compartilhado com login.edge). --}}
+    <script type="module" src="/authkit/assets/passkey_button.js"></script>
   @end
 </body></html>

package/build/host/views/partials/submit_lock.edge

@@ -23,22 +23,12 @@
 
   Incluído view a view (não no partial de styles, que é GERADO por
   scripts/build_host_css.mjs e sobrescreveria a linha).
+
+  M12: era `<script>` INLINE — bloqueado por CSP `script-src 'self'` sem
+  nonce/hash (mesmo bug do splash de logout). Extraído para asset same-origin;
+  o texto do script não mudou, só o lugar onde mora.
 --}}
-<script>
-  document.addEventListener('submit', function (event) {
-    const form = event.target
-    if (!(form instanceof HTMLFormElement)) return
-    setTimeout(function () {
-      if (event.defaultPrevented) return
-      form
-        .querySelectorAll('button[type="submit"], button:not([type]), input[type="submit"]')
-        .forEach(function (el) {
-          el.disabled = true
-        })
-      form.setAttribute('aria-busy', 'true')
-    }, 0)
-  })
-</script>
+<script src="/authkit/assets/submit_lock.js"></script>
 <style>
   form[aria-busy] button[type='submit'],
   form[aria-busy] button:not([type]),

package/build/src/host/admin_console/console_keys_controller.d.ts

@@ -15,10 +15,5 @@ export default class ConsoleKeysController {
     /** GET {prefix}/api/keys — status da chave de assinatura managed (idade + política + ETA). */
     status(ctx: HttpContext): Promise<void | import("../key_rotation_actions.js").KeysStatus>;
     /** POST {prefix}/api/keys/rotate — { retire?, keep? } → rotaciona agora. */
-    rotate(ctx: HttpContext): Promise<void | {
-        rotated: true;
-        newKid: string;
-        retiredKids: string[];
-        keptKids: string[];
-    }>;
+    rotate(ctx: HttpContext): Promise<void | {}>;
 }

package/build/src/host/admin_console/console_keys_controller.js

@@ -2,9 +2,25 @@ import '../augmentations.js';
 import { apiError } from '../admin_api/dto.js';
 import { buildKeysStatus, rotateNow } from '../key_rotation_actions.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { requireSudo } from '../sudo_mode.js';
 function notSupported(ctx) {
     return ctx.response.status(501).send(apiError('not_implemented', 'jwks não é managed+store.'));
 }
+/**
+ * Gate de sudo (M9): rotacionar a chave de assinatura managed é destrutivo o
+ * bastante (invalida tokens/JWKS na hora, dependendo da política de retire)
+ * para exigir reconfirmação recente de identidade — mesmo padrão JSON 403 de
+ * `console_users_controller.ts`/`console_sessions_controller.ts`.
+ */
+async function gateSudo(ctx) {
+    const settings = await resolveRuntimeSettings(ctx);
+    const result = await requireSudo(ctx, settings);
+    if (result === true)
+        return null;
+    return ctx.response
+        .status(403)
+        .send(apiError('sudo_required', 'Identity confirmation required.'));
+}
 /**
  * Endpoints JSON de gestão da chave de assinatura managed para o console admin React.
  *
@@ -34,6 +50,9 @@ export default class ConsoleKeysController {
             (await svc.keystoreAgeDays?.().catch(() => null)) === null) {
             return notSupported(ctx);
         }
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         return rotateNow(svc, ctx.request.body());
     }
 }

package/build/src/host/admin_console/console_sessions_controller.d.ts

@@ -73,19 +73,7 @@ export default class ConsoleSessionsController {
         }[];
     }>;
     /** POST {prefix}/api/users/:id/revoke-sessions */
-    userRevokeSessions(ctx: HttpContext): Promise<void | {
-        sessions: number;
-        grants: number;
-        accessTokens: number;
-        refreshTokens: number;
-        ok: boolean;
-    }>;
+    userRevokeSessions(ctx: HttpContext): Promise<void | {}>;
     /** POST {prefix}/api/sessions/revoke-all?accountId= */
-    revokeAll(ctx: HttpContext): Promise<{
-        sessions: number;
-        grants: number;
-        accessTokens: number;
-        refreshTokens: number;
-        ok: boolean;
-    }>;
+    revokeAll(ctx: HttpContext): Promise<{}>;
 }

package/build/src/host/admin_console/console_sessions_controller.js

@@ -3,7 +3,25 @@ import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { apiError, grantDto, sessionDto } from '../admin_api/dto.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { sessionAccountValidator } from '../admin_validators.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { enrichSessionsWithContext } from '../session_context.js';
+import { requireSudo } from '../sudo_mode.js';
+/**
+ * Gate de sudo (M9): revogar TODAS as sessões/grants de uma conta é
+ * destrutivo (derruba todo device logado, inclusive o próprio, se o alvo for
+ * o admin) — exige reconfirmação recente de identidade. Mesmo padrão de
+ * `console_users_controller.ts` (JSON 403 em vez do redirect que
+ * `requireSudo` monta para telas HTML).
+ */
+async function gateSudo(ctx) {
+    const settings = await resolveRuntimeSettings(ctx);
+    const result = await requireSudo(ctx, settings);
+    if (result === true)
+        return null;
+    return ctx.response
+        .status(403)
+        .send(apiError('sudo_required', 'Identity confirmation required.'));
+}
 /**
  * Endpoints JSON de sessões/grants do console admin React.
  *
@@ -68,6 +86,9 @@ export default class ConsoleSessionsController {
     }
     /** POST {prefix}/api/users/:id/revoke-sessions */
     async userRevokeSessions(ctx) {
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         const accountId = ctx.params.id.trim();
         if (!accountId) {
             return ctx.response.badRequest(apiError('invalid_request', 'O parâmetro id é obrigatório.'));
@@ -95,6 +116,9 @@ export default class ConsoleSessionsController {
     }
     /** POST {prefix}/api/sessions/revoke-all?accountId= */
     async revokeAll(ctx) {
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;

package/build/src/host/admin_console/console_users_controller.d.ts

@@ -80,14 +80,7 @@ export default class ConsoleUsersController {
         disabled: boolean;
     }>;
     /** POST {prefix}/api/users/:id/disable */
-    disable(ctx: HttpContext): Promise<void | {
-        id: string;
-        email: string;
-        name: string | null;
-        avatarUrl: string | null;
-        globalRoles: string[];
-        disabled: boolean;
-    }>;
+    disable(ctx: HttpContext): Promise<void | {}>;
     /** POST {prefix}/api/users/:id/enable */
     enable(ctx: HttpContext): Promise<void | {
         id: string;
@@ -98,13 +91,7 @@ export default class ConsoleUsersController {
         disabled: boolean;
     }>;
     /** POST {prefix}/api/users/:id/reset-password */
-    resetPassword(ctx: HttpContext): Promise<void | {
-        ok: boolean;
-        email: string;
-    }>;
+    resetPassword(ctx: HttpContext): Promise<void | {}>;
     /** DELETE {prefix}/api/users/:id */
-    destroy(ctx: HttpContext): Promise<void | {
-        ok: boolean;
-        deleted: string;
-    }>;
+    destroy(ctx: HttpContext): Promise<void | {}>;
 }

package/build/src/host/admin_console/console_users_controller.js

@@ -8,7 +8,29 @@ import { adminUserCreateValidator, adminUserRolesValidator } from '../admin_vali
 import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { resolveEffectiveRolesCatalog } from '../runtime_toggles.js';
 import { enrichSessionsWithContext } from '../session_context.js';
+import { requireSudo } from '../sudo_mode.js';
 const PAGE_SIZE = 20;
+/**
+ * Gate de sudo (M9) para ações destrutivas do console (delete user, disable,
+ * reset-password): exige confirmação de identidade RECENTE do próprio admin
+ * autenticado (mesma infra usada pelo self-service — `requireSudo` +
+ * `/account/confirm`), não apenas a sessão de admin já autenticada.
+ *
+ * Difere do uso em telas HTML (`account_security_controller`): esta é uma API
+ * JSON consumida pela SPA do console, então o resultado "sudo ausente" vira
+ * 403 JSON em vez de seguir o redirect que `requireSudo` monta internamente
+ * (mesmo padrão de `account_api_controller.ts`, que descarta aquele redirect e
+ * responde o próprio 403).
+ */
+async function gateSudo(ctx) {
+    const settings = await resolveRuntimeSettings(ctx);
+    const result = await requireSudo(ctx, settings);
+    if (result === true)
+        return null;
+    return ctx.response
+        .status(403)
+        .send(apiError('sudo_required', 'Identity confirmation required.'));
+}
 /**
  * Endpoints JSON de usuários do console admin React.
  *
@@ -138,6 +160,11 @@ export default class ConsoleUsersController {
     }
     /** POST {prefix}/api/users/:id/disable */
     async disable(ctx) {
+        // Sudo (M9): desabilitar uma conta é destrutivo o bastante para exigir
+        // reconfirmação — mas `enable()` (reverter) não passa por aqui de propósito.
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         return this.#setStatus(ctx, true);
     }
     /** POST {prefix}/api/users/:id/enable */
@@ -170,6 +197,11 @@ export default class ConsoleUsersController {
     }
     /** POST {prefix}/api/users/:id/reset-password */
     async resetPassword(ctx) {
+        // Sudo (M9): dispara um e-mail de reset em nome do admin — reconfirmação
+        // recente antes de agir.
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
@@ -187,6 +219,11 @@ export default class ConsoleUsersController {
     }
     /** DELETE {prefix}/api/users/:id */
     async destroy(ctx) {
+        // Sudo (M9): deleção é irreversível (cascade) — a ação destrutiva por
+        // excelência que o audit apontou sem gate nenhum.
+        const denied = await gateSudo(ctx);
+        if (denied)
+            return denied;
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;

package/build/src/host/assets/passkey_autofill.js

@@ -0,0 +1,48 @@
+// Passkey autofill (conditional mediation) do login.edge — extraído do
+// `<script type="module">` inline (M12: CSP `script-src 'self'` bloqueia
+// script inline sem nonce/hash). A URL de options vem de `data-options-url`
+// no form (renderizada pelo Edge como atributo HTML, não interpolada dentro
+// do JS) em vez de `{{ uid }}` cru no meio do fetch.
+(async () => {
+  try {
+    // SSR-safe: só roda no browser.
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') return;
+
+    const form = document.getElementById('autofill-passkey-form');
+    if (!form || !window.PublicKeyCredential) return;
+
+    // Detecta suporte a conditional mediation.
+    const supported = await PublicKeyCredential.isConditionalMediationAvailable?.();
+    if (!supported) return;
+
+    const { startAuthentication } = await import('/authkit/assets/webauthn.js');
+    const csrf = form.querySelector('input[name="_csrf"]')?.value ?? '';
+    const optRes = await fetch(form.dataset.optionsUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
+      body: JSON.stringify({}),
+    });
+    if (!optRes.ok) return;
+    const optionsJSON = await optRes.json();
+    // Remove flag interna antes de passar ao browser.
+    delete optionsJSON._discoverable;
+
+    // AbortController: cancela ao navegar/desmontar.
+    const ac = new AbortController();
+    window.addEventListener('beforeunload', () => ac.abort(), { once: true });
+
+    const assertion = await startAuthentication(
+      {
+        optionsJSON,
+        useBrowserAutofill: true,
+        verifyBrowserAutofillInput: true,
+      },
+      ac.signal,
+    );
+
+    document.getElementById('autofill-passkey-response').value = JSON.stringify(assertion);
+    form.submit();
+  } catch {
+    // Fail-safe: abort, suporte ausente ou qualquer erro = login normal.
+  }
+})();

package/build/src/host/assets/passkey_button.js

@@ -0,0 +1,46 @@
+// Botão "entrar com passkey" — compartilhado por login.edge (passwordless
+// antes da senha) e mfa-challenge.edge (2º fator). Extraído do
+// `<script type="module">` inline (M12: CSP `script-src 'self'` bloqueia
+// script inline sem nonce/hash). A URL de options vem de `data-options-url`
+// no form `#passkey-form` (atributo HTML, escapado pelo Edge) em vez de
+// `{{ uid }}` cru interpolado dentro do JS.
+//
+// O bloco "trustDevice" só existe em mfa-challenge.edge (checkbox "confiar
+// neste dispositivo" + hidden `#passkey-trust`); em login.edge os dois
+// seletores dão `null` e o bloco vira no-op — por isso um único arquivo serve
+// as duas views sem branch de view.
+import { startAuthentication } from '/authkit/assets/webauthn.js';
+
+const form = document.getElementById('passkey-form');
+const btn = document.getElementById('passkey-button');
+const errEl = document.getElementById('passkey-error');
+
+if (form && btn) {
+  const csrf = form.querySelector('input[name="_csrf"]')?.value ?? '';
+
+  btn.addEventListener('click', async () => {
+    errEl?.classList.add('hidden');
+    btn.disabled = true;
+    try {
+      const res = await fetch(form.dataset.optionsUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
+        body: JSON.stringify({}),
+      });
+      if (!res.ok) throw new Error('options');
+      const optionsJSON = await res.json();
+      const assertion = await startAuthentication({ optionsJSON });
+      document.getElementById('passkey-response').value = JSON.stringify(assertion);
+
+      // Só em mfa-challenge.edge: propaga a escolha de "confiar neste dispositivo".
+      const trustChk = document.querySelector('input[name="trustDevice"][type="checkbox"]');
+      const trustHidden = document.getElementById('passkey-trust');
+      if (trustHidden) trustHidden.value = trustChk?.checked ? 'on' : '';
+
+      form.submit();
+    } catch (_e) {
+      errEl?.classList.remove('hidden');
+      btn.disabled = false;
+    }
+  });
+}

package/build/src/host/assets/passkey_register.js

@@ -0,0 +1,43 @@
+// Registro de passkey (account/mfa.edge, "adicionar chave de acesso").
+// Extraído do `<script type="module">` inline (M12: CSP `script-src 'self'`
+// bloqueia script inline sem nonce/hash). csrf/URLs vêm de atributos
+// `data-*` no botão `#passkey-add` (Edge escapa atributos HTML — ao contrário
+// de dentro de um `<script>`, onde entidades não são decodificadas) em vez de
+// interpolados como string literal dentro do JS.
+import { startRegistration } from '/authkit/assets/webauthn.js';
+
+const btn = document.getElementById('passkey-add');
+const errEl = document.getElementById('passkey-error');
+
+btn?.addEventListener('click', async () => {
+  const csrf = btn.dataset.csrf ?? '';
+  const optionsUrl = btn.dataset.optionsUrl;
+  const verifyUrl = btn.dataset.verifyUrl;
+
+  errEl?.classList.add('hidden');
+  btn.disabled = true;
+  try {
+    // 1) Opções de registro (challenge guardado na sessão server-side).
+    const optsRes = await fetch(optionsUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
+      body: JSON.stringify({}),
+    });
+    if (!optsRes.ok) throw new Error('options');
+    const optionsJSON = await optsRes.json();
+    // 2) Cerimônia de registro no authenticator.
+    const attResp = await startRegistration({ optionsJSON });
+    // 3) Verifica/persiste no servidor.
+    const verifyRes = await fetch(verifyUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-csrf-token': csrf },
+      body: JSON.stringify({ response: attResp }),
+    });
+    if (!verifyRes.ok) throw new Error('verify');
+    // 4) Recarrega para mostrar a nova passkey.
+    window.location.reload();
+  } catch (_e) {
+    errEl?.classList.remove('hidden');
+    btn.disabled = false;
+  }
+});

package/build/src/host/assets/submit_lock.js

@@ -0,0 +1,39 @@
+// Trava anti-duplo-submit dos forms clássicos (`method="POST"` com
+// navegação) — incluída em TODA view do host-kit via
+// `partials/submit_lock.edge`. Extraída do `<script>` inline (M12: CSP
+// `script-src 'self'` bloqueia script inline sem nonce/hash). Sem nenhuma
+// interpolação por request — o texto é idêntico ao que estava inline, só
+// mudou de lugar.
+//
+// Por quê: os endpoints de interaction/conta disparam ações custosas (envio
+// de e-mail, cerimônia WebAuthn, verificação de código) e, sem feedback, o
+// usuário clica de novo — cada clique vira um POST duplicado e, nas rotas
+// throttled, derruba o usuário no 429 por mera impaciência.
+//
+// Como:
+// - Listener DELEGADO no `document` — cobre todo form, inclusive os montados
+//   depois (sem precisar marcar forms um a um).
+// - A trava é agendada com `setTimeout(0)`: roda DEPOIS do dispatch do
+//   `submit`, quando o entry-list do form já foi construído (um botão de
+//   submit NOMEADO preserva seu valor no POST) e handlers que chamam
+//   `preventDefault` já rodaram (aí `defaultPrevented` evita travar à toa —
+//   sem navegação, sem botão morto).
+// - Validação nativa que barra o submit nem dispara o evento — a trava nunca
+//   liga num form inválido.
+// - `form.submit()` (JS puro, ex.: auto-submit de passkey) NÃO dispara
+//   `submit` — esses forms seguem destravados de propósito.
+// - Não há "destravar": a resposta (redirect ou re-render de erro) chega como
+//   documento NOVO e a página remonta.
+document.addEventListener('submit', (event) => {
+  const form = event.target;
+  if (!(form instanceof HTMLFormElement)) return;
+  setTimeout(() => {
+    if (event.defaultPrevented) return;
+    form
+      .querySelectorAll('button[type="submit"], button:not([type]), input[type="submit"]')
+      .forEach((el) => {
+        el.disabled = true;
+      });
+    form.setAttribute('aria-busy', 'true');
+  }, 0);
+});

package/build/src/host/assets/webauthn_confirm.js

@@ -0,0 +1,39 @@
+// Verificação WebAuthn genérica de account/confirm.edge — UM script para
+// TODOS os blocos `kind: 'webauthn'` da tela (o import do
+// @simplewebauthn/browser é caro e repeti-lo por método não traria nada).
+// Extraído do `<script type="module">` inline (M12: CSP `script-src 'self'`
+// bloqueia script inline sem nonce/hash). Já não interpolava nada por request
+// (endpoint sai do `action` do form, csrf do hidden, mensagem de
+// `data-message`) — só precisou sair do `<script>` inline para o asset.
+import { startAuthentication } from '/authkit/assets/webauthn.js';
+
+for (const block of document.querySelectorAll('[data-authkit-webauthn]')) {
+  const form = block.querySelector('[data-webauthn-form]');
+  const field = block.querySelector('[data-webauthn-response]');
+  const errorBox = block.querySelector('[data-webauthn-error]');
+
+  block.querySelector('[data-webauthn-start]')?.addEventListener('click', async () => {
+    try {
+      // Endpoint de options DERIVADO do descritor, não hardcoded.
+      const optionsResponse = await fetch(form.getAttribute('action') + '/options', {
+        method: 'POST',
+        headers: { 'x-csrf-token': form.querySelector('input[name="_csrf"]').value },
+      });
+      if (!optionsResponse.ok) throw new Error('authkit: options recusadas');
+
+      const optionsJSON = await optionsResponse.json();
+      const assertion = await startAuthentication({ optionsJSON });
+      // O handler lê `request.input('response')` como STRING e faz
+      // JSON.parse — daí o stringify aqui.
+      field.value = JSON.stringify(assertion);
+      form.submit();
+    } catch (error) {
+      // Falha no handshake (usuário cancelou, options recusadas, sem
+      // autenticador). Sem esta mensagem o botão simplesmente não faz
+      // nada e o usuário não tem como saber que deve tentar outro método.
+      console.error(error);
+      errorBox.textContent = errorBox.getAttribute('data-message');
+      errorBox.classList.remove('hidden');
+    }
+  });
+}

package/build/src/host/controllers/passkey_autofill_asset_controller.d.ts

@@ -0,0 +1,18 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/passkey_autofill.js
+ *
+ * Serve o script de autofill de passkey (conditional mediation) do
+ * `login.edge` a partir do próprio host — M12: `login.edge` embutia esse
+ * script como `<script type="module">` INLINE, bloqueado por CSP
+ * `script-src 'self'` (sem nonce/hash). Mesmo tratamento same-origin de
+ * `logout_asset_controller.ts`/`webauthn_asset_controller.ts`.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: carregado na tela de login, antes de
+ * existir qualquer sessão.
+ */
+export default class PasskeyAutofillAssetController {
+    handle(ctx: HttpContext): Promise<unknown>;
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export declare function resetPasskeyAutofillAssetCache(): void;

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

@@ -0,0 +1,30 @@
+import { createStaticAssetHandler } from './static_asset_controller.js';
+/**
+ * URL do asset, ANCORADA em `import.meta.url` (nunca relativa ao cwd) — mesmo
+ * motivo de `webauthn_asset_controller.ts`: `pnpm deploy --legacy` remonta a
+ * árvore de `node_modules` num diretório novo, e um caminho relativo ao cwd
+ * do host apontaria para o lugar errado em produção.
+ */
+const ASSET_URL = new URL('../assets/passkey_autofill.js', import.meta.url);
+const handler = createStaticAssetHandler(ASSET_URL);
+/**
+ * GET /authkit/assets/passkey_autofill.js
+ *
+ * Serve o script de autofill de passkey (conditional mediation) do
+ * `login.edge` a partir do próprio host — M12: `login.edge` embutia esse
+ * script como `<script type="module">` INLINE, bloqueado por CSP
+ * `script-src 'self'` (sem nonce/hash). Mesmo tratamento same-origin de
+ * `logout_asset_controller.ts`/`webauthn_asset_controller.ts`.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: carregado na tela de login, antes de
+ * existir qualquer sessão.
+ */
+export default class PasskeyAutofillAssetController {
+    async handle(ctx) {
+        return handler.handle(ctx);
+    }
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export function resetPasskeyAutofillAssetCache() {
+    handler.resetCache();
+}

package/build/src/host/controllers/passkey_button_asset_controller.d.ts

@@ -0,0 +1,17 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/passkey_button.js
+ *
+ * Serve o botão "entrar com passkey" a partir do próprio host — compartilhado
+ * por `login.edge` (passwordless antes da senha) e `mfa-challenge.edge` (2º
+ * fator). M12: as duas views embutiam esse script como `<script
+ * type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: carregado nas telas de login/MFA, antes
+ * (ou durante) o handshake de autenticação.
+ */
+export default class PasskeyButtonAssetController {
+    handle(ctx: HttpContext): Promise<unknown>;
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export declare function resetPasskeyButtonAssetCache(): void;

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

@@ -0,0 +1,24 @@
+import { createStaticAssetHandler } from './static_asset_controller.js';
+/** Ver o docblock de `passkey_autofill_asset_controller.ts` sobre `import.meta.url`. */
+const ASSET_URL = new URL('../assets/passkey_button.js', import.meta.url);
+const handler = createStaticAssetHandler(ASSET_URL);
+/**
+ * GET /authkit/assets/passkey_button.js
+ *
+ * Serve o botão "entrar com passkey" a partir do próprio host — compartilhado
+ * por `login.edge` (passwordless antes da senha) e `mfa-challenge.edge` (2º
+ * fator). M12: as duas views embutiam esse script como `<script
+ * type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: carregado nas telas de login/MFA, antes
+ * (ou durante) o handshake de autenticação.
+ */
+export default class PasskeyButtonAssetController {
+    async handle(ctx) {
+        return handler.handle(ctx);
+    }
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export function resetPasskeyButtonAssetCache() {
+    handler.resetCache();
+}

package/build/src/host/controllers/passkey_register_asset_controller.d.ts

@@ -0,0 +1,16 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/passkey_register.js
+ *
+ * Serve o script de registro de passkey (account/mfa.edge, "adicionar chave
+ * de acesso") a partir do próprio host. M12: essa view embutia o script como
+ * `<script type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ *
+ * Fica FORA do prefixo do console admin (opt-in): a tela de MFA da conta
+ * (`/account/mfa`) existe em qualquer host, com ou sem console.
+ */
+export default class PasskeyRegisterAssetController {
+    handle(ctx: HttpContext): Promise<unknown>;
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export declare function resetPasskeyRegisterAssetCache(): void;

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

@@ -0,0 +1,23 @@
+import { createStaticAssetHandler } from './static_asset_controller.js';
+/** Ver o docblock de `passkey_autofill_asset_controller.ts` sobre `import.meta.url`. */
+const ASSET_URL = new URL('../assets/passkey_register.js', import.meta.url);
+const handler = createStaticAssetHandler(ASSET_URL);
+/**
+ * GET /authkit/assets/passkey_register.js
+ *
+ * Serve o script de registro de passkey (account/mfa.edge, "adicionar chave
+ * de acesso") a partir do próprio host. M12: essa view embutia o script como
+ * `<script type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ *
+ * Fica FORA do prefixo do console admin (opt-in): a tela de MFA da conta
+ * (`/account/mfa`) existe em qualquer host, com ou sem console.
+ */
+export default class PasskeyRegisterAssetController {
+    async handle(ctx) {
+        return handler.handle(ctx);
+    }
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export function resetPasskeyRegisterAssetCache() {
+    handler.resetCache();
+}

package/build/src/host/controllers/static_asset_controller.d.ts

@@ -0,0 +1,21 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Fábrica compartilhada do padrão "sirva um JS same-origin, cacheado,
+ * memoizado em processo" usado por `webauthn_asset_controller.ts` e
+ * `logout_asset_controller.ts` (ver o CHANGELOG `0.61.3` para a origem do
+ * padrão: CSP `script-src 'self'` bloqueia `<script>` inline sem nonce/hash, e
+ * um asset same-origin é permitido por `'self'` sem depender de nenhum dos
+ * dois).
+ *
+ * Extraída para os assets do M12 (login/MFA/confirm passkey flows +
+ * anti-duplo-submit) em vez de copiar a mesma leitura+cache+404 mais cinco
+ * vezes — os dois controllers originais continuam como estavam (o contrato
+ * público deles, incl. `resetXAssetCache`, é usado pelos testes existentes),
+ * mas todo asset NOVO passa por aqui.
+ */
+export interface AssetHandler {
+    handle(ctx: HttpContext): Promise<unknown>;
+    /** Limpa o cache em memória — só para os testes exercitarem os dois ramos (200/404) no mesmo processo. */
+    resetCache(): void;
+}
+export declare function createStaticAssetHandler(assetUrl: URL): AssetHandler;

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

@@ -0,0 +1,29 @@
+import { readFile } from 'node:fs/promises';
+export function createStaticAssetHandler(assetUrl) {
+    /** `null` = ainda não lido. `false` = lido e ausente (404 memoizado). */
+    let cached = null;
+    return {
+        async handle(ctx) {
+            if (cached === null) {
+                try {
+                    cached = await readFile(assetUrl);
+                }
+                catch {
+                    cached = false;
+                }
+            }
+            if (cached === false) {
+                // 404 limpo: asset não incluído no pacote (build incompleto). As views
+                // que dependem dele degradam sem JS em vez de estourar 500.
+                return ctx.response.notFound();
+            }
+            return ctx.response
+                .type('text/javascript')
+                .header('Cache-Control', 'public, max-age=31536000, immutable')
+                .send(cached);
+        },
+        resetCache() {
+            cached = null;
+        },
+    };
+}

package/build/src/host/controllers/submit_lock_asset_controller.d.ts

@@ -0,0 +1,17 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/submit_lock.js
+ *
+ * Serve a trava anti-duplo-submit incluída em TODA view do host-kit
+ * (`partials/submit_lock.edge`) a partir do próprio host. M12: essa partial
+ * embutia o script como `<script>` INLINE (sem `type="module"`, mas mesmo
+ * bloqueio de CSP `script-src 'self'` sem nonce/hash).
+ *
+ * Carregado em toda tela do fluxo (login, signup, MFA, conta) — SEM
+ * AUTENTICAÇÃO, e é intencional, pelo mesmo motivo do bundle WebAuthn.
+ */
+export default class SubmitLockAssetController {
+    handle(ctx: HttpContext): Promise<unknown>;
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export declare function resetSubmitLockAssetCache(): void;

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

@@ -0,0 +1,24 @@
+import { createStaticAssetHandler } from './static_asset_controller.js';
+/** Ver o docblock de `passkey_autofill_asset_controller.ts` sobre `import.meta.url`. */
+const ASSET_URL = new URL('../assets/submit_lock.js', import.meta.url);
+const handler = createStaticAssetHandler(ASSET_URL);
+/**
+ * GET /authkit/assets/submit_lock.js
+ *
+ * Serve a trava anti-duplo-submit incluída em TODA view do host-kit
+ * (`partials/submit_lock.edge`) a partir do próprio host. M12: essa partial
+ * embutia o script como `<script>` INLINE (sem `type="module"`, mas mesmo
+ * bloqueio de CSP `script-src 'self'` sem nonce/hash).
+ *
+ * Carregado em toda tela do fluxo (login, signup, MFA, conta) — SEM
+ * AUTENTICAÇÃO, e é intencional, pelo mesmo motivo do bundle WebAuthn.
+ */
+export default class SubmitLockAssetController {
+    async handle(ctx) {
+        return handler.handle(ctx);
+    }
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export function resetSubmitLockAssetCache() {
+    handler.resetCache();
+}

package/build/src/host/controllers/webauthn_confirm_asset_controller.d.ts

@@ -0,0 +1,14 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/webauthn_confirm.js
+ *
+ * Serve o script de verificação WebAuthn genérica de `account/confirm.edge`
+ * (um handler para todos os blocos `kind: 'webauthn'` da tela) a partir do
+ * próprio host. M12: essa view embutia o script como `<script
+ * type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ */
+export default class WebauthnConfirmAssetController {
+    handle(ctx: HttpContext): Promise<unknown>;
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export declare function resetWebauthnConfirmAssetCache(): void;

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

@@ -0,0 +1,21 @@
+import { createStaticAssetHandler } from './static_asset_controller.js';
+/** Ver o docblock de `passkey_autofill_asset_controller.ts` sobre `import.meta.url`. */
+const ASSET_URL = new URL('../assets/webauthn_confirm.js', import.meta.url);
+const handler = createStaticAssetHandler(ASSET_URL);
+/**
+ * GET /authkit/assets/webauthn_confirm.js
+ *
+ * Serve o script de verificação WebAuthn genérica de `account/confirm.edge`
+ * (um handler para todos os blocos `kind: 'webauthn'` da tela) a partir do
+ * próprio host. M12: essa view embutia o script como `<script
+ * type="module">` INLINE, bloqueado por CSP `script-src 'self'`.
+ */
+export default class WebauthnConfirmAssetController {
+    async handle(ctx) {
+        return handler.handle(ctx);
+    }
+}
+/** @internal Limpa o cache do asset — só para os testes exercitarem 200 e 404 no mesmo processo. */
+export function resetWebauthnConfirmAssetCache() {
+    handler.resetCache();
+}

package/build/src/host/register_auth_host.js

@@ -182,6 +182,11 @@ const C = {
     accountConfirm: () => import('./controllers/account_confirm_controller.js'),
     webauthnAsset: () => import('./controllers/webauthn_asset_controller.js'),
     logoutAsset: () => import('./controllers/logout_asset_controller.js'),
+    passkeyAutofillAsset: () => import('./controllers/passkey_autofill_asset_controller.js'),
+    passkeyButtonAsset: () => import('./controllers/passkey_button_asset_controller.js'),
+    passkeyRegisterAsset: () => import('./controllers/passkey_register_asset_controller.js'),
+    webauthnConfirmAsset: () => import('./controllers/webauthn_confirm_asset_controller.js'),
+    submitLockAsset: () => import('./controllers/submit_lock_asset_controller.js'),
     // Console React JSON API (session-authed, under {prefix}/api/*).
     consoleShell: () => import('./admin_console/admin_shell_controller.js'),
     consoleOverview: () => import('./admin_console/console_overview_controller.js'),
@@ -392,6 +397,22 @@ export function registerAuthHost(router, opts = {}) {
     // pode usar script inline: o CSP bloqueia sem nonce/hash e o logout fica
     // preso em "Saindo / Encerrando sua sessão…".
     router.get('/authkit/assets/logout.js', [C.logoutAsset]).as('authkit.assets.logout');
+    // M12: as views abaixo embutiam `<script type="module">`/`<script>` INLINE
+    // — bloqueado por CSP `script-src 'self'` sem nonce/hash, mesmo bug do
+    // logout acima. Mesmo tratamento: extraídos para assets same-origin.
+    router
+        .get('/authkit/assets/passkey_autofill.js', [C.passkeyAutofillAsset])
+        .as('authkit.assets.passkeyAutofill');
+    router
+        .get('/authkit/assets/passkey_button.js', [C.passkeyButtonAsset])
+        .as('authkit.assets.passkeyButton');
+    router
+        .get('/authkit/assets/passkey_register.js', [C.passkeyRegisterAsset])
+        .as('authkit.assets.passkeyRegister');
+    router
+        .get('/authkit/assets/webauthn_confirm.js', [C.webauthnConfirmAsset])
+        .as('authkit.assets.webauthnConfirm');
+    router.get('/authkit/assets/submit_lock.js', [C.submitLockAsset]).as('authkit.assets.submitLock');
     // Provider OIDC (wildcard + root) — o que registerOidcRoutes fazia.
     router.any(`${mount}/*`, [C.oidc]).as('authkit.oidc.wildcard');
     router.any(mount, [C.oidc]).as('authkit.oidc.root');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.65.0",
+  "version": "0.65.2",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -66,7 +66,7 @@
     "@adonisjs/drive": "^4.0.0",
     "@adonisjs/lock": "^2.1.0",
     "@adonisjs/lucid": "^22.4.2",
-    "@adonisjs/redis": "^9.2.0 || ^10.0.0",
+    "@adonisjs/redis": "^9.2.0 || ^10.0.0 || ^11.0.0",
     "@adonisjs/session": "^8.1.0",
     "@adonisjs/shield": "^9.0.0",
     "@vinejs/vine": "^4.4.0",