@adonis-agora/authkit-server 0.47.0 → 0.48.0

package/build/src/host/account_paths.js

@@ -0,0 +1,161 @@
+/**
+ * Prefixo e segmentos de tela do console de conta (`/account/*`) — singleton de
+ * processo, configurável/localizável.
+ *
+ * Definidos em tempo de registro das rotas (`registerAuthHost`, via a opção
+ * `accountRoutes`) e lidos em runtime por TODOS os pontos que constroem uma URL
+ * do console de conta: o registro de rotas, os redirects dos controllers, as
+ * URLs absolutas dos e-mails transacionais, os guards de sudo e as views Edge
+ * (injetados como prop global `accountPaths` pelo renderer).
+ *
+ * Por que módulo singleton e não binding do container? Mesma razão do
+ * `admin_prefix` e do `account_login_url`: os guards e o registro de rotas são
+ * closures construídas em tempo de registro, ANTES da primeira request, quando
+ * o container do AdonisJS ainda não existe. Um módulo ESM é inicializado uma vez
+ * por processo — ideal para configuração imutável de boot.
+ *
+ * ── O que é configurável e o que NÃO é ──────────────────────────────────────
+ * Configuráveis: o PREFIXO (`/account` → `/conta`) e o SEGMENTO de cada TELA
+ * navegável (`security` → `seguranca`, `confirm` → `confirmar`, ...). São paths
+ * que o usuário vê na barra de endereço e que um host pode querer no idioma dele.
+ *
+ * NÃO configuráveis (de propósito): os action-subpaths dos POSTs de dentro de
+ * cada tela — `/password`, `/email`, `/enroll`, `/confirm`, `/disable`,
+ * `/passkeys/options`, `/passkeys/verify`, `/delete`, `/export`, o `/magic-link`
+ * e o `/passkey` das rotas de sudo, etc. São endpoints de formulário invisíveis
+ * ao usuário (ele nunca digita `/account/security/password`), servem apenas de
+ * alvo de `<form action>`/`fetch`, e mantê-los fixos evita multiplicar a
+ * superfície de configuração (e a de bugs) sem nenhum ganho de UX. Renomear a
+ * tela já cobre o caso real "quero /conta/seguranca". Idem para o segmento fixo
+ * `api` da JSON API (`{prefix}/api/*`): ele segue o prefixo mas nunca é
+ * traduzido — é contrato de máquina (authkit-react), não de humano.
+ */
+/** Prefixo default do console de conta. */
+const DEFAULT_ACCOUNT_PREFIX = '/account';
+/**
+ * Segmentos default de cada TELA navegável do console de conta. A chave é o
+ * identificador estável usado no código (`accountPath('security')`); o valor é
+ * o segmento de URL, sobrescrevível por `setAccountPaths`.
+ */
+const DEFAULT_ACCOUNT_SEGMENTS = {
+    login: 'login',
+    logout: 'logout',
+    security: 'security',
+    mfa: 'mfa',
+    confirm: 'confirm',
+    tokens: 'tokens',
+    apps: 'apps',
+    orgs: 'orgs',
+    emailConfirm: 'email/confirm',
+};
+let _prefix = DEFAULT_ACCOUNT_PREFIX;
+let _segments = { ...DEFAULT_ACCOUNT_SEGMENTS };
+/**
+ * Normaliza o prefixo: começa com '/', sem trailing slash. Mesma semântica de
+ * `normalizeAdminPrefix`. `'/'` → `'/'` (raiz) é improvável mas seguro.
+ */
+export function normalizeAccountPrefix(raw) {
+    let p = raw.trim();
+    if (!p.startsWith('/'))
+        p = `/${p}`;
+    p = p.replace(/\/+$/, '');
+    return p || '/';
+}
+/**
+ * Normaliza um segmento de tela: sem barras nas pontas (mas preserva barras
+ * internas, ex.: `'email/confirm'`). Valor vazio é ignorado pelo caller.
+ */
+function normalizeSegment(raw) {
+    return raw.trim().replace(/^\/+/, '').replace(/\/+$/, '');
+}
+/**
+ * Define o prefixo e/ou os segmentos de tela do console de conta para este
+ * processo. Chamado UMA VEZ por `registerAuthHost` no boot da aplicação.
+ *
+ * Só sobrescreve o que foi passado — chamada sem `prefix` mantém o prefixo
+ * atual, e segmentos ausentes de `paths` mantêm o default. Valores
+ * vazios/whitespace são ignorados (caem no default), nunca produzem um path
+ * quebrado.
+ *
+ * @example
+ * setAccountPaths({ prefix: '/conta', paths: { security: 'seguranca', confirm: 'confirmar' } })
+ * accountPath('security') // → '/conta/seguranca'
+ * accountPath('confirm')  // → '/conta/confirmar'
+ */
+export function setAccountPaths(opts) {
+    if (!opts)
+        return;
+    if (opts.prefix !== undefined) {
+        const trimmed = opts.prefix.trim();
+        if (trimmed)
+            _prefix = normalizeAccountPrefix(trimmed);
+    }
+    if (opts.paths) {
+        for (const key of Object.keys(opts.paths)) {
+            const value = opts.paths[key];
+            if (value === undefined)
+                continue;
+            const seg = normalizeSegment(value);
+            if (seg)
+                _segments[key] = seg;
+        }
+    }
+}
+/**
+ * Junta o prefixo do console de conta com um subpath arbitrário, tratando o
+ * prefixo raiz (`'/'`) como `''` na composição: sem isso o resultado seria
+ * `'//<sub>'`, que num `<form action>`/`fetch()` é URL protocol-relative (o
+ * browser lê `<sub>` como HOST, não como path).
+ *
+ * Base canônica de `accountPath()` e de QUALQUER outra composição
+ * prefixo+subpath fora das TELAS fixas (ex.: o `{prefix}/api` da JSON API em
+ * `register_auth_host`). Novas composições devem passar por aqui em vez de
+ * reimplementar `${accountPrefix()}/algo` — é exatamente essa duplicação que
+ * reproduz o bug do `//` quando o prefixo normaliza pra raiz.
+ *
+ * @example
+ * joinAccountPath('api') // default → '/account/api'
+ */
+export function joinAccountPath(sub) {
+    const base = _prefix === '/' ? '' : _prefix;
+    return `${base}/${sub}`;
+}
+/**
+ * Retorna o path completo de uma TELA do console de conta (prefixo + segmento).
+ * Para os action-subpaths (POSTs de dentro da tela) concatene o subpath fixo:
+ * `accountPath('security') + '/password'`.
+ *
+ * @example
+ * accountPath('security') // default → '/account/security'
+ * accountPath('confirm')  // default → '/account/confirm'
+ */
+export function accountPath(key) {
+    return joinAccountPath(_segments[key]);
+}
+/**
+ * Retorna o prefixo BRUTO do console de conta (default `'/account'`; pode ser
+ * `'/'` na raiz). Para compor `{prefix}/algo` (ex.: a JSON API, cujo segmento
+ * `api` é fixo — contrato de máquina), use `joinAccountPath('algo')`: ela
+ * colapsa a raiz e evita o `//`. Este getter existe para os casos (ex.: os
+ * asserts de teste) que precisam do valor cru do prefixo.
+ */
+export function accountPrefix() {
+    return _prefix;
+}
+/**
+ * Mapa `{ chave → path completo }` de TODAS as telas. Injetado como prop global
+ * `accountPaths` nas views Edge, para que os `<form action>`/`fetch()` respeitem
+ * os overrides sem cada view conhecer o prefixo.
+ */
+export function accountPathsMap() {
+    const out = {};
+    for (const key of Object.keys(_segments)) {
+        out[key] = accountPath(key);
+    }
+    return out;
+}
+/** Restaura os defaults — uso em testes (isola o singleton entre casos). */
+export function resetAccountPaths() {
+    _prefix = DEFAULT_ACCOUNT_PREFIX;
+    _segments = { ...DEFAULT_ACCOUNT_SEGMENTS };
+}

