@hed-hog/core 0.0.401 → 0.0.404

package/src/file/provider/s3-multipart.util.ts

@@ -0,0 +1,126 @@
+import {
+  AbortMultipartUploadCommand,
+  CompleteMultipartUploadCommand,
+  CreateMultipartUploadCommand,
+  GetObjectCommand,
+  ObjectCannedACL,
+  S3Client,
+  UploadPartCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { Readable } from 'stream';
+import { MultipartUploadPart } from './abstract.provider';
+
+/**
+ * Upload multipart assinado, comum ao S3 e ao Spaces (mesma API): o servidor abre,
+ * assina e fecha; o cliente so recebe URLs que valem para uma parte e expiram.
+ * Mesmo desenho de libraries/studio/src/common/studio-s3-compatible.client.ts.
+ */
+export async function s3CreateMultipartUpload(
+  client: S3Client,
+  bucket: string,
+  key: string,
+  contentType: string,
+  acl?: ObjectCannedACL,
+): Promise<string> {
+  const result = await client.send(
+    new CreateMultipartUploadCommand({
+      Bucket: bucket,
+      Key: key,
+      ContentType: contentType,
+      ...(acl ? { ACL: acl } : {}),
+    }),
+  );
+
+  if (!result.UploadId) {
+    throw new Error('The storage did not return a multipart upload id.');
+  }
+
+  return result.UploadId;
+}
+
+export async function s3SignUploadParts(
+  client: S3Client,
+  bucket: string,
+  key: string,
+  uploadId: string,
+  partNumbers: number[],
+  ttlSeconds: number,
+): Promise<Array<{ partNumber: number; url: string }>> {
+  return Promise.all(
+    partNumbers.map(async (partNumber) => ({
+      partNumber,
+      url: await getSignedUrl(
+        client as any,
+        new UploadPartCommand({
+          Bucket: bucket,
+          Key: key,
+          UploadId: uploadId,
+          PartNumber: partNumber,
+        }),
+        { expiresIn: ttlSeconds },
+      ),
+    })),
+  );
+}
+
+export async function s3CompleteMultipartUpload(
+  client: S3Client,
+  bucket: string,
+  key: string,
+  uploadId: string,
+  parts: MultipartUploadPart[],
+): Promise<void> {
+  await client.send(
+    new CompleteMultipartUploadCommand({
+      Bucket: bucket,
+      Key: key,
+      UploadId: uploadId,
+      MultipartUpload: {
+        Parts: [...parts]
+          .sort((a, b) => a.partNumber - b.partNumber)
+          .map((part) => ({ PartNumber: part.partNumber, ETag: part.etag })),
+      },
+    }),
+  );
+}
+
+export async function s3AbortMultipartUpload(
+  client: S3Client,
+  bucket: string,
+  key: string,
+  uploadId: string,
+): Promise<void> {
+  await client.send(
+    new AbortMultipartUploadCommand({ Bucket: bucket, Key: key, UploadId: uploadId }),
+  );
+}
+
+/** Range GET dos primeiros `bytes`: basta para o sniff do tipo, sem baixar o objeto. */
+export async function s3ReadHead(
+  client: S3Client,
+  bucket: string,
+  key: string,
+  bytes: number,
+): Promise<Buffer> {
+  const length = Math.max(1, Math.floor(bytes));
+  const result = await client.send(
+    new GetObjectCommand({ Bucket: bucket, Key: key, Range: `bytes=0-${length - 1}` }),
+  );
+
+  const stream = result.Body as Readable;
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    chunks.push(buffer);
+    total += buffer.length;
+    // Storage que ignora o Range devolveria o objeto inteiro: para no que basta.
+    if (total >= length) {
+      stream.destroy?.();
+      break;
+    }
+  }
+
+  return Buffer.concat(chunks).subarray(0, length);
+}

package/src/file/provider/s3.provider.ts

@@ -14,7 +14,14 @@ import { BadRequestException } from '@nestjs/common';
 import { createReadStream } from 'fs';
 import { basename } from 'path';
 import { Readable } from 'stream';
