@adonis-agora/authkit-server 0.68.4 → 0.70.0

package/build/src/host/ui-dist/index.html

@@ -8,7 +8,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Sora:wght@400;500;600;700&family=JetBrains+Mono:ital,wght@0,400;0,500;0,600;1,400&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="/__AUTHKIT_BASE__/assets/index-D9CYQnZR.js"></script>
+    <script type="module" crossorigin src="/__AUTHKIT_BASE__/assets/index-Dct63ai-.js"></script>
     <link rel="stylesheet" crossorigin href="/__AUTHKIT_BASE__/assets/index-DTSmD4RU.css">
   </head>
   <body>

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

@@ -1,6 +1,6 @@
 /** Cadastro passwordless: só e-mail + nome (sem senha). O login vem por magic link. */
 export declare const passwordlessSignupValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
-    email: import("@vinejs/vine").VineString;
+    email: import("@vinejs/vine/schema/base/literal").TransformModifier<import("@vinejs/vine").VineString, string>;
     fullName: import("@vinejs/vine").VineString;
 }, {
     email: string;
@@ -13,7 +13,7 @@ export declare const passwordlessSignupValidator: import("@vinejs/vine").VineVal
     fullName: string;
 }>, Record<string, any> | undefined>;
 export declare const signupValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
-    email: import("@vinejs/vine").VineString;
+    email: import("@vinejs/vine/schema/base/literal").TransformModifier<import("@vinejs/vine").VineString, string>;
     fullName: import("@vinejs/vine").VineString;
     password: import("@vinejs/vine").VineString;
 }, {
@@ -30,7 +30,7 @@ export declare const signupValidator: import("@vinejs/vine").VineValidator<impor
     password: string;
 }>, Record<string, any> | undefined>;
 export declare const forgotPasswordValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
-    email: import("@vinejs/vine").VineString;
+    email: import("@vinejs/vine/schema/base/literal").TransformModifier<import("@vinejs/vine").VineString, string>;
 }, {
     email: string;
 }, {
@@ -75,7 +75,7 @@ export declare const changePasswordValidator: import("@vinejs/vine").VineValidat
  */
 export declare const changeEmailValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
     currentPassword: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineString>;
-    newEmail: import("@vinejs/vine").VineString;
+    newEmail: import("@vinejs/vine/schema/base/literal").TransformModifier<import("@vinejs/vine").VineString, string>;
 }, {
     currentPassword?: string | null | undefined;
     newEmail: string;
@@ -123,7 +123,7 @@ export declare const deleteAccountValidator: import("@vinejs/vine").VineValidato
 }>, Record<string, any> | undefined>;
 /** Criação de usuário no console admin (email obrigatório; nome/senha opcionais). */
 export declare const adminCreateUserValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