package/build/src/host/admin_api/admin_orgs_service.d.ts

@@ -1,7 +1,7 @@
+import type { OrgInvitation, OrgMember, OrgSummary } from '../../accounts/account_store.js';
 import type { ResolvedServerConfig } from '../../define_config.js';
-import type { OrgSummary, OrgMember, OrgInvitation } from '../../accounts/account_store.js';
-import type { AdminActor } from './admin_users_service.js';
 import type { SettingsCapability } from '../runtime_settings.js';
+import type { AdminActor } from './admin_users_service.js';
 export interface OrgWithMemberCount extends OrgSummary {
     memberCount: number;
 }

package/build/src/host/admin_api/admin_orgs_service.js

@@ -1,5 +1,6 @@
 import { supportsOrganizations } from '../../accounts/account_store.js';
-import { resolveRoleCatalogList, isRoleInCatalog } from '../runtime_toggles.js';
+import { accountPath } from '../account_paths.js';
+import { isRoleInCatalog, resolveRoleCatalogList } from '../runtime_toggles.js';
 /**
  * Lógica de gestão de organizações compartilhada entre o console admin (HTML)
  * e a Admin REST API (JSON). Usada pelos `AdminOrgsController` e `ApiOrgsController`.
@@ -267,7 +268,7 @@ export class AdminOrgsService {
         });
         // Dispara mail hook (best-effort)
         if (this.cfg.mail?.onOrgInvitation) {
-            const acceptUrl = `${origin}/account/orgs/invitations/${token}/accept`;
+            const acceptUrl = `${origin}${accountPath('orgs')}/invitations/${token}/accept`;
             try {
                 await this.cfg.mail.onOrgInvitation({
                     email: input.email,

package/build/src/host/admin_api/admin_users_service.d.ts

@@ -1,20 +1,20 @@
-import type { HttpContext } from "@adonisjs/core/http";
-import type { ResolvedServerConfig } from "../../define_config.js";
-import type { OidcService } from "../../provider/oidc_service.js";
-import type { AuthAccount } from "../../accounts/account_store.js";
-import { type DeletionResult } from "../account_deletion_service.js";
-import type { SettingsCapability } from "../runtime_settings.js";
+import type { HttpContext } from '@adonisjs/core/http';
+import type { AuthAccount } from '../../accounts/account_store.js';
+import type { ResolvedServerConfig } from '../../define_config.js';
+import type { OidcService } from '../../provider/oidc_service.js';
+import { type DeletionResult } from '../account_deletion_service.js';
+import type { SettingsCapability } from '../runtime_settings.js';
 /** Quem disparou a operação (para auditoria). `admin-api` quando via REST API. */
 export interface AdminActor {
     actorId: string | null;
     ip: string | null;
     /** Marca metadata da auditoria — 'admin-api' nas escritas via REST, 'admin' no console HTML. */
-    source?: "admin-api" | "admin";
+    source?: 'admin-api' | 'admin';
 }
 /** Resultado da deleção via admin: false quando o store não suporta hard delete. */
 export type DeleteUserResult = {
     ok: false;
-    reason: "not_found" | "unsupported";
+    reason: 'not_found' | 'unsupported';
 } | {
     ok: true;
     result: DeletionResult;
@@ -34,7 +34,7 @@ export type EnqueueDeletion = (input: {
     actor: {
         actorId: string | null;
         ip: string | null;
-        source: "admin" | "admin-api";
+        source: 'admin' | 'admin-api';
     };
 }) => Promise<string>;
 export interface CreateUserInput {
@@ -50,10 +50,10 @@ export type CreateUserResult = {
     invited: boolean;
 } | {
     ok: false;
-    reason: "email_taken";
+    reason: 'email_taken';
 } | {
     ok: false;
-    reason: "password_policy";
+    reason: 'password_policy';
     /** Chave i18n da regra violada + params para interpolar. */
     messageKey: string;
     messageParams?: Record<string, string | number>;
@@ -141,7 +141,7 @@ export declare class AdminUsersService {
      *
      * @returns código i18n/erro quando a operação deve ser bloqueada; `null` quando OK.
      */
-    guardGlobalRolesChange(targetId: string, newRoles: string[], actorId: string | null): Promise<"last_admin" | "cannot_self_demote" | null>;
+    guardGlobalRolesChange(targetId: string, newRoles: string[], actorId: string | null): Promise<'last_admin' | 'cannot_self_demote' | null>;
     /** Atualiza nome/avatar (capacidade opcional). Retorna a conta ou null. */
     updateProfile(accountId: string, patch: {
         name?: string | null;

package/build/src/host/admin_api/admin_users_service.js

@@ -1,9 +1,9 @@
-import { randomBytes } from "node:crypto";
-import { supportsAccountDeletion, supportsAccountStatus, supportsProfile, supportsCountByGlobalRole, } from "../../accounts/account_store.js";
-import { sendPasswordResetEmail } from "../default_mailer.js";
-import { AccountDeletionService, } from "../account_deletion_service.js";
-import { PasswordPolicyError } from "../../password/password_manager.js";
-import { resolveEffectiveRolesCatalog } from "../runtime_toggles.js";
+import { randomBytes } from 'node:crypto';
+import { supportsAccountDeletion, supportsAccountStatus, supportsCountByGlobalRole, supportsProfile, } from '../../accounts/account_store.js';
+import { PasswordPolicyError } from '../../password/password_manager.js';
+import { AccountDeletionService } from '../account_deletion_service.js';
+import { sendPasswordResetEmail } from '../default_mailer.js';
+import { resolveEffectiveRolesCatalog } from '../runtime_toggles.js';
 /**
  * Lógica de gestão de usuários compartilhada entre o console admin (B6, HTML) e a
  * Admin REST API (R6, JSON). Encapsula o fluxo "create + invite", reset de senha,
@@ -24,9 +24,9 @@ export class AdminUsersService {
         const store = this.cfg.accountStore;
         const existing = await store.findByEmail(input.email);
         if (existing)
-            return { ok: false, reason: "email_taken" };
+            return { ok: false, reason: 'email_taken' };
         const hasPassword = !!input.password;
-        const initialPassword = input.password ?? randomBytes(24).toString("hex");
+        const initialPassword = input.password ?? randomBytes(24).toString('hex');
         let account;
         try {
             account = await store.create({
@@ -40,7 +40,7 @@ export class AdminUsersService {
             if (error instanceof PasswordPolicyError) {
                 return {
                     ok: false,
-                    reason: "password_policy",
+                    reason: 'password_policy',
                     messageKey: error.key,
                     messageParams: error.params,
                 };
@@ -48,7 +48,7 @@ export class AdminUsersService {
             throw error;
         }
         await this.cfg.audit?.record({
-            type: "user.created",
+            type: 'user.created',
             accountId: account.id,
             email: input.email,
             actorId: actor.actorId,
@@ -70,7 +70,7 @@ export class AdminUsersService {
             return null;
         await this.sendResetEmail(ctx, account.email);
         await this.cfg.audit?.record({
-            type: "user.password_reset_sent",
+            type: 'user.password_reset_sent',
             accountId,
             email: account.email,
             actorId: actor.actorId,
@@ -92,7 +92,7 @@ export class AdminUsersService {
         else
             await store.enableAccount(accountId);
         await this.cfg.audit?.record({
-            type: disable ? "user.disabled" : "user.enabled",
+            type: disable ? 'user.disabled' : 'user.enabled',
             accountId,
             actorId: actor.actorId,
             ip: actor.ip,
@@ -123,7 +123,7 @@ export class AdminUsersService {
             // Roles que o usuário não tinha E que não estão no catálogo = inválidas.
             for (const role of roles) {
                 if (!catalogNames.has(role) && !currentRoles.has(role)) {
-                    return "admin.roles.unknown_role";
+                    return 'admin.roles.unknown_role';
                 }
             }
         }
@@ -137,7 +137,7 @@ export class AdminUsersService {
     /** Roles globais que conferem acesso de admin (default ['ADMIN']). */
     adminRoles() {
         const roles = this.cfg.admin?.roles;
-        return roles && roles.length > 0 ? roles : ["ADMIN"];
+        return roles && roles.length > 0 ? roles : ['ADMIN'];
     }
     /** Um conjunto de roles contém ao menos uma role de admin? */
     hasAdminRole(roles) {
@@ -226,11 +226,11 @@ export class AdminUsersService {
             return null;
         // Auto-rebaixamento: o ator removendo a própria role de admin.
         if (actorId && actorId === targetId)
-            return "cannot_self_demote";
+            return 'cannot_self_demote';
         // Último admin: se o target é o único admin, a remoção causaria lockout.
         const admins = await this.countAdmins();
         if (admins <= 1)
-            return "last_admin";
+            return 'last_admin';
         return null;
     }
     /** Atualiza nome/avatar (capacidade opcional). Retorna a conta ou null. */
@@ -251,15 +251,15 @@ export class AdminUsersService {
     async delete(oidc, accountId, actor, enqueue) {
         const store = this.cfg.accountStore;
         if (!supportsAccountDeletion(store))
-            return { ok: false, reason: "unsupported" };
+            return { ok: false, reason: 'unsupported' };
         const account = await store.findById(accountId);
         if (!account)
-            return { ok: false, reason: "not_found" };
-        const source = actor.source === "admin" ? "admin" : "admin-api";
+            return { ok: false, reason: 'not_found' };
+        const source = actor.source === 'admin' ? 'admin' : 'admin-api';
         // Trilha administrativa ANTES do cascade — assim esta linha também é
         // anonimizada na etapa de anonimização do audit (não reintroduz PII).
         await this.cfg.audit?.record({
-            type: "user.deleted",
+            type: 'user.deleted',
             accountId,
             email: account.email,
             actorId: actor.actorId,

package/build/src/host/admin_api/api_clients_controller.js

@@ -1,7 +1,7 @@
 import '../augmentations.js';
 import { AdminClientsService } from '../admin_clients_service.js';
-import { clientDto, createdClientDto, apiError } from './dto.js';
-import { clientInputValidator, clientCreateInput, clientPartialInput } from '../admin_validators.js';
+import { clientCreateInput, clientInputValidator, clientPartialInput, } from '../admin_validators.js';
+import { apiError, clientDto, createdClientDto } from './dto.js';
 /** Resolve o serviço (== OidcService) + o AdminClientsService. */
 async function clientsService(ctx) {
     const service = await ctx.containerResolver.make('authkit.server');

package/build/src/host/admin_api/api_misc_controller.js

@@ -1,9 +1,9 @@
 import '../augmentations.js';
-import { TokenVerifyService } from './token_verify_service.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { computeAdminStats } from '../admin_stats_service.js';
-import { auditDto, apiError } from './dto.js';
 import { tokenVerifyValidator } from '../admin_validators.js';
+import { apiError, auditDto } from './dto.js';
+import { TokenVerifyService } from './token_verify_service.js';
 /**
  * Endpoints utilitários da Admin REST API: log de auditoria (`GET /audit`) e
  * introspecção genérica de token (`POST /tokens/verify`).

package/build/src/host/admin_api/api_orgs_controller.js

@@ -1,8 +1,8 @@
 import '../augmentations.js';
-import { AdminOrgsService } from './admin_orgs_service.js';
-import { orgDto, orgDetailDto, orgInvitationDto, apiError } from './dto.js';
+import { orgAddMemberValidator, orgCreateValidator, orgInvitationValidator, orgMemberRoleValidator, orgUpdateValidator, } from '../admin_validators.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
-import { orgCreateValidator, orgUpdateValidator, orgAddMemberValidator, orgMemberRoleValidator, orgInvitationValidator, } from '../admin_validators.js';
+import { AdminOrgsService } from './admin_orgs_service.js';
+import { apiError, orgDetailDto, orgDto, orgInvitationDto } from './dto.js';
 /** Lê a config + monta o actor `admin-api` para auditoria. */
 async function ctxBits(ctx) {
     const service = await ctx.containerResolver.make('authkit.server');

package/build/src/host/admin_api/api_settings_controller.js

@@ -1,7 +1,7 @@
 import '../augmentations.js';
+import { SettingLockedError, isSettingLocked, lockedSettingKeys } from '../config_locks.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
-import { settingDto, apiError } from './dto.js';
-import { isSettingLocked, lockedSettingKeys, SettingLockedError } from '../config_locks.js';
+import { apiError, settingDto } from './dto.js';
 /** 423 Locked: a setting foi travada via defineConfig (não editável em runtime). */
 function lockedResponse(ctx, err) {
     return ctx.response
@@ -16,8 +16,8 @@ function notSupported(ctx) {
 function resolveOrgId(ctx) {
     const qs = ctx.request.qs();
     if ('organizationId' in qs) {
-        const v = qs['organizationId'];
-        return v && v.trim() ? v.trim() : null;
+        const v = qs.organizationId;
+        return v?.trim() ? v.trim() : null;
     }
     return null;
 }
@@ -99,7 +99,13 @@ export default class ApiSettingsController {
             metadata: { key, value: body.value, organizationId: orgId },
         });
         const saved = await svc.getSetting(key, orgId);
-        return settingDto({ key, organizationId: orgId, value: saved, updatedAt: new Date(), updatedBy: null });
+        return settingDto({
+            key,
+            organizationId: orgId,
+            value: saved,
+            updatedAt: new Date(),
+            updatedBy: null,
+        });
     }
     /** DELETE /settings/:key */
     async destroy(ctx) {

package/build/src/host/admin_api/api_users_controller.d.ts

@@ -1,5 +1,5 @@
-import "../augmentations.js";
-import type { HttpContext } from "@adonisjs/core/http";
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
 /**
  * Recurso de usuários da Admin REST API (R6). JSON puro (camelCase), erros no
  * envelope `{ error: { code, message } }`. Toda escrita audita com `actor: 'admin-api'`.

package/build/src/host/admin_api/api_users_controller.js

@@ -1,10 +1,10 @@
-import "../augmentations.js";
-import { AdminUsersService } from "./admin_users_service.js";
-import { AdminSessionsService } from "../admin_sessions_service.js";
-import { enrichSessionsWithContext } from "../session_context.js";
-import { resolveRuntimeSettings } from "../runtime_settings.js";
-import { userDto, sessionDto, grantDto, apiError } from "./dto.js";
-import { adminUserCreateValidator, adminUserUpdateValidator, } from "../admin_validators.js";
+import '../augmentations.js';
+import { AdminSessionsService } from '../admin_sessions_service.js';
+import { adminUserCreateValidator, adminUserUpdateValidator } from '../admin_validators.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { enrichSessionsWithContext } from '../session_context.js';
+import { AdminUsersService } from './admin_users_service.js';
+import { apiError, grantDto, sessionDto, userDto } from './dto.js';
 const PAGE_SIZE = 20;
 /**
  * Lê a config + monta o actor `admin-api` para auditoria. O `actorId` recebe o
@@ -13,12 +13,12 @@ const PAGE_SIZE = 20;
  * vazar o segredo. `null` apenas se a guard não anexou (defensivo).
  */
 async function ctxBits(ctx) {
-    const service = await ctx.containerResolver.make("authkit.server");
+    const service = await ctx.containerResolver.make('authkit.server');
     const cfg = service.config;
     const actor = {
         actorId: ctx.adminApiKeyId ?? null,
         ip: ctx.request.ip?.() ?? null,
-        source: "admin-api",
+        source: 'admin-api',
     };
     return { service, cfg, actor };
 }
@@ -30,10 +30,9 @@ export default class ApiUsersController {
     /** GET /users — listagem paginada com busca por e-mail. */
     async index(ctx) {
         const { cfg } = await ctxBits(ctx);
-        const search = ctx.request.input("search", "").trim();
-        const page = Math.max(1, Number.parseInt(ctx.request.input("page", "1"), 10) || 1);
-        const limit = Math.max(1, Math.min(100, Number.parseInt(ctx.request.input("limit", String(PAGE_SIZE)), 10) ||
-            PAGE_SIZE));
+        const search = ctx.request.input('search', '').trim();
+        const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
+        const limit = Math.max(1, Math.min(100, Number.parseInt(ctx.request.input('limit', String(PAGE_SIZE)), 10) || PAGE_SIZE));
         const result = await cfg.accountStore.listAccounts({ search, page, limit });
         const users = new AdminUsersService(cfg);
         const data = await Promise.all(result.data.map(async (u) => userDto(u, await users.isDisabled(u.id))));
@@ -42,10 +41,10 @@ export default class ApiUsersController {
     /** GET /users/:id */
     async show(ctx) {
         const { cfg } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await cfg.accountStore.findById(id);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         const disabled = await new AdminUsersService(cfg).isDisabled(id);
         return userDto(account, disabled);
     }
@@ -61,10 +60,10 @@ export default class ApiUsersController {
             invite: invite ?? false,
         }, actor);
         if (!result.ok) {
-            if (result.reason === "password_policy") {
-                return ctx.response.badRequest(apiError("password_policy", cfg.messages[result.messageKey] ?? result.messageKey));
+            if (result.reason === 'password_policy') {
+                return ctx.response.badRequest(apiError('password_policy', cfg.messages[result.messageKey] ?? result.messageKey));
             }
-            return ctx.response.conflict(apiError("email_taken", "Já existe uma conta com este e-mail."));
+            return ctx.response.conflict(apiError('email_taken', 'Já existe uma conta com este e-mail.'));
         }
         ctx.response.status(201);
         return { ...userDto(result.account), invited: result.invited };
@@ -72,10 +71,10 @@ export default class ApiUsersController {
     /** PATCH /users/:id — { globalRoles?, name?, avatarUrl? }. */
     async update(ctx) {
         const { cfg, actor } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await cfg.accountStore.findById(id);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         const users = new AdminUsersService(cfg);
         const { globalRoles: roles, name, avatarUrl, } = await ctx.request.validateUsing(adminUserUpdateValidator);
         if (Array.isArray(roles)) {
@@ -83,11 +82,11 @@ export default class ApiUsersController {
             // Proteções de escalonamento/lockout: último admin + auto-rebaixamento.
             // O actorId vem do id da API key (M9); self-demote só aplica se identificável.
             const guard = await users.guardGlobalRolesChange(id, normalized, actor.actorId);
-            if (guard === "last_admin") {
-                return ctx.response.conflict(apiError("last_admin", "Não é possível remover a última conta com a role de administrador."));
+            if (guard === 'last_admin') {
+                return ctx.response.conflict(apiError('last_admin', 'Não é possível remover a última conta com a role de administrador.'));
             }
-            if (guard === "cannot_self_demote") {
-                return ctx.response.conflict(apiError("cannot_self_demote", "Você não pode remover a sua própria role de administrador."));
+            if (guard === 'cannot_self_demote') {
+                return ctx.response.conflict(apiError('cannot_self_demote', 'Você não pode remover a sua própria role de administrador.'));
             }
             // Valida contra o catálogo (mesmo caminho do console) — roles fora do
             // catálogo (e que o usuário não tinha) → 422.
@@ -96,7 +95,7 @@ export default class ApiUsersController {
             if (errorKey) {
                 return ctx.response
                     .status(422)
-                    .send(apiError("invalid_role", cfg.messages[errorKey] ?? errorKey));
+                    .send(apiError('invalid_role', cfg.messages[errorKey] ?? errorKey));
             }
         }
         if (name !== undefined || avatarUrl !== undefined) {
@@ -113,20 +112,20 @@ export default class ApiUsersController {
     /** DELETE /users/:id — deleção completa (cascade) da conta. */
     async destroy(ctx) {
         const { service, cfg, actor } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         // OPT-IN durável: passa o enqueue (cascade async); senão delete() roda síncrono.
         const enqueue = cfg.accountLifecycle?.durable
-            ? (await import("../durable/index.js")).enqueueDeletionVia(ctx.containerResolver)
+            ? (await import('../durable/index.js')).enqueueDeletionVia(ctx.containerResolver)
             : undefined;
         const outcome = await new AdminUsersService(cfg).delete(service, id, actor, enqueue);
         if (!outcome.ok) {
-            if (outcome.reason === "not_found") {
-                return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            if (outcome.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
             }
-            return ctx.response.conflict(apiError("capability_unsupported", "O store de contas não suporta deletar usuários."));
+            return ctx.response.conflict(apiError('capability_unsupported', 'O store de contas não suporta deletar usuários.'));
         }
         // Modo durável: a deleção foi ENFILEIRADA (cascade async) — responde 202-style.
-        if ("enqueued" in outcome) {
+        if ('enqueued' in outcome) {
             return { id, deleted: true, enqueued: true, runId: outcome.runId };
         }
         return { id, deleted: true, ...outcome.result };
@@ -141,26 +140,26 @@ export default class ApiUsersController {
     }
     async #setStatus(ctx, disable) {
         const { cfg, actor } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const applied = await new AdminUsersService(cfg).setStatus(id, disable, actor);
         if (!applied) {
-            return ctx.response.conflict(apiError("capability_unsupported", "O store de contas não suporta habilitar/desabilitar."));
+            return ctx.response.conflict(apiError('capability_unsupported', 'O store de contas não suporta habilitar/desabilitar.'));
         }
         return { id, disabled: disable };
     }
     /** POST /users/:id/reset-password — envia o e-mail de reset. */
     async resetPassword(ctx) {
         const { cfg, actor } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await new AdminUsersService(cfg).resetPassword(ctx, id, actor);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         return { id, sent: true };
     }
     /** GET /users/:id/sessions — sessões (enriquecidas com contexto) + grants ativos. */
     async sessions(ctx) {
         const { service, cfg } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const admin = new AdminSessionsService(service);
         const sessions = await enrichSessionsWithContext(cfg, id, await admin.listSessions(id));
         const grants = await admin.listGrants(id);
@@ -173,10 +172,10 @@ export default class ApiUsersController {
     /** POST /users/:id/revoke-sessions — revoga todas as sessões/grants. */
     async revokeSessions(ctx) {
         const { service, cfg, actor } = await ctxBits(ctx);
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const result = await new AdminSessionsService(service).revokeAll(id);
         await cfg.audit?.record({
-            type: "session.revoked_all",
+            type: 'session.revoked_all',
             accountId: id,
             actorId: actor.actorId,
             ip: actor.ip,

package/build/src/host/admin_api/dto.d.ts

@@ -1,9 +1,9 @@
 import type { AuthAccount } from '../../accounts/account_store.js';
-import type { OrgSummary, OrgMember, OrgInvitation } from '../../accounts/account_store.js';
-import type { OrgDetail } from './admin_orgs_service.js';
-import type { AdminClient, CreatedClient } from '../admin_clients_service.js';
-import type { AdminSession, AdminGrant } from '../admin_sessions_service.js';
+import type { OrgInvitation, OrgMember, OrgSummary } from '../../accounts/account_store.js';
 import type { StoredAuditEvent } from '../../audit/audit_sink.js';
+import type { AdminClient, CreatedClient } from '../admin_clients_service.js';
+import type { AdminGrant, AdminSession } from '../admin_sessions_service.js';
+import type { OrgDetail } from './admin_orgs_service.js';
 /** Projeta uma conta para a forma JSON (camelCase) da Admin REST API. */
 export declare function userDto(account: AuthAccount, disabled?: boolean): {
     id: string;