-import { AbstractProvider } from './abstract.provider';
+import { AbstractProvider, MultipartUploadPart } from './abstract.provider';
+import {
+  s3AbortMultipartUpload,
+  s3CompleteMultipartUpload,
+  s3CreateMultipartUpload,
+  s3ReadHead,
+  s3SignUploadParts,
+} from './s3-multipart.util';
 
 export class S3Provider extends AbstractProvider {
   private S3: S3 | undefined;
@@ -253,4 +260,61 @@ export class S3Provider extends AbstractProvider {
     // Use S3Client instance for getSignedUrl
     return await getSignedUrl(s3Client as any, command, { expiresIn: expires });
   }
+
+  async createMultipartUpload(key: string, contentType: string): Promise<string> {
+    return s3CreateMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-s3-bucket'],
+      this.resolveS3Key(key),
+      contentType,
+    );
+  }
+
+  async signUploadParts(
+    key: string,
+    uploadId: string,
+    partNumbers: number[],
+    ttlSeconds: number,
+  ) {
+    return s3SignUploadParts(
+      await this.getS3Client(),
+      this.setting['storage-s3-bucket'],
+      this.resolveS3Key(key),
+      uploadId,
+      partNumbers,
+      ttlSeconds,
+    );
+  }
+
+  async completeMultipartUpload(
+    key: string,
+    uploadId: string,
+    parts: MultipartUploadPart[],
+  ): Promise<void> {
+    await s3CompleteMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-s3-bucket'],
+      this.resolveS3Key(key),
+      uploadId,
+      parts,
+    );
+  }
+
+  async abortMultipartUpload(key: string, uploadId: string): Promise<void> {
+    await s3AbortMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-s3-bucket'],
+      this.resolveS3Key(key),
+      uploadId,
+    );
+  }
+
+  async readHead(key: string, bytes: number): Promise<Buffer> {
+    return s3ReadHead(
+      await this.getS3Client(),
+      this.setting['storage-s3-bucket'],
+      this.resolveS3Key(key),
+      bytes,
+    );
+  }
 }

package/src/file/provider/spaces.provider.ts

@@ -14,7 +14,14 @@ import { BadRequestException } from '@nestjs/common';
 import { createReadStream } from 'fs';
 import { basename } from 'path';
 import { Readable } from 'stream';
-import { AbstractProvider } from './abstract.provider';
+import { AbstractProvider, MultipartUploadPart } from './abstract.provider';
+import {
+  s3AbortMultipartUpload,
+  s3CompleteMultipartUpload,
+  s3CreateMultipartUpload,
+  s3ReadHead,
+  s3SignUploadParts,
+} from './s3-multipart.util';
 
 export class SpacesProvider extends AbstractProvider {
   private S3: S3 | undefined;
@@ -280,4 +287,63 @@ export class SpacesProvider extends AbstractProvider {
     });
     return await getSignedUrl(s3Client as any, command, { expiresIn: expires });
   }
+
+  /** Mesmo ACL dos demais uploads deste provider (o objeto nasce com ele no create). */
+  async createMultipartUpload(key: string, contentType: string): Promise<string> {
+    return s3CreateMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-spaces-bucket'],
+      this.resolveKey(key),
+      contentType,
+      'public-read',
+    );
+  }
+
+  async signUploadParts(
+    key: string,
+    uploadId: string,
+    partNumbers: number[],
+    ttlSeconds: number,
+  ) {
+    return s3SignUploadParts(
+      await this.getS3Client(),
+      this.setting['storage-spaces-bucket'],
+      this.resolveKey(key),
+      uploadId,
+      partNumbers,
+      ttlSeconds,
+    );
+  }
+
+  async completeMultipartUpload(
+    key: string,
+    uploadId: string,
+    parts: MultipartUploadPart[],
+  ): Promise<void> {
+    await s3CompleteMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-spaces-bucket'],
+      this.resolveKey(key),
+      uploadId,
+      parts,
+    );
+  }
+
+  async abortMultipartUpload(key: string, uploadId: string): Promise<void> {
+    await s3AbortMultipartUpload(
+      await this.getS3Client(),
+      this.setting['storage-spaces-bucket'],
+      this.resolveKey(key),
+      uploadId,
+    );
+  }
+
+  async readHead(key: string, bytes: number): Promise<Buffer> {
+    return s3ReadHead(
+      await this.getS3Client(),
+      this.setting['storage-spaces-bucket'],
+      this.resolveKey(key),
+      bytes,
+    );
+  }
 }

