@adonis-agora/authkit-server 0.34.0

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

@@ -0,0 +1,80 @@
+import type { OidcService } from "../provider/oidc_service.js";
+import type { ResolvedServerConfig } from "../define_config.js";
+import type { AuthAccount } from "../accounts/account_store.js";
+import type { DeletionActor } from "./account_deletion_service.js";
+/**
+ * As 9 etapas do cascade de deleção de conta (LGPD/GDPR) extraídas em operações
+ * DISCRETAS e IDEMPOTENTES. Cada uma é chamável individualmente — re-executar uma
+ * etapa já concluída é um no-op seguro (o artefato já não existe / já está
+ * anonimizado). Isto permite que:
+ *
+ *   - o {@link AccountDeletionService} síncrono as chame em sequência, na MESMA
+ *     ordem e com a MESMA semântica best-effort de sempre (caminho inalterado);
+ *   - o workflow durável (subpath `/durable`) envolva cada etapa em um `ctx.step`,
+ *     ganhando retry por-etapa + resumabilidade SEM duplicar a lógica de negócio.
+ *
+ * Cada operação retorna o "delta" que produz; o caller acumula no
+ * {@link DeletionResult}. Nenhuma operação lança em condições esperadas — o
+ * tratamento best-effort (try/catch) é responsabilidade do caller, para manter o
+ * comportamento síncrono byte-idêntico ao original.
+ */
+/** Snapshot mínimo da conta capturado ANTES da destruição (e-mail + avatar). */
+export interface AccountSnapshot {
+    id: string;
+    email: string;
+    avatarUrl: string | null;
+}
+/**
+ * Carrega o snapshot da conta. Retorna null se a conta não existe (ou já foi
+ * deletada) — idempotente: re-executar após a deleção da linha devolve null.
+ */
+export declare function snapshotAccount(cfg: ResolvedServerConfig, accountId: string): Promise<AccountSnapshot | null>;
+/**
+ * 1) Emite o audit `account.deleted` ANTES de qualquer destruição, com os
+ * identificadores reais. Idempotente o suficiente: re-emitir registra uma segunda
+ * linha (que também será anonimizada) — inofensivo para a trilha de auditoria.
+ */
+export declare function auditDeleted(cfg: ResolvedServerConfig, snapshot: AccountSnapshot, actor: DeletionActor): Promise<void>;
+/** 2) Revoga TODAS as sessões + grants do oidc-provider (cascateia os tokens). */
+export declare function revokeSessions(oidc: OidcService, accountId: string): Promise<{
+    sessions: number;
+    grants: number;
+    accessTokens: number;
+    refreshTokens: number;
+}>;
+/** 3) Revoga todos os Personal Access Tokens da conta (quando há patStore). */
+export declare function revokePats(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    pats: number;
+}>;
+/** 4) Remove todas as passkeys / credenciais WebAuthn (capability-probed). */
+export declare function removePasskeys(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    passkeys: number;
+}>;
+/** 5) Desliga o MFA (limpa segredo TOTP + recovery codes) (capability-probed). */
+export declare function disableMfa(cfg: ResolvedServerConfig, accountId: string): Promise<void>;
+/** 6) Desliga as identidades de provider linkadas (capability-probed). */
+export declare function unlinkProviders(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    providerIdentities: number;
+}>;
+/** 6b) Remove memberships + convites de organizations (capability-probed). */
+export declare function removeFromOrgs(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    orgMemberships: number;
+    orgInvitations: number;
+}>;
+/** 7) Apaga o avatar no drive (best-effort, fail-safe). */
+export declare function deleteAccountAvatar(cfg: ResolvedServerConfig, avatarUrl: string | null): Promise<{
+    avatarDeleted: boolean;
+}>;
+/** 8) Anonimiza o histórico de audit da conta (quando o sink suporta). */
+export declare function anonymizeAudit(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    auditAnonymized: number;
+}>;
+/**
+ * 9) Deleta a linha da conta — a ÚLTIMA etapa (forward-only). Idempotente:
+ * re-executar após a linha já ter sido deletada devolve `false` (sem efeito).
+ */
+export declare function deleteAccountRow(cfg: ResolvedServerConfig, accountId: string): Promise<{
+    ok: boolean;
+}>;
+/** Re-export do tipo usado pelos JSDoc acima, p/ conveniência dos consumidores. */
+export type { AuthAccount };

package/build/src/host/account_deletion_ops.js