-    email: import("@vinejs/vine").VineString;
+    email: import("@vinejs/vine/schema/base/literal").TransformModifier<import("@vinejs/vine").VineString, string>;
     name: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineString>;
     password: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineString>;
 }, {

package/build/src/host/validators.js

@@ -1,16 +1,28 @@
 import vine from '@vinejs/vine';
+import { normalizeEmailIdentifier } from './email_identifier.js';
+/**
+ * E-mail usado como IDENTIDADE da conta. Normalização ÚNICA e conservadora
+ * ({@link normalizeEmailIdentifier}: `trim` + `toLowerCase`) — a MESMA aplicada
+ * no passo de identificador do login, para que os dois lados concordem.
+ *
+ * NÃO use `.normalizeEmail()` do VineJS aqui: ele aplica os defaults do
+ * validator.js, que no gmail REMOVEM os pontos e o sub-endereço `+tag` — a
+ * conta nascia com um endereço diferente do digitado e a pessoa ficava trancada
+ * do lado de fora (ver `host/email_identifier.ts`).
+ */
+const emailIdentifier = () => vine.string().trim().email().transform(normalizeEmailIdentifier);
 /** Cadastro passwordless: só e-mail + nome (sem senha). O login vem por magic link. */
 export const passwordlessSignupValidator = vine.compile(vine.object({
-    email: vine.string().trim().email().normalizeEmail(),
+    email: emailIdentifier(),
     fullName: vine.string().trim().minLength(2).maxLength(255),
 }));
 export const signupValidator = vine.compile(vine.object({
-    email: vine.string().trim().email().normalizeEmail(),
+    email: emailIdentifier(),
     fullName: vine.string().trim().minLength(2).maxLength(255),
     password: vine.string().minLength(8).maxLength(255),
 }));
 export const forgotPasswordValidator = vine.compile(vine.object({
-    email: vine.string().trim().email().normalizeEmail(),
+    email: emailIdentifier(),
 }));
 export const resetPasswordValidator = vine.compile(vine.object({
     token: vine.string().trim().minLength(1),
@@ -31,7 +43,7 @@ export const changePasswordValidator = vine.compile(vine.object({
  */
 export const changeEmailValidator = vine.compile(vine.object({
     currentPassword: vine.string().minLength(1).optional(),
-    newEmail: vine.string().trim().email().normalizeEmail(),
+    newEmail: emailIdentifier(),
 }));
 /**
  * Edição de perfil no console de conta: nome e avatarUrl, ambos opcionais.
@@ -52,7 +64,7 @@ export const deleteAccountValidator = vine.compile(vine.object({
 }));
 /** Criação de usuário no console admin (email obrigatório; nome/senha opcionais). */
 export const adminCreateUserValidator = vine.compile(vine.object({
-    email: vine.string().trim().email().normalizeEmail(),
+    email: emailIdentifier(),
     name: vine.string().trim().maxLength(255).optional(),
     password: vine.string().minLength(8).maxLength(255).optional(),
 }));

package/build/src/provider/build_provider.js

@@ -3,6 +3,7 @@ import { pickModelAdapterClass } from '../adapters/factory.js';
 import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
+import { registrationPolicyMiddleware } from './registration_policy.js';
 /** Atualiza o holder mutável do TTL de sessão com os valores da setting. */
 export function updateSessionTtlHolder(holder, policy) {
     holder.rememberSec = Math.max(1, Math.floor(policy.rememberDays * 86400));
@@ -47,18 +48,34 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             },
         }
         : {};
-    // Access Tokens RFC 9068 (JWT) via Resource Indicators (RFC 8707). Só montamos a
-    // feature quando ALGUM AT deve ser JWT — caso contrário (default opaque) o
-    // oidc-provider mantém o comportamento atual (AT opaco introspecionável) intocado.
+    // Resource Indicators (RFC 8707). A feature do oidc-provider é montada quando:
     //
-    // Um JWT AT no oidc-provider SEMPRE exige um resource indicator com `aud`: o
-    // `defaultResource` injeta a resource default (o `audience`, default issuer) quando
-    // o client não pede `resource` explicitamente, e o `getResourceServerInfo` descreve
-    // a API (scope/audience/formato/TTL) — onde `accessTokenFormat: 'jwt'` faz o token
-    // sair como JWS `typ: at+jwt` assinado com a chave corrente do JWKS.
+    //   - ALGUM AT deve ser JWT (RFC 9068): um JWT AT SEMPRE exige um resource com
+    //     `aud`, então o `defaultResource` injeta o `audience` (default issuer)
+    //     quando o client não pede `resource` — comportamento histórico; ou
+    //   - há `accessTokens.resources` declarados, mesmo todos OPACOS: clientes que
+    //     mandam `resource` (ex.: clientes MCP, cuja spec exige o parâmetro) passam
+    //     a ser aceitos. Sem `resource` no pedido, NADA muda: o `defaultResource`
+    //     devolve `undefined` e o AT continua o opaco de sempre (userinfo, sessão
+    //     web), sem `aud`.
+    //
+    // Nos dois casos o `resource` pedido é validado contra a lista declarada
+    // (chaves de `resources` + o `audience` no modo JWT): fora dela → `invalid_target`
+    // (RFC 8707 §2). O resource concedido fica registrado no Grant (consent) e no
+    // AT (`aud` = `audience` da resource), inclusive no token opaco, que continua
+    // encontrável por `AccessToken.find` e introspecionável.
     const at = config.accessTokens;
     const allScopes = ['openid', 'profile', 'email', 'offline_access', 'roles'];
-    const resourceIndicatorFeatures = at.anyJwt
+    const declaredResources = Object.keys(at.resources);
+    const findResource = (indicator) => {
+        if (at.resources[indicator])
+            return { key: indicator, rc: at.resources[indicator] };
+        // Tolerância à barra final (`https://app/mcp` ≡ `https://app/mcp/`).
+        const trimmed = indicator.replace(/\/+$/, '');
+        const key = declaredResources.find((k) => k.replace(/\/+$/, '') === trimmed);
+        return key ? { key, rc: at.resources[key] } : null;
+    };
+    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0
         ? {
             resourceIndicators: {
                 enabled: true,
@@ -67,14 +84,20 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                     // resources já concedidas — devolvemos para não falhar a request.
                     if (oneOf)
                         return oneOf;
-                    // Authorize/sem resource explícito: liga ao resource default (modo simples).
-                    return at.audience;
+                    // Authorize/sem resource explícito: no modo JWT, liga ao resource
+                    // default (modo simples). Só opaco: sem resource (AT de sempre).
+                    return at.anyJwt ? at.audience : undefined;
                 },
                 useGrantedResource: async () => true,
                 getResourceServerInfo: (_ctx, resourceIndicator, _client) => {
-                    const rc = at.resources[resourceIndicator];
-                    const format = rc?.format ?? (resourceIndicator === at.audience ? at.format : 'opaque');
-                    const audience = rc?.audience ?? resourceIndicator;
+                    const found = findResource(resourceIndicator);
+                    const isDefault = at.anyJwt && resourceIndicator === at.audience;
+                    if (!found && !isDefault) {
+                        throw new oidc.errors.InvalidTarget(`resource indicator not allowed: ${resourceIndicator}`);
+                    }
+                    const rc = found?.rc;
+                    const format = rc?.format ?? at.format;
+                    const audience = rc?.audience ?? found?.key ?? resourceIndicator;
                     const scope = (rc?.scopes ?? allScopes).join(' ');
                     const info = {
                         scope,
@@ -279,6 +302,15 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         writable: true,
         configurable: true,
     });
+    // Política do registro dinâmico (redirect URIs + só fluxo de código + gancho do
+    // host). Middleware PRÉ-rota: roda antes do `/reg` do provider, que sozinho
+    // aceitaria qualquer redirect sintaticamente válido. Ver registration_policy.ts.
+    if (dynReg.enabled && (dynReg.redirectUriPolicy || dynReg.validateRegistration)) {
+        provider.use(registrationPolicyMiddleware({
+            policy: dynReg.redirectUriPolicy,
+            validate: dynReg.validateRegistration,
+        }));
+    }
     provider.proxy = true;
     return provider;
 }

package/build/src/provider/registration_policy.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Política do registro dinâmico de clients (RFC 7591 / RFC 7592).
+ *
+ * O oidc-provider, sozinho, aceita qualquer `redirect_uri` que passe na
+ * validação sintática de metadata (qualquer `https://…`, por exemplo). Com o
+ * registro ABERTO (sem Initial Access Token — o caso dos clientes MCP, que não
+ * têm como obter um IAT), isso deixa qualquer um registrar um client cujo
+ * callback é um domínio do atacante e usar a tela de consent do IdP como isca.
+ * O que protege o usuário é PARA ONDE o código de autorização pode ir.
+ *
+ * Esta política roda ANTES do provider (middleware Koa em `provider.use`), no
+ * `POST /reg` (criação) e no `PUT /reg/:clientId` (update do RFC 7592), e:
+ *
+ *   1. confere cada `redirect_uris` / `post_logout_redirect_uris` contra a
+ *      política (loopback, URLs exatas, esquemas de app instalado, https);
+ *   2. restringe o client ao fluxo de código (`authorization_code` +
+ *      `refresh_token`, `response_type=code`) — PKCE já é obrigatório no IdP;
+ *   3. normaliza `application_type: 'native'` quando todos os redirects são
+ *      loopback/app instalado (é o que o client é, e sem isso o oidc-provider
+ *      recusa esquema próprio);
+ *   4. chama o gancho `validateRegistration` do host, se houver.
+ *
+ * Funções puras + um middleware fino, para serem testadas isoladamente.
+ */
+/** Política de redirect URIs aceita no registro dinâmico. */
+export interface RedirectUriPolicy {
+    /**
+     * Aceita `http://localhost`, `http://127.0.0.1` e `http://[::1]` em QUALQUER
+     * porta e path (RFC 8252 §7.3 — apps nativos/CLIs escutam numa porta efêmera).
+     * Default: `true`.
+     */
+    loopback?: boolean;
+    /** URLs de callback aceitas por igualdade EXATA (ex.: callbacks de fornecedores). Default: `[]`. */
+    exact?: string[];
+    /**
+     * Esquemas privados de app instalado (RFC 8252 §7.1), sem o `:`, ex.:
+     * `['cursor', 'vscode']`. Default: `[]`.
+     */
+    appSchemes?: string[];
+    /**
+     * Aceita QUALQUER redirect `https://`. É o comportamento do oidc-provider sem
+     * política — só faz sentido com registro protegido por Initial Access Token.
+     * Default: `false`.
+     */
+    anyHttps?: boolean;
+}
+export interface ResolvedRedirectUriPolicy {
+    loopback: boolean;
+    exact: string[];
+    appSchemes: string[];
+    anyHttps: boolean;
+}
+/** Operação de registro que está sendo validada. */
+export type RegistrationOperation = 'create' | 'update';
+/**
+ * Gancho do host para validar/ajustar o metadata de um registro dinâmico,
+ * depois da política de redirect. Pode:
+ *   - retornar `void` → segue com o metadata como está;
+ *   - retornar um objeto → ele SUBSTITUI o metadata enviado ao provider;
+ *   - lançar {@link RegistrationPolicyError} → o registro é recusado com
+ *     `400 { error, error_description }`.
+ * Qualquer outro erro sobe (500).
+ */
+export type ValidateRegistrationHook = (metadata: Record<string, unknown>, info: {
+    operation: RegistrationOperation;
+    ctx: unknown;
+}) => void | Record<string, unknown> | Promise<void | Record<string, unknown>>;
+/** Erro de política: vira `400 { error: code, error_description: message }`. */
+export declare class RegistrationPolicyError extends Error {
+    readonly code: 'invalid_redirect_uri' | 'invalid_client_metadata';
+    constructor(code: 'invalid_redirect_uri' | 'invalid_client_metadata', description: string);
+}
+/** Default seguro do registro ABERTO: só loopback, nada de web arbitrário. */
+export declare const OPEN_REGISTRATION_REDIRECT_POLICY: ResolvedRedirectUriPolicy;
+export declare function resolveRedirectUriPolicy(input: RedirectUriPolicy): ResolvedRedirectUriPolicy;
+export type RedirectKind = 'loopback' | 'app' | 'web';
+/** Classifica um redirect pela política; `null` = fora dela. */
+export declare function classifyRedirect(uri: string, policy: ResolvedRedirectUriPolicy): RedirectKind | null;
+/**
+ * Confere o metadata de um registro contra a política. Devolve o metadata
+ * normalizado ou lança {@link RegistrationPolicyError}.
+ */
+export declare function checkClientRegistration(metadata: Record<string, unknown>, policy: ResolvedRedirectUriPolicy): Record<string, unknown>;
+/**
+ * Qual operação de registro o request atinge, com a MESMA regra de casamento do
+ * router do provider: case-insensitive e, se o path exato não casar, uma nova
+ * tentativa sem UMA barra final (`/reg/` ≡ `/reg`). `null` = não é registro.
+ */
+export declare function registrationOperation(method: string, path: string, foldedBase: string): RegistrationOperation | null;
+/**
+ * Middleware Koa (para `provider.use`) que aplica a política no registro
+ * dinâmico. `registrationPath` é o path da rota DENTRO do provider (default
+ * `/reg`; sob koa-mount o prefixo do issuer já foi removido).
+ */
+export declare function registrationPolicyMiddleware(options: {
+    policy: ResolvedRedirectUriPolicy | null;
+    validate?: ValidateRegistrationHook;
+    registrationPath?: string;
+}): (ctx: any, next: () => Promise<void>) => Promise<void>;

package/build/src/provider/registration_policy.js

@@ -0,0 +1,229 @@
+/**
+ * Política do registro dinâmico de clients (RFC 7591 / RFC 7592).
+ *
+ * O oidc-provider, sozinho, aceita qualquer `redirect_uri` que passe na
+ * validação sintática de metadata (qualquer `https://…`, por exemplo). Com o
+ * registro ABERTO (sem Initial Access Token — o caso dos clientes MCP, que não
+ * têm como obter um IAT), isso deixa qualquer um registrar um client cujo
+ * callback é um domínio do atacante e usar a tela de consent do IdP como isca.
+ * O que protege o usuário é PARA ONDE o código de autorização pode ir.
+ *
+ * Esta política roda ANTES do provider (middleware Koa em `provider.use`), no
+ * `POST /reg` (criação) e no `PUT /reg/:clientId` (update do RFC 7592), e:
+ *
+ *   1. confere cada `redirect_uris` / `post_logout_redirect_uris` contra a
+ *      política (loopback, URLs exatas, esquemas de app instalado, https);
+ *   2. restringe o client ao fluxo de código (`authorization_code` +
+ *      `refresh_token`, `response_type=code`) — PKCE já é obrigatório no IdP;
+ *   3. normaliza `application_type: 'native'` quando todos os redirects são
+ *      loopback/app instalado (é o que o client é, e sem isso o oidc-provider
+ *      recusa esquema próprio);
+ *   4. chama o gancho `validateRegistration` do host, se houver.
+ *
+ * Funções puras + um middleware fino, para serem testadas isoladamente.
+ */
+/** Erro de política: vira `400 { error: code, error_description: message }`. */
+export class RegistrationPolicyError extends Error {
+    code;
+    constructor(code, description) {
+        super(description);
+        this.name = 'RegistrationPolicyError';
+        this.code = code;
+    }
+}
+/** Default seguro do registro ABERTO: só loopback, nada de web arbitrário. */
+export const OPEN_REGISTRATION_REDIRECT_POLICY = Object.freeze({
+    loopback: true,
+    exact: [],
+    appSchemes: [],
+    anyHttps: false,
+});
+export function resolveRedirectUriPolicy(input) {
+    return {
+        loopback: input.loopback ?? true,
+        exact: [...(input.exact ?? [])],
+        appSchemes: (input.appSchemes ?? []).map((s) => s.replace(/:$/, '').toLowerCase()),
+        anyHttps: input.anyHttps ?? false,
+    };
+}
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Classifica um redirect pela política; `null` = fora dela. */
+export function classifyRedirect(uri, policy) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return null;
+    }
+    // Credencial embutida e fragmento nunca são redirect legítimo (RFC 6749 §3.1.2).
+    if (url.username || url.password || url.hash)
+        return null;
+    if (policy.loopback && url.protocol === 'http:' && LOOPBACK_HOSTS.has(url.hostname)) {
+        return 'loopback';
+    }
+    if (policy.exact.includes(uri))
+        return 'web';
+    const scheme = url.protocol.slice(0, -1).toLowerCase();
+    if (policy.appSchemes.includes(scheme))
+        return 'app';
+    if (policy.anyHttps && url.protocol === 'https:')
+        return 'web';
+    return null;
+}
+function stringList(value) {
+    if (value === undefined)
+        return null;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string'))
+        return null;
+    return value;
+}
+const ALLOWED_GRANTS = new Set(['authorization_code', 'refresh_token']);
+/**
+ * Confere o metadata de um registro contra a política. Devolve o metadata
+ * normalizado ou lança {@link RegistrationPolicyError}.
+ */
+export function checkClientRegistration(metadata, policy) {
+    const redirects = stringList(metadata.redirect_uris);
+    if (!redirects || redirects.length === 0) {
+        throw new RegistrationPolicyError('invalid_redirect_uri', 'redirect_uris is required');
+    }
+    const kinds = [];
+    for (const uri of redirects) {
+        const kind = classifyRedirect(uri, policy);
+        if (!kind) {
+            throw new RegistrationPolicyError('invalid_redirect_uri', `redirect_uri not allowed by the registration policy: ${uri}`);
+        }
+        kinds.push(kind);
+    }
+    if (metadata.post_logout_redirect_uris !== undefined) {
+        const logout = stringList(metadata.post_logout_redirect_uris);
+        if (!logout || logout.some((uri) => !classifyRedirect(uri, policy))) {
+            throw new RegistrationPolicyError('invalid_client_metadata', 'post_logout_redirect_uris not allowed by the registration policy');
+        }
+    }
+    const grants = metadata.grant_types === undefined ? ['authorization_code'] : stringList(metadata.grant_types);
+    if (!grants?.includes('authorization_code') || grants.some((g) => !ALLOWED_GRANTS.has(g))) {
+        throw new RegistrationPolicyError('invalid_client_metadata', 'only the authorization_code and refresh_token grant types are allowed');
+    }
+    const responses = metadata.response_types === undefined ? ['code'] : stringList(metadata.response_types);
+    if (responses?.length !== 1 || responses[0] !== 'code') {
+        throw new RegistrationPolicyError('invalid_client_metadata', 'only response_type=code is allowed');
+    }
+    const native = kinds.every((kind) => kind !== 'web');
+    return native && metadata.application_type === undefined
+        ? { ...metadata, application_type: 'native' }
+        : metadata;
+}
+/** Mesmo teto do `selective_body` do oidc-provider. */
+const BODY_LIMIT = 56 * 1024;
+/**
+ * Lê o corpo JSON do request. Quando o Adonis já parseou (a ponte do
+ * `OidcCallbackController` põe o objeto em `req.body`), usa-o; senão consome o
+ * stream. Devolve `undefined` quando não dá para interpretar como objeto — o
+ * provider segue e responde o erro de parse ele mesmo.
+ */
+async function readJsonBody(ctx) {
+    const req = ctx.req;
+    let raw;
+    if (req.readable && !req.readableEnded) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            size += chunk.length;
+            if (size > BODY_LIMIT)
+                return undefined;
+            chunks.push(chunk);
+        }
+        raw = Buffer.concat(chunks).toString('utf8');
+        // O stream foi consumido: o provider cai no fallback `req.body`.
+        req.body = raw;
+    }
+    else {
+        raw = req.body ?? ctx.request?.body;
+    }
+    if (typeof raw === 'string' || Buffer.isBuffer(raw)) {
+        try {
+            raw = JSON.parse(raw.toString());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    return raw;
+}
+/**
+ * Case-folding IDÊNTICO ao do router do oidc-provider (`lib/helpers/router.js`,
+ * `fold`): o router casa rotas sem diferenciar maiúsculas. Comparar o path cru
+ * deixaria `POST /REG` chegar ao handler de registro sem passar pela política.
+ */
+function foldPath(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        if (value.charCodeAt(i) > 127) {
+            let out = '';
+            for (const char of value) {
+                const upper = char.toUpperCase();
+                out +=
+                    upper.length === 1 &&
+                        !((char.codePointAt(0) ?? 0) > 127 && (upper.codePointAt(0) ?? 0) < 128)
+                        ? upper
+                        : char;
+            }
+            return out;
+        }
+    }
+    return value.toUpperCase();
+}
+/**
+ * Qual operação de registro o request atinge, com a MESMA regra de casamento do
+ * router do provider: case-insensitive e, se o path exato não casar, uma nova
+ * tentativa sem UMA barra final (`/reg/` ≡ `/reg`). `null` = não é registro.
+ */
+export function registrationOperation(method, path, foldedBase) {
+    const folded = foldPath(path);
+    if (method === 'POST') {
+        const trimmed = folded.length > 1 && folded.endsWith('/') ? folded.slice(0, -1) : folded;
+        return folded === foldedBase || trimmed === foldedBase ? 'create' : null;
+    }
+    // `PUT <base>/:clientId` (RFC 7592). Mais largo que o router de propósito:
+    // tudo sob `<base>/` passa pela política.
+    if (method === 'PUT' && folded.startsWith(`${foldedBase}/`))
+        return 'update';
+    return null;
+}
+/**
+ * Middleware Koa (para `provider.use`) que aplica a política no registro
+ * dinâmico. `registrationPath` é o path da rota DENTRO do provider (default
+ * `/reg`; sob koa-mount o prefixo do issuer já foi removido).
+ */
+export function registrationPolicyMiddleware(options) {
+    const base = foldPath(options.registrationPath ?? '/reg');
+    return async (ctx, next) => {
+        const operation = registrationOperation(ctx.method, ctx.path, base);
+        if (!operation || !ctx.is('application/json'))
+            return next();
+        const metadata = await readJsonBody(ctx);
+        if (!metadata)
+            return next();
+        try {
+            let checked = options.policy ? checkClientRegistration(metadata, options.policy) : metadata;
+            if (options.validate) {
+                const replaced = await options.validate(checked, { operation, ctx });
+                if (replaced && typeof replaced === 'object')
+                    checked = replaced;
+            }
+            ctx.req.body = checked;
+        }
+        catch (error) {
+            if (!(error instanceof RegistrationPolicyError))
+                throw error;
+            ctx.status = 400;
+            ctx.set('cache-control', 'no-store');
+            ctx.body = { error: error.code, error_description: error.message };
+            return;
+        }
+        return next();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.68.4",
+  "version": "0.70.0",
   "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",
@@ -113,7 +113,7 @@
     "qrcode": "1.5.4"
   },
   "devDependencies": {
-    "@adonis-agora/authkit-react": "0.21.0",
+    "@adonis-agora/authkit-react": "0.22.0",
     "@adonis-agora/durable": "0.40.0",
     "@adonis-agora/telescope": "0.21.1",
     "@adonisjs/ally": "6.3.0",