package/src/integration-profile/integration-profile.secrets.ts

@@ -85,8 +85,9 @@ export const INTEGRATION_SECRET_KEYS: Record<string, string[]> = {
   // App do Instagram (Instagram API with Instagram Login) — o segredo do app do
   // INSTAGRAM, nao o do app da Meta. Troca o code do OAuth pelo token de
   // qualquer conta que autorize o app; os tokens de 60 dias das contas ficam
-  // cifrados em social_channel.
-  'instagram-social': ['app_secret'],
+  // cifrados em social_channel. O webhook_verify_token e comparado no
+  // handshake do webhook do Instagram (inbox de comentarios e DMs).
+  'instagram-social': ['app_secret', 'webhook_verify_token'],
   // Apps do Google para o modulo social (um projeto por rede). O client_secret
   // troca o code do OAuth pelo refresh token de qualquer canal/local que
   // autorize o app; os refresh tokens ficam cifrados em social_channel.
@@ -97,6 +98,10 @@ export const INTEGRATION_SECRET_KEYS: Record<string, string[]> = {
   // pagina que autorize o app; as credenciais das paginas (envelope lir1:/lia1:)
   // ficam cifradas em social_channel.
   'linkedin-social': ['client_secret'],
+  // App do X (OAuth 2.0, cliente confidencial). O client_secret vai no header
+  // Basic da troca do code, da renovacao e da revogacao; os tokens de cada
+  // conta (que rotacionam) ficam cifrados em social_channel_oauth_token.
+  'x-social': ['client_secret'],
 };
 
 /** Chaves sensíveis de um provider (vazio se desconhecido). */

package/src/integration-profile/integration-profile.service.ts

@@ -544,6 +544,7 @@ export class IntegrationProfileService {
       provider: provider.slug,
       ...(outcome.info ? { info: outcome.info } : {}),
       ...(outcome.warning ? { warning: outcome.warning } : {}),
+      ...(outcome.warningCodes?.length ? { warning_codes: outcome.warningCodes } : {}),
       tested_at: new Date().toISOString(),
       persisted,
     };

package/src/integration-profile/testers/http-probe.ts

@@ -81,16 +81,18 @@ export async function probeJson(
   signal: AbortSignal,
 ): Promise<ProbeResult> {
   const response = await fetch(url, { ...init, signal });
-  const text = (await response.text().catch(() => '')).slice(0, 2_000);
+  const raw = await response.text().catch(() => '');
 
+  // O parse usa o corpo inteiro: um access token JWT (ex.: o do Graph com muitas
+  // permissões de aplicação) passa fácil de 2 KB, e o JSON truncado viraria `{}`.
   let body: any = {};
   try {
-    body = text ? JSON.parse(text) : {};
+    body = raw ? JSON.parse(raw) : {};
   } catch {
     body = {};
   }
 
-  return { ok: response.ok, status: response.status, body, text };
+  return { ok: response.ok, status: response.status, body, text: raw.slice(0, 2_000) };
 }
 
 /** Remove qualquer ocorrência dos segredos do texto. */

package/src/integration-profile/testers/integration-tester.types.ts

@@ -26,6 +26,11 @@ export type IntegrationTestOutcome = {
    * verificado, service account sem acesso ao app, pool inexistente). Não reprova.
    */
   warning?: string;
+  /**
+   * Códigos estáveis dos avisos, na ordem do `warning`, para a UI traduzir. O
+   * `warning` continua sendo o texto de fallback de quem não conhece o código.
+   */
+  warningCodes?: string[];
 };
 
 export type IntegrationTestContext = {

package/src/integration-profile/testers/oauth.testers.spec.ts

@@ -126,6 +126,19 @@ describe('microsoft-oauth tester', () => {
     expect(outcome.info).toContain('contoso');
   });
 
+  it('aprova quando o token é maior que o limite de texto guardado', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ token_type: 'Bearer', access_token: 'x'.repeat(5_000) }),
+    );
+
+    const outcome = await tester.test(
+      { client_id: 'a', client_secret: 'b', tenant_id: 'contoso' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+  });
+
   it.each([
     ['AADSTS7000215', 'Invalid client secret.'],
     ['AADSTS700016', 'Application not found in tenant "contoso".'],

package/src/integration-profile/testers/tester-coverage.spec.ts

@@ -25,6 +25,8 @@ const EXTERNAL_PROVIDERS = new Set([
   'google-business-social',
   // App do LinkedIn (paginas de empresa): o tester vive em libraries/social.
   'linkedin-social',
+  // App do X (OAuth 2.0 com PKCE): o tester vive em libraries/social.
+  'x-social',
 ]);
 
 /** Providers legítimos sem nenhum campo secreto. */

package/src/mail/mail.service.spec.ts

@@ -82,6 +82,31 @@ describe('MailService', () => {
       expect(call('A\r\nB', {})).toBe('A<br/>B');
     });
 
+    // Bug real: o aviso interno do SAC, escrito em HTML indentado, chegava com
+    // um vao entre cada campo — cada quebra entre dois <p> virava <br/>.
+    it('não gera <br/> na quebra que só separa uma tag da seguinte', () => {
+      expect(call('<div>\n  <p>A</p>\n  <p>B</p>\n</div>', {})).toBe(
+        '<div><p>A</p><p>B</p></div>',
+      );
+      expect(call('<p>A</p>\r\n\r\n<p>B</p>', {})).toBe('<p>A</p><p>B</p>');
+    });
+
+    it('não gera <br/> entre tag e bloco {{#if}}/{{/if}}', () => {
+      const src =
+        '<p>A</p>\n{{#if x}}<p>X</p>{{/if}}\n<p>B</p>\n{{#if y}}\n  <p>Y</p>\n{{else}}\n  <p>N</p>\n{{/if}}';
+      expect(call(src, { x: true })).toBe('<p>A</p><p>X</p><p>B</p><p>N</p>');
+    });
+
+    it('mantém o <br/> da quebra que vem depois de texto ou de variável', () => {
+      expect(call('Olá,\n<div>x</div>', {})).toBe('Olá,<br/><div>x</div>');
+      expect(call('Oi {{name}}\n<p>x</p>', { name: 'Bob' })).toBe(
+        'Oi Bob<br/><p>x</p>',
+      );
+      expect(call('<strong>A</strong>\ntexto', {})).toBe(
+        '<strong>A</strong><br/>texto',
+      );
+    });
+
     it('preserva as quebras de linha de um documento HTML completo (não injeta <br/> dentro de <style>/<head>)', () => {
       // Bug real: um HTML completo colado em Templates de e-mail (que
       // funciona no preview cru de Campanhas) aparecia quebrado aqui porque

package/src/mail/mail.service.ts

@@ -44,6 +44,14 @@ import { IncidentService } from '../incident/incident.service';
 
 export type { SendTemplatedMailResult } from './dto/send.dto';
 
+/**
+ * Quebra de linha (com a indentacao em volta) entre o fim de uma tag ou de um
+ * bloco do Handlebars e o comeco da proxima tag ou bloco. `{{variavel}}` nao
+ * conta como bloco: depois dela vem texto, e a quebra e do autor.
+ */
+const TAG_TO_TAG_LINE_BREAK =
+  /(>|\{\{[#/][^}]*\}\}|\{\{else\}\})[ \t]*(?:\r\n|\n|\r)\s*(?=<|\{\{[#/]|\{\{else\}\})/g;
+
 @Injectable()
 export class MailService implements OnModuleInit {
   private readonly logger = new Logger(MailService.name);
@@ -692,9 +700,18 @@ export class MailService implements OnModuleInit {
       // caso; aqui só espelhamos a mesma detecção pra não mutilar antes
       // disso). Emails simples (sem <html>) continuam ganhando <br/> pra
       // preservar quebras de linha digitadas pelo usuário.
+      //
+      // A quebra que só separa uma tag (ou um bloco `{{#if}}`/`{{/if}}`) da
+      // seguinte é indentação do template, não texto: virar <br/> ali punha
+      // uma linha em branco entre cada <p> de todo template escrito em HTML
+      // de várias linhas. Essa sai antes; a que vem depois de texto continua.
+      // A quebra final (todo bloco `|` do YAML termina em uma) também sai.
       const normalized = isFullHtmlDocument(source)
         ? source
-        : source.replace(/(\r\n|\n|\r)/g, '<br/>');
+        : source
+            .trimEnd()
+            .replace(TAG_TO_TAG_LINE_BREAK, '$1')
+            .replace(/(\r\n|\n|\r)/g, '<br/>');
       const template = Handlebars.compile(normalized, { noEscape: !escapeHtml });
       return template(data);
     } catch (error: any) {

package/src/mcp/mcp-server.service.spec.ts

@@ -195,6 +195,22 @@ describe('McpServerService', () => {
       );
     });
 
+    it('handler void responde { success: true } em vez de um text ausente', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue(undefined);
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      const result = await callHandler({ params: { name: 'tool-a', arguments: {} } });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: JSON.stringify({ success: true }) }],
+      });
+    });
+
     it('trata argumentos ausentes como objeto vazio', async () => {
       const { service, deps } = makeService();
       const handler = jest.fn<any>().mockResolvedValue({});

package/src/mcp/mcp-server.service.ts

@@ -88,7 +88,16 @@ export class McpServerService {
           success: true,
           durationMs: Date.now() - start,
         });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        // Handler `void` (ex.: um delete) dá `JSON.stringify(undefined) === undefined`, e o
+        // cliente MCP recusa o resultado inteiro por faltar `text` — mesmo com a ação feita.
+        return {
+          content: [
+            {
+              type: 'text',
+              text: result === undefined ? JSON.stringify({ success: true }) : JSON.stringify(result),
+            },
+          ],
+        };
       } catch (e: any) {
         await this.audit.record({
           userId: context.userId,

package/src/pdf/document/pdf-document.css.ts

@@ -234,5 +234,93 @@ export function buildDocumentCss(theme: PdfDocumentTheme, landscape = false): st
     }
     .legend p { margin: 0 0 3px; }
     .page-break { break-before: page; }
+
+    /* ── Barra empilhada e cartões de progresso ── */
+    .seg-bar {
+      display: flex;
+      height: 6px;
+      border-radius: 999px;
+      overflow: hidden;
+      background: ${line};
+      margin: 8px 0;
+    }
+    .seg { display: block; height: 100%; }
+    .seg-ink, .dot-ink { background: ${ink}; }
+    .seg-muted, .dot-muted { background: #8f8f94; }
+    .seg-light, .dot-light { background: #cfcfd4; }
+    .seg-accent, .dot-accent { background: ${primary}; }
+    .seg-danger, .dot-danger { background: #dc2626; }
+    .dot {
+      display: inline-block;
+      width: 7px;
+      height: 7px;
+      border-radius: 50%;
+      margin-right: 5px;
+      vertical-align: middle;
+    }
+    .seg-block {
+      border: 1px solid ${line};
+      border-radius: 12px;
+      padding: 12px 16px;
+      margin-bottom: 18px;
+      break-inside: avoid;
+    }
+    .seg-title { font-size: 13px; font-weight: 700; color: ${ink}; }
+    .seg-legend { display: flex; flex-wrap: wrap; gap: 6px 18px; font-size: 10px; color: ${ink}; }
+    .seg-legend-item { white-space: nowrap; }
+    .seg-caption { font-size: 10.5px; color: ${ink}; margin-top: 8px; }
+    .pc-legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 6px 18px;
+      font-size: 10px;
+      color: ${mutedFg};
+      margin-bottom: 12px;
+    }
+    .pc-grid { display: grid; gap: 12px; align-items: start; }
+    .pc-grid-1 { grid-template-columns: 1fr; }
+    .pc-grid-2 { grid-template-columns: repeat(2, 1fr); }
+    .pc-card {
+      border: 1px solid ${line};
+      border-radius: 12px;
+      padding: 12px 14px;
+      break-inside: avoid;
+    }
+    .pc-head { display: flex; justify-content: space-between; align-items: flex-start; gap: 10px; }
+    .pc-title { font-size: 13px; font-weight: 700; color: ${ink}; line-height: 1.25; }
+    .pc-subtitle { font-size: 9.5px; color: ${mutedFg}; margin-top: 2px; }
+    .pc-value { text-align: right; white-space: nowrap; }
+    .pc-value-num { font-size: 22px; font-weight: 700; color: ${ink}; line-height: 1; }
+    .pc-value-hint { font-size: 9px; color: ${mutedFg}; margin-top: 2px; }
+    .pc-list-title { font-size: 10px; font-weight: 700; color: ${ink}; margin: 4px 0 6px; }
+    .pc-entry {
+      border: 1px solid ${line};
+      border-radius: 8px;
+      padding: 6px 10px;
+      margin-bottom: 6px;
+      break-inside: avoid;
+    }
+    .pc-entry-hl { border-color: transparent; }
+    .pc-entry-hl-accent { background: color-mix(in srgb, ${primary} 16%, white); }
+    .pc-entry-hl-danger { background: #fee2e2; }
+    .pc-entry-text { font-size: 10.5px; color: ${ink}; }
+    .pc-entry-meta {
+      display: flex;
+      justify-content: space-between;
+      gap: 8px;
+      font-size: 9.5px;
+      margin-top: 1px;
+    }
+    .pc-entry-status { font-weight: 700; color: ${ink}; }
+    .pc-entry-aside { color: ${mutedFg}; white-space: nowrap; }
+    .pc-entry-sub { font-size: 9px; color: ${mutedFg}; margin-top: 2px; }
+    .pc-entry-sub-danger { color: #b91c1c; font-weight: 700; }
+    .pc-empty {
+      background: ${mutedBg};
+      border-radius: 8px;
+      padding: 8px 10px;
+      font-size: 10px;
+      color: ${ink};
+    }
   `;
 }

package/src/pdf/document/pdf-document.renderer.spec.ts

@@ -127,3 +127,46 @@ describe('documento', () => {
     expect(html).toContain('size: A4 landscape');
   });
 });
+
+describe('barra e cartões de progresso', () => {
+  it('reparte a barra pelo total e mostra a legenda com a porcentagem', () => {
+    const html = renderBlock({
+      kind: 'segmentBar',
+      title: 'Com quem estão',
+      segments: [
+        { label: 'Com o aluno', value: 1, tone: 'muted' },
+        { label: 'Aguardando', value: 3, tone: 'accent' },
+        { label: 'Em revisão', value: 0, tone: 'light' },
+      ],
+    });
+
+    expect(html).toContain('seg-muted" style="width:25.00%"');
+    expect(html).toContain('seg-accent" style="width:75.00%"');
+    expect(html).not.toContain('seg-light" style');
+    expect(html).toContain('<strong>3 (75%)</strong>');
+  });
+
+  it('escapa o texto de cada cartão e cai no texto de vazio sem itens', () => {
+    const html = renderBlock({
+      kind: 'progressCards',
+      items: [
+        {
+          title: '<b>Ana</b>',
+          value: '25%',
+          segments: [{ value: 1, tone: 'ink' }],
+          listTitle: 'Tarefas em aberto (1)',
+          entries: [
+            { text: 'Acesso & API', status: 'Aguardando', tone: 'accent', highlight: true, sub: 'Atrasada', subTone: 'danger' },
+          ],
+        },
+        { title: 'Bruno', value: '100%', segments: [], entries: [], emptyText: 'Tudo concluído.' },
+      ],
+    });
+
+    expect(html).toContain('&lt;b&gt;Ana&lt;/b&gt;');
+    expect(html).toContain('Acesso &amp; API');
+    expect(html).toContain('pc-entry-hl-accent');
+    expect(html).toContain('pc-entry-sub-danger');
+    expect(html).toContain('<div class="pc-empty">Tudo concluído.</div>');
+  });
+});