@@ -0,0 +1,118 @@
+import { supportsAccountDeletion, supportsMfa, supportsOrganizations, supportsPasskeys, supportsProviderIdentity, } from "../accounts/account_store.js";
+import { AdminSessionsService } from "./admin_sessions_service.js";
+import { deleteAvatar } from "./avatar_storage.js";
+/**
+ * Carrega o snapshot da conta. Retorna null se a conta não existe (ou já foi
+ * deletada) — idempotente: re-executar após a deleção da linha devolve null.
+ */
+export async function snapshotAccount(cfg, accountId) {
+    const account = await cfg.accountStore.findById(accountId);
+    if (!account)
+        return null;
+    return {
+        id: account.id,
+        email: account.email,
+        avatarUrl: account.avatarUrl ?? null,
+    };
+}
+/**
+ * 1) Emite o audit `account.deleted` ANTES de qualquer destruição, com os
+ * identificadores reais. Idempotente o suficiente: re-emitir registra uma segunda
+ * linha (que também será anonimizada) — inofensivo para a trilha de auditoria.
+ */
+export async function auditDeleted(cfg, snapshot, actor) {
+    await cfg.audit?.record({
+        type: "account.deleted",
+        accountId: snapshot.id,
+        email: snapshot.email,
+        actorId: actor.actorId,
+        ip: actor.ip,
+        metadata: { actor: actor.source },
+    });
+}
+/** 2) Revoga TODAS as sessões + grants do oidc-provider (cascateia os tokens). */
+export async function revokeSessions(oidc, accountId) {
+    const revoke = await new AdminSessionsService(oidc).revokeAll(accountId);
+    return {
+        sessions: revoke.sessions,
+        grants: revoke.grants,
+        accessTokens: revoke.accessTokens,
+        refreshTokens: revoke.refreshTokens,
+    };
+}
+/** 3) Revoga todos os Personal Access Tokens da conta (quando há patStore). */
+export async function revokePats(cfg, accountId) {
+    if (!cfg.patStore)
+        return { pats: 0 };
+    let pats = 0;
+    const list = await cfg.patStore.listForAccount(accountId);
+    for (const pat of list) {
+        const ok = await cfg.patStore.revoke(accountId, pat.id);
+        if (ok)
+            pats++;
+    }
+    return { pats };
+}
+/** 4) Remove todas as passkeys / credenciais WebAuthn (capability-probed). */
+export async function removePasskeys(cfg, accountId) {
+    const store = cfg.accountStore;
+    if (!supportsPasskeys(store))
+        return { passkeys: 0 };
+    let passkeys = 0;
+    const list = await store.listPasskeys(accountId);
+    for (const pk of list) {
+        await store.removePasskey(accountId, pk.id);
+        passkeys++;
+    }
+    return { passkeys };
+}
+/** 5) Desliga o MFA (limpa segredo TOTP + recovery codes) (capability-probed). */
+export async function disableMfa(cfg, accountId) {
+    const store = cfg.accountStore;
+    if (!supportsMfa(store))
+        return;
+    await store.disableMfa(accountId);
+}
+/** 6) Desliga as identidades de provider linkadas (capability-probed). */
+export async function unlinkProviders(cfg, accountId) {
+    const store = cfg.accountStore;
+    if (!supportsProviderIdentity(store))
+        return { providerIdentities: 0 };
+    const providerIdentities = await store.unlinkAllProviderIdentities(accountId);
+    return { providerIdentities };
+}
+/** 6b) Remove memberships + convites de organizations (capability-probed). */
+export async function removeFromOrgs(cfg, accountId) {
+    const store = cfg.accountStore;
+    if (!supportsOrganizations(store))
+        return { orgMemberships: 0, orgInvitations: 0 };
+    const orgResult = await store.removeAccountFromAllOrgs(accountId);
+    return {
+        orgMemberships: orgResult.memberships,
+        orgInvitations: orgResult.invitations,
+    };
+}
+/** 7) Apaga o avatar no drive (best-effort, fail-safe). */
+export async function deleteAccountAvatar(cfg, avatarUrl) {
+    const avatarDeleted = await deleteAvatar(cfg.uploads, avatarUrl);
+    return { avatarDeleted };
+}
+/** 8) Anonimiza o histórico de audit da conta (quando o sink suporta). */
+export async function anonymizeAudit(cfg, accountId) {
+    if (cfg.audit && typeof cfg.audit.anonymizeAccount === "function") {
+        const auditAnonymized = await cfg.audit.anonymizeAccount(accountId);
+        return { auditAnonymized };
+    }
+    return { auditAnonymized: 0 };
+}
+/**
+ * 9) Deleta a linha da conta — a ÚLTIMA etapa (forward-only). Idempotente:
+ * re-executar após a linha já ter sido deletada devolve `false` (sem efeito).
+ */
+export async function deleteAccountRow(cfg, accountId) {
+    const store = cfg.accountStore;
+    if (!supportsAccountDeletion(store))
+        return { ok: false };
+    const ok = await store.deleteAccount(accountId);
+    return { ok };
+}

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

