@hed-hog/core 0.0.401 → 0.0.402

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

@@ -4,7 +4,10 @@ import {
   PdfDocumentBlock,
   PdfDocumentCard,
   PdfDocumentInput,
+  PdfDocumentProgressCard,
   PdfDocumentRow,
+  PdfDocumentSegment,
+  PdfDocumentSegmentTone,
   PdfDocumentTableCell,
   PdfDocumentTableColumn,
 } from './pdf-document.types';
@@ -119,6 +122,99 @@ function renderTable(block: Extract<PdfDocumentBlock, { kind: 'table' }>): strin
   return truncatedNote ? `${table}<div class="note">${escapeHtml(truncatedNote)}</div>` : table;
 }
 
+/** Barra fina empilhada. Largura em % do total; total zero vira barra vazia. */
+function renderSegments(segments: PdfDocumentSegment[]): string {
+  const total = segments.reduce((sum, segment) => sum + Math.max(0, segment.value), 0);
+  const parts =
+    total > 0
+      ? segments
+          .filter((segment) => segment.value > 0)
+          .map(
+            (segment) =>
+              `<span class="seg seg-${segment.tone}" style="width:${((segment.value / total) * 100).toFixed(2)}%"></span>`,
+          )
+          .join('')
+      : '';
+
+  return `<div class="seg-bar">${parts}</div>`;
+}
+
+const dot = (tone: PdfDocumentSegmentTone): string => `<span class="dot dot-${tone}"></span>`;
+
+function renderSegmentBar(block: Extract<PdfDocumentBlock, { kind: 'segmentBar' }>): string {
+  const total = block.segments.reduce((sum, segment) => sum + Math.max(0, segment.value), 0);
+  const legend = block.segments
+    .map((segment) => {
+      const pct = total > 0 ? Math.round((segment.value / total) * 100) : 0;
+      return (
+        `<span class="seg-legend-item">${dot(segment.tone)}${escapeHtml(segment.label ?? '')} ` +
+        `<strong>${segment.value} (${pct}%)</strong></span>`
+      );
+    })
+    .join('');
+
+  return (
+    '<div class="seg-block">' +
+    (block.title ? `<div class="seg-title">${escapeHtml(block.title)}</div>` : '') +
+    renderSegments(block.segments) +
+    `<div class="seg-legend">${legend}</div>` +
+    (block.caption ? `<div class="seg-caption">${escapeHtml(block.caption)}</div>` : '') +
+    '</div>'
+  );
+}
+
+function renderProgressCard(card: PdfDocumentProgressCard): string {
+  const entries = card.entries
+    .map(
+      (entry) =>
+        `<div class="pc-entry${entry.highlight ? ` pc-entry-hl pc-entry-hl-${entry.tone}` : ''}">` +
+        `<div class="pc-entry-text">${escapeHtml(entry.text)}</div>` +
+        '<div class="pc-entry-meta">' +
+        `<span class="pc-entry-status">${dot(entry.tone)}${escapeHtml(entry.status)}</span>` +
+        (entry.aside ? `<span class="pc-entry-aside">${escapeHtml(entry.aside)}</span>` : '') +
+        '</div>' +
+        (entry.sub
+          ? `<div class="pc-entry-sub${entry.subTone === 'danger' ? ' pc-entry-sub-danger' : ''}">${escapeHtml(entry.sub)}</div>`
+          : '') +
+        '</div>',
+    )
+    .join('');
+
+  const body =
+    card.entries.length > 0
+      ? (card.listTitle ? `<div class="pc-list-title">${escapeHtml(card.listTitle)}</div>` : '') + entries
+      : card.emptyText
+        ? `<div class="pc-empty">${escapeHtml(card.emptyText)}</div>`
+        : '';
+
+  return (
+    '<div class="pc-card">' +
+    '<div class="pc-head">' +
+    `<div class="pc-head-text"><div class="pc-title">${escapeHtml(card.title)}</div>` +
+    (card.subtitle ? `<div class="pc-subtitle">${escapeHtml(card.subtitle)}</div>` : '') +
+    '</div>' +
+    `<div class="pc-value"><div class="pc-value-num">${escapeHtml(card.value)}</div>` +
+    (card.valueHint ? `<div class="pc-value-hint">${escapeHtml(card.valueHint)}</div>` : '') +
+    '</div></div>' +
+    renderSegments(card.segments) +
+    body +
+    '</div>'
+  );
+}
+
+function renderProgressCards(block: Extract<PdfDocumentBlock, { kind: 'progressCards' }>): string {
+  const legend = block.legend?.length
+    ? `<div class="pc-legend">${block.legend
+        .map((item) => `<span class="seg-legend-item">${dot(item.tone)}${escapeHtml(item.label)}</span>`)
+        .join('')}</div>`
+    : '';
+
+  return (
+    legend +
+    `<div class="pc-grid pc-grid-${block.columns ?? 2}">${block.items.map(renderProgressCard).join('')}</div>`
+  );
+}
+
 export function renderBlock(block: PdfDocumentBlock): string {
   switch (block.kind) {
     case 'section':
@@ -159,6 +255,12 @@ export function renderBlock(block: PdfDocumentBlock): string {
         '</div>'
       );
 
+    case 'segmentBar':
+      return renderSegmentBar(block);
+
+    case 'progressCards':
+      return renderProgressCards(block);
+
     case 'note':
       return `<div class="note${block.tone === 'accent' ? ' note-accent' : ''}">${escapeHtml(block.text)}</div>`;
 

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

@@ -47,6 +47,47 @@ export interface PdfDocumentTableCell {
 
 export type PdfDocumentRow = Array<string | number | null | undefined | PdfDocumentTableCell>;
 
+/**
+ * Paleta fechada das barras e marcadores — o chamador escolhe o papel, o tema
+ * decide a cor: 'ink' (feito), 'muted' e 'light' (dois cinzas), 'accent' (cor
+ * da marca) e 'danger' (atraso).
+ */
+export type PdfDocumentSegmentTone = 'ink' | 'muted' | 'light' | 'accent' | 'danger';
+
+export interface PdfDocumentSegment {
+  value: number;
+  tone: PdfDocumentSegmentTone;
+  /** Só a barra avulsa (`segmentBar`) mostra rótulo, na legenda abaixo dela. */
+  label?: string;
+}
+
+export interface PdfDocumentProgressEntry {
+  text: string;
+  /** Linha pequena com marcador da cor de `tone` (ex.: "Em revisão"). */
+  status: string;
+  tone: PdfDocumentSegmentTone;
+  /** Texto à direita da linha de status (ex.: "há 3d 4h"). */
+  aside?: string;
+  /** Terceira linha opcional (ex.: o prazo). */
+  sub?: string;
+  subTone?: 'muted' | 'danger';
+  /** Fundo tingido com a cor do `tone` — o item que pede atenção. */
+  highlight?: boolean;
+}
+
+export interface PdfDocumentProgressCard {
+  title: string;
+  subtitle?: string;
+  /** O número grande à direita (ex.: "33%"). */
+  value: string;
+  valueHint?: string;
+  segments: PdfDocumentSegment[];
+  listTitle?: string;
+  entries: PdfDocumentProgressEntry[];
+  /** Mostrado no lugar da lista quando `entries` vem vazio. */
+  emptyText?: string;
+}
+
 export type PdfDocumentBlock =
   | { kind: 'section'; title: string; hint?: string }
   | {
@@ -73,6 +114,17 @@ export type PdfDocumentBlock =
     }
   | { kind: 'chart'; title?: string; svg: SafeSvg; caption?: string }
   | { kind: 'chartGrid'; items: Array<{ title?: string; svg: SafeSvg; caption?: string }> }
+  /** Barra empilhada com legenda "rótulo N (x%)" — a composição de um total. */
+  | { kind: 'segmentBar'; title?: string; segments: PdfDocumentSegment[]; caption?: string }
+  /** Grade de cartões com %, barra e lista de itens — um por pessoa, por exemplo. */
+  | {
+      kind: 'progressCards';
+      items: PdfDocumentProgressCard[];
+      /** Legenda dos marcadores, acima da grade. */
+      legend?: Array<{ label: string; tone: PdfDocumentSegmentTone }>;
+      /** Padrão: 2. */
+      columns?: 1 | 2;
+    }
   | { kind: 'note'; text: string; tone?: 'muted' | 'accent' }
   | { kind: 'legend'; lines: string[] }
   | { kind: 'pageBreak' };

package/src/pdf/pdf.service.ts

@@ -53,6 +53,12 @@ export interface PdfGenerateOptions {
   waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
   /** Ceiling for `page.setContent`, in ms. Defaults to Playwright's own (30s). */
   timeoutMs?: number;
+  /**
+   * JS expression evaluated in the page after `setContent`; the snapshot waits
+   * until it is truthy. For HTML whose layout settles asynchronously (webfonts
+   * loaded via `document.fonts`, measuring scripts that run after them).
+   */
+  readyExpression?: string;
   scale?: number;
   pageRanges?: string;
   /** Short identifier for the logs when a render fails or the queue saturates. */
@@ -385,6 +391,11 @@ export class PdfService {
         waitUntil: options.waitUntil ?? 'networkidle',
         ...(options.timeoutMs ? { timeout: options.timeoutMs } : {}),
       });
+      if (options.readyExpression) {
+        await page.waitForFunction(options.readyExpression, undefined, {
+          ...(options.timeoutMs ? { timeout: options.timeoutMs } : {}),
+        });
+      }
 
       return Buffer.from(await run(page));
     } catch (error) {

package/src/setting/setting.service.ts

@@ -555,6 +555,9 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       'lms-video-frame-capture-interval-seconds',
       'lms-error-modal-enabled',
       'url',
+      // Base dos callbacks OAuth do backend (canais do social): o perfil de
+      // integração mostra a URL exata que o backend envia ao provider.
+      'api-url',
       'app-urls',
       // Hcode Store: liga/desliga a venda no frontend (o backend também
       // recusa o checkout — isto é só para a UI mostrar "Em breve" cedo).

package/src/task/task.service.spec.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { TasksService } from './task.service';
+
+const runMonitoredCron = jest.fn((_prisma: any, _options: any, work: () => any) => work());
+
+jest.mock('../observability/monitored-cron', () => ({ runMonitoredCron }));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { TasksService } = require('./task.service');
 
 const makeDeps = () => {
   const prismaService = { $executeRaw: jest.fn().mockResolvedValue(0) };
@@ -23,6 +29,25 @@ describe('TasksService', () => {
       expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(8);
       expect(deps.settingService.getSettingValues).toHaveBeenCalled();
     });
+
+    it('elege um unico pod por tick via runMonitoredCron', async () => {
+      // Sem eleicao, todos os pods drenavam o access_log ao mesmo tempo e
+      // esgotavam o pool (Sentry 7692792694).
+      const { service, deps } = makeService();
+      await service.clear();
+      expect(runMonitoredCron).toHaveBeenCalledWith(
+        deps.prismaService,
+        expect.objectContaining({ slug: 'core-daily-cleanup', maxRuntimeMinutes: 15 }),
+        expect.any(Function),
+      );
+    });
+
+    it('nao limpa nada quando outro pod ganhou o tick', async () => {
+      runMonitoredCron.mockImplementationOnce(async () => undefined);
+      const { service, deps } = makeService();
+      await service.clear();
+      expect(deps.prismaService.$executeRaw).not.toHaveBeenCalled();
+    });
   });
 
   describe('clearExpiredMfaChallenges (default de batch limit)', () => {
@@ -46,6 +71,57 @@ describe('TasksService', () => {
   });
 
   describe('clearOldAccessLogs', () => {
+    let setTimeoutSpy: ReturnType<typeof jest.spyOn>;
+
+    beforeEach(() => {
+      // A pausa entre lotes nao interessa aqui: resolve na hora.
+      setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((fn: () => void) => {
+        fn();
+        return 0;
+      }) as any);
+    });
+
+    afterEach(() => setTimeoutSpy.mockRestore());
+
+    it('pausa entre lotes cheios, mas nao depois do ultimo', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(42);
+
+      await (service as any).clearOldAccessLogs();
+
+      expect(setTimeoutSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('para sem falhar quando o pool esgota no meio da drenagem', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw
+        .mockResolvedValueOnce(100)
+        .mockRejectedValueOnce(
+          Object.assign(new Error('Timed out fetching a new connection from the connection pool'), {
+            code: 'P2024',
+          }),
+        );
+
+      await expect((service as any).clearOldAccessLogs()).resolves.toBeUndefined();
+      expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(2);
+    });
+
+    it('propaga erro que nao e de pool', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.$executeRaw.mockRejectedValueOnce(new Error('syntax error'));
+
+      await expect((service as any).clearOldAccessLogs()).rejects.toThrow('syntax error');
+    });
+
     it('repete lotes ate drenar o acumulo', async () => {
       // O bug: um unico lote por execucao diaria contra uma ingestao uma ordem
       // de grandeza maior deixava a retencao inalcancavel.

package/src/task/task.service.ts

@@ -1,8 +1,15 @@
-import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import {
+  classifyDatabaseInfraError,
+  Prisma,
+  PrismaService,
+} from '@hed-hog/api-prisma';
 import { Injectable, Logger } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
+import { runMonitoredCron } from '../observability/monitored-cron';
 import { SettingService } from '../setting/setting.service';
 
+const CLEANUP_CRON_SCHEDULE = CronExpression.EVERY_DAY_AT_MIDNIGHT;
+
 /**
  * Teto de tempo da limpeza do `access_log`. Existe para o caso da entrada
  * superar a saída de novo: o laço para e devolve o resto para a execução
@@ -10,6 +17,14 @@ import { SettingService } from '../setting/setting.service';
  */
 const ACCESS_LOG_CLEANUP_BUDGET_MS = 10 * 60 * 1000;
 
+/**
+ * Pausa entre dois lotes cheios do `access_log`. Sem ela o laço emenda um DELETE
+ * de 20 mil linhas no outro e o Postgres (1 CPU) não sobra para o tráfego: as
+ * requests do pod ficam lentas, seguram as 5 conexões do pool e o próprio lote
+ * seguinte morre em "Timed out fetching a new connection" (Sentry 7692792694).
+ */
+const ACCESS_LOG_BATCH_PAUSE_MS = 500;
+
 @Injectable()
 export class TasksService {
   private readonly logger = new Logger(TasksService.name);
@@ -24,9 +39,21 @@ export class TasksService {
    *
    * As tarefas são executadas sequencialmente para evitar contenção excessiva no banco.
    * Cada tarefa possui logging detalhado para monitoramento e troubleshooting.
+   *
+   * O @Cron dispara no mesmo segundo em todos os pods (API e workers); sem a
+   * eleição do `runMonitoredCron` cada um drenava o `access_log` em paralelo,
+   * disputando as mesmas linhas e saturando o banco.
    */
-  @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
+  @Cron(CLEANUP_CRON_SCHEDULE)
   async clear() {
+    await runMonitoredCron(
+      this.prismaService,
+      { slug: 'core-daily-cleanup', schedule: CLEANUP_CRON_SCHEDULE, maxRuntimeMinutes: 15 },
+      () => this.runCleanup(),
+    );
+  }
+
+  private async runCleanup(): Promise<void> {
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
     this.logger.verbose('Running scheduled cleanup tasks');
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
@@ -307,18 +334,18 @@ export class TasksService {
     let deleted = 0;
     let batches = 0;
     for (;;) {
-      const removed = await this.prismaService.$executeRaw`
-        WITH del AS (
-          SELECT id
-          FROM access_log
-          WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
-          ORDER BY id
-          LIMIT ${batchLimit}
-        )
-        DELETE FROM access_log al
-        USING del
-        WHERE al.id = del.id
-      `;
+      let removed: number;
+      try {
+        removed = await this.deleteAccessLogBatch(retentionDays, batchLimit);
+      } catch (error) {
+        // Limpeza é best-effort: com o pool saturado o resto fica para a próxima
+        // execução, como no estouro do orçamento de tempo.
+        if (classifyDatabaseInfraError(error) !== 'pool') throw error;
+        this.logger.warn(
+          `Access log cleanup stopped on a saturated connection pool after ${deleted} rows; the remainder goes on the next run.`,
+        );
+        break;
+      }
 
       deleted += removed;
       batches += 1;
@@ -331,6 +358,8 @@ export class TasksService {
         );
         break;
       }
+
+      await new Promise((resolve) => setTimeout(resolve, ACCESS_LOG_BATCH_PAUSE_MS));
     }
 
     this.logger.verbose(
@@ -338,6 +367,21 @@ export class TasksService {
     );
   }
 
+  private deleteAccessLogBatch(retentionDays: number, batchLimit: number): Promise<number> {
+    return this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM access_log
+        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM access_log al
+      USING del
+      WHERE al.id = del.id
+    `;
+  }
+
   private async clearOldNotifications(): Promise<void> {
     const settings = await this.settingService.getSettingValues([
       'cleanup-batch-limit',

package/src/whatsapp-sender/whatsapp-sender.service.spec.ts

@@ -1,6 +1,8 @@
 import {
   WhatsappSendError,
   WhatsappSenderService,
+  WHATSAPP_OFFICIAL_ONLY,
+  toTemplateParam,
 } from './whatsapp-sender.service';
 
 describe('WhatsappSenderService', () => {
@@ -171,15 +173,203 @@ describe('WhatsappSenderService', () => {
       const error = await sendAndCatch();
 
       expect(error.retryable).toBe(false);
+      expect(error.isTransient).toBe(false);
       expect(error.message).toMatch(/HTTP 400/);
     });
 
     it('5xx e 429 podem ser tentados de novo', async () => {
       respond(502, {});
-      expect((await sendAndCatch()).retryable).toBe(true);
+      const serverError = await sendAndCatch();
+      expect(serverError.retryable).toBe(true);
+      expect(serverError.isTransient).toBe(true);
 
       respond(429, {});
       expect((await sendAndCatch()).retryable).toBe(true);
     });
+
+    it('sessao fechada na Evolution pede para reconectar a instancia', async () => {
+      respond(500, {
+        status: 500,
+        error: 'Internal Server Error',
+        response: { message: 'Connection Closed' },
+      });
+
+      const error = await sendAndCatch();
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(true);
+      expect(error.isTransient).toBe(true);
+      expect(error.message).toMatch(/desconectada/);
+      expect(error.message).toMatch(/Reconecte a instância/);
+    });
+  });
+
+  // Sem phone_number_id no envio nem no perfil, vale o número padrão que a
+  // library whatsapp registra — senão cada comunicação pede o id à mão.
+  describe('número padrão do perfil no provider oficial', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    const build = (phoneNumber: any, withDelegate = true) => {
+      const prisma: any = {
+        integration_profile: {
+          findUnique: jest.fn().mockResolvedValue({
+            id: 15,
+            slug: 'whatsapp-api-hcode',
+            config: { access_token: 'token' },
+            integration_provider: { slug: 'whatsapp-official' },
+            integration_type: { slug: 'whatsapp' },
+          }),
+          findFirst: jest.fn(),
+        },
+      };
+      if (withDelegate) {
+        prisma.whatsapp_phone_number = {
+          findFirst: jest.fn().mockResolvedValue(phoneNumber),
+        };
+      }
+      return { prisma, service: new WhatsappSenderService(prisma) };
+    };
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('envia pelo número padrão quando o chamador não informa', async () => {
+      const { prisma, service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({ profileSlug: 'whatsapp-api-hcode', to: '5511999999999', text: 'oi' });
+
+      expect(prisma.whatsapp_phone_number.findFirst).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: { integration_profile_id: 15, is_default: true, status: 'active' },
+        }),
+      );
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/1188434797689179/messages');
+    });
+
+    it('o id informado pelo chamador vence o padrão', async () => {
+      const { prisma, service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({
+        profileSlug: 'whatsapp-api-hcode',
+        to: '5511999999999',
+        text: 'oi',
+        phoneNumberId: '555',
+      });
+
+      expect(prisma.whatsapp_phone_number.findFirst).not.toHaveBeenCalled();
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/555/messages');
+    });
+
+    it('sem padrão nem tabela, recusa sem chamar a Graph API', async () => {
+      const { service } = build(null, false);
+
+      await expect(
+        service.send({ profileSlug: 'whatsapp-api-hcode', to: '5511999999999', text: 'oi' }),
+      ).rejects.toThrow('não tem número padrão');
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('achata as quebras de linha dos parâmetros do template', async () => {
+      const { service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({
+        profileSlug: 'whatsapp-api-hcode',
+        to: '5511999999999',
+        text: 'oi',
+        template: { name: 'lms_resumo', params: ['Maria', 'linha 1\n\nlinha 2'] },
+      });
+
+      const body = JSON.parse(fetchSpy.mock.calls[0][1].body);
+      expect(body.template.components[0].parameters).toEqual([
+        { type: 'text', text: 'Maria' },
+        { type: 'text', text: 'linha 1 · linha 2' },
+      ]);
+    });
+  });
+
+  describe('toTemplateParam', () => {
+    it('troca quebra de linha e tab por separador e colapsa espaços', () => {
+      expect(toTemplateParam('a\n\nb\tc     d')).toBe('a · b · c d');
+    });
+
+    it('não deixa parâmetro vazio, que a Meta recusa', () => {
+      expect(toTemplateParam('  ')).toBe('-');
+      expect(toTemplateParam(undefined)).toBe('-');
+    });
+  });
+
+  // Envio em lote para aluno não pode sair pela Evolution (WhatsApp Web): um
+  // disparo desses desconectou e bloqueou o número por 24h.
+  describe('restrição de provider', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('recusa um perfil Evolution escolhido à mão, sem nova tentativa', async () => {
+      const { service } = buildService('evolution-api');
+
+      const error = await service
+        .send({
+          profileSlug: 'hcode',
+          to: '5511999999999',
+          text: 'oi',
+          providers: WHATSAPP_OFFICIAL_ONLY,
+        })
+        .catch((e) => e);
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(false);
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('sem perfil escolhido, o fallback só procura perfis do provider exigido', async () => {
+      const { prisma, service } = buildService('whatsapp-official');
+      prisma.integration_profile.findFirst.mockResolvedValue({
+        id: 15,
+        slug: 'whatsapp-api-hcode',
+        config: { access_token: 'token', phone_number_id: '1188434797689179' },
+        integration_provider: { slug: 'whatsapp-official' },
+        integration_type: { slug: 'whatsapp' },
+      });
+
+      await service.send({ to: '5511999999999', text: 'oi', providers: WHATSAPP_OFFICIAL_ONLY });
+
+      expect(prisma.integration_profile.findFirst).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            integration_provider: { slug: { in: ['whatsapp-official'] } },
+          }),
+        }),
+      );
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/1188434797689179/messages');
+    });
+
+    it('isConfigured é falso para perfil de outro provider', async () => {
+      const { service } = buildService('evolution-api');
+
+      await expect(service.isConfigured('hcode', WHATSAPP_OFFICIAL_ONLY)).resolves.toBe(false);
+    });
+
+    it('sem restrição, a Evolution continua aceita', async () => {
+      const { service } = buildService('evolution-api');
+
+      await expect(service.isConfigured('hcode')).resolves.toBe(false);
+      // `false` aqui é só por falta de baseUrl/token no config de teste — o
+      // perfil foi resolvido, não recusado.
+      await expect(
+        service.describeProfile('hcode'),
+      ).resolves.toMatchObject({ providerSlug: 'evolution-api' });
+    });
   });
 });