@dudousxd/adonis-authkit-server 0.4.0 → 0.6.0

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

@@ -3,7 +3,9 @@ import { brandFor, isFirstParty } from '../branding.js';
 import { translate } from '../i18n.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
 import { notifyLoginSuccess } from '../login_notify.js';
-import { supportsPasskeys } from '../../accounts/account_store.js';
+import { supportsPasskeys, supportsMagicLink } from '../../accounts/account_store.js';
+import { sendMagicLinkEmail } from '../default_mailer.js';
+import { TRUSTED_DEVICE_COOKIE, buildTrustedDevicePayload, isTrustedDeviceValid, } from '../trusted_device.js';
 const SESSION_KEY = 'authkit_login_email';
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
@@ -45,6 +47,10 @@ export default class AuthInteractionController {
         // Step 2: password — look up user for personalisation (enumeration-safe: always show step 2)
         const acc = await cfg.accountStore.findByEmail(email);
         const account = acc ? { fullName: acc.name ?? null, globalRoles: acc.globalRoles ?? [] } : null;
+        // Passwordless: magic link disponível se ligado E o store suporta. Passkey-first
+        // disponível se ligado, o store suporta E a conta tem ao menos uma passkey.
+        const magicLinkAvailable = cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore);
+        const passkeyFirstAvailable = cfg.passwordless.passkeyFirst && !!acc && (await this.hasPasskeys(cfg, acc.id));
         return render(ctx, 'login', {
             uid: details.uid,
             csrfToken: ctx.request.csrfToken,
@@ -52,6 +58,8 @@ export default class AuthInteractionController {
             email,
             account,
             brand,
+            magicLinkAvailable,
+            passkeyFirstAvailable,
         });
     }
     /**
@@ -102,7 +110,9 @@ export default class AuthInteractionController {
                     ? translate(cfg.messages, 'errors.account_locked', {
                         seconds: result.retryAfterSec ?? 0,
                     })
-                    : translate(cfg.messages, 'errors.invalid_credentials'),
+                    : result.disabled
+                        ? translate(cfg.messages, 'errors.account_disabled')
+                        : translate(cfg.messages, 'errors.invalid_credentials'),
                 brand,
             });
         }
@@ -126,6 +136,18 @@ export default class AuthInteractionController {
                     noEnrollment: true,
                 });
             }
+            // Trusted device: se o mecanismo está ligado, a conta JÁ tem MFA enrolado e
+            // o request NÃO é um step-up (que sempre força o MFA), um cookie de confiança
+            // válido para ESTA conta pula o 2º fator. amr fica `['pwd']` (sem acr de MFA).
+            if (cfg.trustedDevices.enabled && mfa.enabled && !mfaRequired) {
+                const trusted = await this.checkTrustedDevice(ctx, acc.id, mfa.enabledAt ?? null);
+                if (trusted) {
+                    await service.interactions.completeLogin(ctx, acc.id, { amr: ['pwd'] });
+                    await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip, clientId });
+                    ctx.session.forget(SESSION_KEY);
+                    return;
+                }
+            }
             ctx.session.put(MFA_PENDING_KEY, acc.id);
             // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
             // tem ao menos uma credencial registrada.
@@ -135,6 +157,8 @@ export default class AuthInteractionController {
                 csrfToken: ctx.request.csrfToken,
                 brand,
                 passkeyAvailable,
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
             });
         }
         // Sem MFA: finaliza a interaction (escreve o 303 de volta para o client).
@@ -185,9 +209,13 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.invalid_code'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
             });
         }
-        // Sucesso no 2º fator: finaliza a interaction para o accountId pendente.
+        // Sucesso no 2º fator: opcionalmente confia neste dispositivo (checkbox).
+        await this.maybeTrustDevice(ctx, cfg, accountId);
+        // Finaliza a interaction para o accountId pendente.
         ctx.session.forget(MFA_PENDING_KEY);
         ctx.session.forget(SESSION_KEY);
         await notifyLoginSuccess(ctx, cfg, {
@@ -230,6 +258,135 @@ export default class AuthInteractionController {
         const list = await cfg.accountStore.listPasskeys(accountId);
         return Array.isArray(list) && list.length > 0;
     }
+    /**
+     * Lê o cookie de dispositivo confiável (encriptado, appKey-backed) e valida que
+     * pertence a `accountId`, não expirou e é posterior ao último (re)enrollment de
+     * MFA. Step-up NÃO chama isto (força sempre o MFA). Best-effort: qualquer erro de
+     * leitura → não confiável.
+     */
+    async checkTrustedDevice(ctx, accountId, mfaEnabledAt) {
+        try {
+            const payload = ctx.request.encryptedCookie(TRUSTED_DEVICE_COOKIE);
+            return isTrustedDeviceValid(payload, { accountId, mfaEnabledAt });
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Se o checkbox "confiar neste dispositivo" foi marcado E o mecanismo está ligado,
+     * grava o cookie encriptado de confiança para a conta (skip MFA por N dias).
+     */
+    async maybeTrustDevice(ctx, cfg, accountId) {
+        if (!cfg.trustedDevices.enabled)
+            return;
+        const checked = ctx.request.input('trustDevice');
+        // Checkbox HTML: presente ('on'/'true'/'1') = marcado.
+        const on = checked === 'on' || checked === 'true' || checked === '1' || checked === true;
+        if (!on)
+            return;
+        const payload = buildTrustedDevicePayload(accountId, cfg.trustedDevices);
+        ctx.response.encryptedCookie(TRUSTED_DEVICE_COOKIE, payload, {
+            httpOnly: true,
+            sameSite: 'lax',
+            maxAge: cfg.trustedDevices.days * 24 * 60 * 60,
+        });
+    }
+    /**
+     * accountId para uma cerimônia de passkey no login. Prioriza o accountId pendente
+     * do MFA (passkey como 2º fator). Quando ausente e o passkey-first está ligado,
+     * resolve a conta pelo e-mail guardado na sessão (passkey ANTES da senha) — só se
+     * a conta existe E tem ao menos uma passkey.
+     */
+    async resolvePasskeyAccountId(ctx, cfg) {
+        const pending = ctx.session.get(MFA_PENDING_KEY);
+        if (pending)
+            return pending;
+        if (!cfg.passwordless?.passkeyFirst)
+            return undefined;
+        const email = ctx.session.get(SESSION_KEY);
+        if (!email)
+            return undefined;
+        const acc = await cfg.accountStore.findByEmail(email);
+        if (!acc)
+            return undefined;
+        return (await this.hasPasskeys(cfg, acc.id)) ? acc.id : undefined;
+    }
+    /**
+     * POST /auth/interaction/:uid/magic
+     * Magic link: lê o e-mail da sessão (passwordless.magicLink ligado), emite um
+     * token de uso único e dispara o e-mail. SEMPRE renderiza "link enviado",
+     * independentemente de a conta existir (anti-enumeração). Throttled como o login.
+     */
+    async magicLinkRequest(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const details = await service.interactions.details(ctx);
+        const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
+        const email = ctx.session.get(SESSION_KEY);
+        const uid = ctx.request.param('uid');
+        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
+            const issued = await cfg.accountStore.issueMagicLinkToken(email);
+            if (issued) {
+                await cfg.audit?.record({
+                    type: 'login.magic_link_sent',
+                    accountId: issued.account.id,
+                    email,
+                    ip: ctx.request.ip?.() ?? null,
+                    clientId: details.params.client_id ?? null,
+                });
+                const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+                const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+                if (cfg.mail?.onMagicLink) {
+                    await cfg.mail.onMagicLink({ email, magicUrl, token: issued.token });
+                }
+                else {
+                    await sendMagicLinkEmail(ctx, { email, magicUrl });
+                }
+            }
+        }
+        // Resposta uniforme (não vaza existência de conta).
+        return render(ctx, 'login', {
+            uid,
+            csrfToken: ctx.request.csrfToken,
+            step: 'password',
+            email,
+            account: null,
+            brand,
+            magicLinkSent: true,
+        });
+    }
+    /**
+     * GET /auth/interaction/:uid/magic?token=...
+     * Consome o magic link. Em sucesso finaliza o login (amr `['email']`). Token
+     * inválido/expirado volta ao início do login.
+     */
+    async magicLinkConsume(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const uid = ctx.request.param('uid');
+        const ip = ctx.request.ip?.() ?? null;
+        const clientId = (await service.interactions.details(ctx)).params.client_id;
+        const token = ctx.request.qs().token ?? '';
+        if (!cfg.passwordless.magicLink || !supportsMagicLink(cfg.accountStore) || !token) {
+            return ctx.response.redirect(`/auth/interaction/${uid}`);
+        }
+        const acc = await cfg.accountStore.consumeMagicLinkToken(token);
+        if (!acc) {
+            await cfg.audit?.record({ type: 'login.failure', ip, clientId, metadata: { stage: 'magic_link' } });
+            return ctx.response.redirect(`/auth/interaction/${uid}`);
+        }
+        await notifyLoginSuccess(ctx, cfg, {
+            accountId: acc.id,
+            email: acc.email,
+            ip,
+            clientId: clientId ?? null,
+            metadata: { method: 'magic_link' },
+        });
+        ctx.session.forget(SESSION_KEY);
+        await service.interactions.completeLogin(ctx, acc.id, { amr: ['email'] });
+    }
     /**
      * POST /auth/interaction/:uid/passkey/options
      * Gera as opções de autenticação por passkey para o accountId pendente do MFA,
@@ -238,13 +395,17 @@ export default class AuthInteractionController {
     async passkeyOptions(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
-        const accountId = ctx.session.get(MFA_PENDING_KEY);
+        const accountId = await this.resolvePasskeyAccountId(ctx, cfg);
         if (!accountId) {
-            return ctx.response.badRequest({ message: 'Sessão expirada' });
+            return ctx.response.badRequest({
+                message: translate(cfg.messages, 'errors.session_expired'),
+            });
         }
         const generated = await cfg.accountStore.generatePasskeyAuthenticationOptions?.(accountId);
         if (!generated) {
-            return ctx.response.notFound({ message: 'Nenhuma passkey registrada' });
+            return ctx.response.notFound({
+                message: translate(cfg.messages, 'errors.no_passkey_registered'),
+            });
         }
         ctx.session.put(PASSKEY_AUTH_CHALLENGE_KEY, generated.challenge);
         return generated.options;
@@ -262,7 +423,7 @@ export default class AuthInteractionController {
         const render = cfg.render;
         const details = await service.interactions.details(ctx);
         const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
-        const accountId = ctx.session.get(MFA_PENDING_KEY);
+        const accountId = await this.resolvePasskeyAccountId(ctx, cfg);
         const challenge = ctx.session.get(PASSKEY_AUTH_CHALLENGE_KEY);
         const ip = ctx.request.ip?.() ?? null;
         const clientId = details.params.client_id ?? null;
@@ -297,8 +458,12 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'mfa_challenge.passkey_error'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
             });
         }
+        // Passkey OK: opcionalmente confia neste dispositivo (checkbox no challenge).
+        await this.maybeTrustDevice(ctx, cfg, accountId);
         ctx.session.forget(MFA_PENDING_KEY);
         ctx.session.forget(SESSION_KEY);
         await notifyLoginSuccess(ctx, cfg, {
@@ -307,7 +472,9 @@ export default class AuthInteractionController {
             clientId,
             metadata: { mfa: 'webauthn' },
         });
-        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, 'webauthn'));
+        // Step-up carimba acr/amr quando solicitado; senão a passkey conta como o fator
+        // forte do login (amr `['webauthn']`) — vale tanto p/ MFA quanto passkey-first.
+        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, 'webauthn') ?? { amr: ['webauthn'] });
     }
     /**
      * GET /auth/interaction/:uid/switch

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

@@ -45,6 +45,14 @@ export declare function sendNewLoginEmail(ctx: HttpContext, data: {
     ip: string;
     when: string;
 }): Promise<void>;
+/**
+ * Envia o e-mail de magic link (login passwordless) pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendMagicLinkEmail(ctx: HttpContext, data: {
+    email: string;
+    magicUrl: string;
+}): Promise<void>;
 /**
  * Envia o e-mail de verificação pelo mailer default do host.
  * Best-effort: no fallback (sem mail) loga o link; nunca lança.

package/build/src/host/default_mailer.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { renderTransactionalEmail } from './email_templates.js';
+import { resolveMessages, translate, } from './i18n.js';
 let mailServicePromise;
 /**
  * Importa o service de mail do HOST de forma preguiçosa e fail-safe.
@@ -78,6 +79,22 @@ function resolveBrand(ctx) {
     }
     return { appName: 'AuthKit' };
 }
+/**
+ * Resolve o catálogo de mensagens i18n a partir do `config/authkit.ts` (i18n).
+ * Cai no default (`en`) se a config não for resolvível. Usado para localizar
+ * os e-mails transacionais (assunto/cabeçalho/corpo).
+ */
+function resolveMailMessages(ctx) {
+    try {
+        const resolver = ctx.containerResolver;
+        const i18n = resolver.app?.config?.get?.('authkit')?.i18n;
+        return { messages: resolveMessages(i18n), locale: i18n?.locale ?? 'en' };
+    }
+    catch {
+        // sem config authkit resolvível — usa o default `en`.
+        return { messages: resolveMessages(), locale: 'en' };
+    }
+}
 async function sendEmail(ctx, to, content) {
     const mail = await loadMail();
     if (!mail)
@@ -97,14 +114,17 @@ async function sendEmail(ctx, to, content) {
 export async function sendPasswordResetEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Redefinição de senha',
-            heading: 'Redefinição de senha',
-            intro: `Recebemos um pedido para redefinir a senha da sua conta em ${brand.appName}. Clique no botão abaixo para escolher uma nova senha. Se não foi você, ignore este e-mail.`,
-            ctaLabel: 'Redefinir senha',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.reset.subject'),
+            heading: translate(t, 'mail.reset.heading'),
+            intro: translate(t, 'mail.reset.intro'),
+            ctaLabel: translate(t, 'mail.reset.cta'),
             ctaUrl: data.resetUrl,
-            footnote: 'Por segurança, este link expira em breve e só pode ser usado uma vez.',
+            footnote: translate(t, 'mail.reset.fallback'),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
@@ -122,14 +142,17 @@ export async function sendPasswordResetEmail(ctx, data) {
 export async function sendEmailChangeConfirmationEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Confirme seu novo e-mail',
-            heading: 'Confirme seu novo e-mail',
-            intro: `Recebemos um pedido para alterar o e-mail da sua conta em ${brand.appName} para este endereço. Clique no botão abaixo para confirmar a alteração. Se não foi você, ignore este e-mail — nada será alterado.`,
-            ctaLabel: 'Confirmar novo e-mail',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.email_change.subject'),
+            heading: translate(t, 'mail.email_change.heading'),
+            intro: translate(t, 'mail.email_change.intro'),
+            ctaLabel: translate(t, 'mail.email_change.cta'),
             ctaUrl: data.confirmUrl,
-            footnote: 'Por segurança, este link expira em breve e só pode ser usado uma vez.',
+            footnote: translate(t, 'mail.email_change.fallback'),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
@@ -147,15 +170,23 @@ export async function sendEmailChangeConfirmationEmail(ctx, data) {
 export async function sendNewLoginEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const intro = [
+            translate(t, 'mail.new_login.intro'),
+            translate(t, 'mail.new_login.when', { date: data.when }),
+            translate(t, 'mail.new_login.ip', { ip: data.ip }),
+        ].join(' ');
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Novo acesso à sua conta',
-            heading: 'Novo acesso à sua conta',
-            intro: `Detectamos um novo acesso à sua conta em ${brand.appName} a partir do IP ${data.ip} em ${data.when}. Se foi você, nenhuma ação é necessária. Se não reconhece este acesso, altere sua senha imediatamente.`,
-            ctaLabel: 'Acessar minha conta',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.new_login.subject'),
+            heading: translate(t, 'mail.new_login.heading'),
+            intro,
+            ctaLabel: translate(t, 'account.security.title'),
             ctaUrl: `${origin}/account/security`,
-            footnote: 'Você está recebendo este alerta porque um login foi feito de um endereço de IP não visto antes.',
+            footnote: translate(t, 'mail.new_login.fallback'),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
@@ -166,6 +197,34 @@ export async function sendNewLoginEmail(ctx, data) {
         ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar alerta de novo acesso');
     }
 }
+/**
+ * Envia o e-mail de magic link (login passwordless) pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendMagicLinkEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.magic_link.subject'),
+            heading: translate(t, 'mail.magic_link.heading'),
+            intro: translate(t, 'mail.magic_link.intro'),
+            ctaLabel: translate(t, 'mail.magic_link.cta'),
+            ctaUrl: data.magicUrl,
+            footnote: translate(t, 'mail.magic_link.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ magicUrl: data.magicUrl, email: data.email }, 'authkit: magic link de login (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar magic link de login');
+    }
+}
 /**
  * Envia o e-mail de verificação pelo mailer default do host.
  * Best-effort: no fallback (sem mail) loga o link; nunca lança.
@@ -173,12 +232,15 @@ export async function sendNewLoginEmail(ctx, data) {
 export async function sendEmailVerificationEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Verifique seu e-mail',
-            heading: 'Confirme seu e-mail',
-            intro: `Bem-vindo(a) ao ${brand.appName}! Confirme seu endereço de e-mail clicando no botão abaixo para ativar sua conta.`,
-            ctaLabel: 'Verificar e-mail',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.verify.subject'),
+            heading: translate(t, 'mail.verify.heading'),
+            intro: translate(t, 'mail.verify.intro'),
+            ctaLabel: translate(t, 'mail.verify.cta'),
             ctaUrl: data.verifyUrl,
         });
         const sent = await sendEmail(ctx, data.email, content);

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

@@ -30,6 +30,10 @@ interface EmailTemplateInput {
     ctaUrl: string;
     /** Linha auxiliar abaixo do botão (ex.: validade do link). */
     footnote?: string;
+    /** Texto que precede o link de fallback (i18n). Default em inglês. */
+    linkFallback?: string;
+    /** Locale do documento HTML (atributo `lang`). Default: 'en'. */
+    locale?: string;
 }
 export declare function renderTransactionalEmail(input: EmailTemplateInput): EmailContent;
 export {};

package/build/src/host/email_templates.js

@@ -21,8 +21,11 @@ export function renderTransactionalEmail(input) {
     const accent = input.brand.accent || FALLBACK_ACCENT;
     const company = input.brand.company || appName;
     const year = '©'; // ano resolvido fora (sem Date.* aqui); rodapé usa só o nome.
+    const lang = input.locale || 'en';
+    const linkFallback = input.linkFallback ||
+        'If the button does not work, copy and paste this link into your browser:';
     const html = `<!doctype html>
-<html lang="pt-BR">
+<html lang="${esc(lang)}">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -42,7 +45,7 @@ export function renderTransactionalEmail(input) {
 <a href="${esc(input.ctaUrl)}" style="display:inline-block;padding:12px 24px;font-size:15px;font-weight:600;color:#ffffff;text-decoration:none;border-radius:8px;">${esc(input.ctaLabel)}</a>
 </td></tr></table>
 ${input.footnote ? `<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">${esc(input.footnote)}</p>` : ''}
-<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">Se o botão não funcionar, copie e cole este link no navegador:<br><a href="${esc(input.ctaUrl)}" style="color:${esc(accent)};word-break:break-all;">${esc(input.ctaUrl)}</a></p>
+<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">${esc(linkFallback)}<br><a href="${esc(input.ctaUrl)}" style="color:${esc(accent)};word-break:break-all;">${esc(input.ctaUrl)}</a></p>
 </td></tr>
 <tr><td style="padding:24px 28px 28px;border-top:1px solid #f3f4f6;">
 <p style="margin:0;font-size:12px;line-height:1.5;color:#9ca3af;">${esc(company)} ${year}</p>