@@ -0,0 +1,63 @@
+import type { OidcService } from "../provider/oidc_service.js";
+/** Quem disparou a deleção (auditoria). 'self' = o próprio usuário; senão admin. */
+export interface DeletionActor {
+    /** Id de quem agiu: o próprio user (self-service) ou o admin. null para admin-api. */
+    actorId: string | null;
+    /** IP da request, quando disponível. */
+    ip: string | null;
+    /**
+     * Origem da deleção (vai no metadata do audit):
+     *   - 'self'      → o próprio usuário no console de conta;
+     *   - 'admin'     → um admin pelo console HTML;
+     *   - 'admin-api' → via Admin REST API / SDK.
+     */
+    source: "self" | "admin" | "admin-api";
+}
+/** Contagens do que foi removido no cascade (para auditoria/diagnóstico). */
+export interface DeletionResult {
+    ok: boolean;
+    sessions: number;
+    grants: number;
+    accessTokens: number;
+    refreshTokens: number;
+    pats: number;
+    passkeys: number;
+    providerIdentities: number;
+    /** Linhas de audit anonimizadas (não deletadas). */
+    auditAnonymized: number;
+    /** Avatar removido do drive (best-effort). */
+    avatarDeleted: boolean;
+    /** Memberships em organizations removidas. */
+    orgMemberships: number;
+    /** Convites pendentes de organizations removidos. */
+    orgInvitations: number;
+}
+/**
+ * Orquestra a deleção COMPLETA de uma conta (LGPD/GDPR — "direito ao
+ * esquecimento"), compartilhada entre o self-service (console de conta) e o admin
+ * (console HTML + Admin REST API + SDK embedded). O cascade, na ordem:
+ *
+ *   1. emite o audit `account.deleted` ANTES de qualquer destruição (com o ator
+ *      correto), para que o evento exista com os identificadores reais;
+ *   2. revoga TODAS as sessões + grants do oidc-provider (cascateia os tokens);
+ *   3. revoga todos os Personal Access Tokens da conta (quando há patStore);
+ *   4. remove todas as passkeys / credenciais WebAuthn (capability-probed);
+ *   5. desliga o MFA (limpa segredo TOTP + recovery codes) (capability-probed);
+ *   6. desliga as identidades de provider linkadas (capability-probed);
+ *   7. apaga o avatar no drive (best-effort, fail-safe);
+ *   8. ANONIMIZA o histórico de audit da conta (mantém as linhas, remove os
+ *      identificadores pessoais) — só quando o sink suporta `anonymizeAccount`;
+ *   9. deleta a linha da conta (capability-probed: {@link AccountDeletionCapability}).
+ *
+ * Capability-probed: se o store não suporta delete, `delete()` retorna
+ * `{ ok: false }` e nada é destruído (a UI/admin não deve sequer oferecer a ação).
+ * Cada etapa é isolada (best-effort) — uma falha não impede as demais nem a
+ * destruição final da conta.
+ */
+export declare class AccountDeletionService {
+    #private;
+    constructor(oidc: OidcService);
+    /** Indica se a deleção está disponível (o store suporta hard delete). */
+    get canDelete(): boolean;
+    delete(accountId: string, actor: DeletionActor): Promise<DeletionResult>;
+}

package/build/src/host/account_deletion_service.js

@@ -0,0 +1,133 @@
+import { supportsAccountDeletion } from "../accounts/account_store.js";
+import { anonymizeAudit, auditDeleted, deleteAccountAvatar, deleteAccountRow, disableMfa, removeFromOrgs, removePasskeys, revokePats, revokeSessions, snapshotAccount, unlinkProviders, } from "./account_deletion_ops.js";
+/**
+ * Orquestra a deleção COMPLETA de uma conta (LGPD/GDPR — "direito ao
+ * esquecimento"), compartilhada entre o self-service (console de conta) e o admin
+ * (console HTML + Admin REST API + SDK embedded). O cascade, na ordem:
+ *
+ *   1. emite o audit `account.deleted` ANTES de qualquer destruição (com o ator
+ *      correto), para que o evento exista com os identificadores reais;
+ *   2. revoga TODAS as sessões + grants do oidc-provider (cascateia os tokens);
+ *   3. revoga todos os Personal Access Tokens da conta (quando há patStore);
+ *   4. remove todas as passkeys / credenciais WebAuthn (capability-probed);
+ *   5. desliga o MFA (limpa segredo TOTP + recovery codes) (capability-probed);
+ *   6. desliga as identidades de provider linkadas (capability-probed);
+ *   7. apaga o avatar no drive (best-effort, fail-safe);
+ *   8. ANONIMIZA o histórico de audit da conta (mantém as linhas, remove os
+ *      identificadores pessoais) — só quando o sink suporta `anonymizeAccount`;
+ *   9. deleta a linha da conta (capability-probed: {@link AccountDeletionCapability}).
+ *
+ * Capability-probed: se o store não suporta delete, `delete()` retorna
+ * `{ ok: false }` e nada é destruído (a UI/admin não deve sequer oferecer a ação).
+ * Cada etapa é isolada (best-effort) — uma falha não impede as demais nem a
+ * destruição final da conta.
+ */
+export class AccountDeletionService {
+    #cfg;
+    #oidc;
+    constructor(oidc) {
+        this.#oidc = oidc;
+        this.#cfg = oidc.config;
+    }
+    /** Indica se a deleção está disponível (o store suporta hard delete). */
+    get canDelete() {
+        return supportsAccountDeletion(this.#cfg.accountStore);
+    }
+    async delete(accountId, actor) {
+        const cfg = this.#cfg;
+        const store = cfg.accountStore;
+        const result = {
+            ok: false,
+            sessions: 0,
+            grants: 0,
+            accessTokens: 0,
+            refreshTokens: 0,
+            pats: 0,
+            passkeys: 0,
+            providerIdentities: 0,
+            auditAnonymized: 0,
+            avatarDeleted: false,
+            orgMemberships: 0,
+            orgInvitations: 0,
+        };
+        if (!supportsAccountDeletion(store))
+            return result;
+        // Snapshot da conta ANTES de destruir (precisamos do e-mail/avatar p/ audit + drive).
+        const snapshot = await snapshotAccount(cfg, accountId);
+        if (!snapshot)
+            return result;
+        // O cascade chama as MESMAS operações idempotentes do `account_deletion_ops`,
+        // na MESMA ordem e com a MESMA semântica best-effort (cada etapa isolada). O
+        // workflow durável (subpath `/durable`) envolve estas operações em `ctx.step`.
+        // 1) Audit `account.deleted` ANTES de anonimizar/destruir — registra com os
+        // identificadores reais (a anonimização posterior cuidará desta linha também).
+        await auditDeleted(cfg, snapshot, actor);
+        // 2) Sessões + grants (cascateia os tokens do oidc-provider).
+        try {
+            const revoke = await revokeSessions(this.#oidc, accountId);
+            result.sessions = revoke.sessions;
+            result.grants = revoke.grants;
+            result.accessTokens = revoke.accessTokens;
+            result.refreshTokens = revoke.refreshTokens;
+        }
+        catch {
+            // best-effort: a destruição da conta segue mesmo se a enumeração falhar.
+        }
+        // 3) Personal Access Tokens.
+        try {
+            result.pats = (await revokePats(cfg, accountId)).pats;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 4) Passkeys / credenciais WebAuthn.
+        try {
+            result.passkeys = (await removePasskeys(cfg, accountId)).passkeys;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 5) MFA / TOTP (segredo + recovery codes).
+        try {
+            await disableMfa(cfg, accountId);
+        }
+        catch {
+            /* best-effort */
+        }
+        // 6) Identidades de provider linkadas (Google, GitHub, …).
+        try {
+            result.providerIdentities = (await unlinkProviders(cfg, accountId)).providerIdentities;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 6b) Organizations: remove memberships + convites da conta (best-effort).
+        // Nota: se a conta é o ÚNICO owner de uma org, a org fica sem owner e isso é
+        // documentado no JSDoc — a deleção NUNCA é bloqueada por LGPD/GDPR.
+        try {
+            const orgResult = await removeFromOrgs(cfg, accountId);
+            result.orgMemberships = orgResult.orgMemberships;
+            result.orgInvitations = orgResult.orgInvitations;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 7) Avatar no drive (best-effort, fail-safe).
+        try {
+            result.avatarDeleted = (await deleteAccountAvatar(cfg, snapshot.avatarUrl)).avatarDeleted;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 8) Anonimiza o histórico de audit (mantém as linhas, remove identificadores).
+        try {
+            result.auditAnonymized = (await anonymizeAudit(cfg, accountId)).auditAnonymized;
+        }
+        catch {
+            /* best-effort */
+        }
+        // 9) Deleta a linha da conta.
+        result.ok = (await deleteAccountRow(cfg, accountId)).ok;
+        return result;
+    }
+}

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

@@ -0,0 +1,76 @@
+import type { OidcService } from "../provider/oidc_service.js";
+/** Payload de export de dados de uma conta (portabilidade — LGPD/GDPR). */
+export interface AccountExport {
+    /** Versão do formato do export (para evolução futura). */
+    exportVersion: number;
+    /** Instante do export (ISO 8601). */
+    exportedAt: string;
+    /** Perfil (sem hash de senha nem segredos). */
+    profile: {
+        id: string;
+        email: string;
+        name: string | null;
+        avatarUrl: string | null;
+        globalRoles: string[];
+    };
+    /** Identidades de provider linkadas (SEM tokens). */
+    linkedIdentities: Array<{
+        provider: string;
+        providerUserId: string;
+        email: string | null;
+    }>;
+    /** Apps autorizados (grants), com contagens de tokens vivos — sem material de token. */
+    authorizedApps: Array<{
+        clientId: string | null;
+        accessTokens: number;
+        refreshTokens: number;
+    }>;
+    /** Metadados das sessões ativas (sem material de sessão/cookie). */
+    sessions: Array<{
+        id: string;
+        loginTs: number | null;
+        amr: string[];
+    }>;
+    /** Metadados das passkeys (sem chave pública nem counter). */
+    passkeys: Array<{
+        id: string;
+        label: string | null;
+        createdAt: string;
+    }>;
+    /** Eventos de auditoria do próprio usuário (já anonimizados de IP de terceiros? não — são seus). */
+    auditLog: Array<{
+        type: string;
+        clientId: string | null;
+        ip: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string | null;
+    }>;
+    /** Memberships em organizations (multi-tenancy). */
+    organizations?: Array<{
+        orgId: string;
+        name: string;
+        slug: string;
+        role: string;
+    }>;
+}
+/**
+ * Monta o pacote de dados de uma conta para portabilidade (LGPD/GDPR). NUNCA
+ * inclui segredos: hash de senha, segredo TOTP, recovery codes, chave pública de
+ * passkey, material de sessão/token ou tokens de provider. Tudo que é incluído é
+ * metadado ou dado de perfil que o próprio usuário forneceu.
+ */
+export declare class AccountExportService {
+    #private;
+    constructor(oidc: OidcService);
+    /**
+     * Gera o export, ou null se a conta não existe. Caminho SÍNCRONO de sempre —
+     * apenas delega para {@link collect} (a coleta inline, byte-idêntica ao original).
+     */
+    export(accountId: string): Promise<AccountExport | null>;
+    /**
+     * Coleta + monta o payload de export (a lógica de sempre). Exposta como uma
+     * operação discreta para o workflow durável (`authkit.account.export`) reusar
+     * como um `ctx.step` — read-only, sem efeitos colaterais destrutivos.
+     */
+    collect(accountId: string): Promise<AccountExport | null>;
+}

package/build/src/host/account_export_service.js

@@ -0,0 +1,140 @@
+import { supportsOrganizations, supportsPasskeys, supportsProviderIdentity, } from "../accounts/account_store.js";
+import { AdminSessionsService } from "./admin_sessions_service.js";
+/** Limite de eventos de audit incluídos no export (evita payloads gigantes). */
+const AUDIT_EXPORT_LIMIT = 1000;
+/**
+ * Monta o pacote de dados de uma conta para portabilidade (LGPD/GDPR). NUNCA
+ * inclui segredos: hash de senha, segredo TOTP, recovery codes, chave pública de
+ * passkey, material de sessão/token ou tokens de provider. Tudo que é incluído é
+ * metadado ou dado de perfil que o próprio usuário forneceu.
+ */
+export class AccountExportService {
+    #cfg;
+    #oidc;
+    constructor(oidc) {
+        this.#oidc = oidc;
+        this.#cfg = oidc.config;
+    }
+    /**
+     * Gera o export, ou null se a conta não existe. Caminho SÍNCRONO de sempre —
+     * apenas delega para {@link collect} (a coleta inline, byte-idêntica ao original).
+     */
+    async export(accountId) {
+        return this.collect(accountId);
+    }
+    /**
+     * Coleta + monta o payload de export (a lógica de sempre). Exposta como uma
+     * operação discreta para o workflow durável (`authkit.account.export`) reusar
+     * como um `ctx.step` — read-only, sem efeitos colaterais destrutivos.
+     */
+    async collect(accountId) {
+        const cfg = this.#cfg;
+        const store = cfg.accountStore;
+        const account = await store.findById(accountId);
+        if (!account)
+            return null;
+        // Identidades de provider (capability-probed; sem tokens).
+        let linkedIdentities = [];
+        if (supportsProviderIdentity(store)) {
+            try {
+                linkedIdentities = (await store.listProviderIdentities(accountId)).map((i) => ({
+                    provider: i.provider,
+                    providerUserId: i.providerUserId,
+                    email: i.email ?? null,
+                }));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        // Sessões + grants (apps autorizados) — só metadados, sem tokens.
+        let sessions = [];
+        let authorizedApps = [];
+        try {
+            const admin = new AdminSessionsService(this.#oidc);
+            sessions = (await admin.listSessions(accountId)).map((s) => ({
+                id: s.id,
+                loginTs: s.loginTs ?? null,
+                amr: s.amr ?? [],
+            }));
+            authorizedApps = (await admin.listGrants(accountId)).map((g) => ({
+                clientId: g.clientId ?? null,
+                accessTokens: g.accessTokens,
+                refreshTokens: g.refreshTokens,
+            }));
+        }
+        catch {
+            /* best-effort (adapter sem list) */
+        }
+        // Passkeys — só metadados (id/label/createdAt), nunca a chave pública.
+        let passkeys = [];
+        if (supportsPasskeys(store)) {
+            try {
+                passkeys = (await store.listPasskeys(accountId)).map((p) => ({
+                    id: p.id,
+                    label: p.label ?? null,
+                    createdAt: p.createdAt,
+                }));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        // Organizations (capability-probed).
+        let organizations = [];
+        if (supportsOrganizations(store)) {
+            try {
+                const orgs = await store.listOrgsForAccount(accountId);
+                organizations = orgs.map((o) => ({
+                    orgId: o.id,
+                    name: o.name,
+                    slug: o.slug,
+                    role: o.role,
+                }));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        // Audit do próprio usuário (quando o sink suporta consulta).
+        let auditLog = [];
+        if (cfg.audit && typeof cfg.audit.list === "function") {
+            try {
+                const page = await cfg.audit.list({
+                    subject: accountId,
+                    page: 1,
+                    limit: AUDIT_EXPORT_LIMIT,
+                });
+                auditLog = page.data.map((e) => ({
+                    type: e.type,
+                    clientId: e.clientId ?? null,
+                    ip: e.ip ?? null,
+                    metadata: e.metadata ?? null,
+                    createdAt: typeof e.createdAt === "string"
+                        ? e.createdAt
+                        : (e.createdAt?.toISOString?.() ?? null),
+                }));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        return {
+            exportVersion: 1,
+            exportedAt: new Date().toISOString(),
+            profile: {
+                id: account.id,
+                email: account.email,
+                name: account.name ?? null,
+                avatarUrl: account.avatarUrl ?? null,
+                globalRoles: account.globalRoles ?? [],
+            },
+            linkedIdentities,
+            authorizedApps,
+            sessions,
+            passkeys,
+            auditLog,
+            organizations,
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Destino default da área da conta (pós-login do console sem `return_to`,
+ * confirmações de e-mail, fallback de redirects).
+ *
+ * Configurável via `accountHome` no defineConfig; default '/account/security'
+ * (a "minha conta" natural — perfil, senha, sessões). Nunca '/account/tokens':
+ * aterrissar usuário comum numa tela de Personal Access Tokens é hostil.
+ */
+export declare function accountHome(cfg: {
+    accountHome?: string;
+}): string;

package/build/src/host/account_home.js

@@ -0,0 +1,11 @@
+/**
+ * Destino default da área da conta (pós-login do console sem `return_to`,
+ * confirmações de e-mail, fallback de redirects).
+ *
+ * Configurável via `accountHome` no defineConfig; default '/account/security'
+ * (a "minha conta" natural — perfil, senha, sessões). Nunca '/account/tokens':
+ * aterrissar usuário comum numa tela de Personal Access Tokens é hostil.
+ */
+export function accountHome(cfg) {
+    return cfg.accountHome ?? '/account/security';
+}