@aksp/opencrew 1.5.0 → 1.6.1

package/templates/_opencrew/core/scripts/verificar/proibicoes.mjs

@@ -0,0 +1,100 @@
+// Proibições da memória da crew: os itens de `## Proibições Explícitas` do `memories.md`.
+// Numa linha, vale como proibido o termo entre aspas até o primeiro marcador de troca; o que vem
+// depois do marcador é termo preferido. Spec: fase-r1-reparos-1-6-1.md, regra 11.
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { lerTexto, semAcento } from './leitura.mjs';
+
+// Entre aspas retas o termo não começa nem acaba por espaço ou aspa: `""` e a polegada de `15"`
+// não abrem um par, e o termo de verdade, mais adiante na linha, continua sendo lido.
+const ASPAS = /"([^\s"](?:[^"]{0,198}[^\s"])?)"|“([^”]{1,200})”|‘([^’]{1,200})’|`([^`]{1,200})`|(?<![\p{L}])'([^']{1,200})'(?![\p{L}])/gu;
+const MARCADORES = new Set(['prefira', 'preferir', 'use', 'usar', 'utilize', 'utilizar', '→', '->']);
+const NEGACOES = new Set('nao nunca nem jamais sem evite evitar proibido proibida proibidos proibidas vetado vetada parar pare deixar deixe'.split(' '));
+// Com estas expressões a linha está escrita ao contrário: todos os termos continuam proibidos.
+const SEM_TROCA = /(?<![\p{L}\p{N}])(?:em vez de|ao inves de|no lugar de)(?![\p{L}\p{N}])/u;
+
+/** Fichas da linha, na ordem: termos entre aspas, e palavras e setas de fora das aspas. */
+function fichas(linha) {
+  const saida = [];
+  let pos = 0;
+  const deFora = (ate) => {
+    for (const m of linha.slice(pos, ate).matchAll(/[\p{L}\p{N}]+|→|->/gu)) {
+      saida.push({ palavra: semAcento(m[0]), fim: pos + m.index + m[0].length });
+    }
+  };
+  for (const m of linha.matchAll(ASPAS)) {
+    deFora(m.index);
+    saida.push({ termo: m.slice(1).find(Boolean), inicio: m.index });
+    pos = m.index + m[0].length;
+  }
+  deFora(linha.length);
+  return saida;
+}
+
+/** `por` só é marcador logo antes de um termo entre aspas. */
+function ehMarcador(f, i, linha) {
+  const { palavra, fim } = f[i];
+  if (MARCADORES.has(palavra)) return true;
+  const depois = f[i + 1];
+  return palavra === 'por' && depois?.termo != null && linha.slice(fim, depois.inicio).trim() === '';
+}
+
+/** Há negação entre as 3 palavras antes do marcador? A procura para no termo entre aspas anterior. */
+function negado(f, i) {
+  for (let n = 1; n <= 3 && f[i - n]?.palavra; n++) {
+    if (NEGACOES.has(f[i - n].palavra)) return true;
+  }
+  return false;
+}
+
+/** Posição do primeiro marcador de troca que vale: depois do primeiro termo e sem negação antes. */
+function primeiroMarcador(f, linha) {
+  const primeiroTermo = f.findIndex((x) => x.termo != null);
+  const deFora = f.filter((x) => x.palavra).map((x) => x.palavra).join(' ');
+  if (primeiroTermo < 0 || SEM_TROCA.test(deFora)) return -1;
+  return f.findIndex((x, i) => i > primeiroTermo && x.palavra && ehMarcador(f, i, linha) && !negado(f, i));
+}
+
+/** Termos proibidos e termos preferidos de uma linha de proibição. */
+export function lerLinha(linha) {
+  const f = fichas(linha);
+  const corte = primeiroMarcador(f, linha);
+  const termos = (de, ate) => f.slice(de, ate).filter((x) => x.termo != null).map((x) => x.termo);
+  return corte < 0 ? { proibidos: termos(0), preferidos: [] } : { proibidos: termos(0, corte), preferidos: termos(corte) };
+}
+
+/**
+ * Itens de lista (`-`, `*`, `+` ou numerada) da seção "Proibições Explícitas" — cabeçalho de
+ * nível 2 a 4, com ou sem símbolo antes do texto —, até o próximo cabeçalho do mesmo nível ou
+ * acima, ou até uma linha `---`.
+ */
+function itensDaSecao(texto) {
+  const linhas = texto.split(/\r?\n/);
+  const titulos = linhas.map((l) => l.match(/^(#{2,4})\s+(.*)$/s));
+  const inicio = titulos.findIndex((t) => t && semAcento(t[2]).replace(/^[^\p{L}\p{N}]+/u, '').startsWith('proibicoes explicitas'));
+  if (inicio < 0) return [];
+  const acima = new RegExp(`^#{1,${titulos[inicio][1].length}}\\s`);
+  const resto = linhas.slice(inicio + 1);
+  const fim = resto.findIndex((l) => acima.test(l) || l.trim() === '---');
+  return resto.slice(0, fim < 0 ? resto.length : fim).filter((l) => /^\s*(?:[-*+]|\d{1,3}[.)])\s+/.test(l));
+}
+
+/**
+ * Proibições da crew. Itens sem aspas são contados, mas não verificados.
+ * @returns {Promise<{ existe: boolean, termos: string[], preferidos: string[], semAspas: number }>}
+ */
+export async function lerProibicoes(raiz, crew) {
+  // `resolve`, não `join`: a crew pode vir em caminho absoluto de dentro do projeto.
+  const arquivo = path.resolve(raiz, crew, '_memory', 'memories.md');
+  const r = { existe: existsSync(arquivo), termos: [], preferidos: [], semAspas: 0 };
+  if (!r.existe) return r;
+  for (const linha of itensDaSecao(await lerTexto(arquivo))) {
+    const { proibidos, preferidos } = lerLinha(linha);
+    if (!proibidos.length && !preferidos.length) r.semAspas += 1;
+    r.termos.push(...proibidos);
+    r.preferidos.push(...preferidos);
+  }
+  const proibido = new Set(r.termos.map(semAcento));
+  r.preferidos = r.preferidos.filter((t) => !proibido.has(semAcento(t)));
+  return r;
+}

package/templates/_opencrew/core/scripts/verificar/regras.mjs

@@ -1,95 +1,116 @@
-// Regras do verificador automático (specs/fase-u1-revisor-com-dentes.md §5).
-// Máximos bloqueiam (fácil de corrigir: encurtar); mínimos alertam (podem depender do usuário).
-import { lerFrontmatter, semFrontmatter, semAcento } from './leitura.mjs';
+// Checagens gerais do verificador automático — valem para qualquer arquivo de texto:
+// placeholders, [PREENCHER], termos proibidos e afirmações a confirmar.
+// Specs: fase-u1-revisor-com-dentes.md §5 e fase-r1-reparos-1-6-1.md, regras 8 e 10.
+// As expressões regulares daqui rodam sobre texto do usuário: nenhuma tem repetição sem teto
+// que possa recomeçar em cada posição do texto.
+import { semFrontmatter, semDiacritico } from './leitura.mjs';
 
 const segmentador = new Intl.Segmenter('pt', { granularity: 'grapheme' });
 
 /** Bloqueio que só o usuário resolve ([PREENCHER: …]). */
 export const FALTA_INFO = 'Falta informação sua';
+/** Itens das linhas "Não medido — …" e "Não verificado — …" (nível: alerta ou nenhum). */
+export const NAO_MEDIDO = 'Não medido';
+export const NAO_VERIFICADO = 'Não verificado';
 
-/** Caracteres visíveis: sem marcadores de negrito/itálico; emoji conta 1. */
+/** Caracteres visíveis: sem marcadores de negrito/itálico; emoji conta 1; quebra de linha conta. */
 export function contar(texto) {
   const limpo = String(texto).replace(/\*\*|__/g, '').replace(/\*([^*\n]+)\*/g, '$1').trim();
   return [...segmentador.segment(limpo)].length;
 }
 
-const contarHashtags = (texto) => (texto.match(/#[\p{L}\p{N}_]+/gu) ?? []).length;
+export const item = (nome, medido, limite, nivel, detalhe = '') => ({ item: nome, medido, limite, nivel, detalhe });
 
-const item = (nome, medido, limite, nivel, detalhe = '') => ({ item: nome, medido, limite, nivel, detalhe });
+const TRECHO = /[^\s()[\]<>"']+/g; // trecho sem espaço: um link, um número, uma palavra
+const REPETIDO = /(\d)\1{5,}/; // 6 ou mais dígitos iguais seguidos
+const COR_HEX = /#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3})(?![0-9a-z])/gi;
+const EM_LINK = /http|wa\.me|tel:|\//i;
+const VARIAVEL = /\{\{[^{}\n]{1,100}\}\}/g;
+const EXPRESSOES = [
+  /\[(?:empresa|cliente|nome|feira|evento|produto|cidade|link|url|telefone|e-?mail|data)\b[^\]]{0,200}\](?!\()/giu,
+  /lorem ipsum/gi,
+  /\bX{3,}\b(?![ \t]+\p{Lu})/gu, // "XXX Congresso" é numeral romano, não placeholder
+];
+const DOMINIOS = /\b(?:example\.com|seusite\.com(?:\.br)?|suaempresa\.com(?:\.br)?)\b/gi;
 
-function maximo(nome, medido, limite) {
-  if (typeof limite !== 'number') return null;
-  return item(nome, medido, limite, medido > limite ? 'bloqueio' : 'ok');
+function semPontuacaoFinal(s) {
+  let fim = s.length;
+  while (fim > 0 && '.,;:!?'.includes(s[fim - 1])) fim--;
+  return s.slice(0, fim);
 }
 
-function minimo(nome, medido, limite) {
-  if (typeof limite !== 'number') return null;
-  return item(nome, medido, limite, medido < limite ? 'alerta' : 'ok');
+/**
+ * Dígitos repetidos só contam em link ou telefone: trecho com `http`, `wa.me`, `tel:` ou `/`,
+ * ou sequência de 10 dígitos ou mais. Cor hexadecimal nunca conta.
+ */
+function digitosRepetidos(texto) {
+  const achados = [];
+  for (const [trecho] of texto.matchAll(TRECHO)) {
+    const semCor = trecho.replace(COR_HEX, '');
+    if (!REPETIDO.test(semCor)) continue;
+    const telefone = (semCor.match(/\d{10,}/g) ?? []).some((seq) => REPETIDO.test(seq));
+    if (telefone || EM_LINK.test(semCor)) achados.push(trecho);
+  }
+  return achados;
 }
 
-const NAO_CONTA = /^(mailto:|tel:|https?:\/\/(wa\.me|api\.whatsapp\.com)\/)/i;
+/** O texto tem `{{variável}}` de personalização? */
+export const temVariavel = (texto) => texto.search(VARIAVEL) >= 0;
 
-function contarLinks(corpo, dominio) {
-  const urls = [...corpo.matchAll(/\[[^\]]*\]\(([^)\s]+)[^)]*\)/g)].map((m) => m[1]).filter((u) => !NAO_CONTA.test(u));
-  const interno = (u) => !/^https?:\/\//i.test(u) || (dominio && new URL(u).hostname.replace(/^www\./, '') === dominio);
-  return { internos: urls.filter(interno).length, externos: urls.filter((u) => !interno(u)).length };
-}
+/** O detalhe de um achado nunca cresce com o arquivo: acima do teto, é cortado com reticências. */
+const cortar = (s, teto) => (s.length > teto ? `${s.slice(0, teto).trimEnd()}…` : s);
 
-/** Blog: frontmatter com título → título, meta description e links. */
-export function regrasBlog(texto, limites, dominio) {
-  const fm = lerFrontmatter(texto);
-  const titulo = fm?.title ?? fm?.titulo;
-  if (titulo == null || !limites) return [];
-  const meta = fm.meta_description ?? fm.meta_descricao;
-  const { internos, externos } = contarLinks(semFrontmatter(texto), dominio);
-  return [
-    maximo('Título (SEO) — caracteres', contar(titulo), limites.title_max_chars),
-    meta != null ? maximo('Meta description — caracteres', contar(meta), limites.meta_description_chars) : null,
-    minimo('Links internos', internos, limites.min_internal_links),
-    minimo('Links externos', externos, limites.min_external_links),
-  ].filter(Boolean);
+function placeholders(texto, variavelBloqueia) {
+  const expressoes = [...EXPRESSOES, ...(variavelBloqueia ? [VARIAVEL] : []), DOMINIOS];
+  const achados = [...digitosRepetidos(texto), ...expressoes.flatMap((rx) => [...texto.matchAll(rx)].map((m) => m[0]))];
+  return achados.map((achado) => item('Placeholder', null, null, 'bloqueio', cortar(semPontuacaoFinal(achado), 160)));
 }
 
-/** Seções por canal (cabeçalhos "Legenda Instagram", "Post LinkedIn", "Tweet"…). */
-export function regrasCanais(secoes, limitesPorFormato) {
-  const itens = [];
-  for (const s of secoes) {
-    const t = semAcento(s.titulo);
-    const ig = limitesPorFormato['instagram-feed'];
-    if (/instagram/.test(t) && /legenda|caption/.test(t) && ig) {
-      itens.push(maximo('Legenda Instagram — caracteres', contar(s.corpo), ig.caption_max_chars));
-      itens.push(maximo('Legenda Instagram — hashtags', contarHashtags(s.corpo), ig.hashtags_max));
-    } else if (/instagram/.test(t) && /carrossel|carousel/.test(t) && ig) {
-      const slides = (s.corpo.match(/^\s*(?:#{3,6}\s*|\*\*\s*)slide\s*\d+/gim) ?? []).length;
-      if (slides) itens.push(maximo('Carrossel Instagram — slides', slides, ig.carousel_max_slides));
-    }
-    const li = limitesPorFormato['linkedin-post'];
-    if (/linkedin/.test(t) && !/carrossel|carousel/.test(t) && li) {
-      itens.push(maximo('Post LinkedIn — caracteres', contar(s.corpo), li.post_max_chars));
-      itens.push(maximo('Post LinkedIn — hashtags', contarHashtags(s.corpo), li.hashtags_max));
-    }
-    const tw = limitesPorFormato['twitter-post'];
-    if (/tweet|twitter/.test(t) && tw) {
-      s.corpo.split(/\n\s*\n/).filter((p) => p.trim()).forEach((p, i) => {
-        const r = maximo(`Tweet ${i + 1} — caracteres`, contar(p), tw.tweet_max_chars);
-        if (r?.nivel === 'bloqueio') itens.push(r);
-      });
-    }
+/**
+ * `[PREENCHER: …]`, de qualquer tamanho, numa passada só: cada abertura vai até o primeiro `]`;
+ * a que cai dentro do pedido anterior é pulada; sem `]` adiante, a busca para.
+ */
+function pedidosAoUsuario(texto) {
+  const pedidos = [];
+  let fecha = -1;
+  for (const m of texto.matchAll(/\[PREENCHER:?/giu)) {
+    if (m.index < fecha) continue;
+    fecha = texto.indexOf(']', m.index);
+    if (fecha < 0) break;
+    const dentro = texto.slice(m.index + m[0].length, fecha).trim();
+    pedidos.push(item(FALTA_INFO, null, null, 'bloqueio', cortar(dentro, 300) || texto.slice(m.index, fecha + 1)));
   }
-  return itens.filter(Boolean);
+  return pedidos;
 }
 
-const PLACEHOLDERS = [
-  /(?:https?:\/\/)?[^\s()[\]<>"']*?(\d)\1{5,}[^\s()[\]<>"']*/g, // 6+ dígitos repetidos (wa.me/5584999999999)
-  /\[(?:empresa|cliente|nome|feira|evento|produto|cidade|link|url|telefone|e-?mail|data)\b[^\]]*\](?!\()/giu,
-  /lorem ipsum/gi,
-  /\bX{3,}\b/g,
-  /\{\{[^}]+\}\}/g,
-  /\b(?:example\.com|seusite\.com(?:\.br)?|suaempresa\.com(?:\.br)?)\b/gi,
-];
+const ESPECIAIS = /[.*+?^${}()|[\]\\]/g;
+const BORDA = '[\\p{L}\\p{N}]';
+
+/**
+ * Termo proibido é palavra inteira, com plural simples (`s`, `es`), sem diferenciar maiúsculas e
+ * acentos. Sigla (até 5 letras, todas maiúsculas) compara diferenciando maiúsculas. Entre as
+ * palavras do termo vale qualquer espaço: quebra de linha, dois espaços, espaço não separável.
+ */
+function casaTermo(termo, exato, minusculo) {
+  const alvo = semDiacritico(termo.trim());
+  if (!alvo) return false;
+  const sigla = /^\p{Lu}{1,5}$/u.test(alvo);
+  const padrao = (sigla ? alvo : alvo.toLowerCase()).replace(ESPECIAIS, '\\$&').replace(/\s+/g, '\\s+');
+  const rx = new RegExp(`(?<!${BORDA})${padrao}(?:[sS]|[eE][sS])?(?!${BORDA})`, 'u');
+  return rx.test(sigla ? exato : minusculo);
+}
+
+function termosProibidos(texto, proibidos) {
+  const exato = semDiacritico(texto);
+  const minusculo = exato.toLowerCase();
+  return proibidos
+    .filter((termo) => casaTermo(termo, exato, minusculo))
+    .map((termo) => item('Termo proibido (memória da crew)', null, null, 'bloqueio', termo));
+}
 
 const PRIMEIRA_PESSOA = /(?<!\p{L})(eu|nós|nosso|nossa|nossos|nossas|investimos|atendemos|fizemos|ajudamos|fundamos|começamos|criamos|entregamos|nossa equipe)(?!\p{L})/iu;
-const DADO_CONCRETO = /R\$\s?\d|US\$\s?\d|\d+([.,]\d+)?\s?%|\d+\s+(clientes|empresas|eventos|anos|projetos|pessoas)/iu;
+// `(?<!\d)`: só o começo de cada número é tentado.
+const DADO_CONCRETO = /R\$\s?\d|US\$\s?\d|(?<!\d)\d+(?:[.,]\d+)?\s?%|(?<!\d)\d+\s+(?:clientes|empresas|eventos|anos|projetos|pessoas)/iu;
 
 // Ano só conta como dado concreto se for passado: "Congresso 2026" (ano atual/futuro) é nome de
 // evento, não afirmação sobre a história da empresa (achado no uso real).
@@ -99,29 +120,27 @@ function temDadoConcreto(frase) {
   return [...frase.matchAll(/(?<!\d)((?:19|20)\d{2})(?!\d)/g)].some((m) => Number(m[1]) < atual);
 }
 
-const citar = (frase) => {
-  const limpa = frase.replace(/\*\*|__/g, '').replace(/\*([^*\n]+)\*/g, '$1').trim();
-  return limpa.length > 160 ? `${limpa.slice(0, 160).trimEnd()}…` : limpa;
-};
-
-/** Checagens que valem para qualquer texto. */
-export function regrasGerais(texto, proibidos) {
-  const corpo = semFrontmatter(texto);
-  const itens = [];
-  for (const rx of PLACEHOLDERS) {
-    for (const m of texto.matchAll(rx)) itens.push(item('Placeholder', null, null, 'bloqueio', m[0].replace(/[.,;:!?]+$/, '')));
-  }
-  for (const m of texto.matchAll(/\[PREENCHER:?\s*([^\]]*)\]/giu)) {
-    itens.push(item(FALTA_INFO, null, null, 'bloqueio', m[1].trim() || m[0]));
-  }
-  const normal = semAcento(texto);
-  for (const termo of proibidos) {
-    if (normal.includes(semAcento(termo))) itens.push(item('Termo proibido (memória da crew)', null, null, 'bloqueio', termo));
-  }
-  for (const frase of corpo.split(/(?<=[.!?])\s+|\n+/)) {
-    if (PRIMEIRA_PESSOA.test(frase) && temDadoConcreto(frase)) {
-      itens.push(item('Afirmação a confirmar', null, null, 'alerta', citar(frase)));
-    }
-  }
-  return itens;
+const citar = (frase) => cortar(frase.replace(/\*\*|__/g, '').replace(/\*([^*\n]+)\*/g, '$1').trim(), 160);
+
+function afirmacoes(corpo) {
+  return corpo
+    .split(/(?<=[.!?])\s+|\n+/)
+    .filter((frase) => PRIMEIRA_PESSOA.test(frase) && temDadoConcreto(frase))
+    .map((frase) => item('Afirmação a confirmar', null, null, 'alerta', citar(frase)));
+}
+
+/**
+ * Checagens que valem para qualquer texto.
+ * @param {string} texto
+ * @param {string[]} proibidos termos proibidos da memória da crew
+ * @param {{ variavelBloqueia?: boolean }} [opcoes] false em e-mail e WhatsApp: `{{variável}}`
+ *   vira nota informativa (quem chama escreve a nota)
+ */
+export function regrasGerais(texto, proibidos, { variavelBloqueia = true } = {}) {
+  return [
+    ...placeholders(texto, variavelBloqueia),
+    ...pedidosAoUsuario(texto),
+    ...termosProibidos(texto, proibidos),
+    ...afirmacoes(semFrontmatter(texto)),
+  ];
 }

package/templates/_opencrew/core/scripts/verificar/relatorio.mjs

@@ -0,0 +1,43 @@
+// Relatório do verificador em markdown (PT-BR). A última linha é o status que o runner lê.
+import { NAO_MEDIDO, NAO_VERIFICADO } from './regras.mjs';
+
+const ROTULO = { bloqueio: '❌ Bloqueio', alerta: '⚠️ Alerta', ok: '✅ OK' };
+const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
+const ehNaoMedido = (i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO;
+
+function tabela(medidos) {
+  if (!medidos.length) return [];
+  const linhas = medidos.map((i) => `| ${i.item.replace(/\|/g, '\\|')} | ${i.medido} | ${i.minimo ? '≥' : '≤'} ${i.limite} | ${ROTULO[i.nivel]} |`);
+  return ['| Item | Medido | Limite | Resultado |', '|---|---|---|---|', ...linhas];
+}
+
+/** "Não medido" e "Não verificado" começam por ⚠️ quando são alerta e por ⚪ quando não têm nível. */
+function linhaDoAchado(i) {
+  if (ehNaoMedido(i)) return `- ${i.nivel === 'alerta' ? '⚠️' : '⚪'} ${i.item} — ${i.detalhe}`;
+  return `- ${ROTULO[i.nivel]} — ${i.item}: "${i.detalhe}"`;
+}
+
+function secaoDoArquivo(a) {
+  const medidos = tabela(a.itens.filter((i) => i.medido != null));
+  const achados = a.itens.filter((i) => i.medido == null).map(linhaDoAchado);
+  if (a.fecho) achados.push(`- ${a.fecho}`);
+  const entre = medidos.length && achados.length ? [''] : [];
+  return [`### ${a.arquivo}`, '', ...medidos, ...entre, ...achados, ''];
+}
+
+/** @param {object} r resultado de `verificar()` */
+export function formatarRelatorio(r) {
+  const naoTexto = r.naoTexto ?? [];
+  const notas = [...r.notas];
+  if (naoTexto.length) notas.push(`⚪ ${NAO_VERIFICADO} — não é texto (${naoTexto.length}): ${naoTexto.join(', ')}`);
+  const resumo = [plural(r.bloqueios, 'bloqueio', 'bloqueios'), plural(r.alertas, 'alerta', 'alertas'), plural(r.naoMedidos ?? 0, 'não medido', 'não medidos')];
+  return [
+    '## Verificação automática',
+    '',
+    ...r.arquivos.flatMap(secaoDoArquivo),
+    ...(notas.length ? ['**Notas:**', ...notas.map((n) => `- ${n}`), ''] : []),
+    `**Resumo: ${resumo.join(', ')}**`,
+    '',
+    `VERIFICACAO:${r.status}`,
+  ].join('\n');
+}

package/templates/_opencrew/core/scripts/verificar/secoes.mjs

@@ -0,0 +1,145 @@
+// Seções de um texto nos dois jeitos de escrever: cabeçalho markdown e linha `=== RÓTULO ===`.
+// Devolve os trechos que podem virar peça, cada um com o seu texto próprio (o corpo sem os
+// trechos das candidatas de dentro). Nenhuma expressão regular daqui refaz a linha inteira a cada
+// tentativa: a do cabeçalho leva a flag `s`, para o resto da linha nunca falhar.
+import { semAcento } from './leitura.mjs';
+
+export const BLOG = ['blog-post', 'blog-seo'];
+
+// Palavra inteira (antes e depois não há letra nem dígito), com o plural escrito em cada forma.
+const palavra = (formas) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${formas})(?![\\p{L}\\p{N}])`, 'u');
+const CANAL = { instagram: palavra('instagram'), linkedin: palavra('linkedin'), twitter: palavra('twitter|tweets?') };
+// "Slide N" é um slide, não um carrossel: o singular fica de fora.
+const PECA = {
+  legenda: palavra('legendas?|captions?'),
+  slides: palavra('carrossel|carrosseis|carousels?|slides'),
+  post: palavra('posts?'),
+  hashtags: palavra('hashtags?'),
+};
+// Linha de slide: "Slide N" ou "Slide #N", com até 12 caracteres que não são letra nem dígito
+// antes (emoji, colchete, ">", "|", "#", negrito, espaço).
+const SLIDE_N = /^[^\p{L}\p{N}]{0,12}slide\s{0,3}#?(\d{1,4})(?!\d)/iu;
+// Cabeçalho que começa por "hashtags" é só hashtags, com qualquer palavra depois.
+const SO_HASHTAGS = /^(?:\*\*|__|\*|_)?\s*hashtags?(?![\p{L}\p{N}])/u;
+const FORMATO_DO_CANAL = { instagram: 'instagram-feed', linkedin: 'linkedin-post', twitter: 'twitter-post' };
+// Só a cerca de código: três crases ou três tis, com ou sem o nome da linguagem.
+const CERCA = /^(?:`{3,}|~{3,})[ \t]{0,3}[\p{L}\p{N}_+.#-]{0,30}$/u;
+
+/** Número do slide de uma linha que começa por "Slide N" (cabeçalho, negrito, item ou texto). */
+export function numeroDoSlide(linha) {
+  const m = linha.trim().replace(/^(?:#{1,6}|[-*+]|\d{1,3}[.)])\s+/, '').match(SLIDE_N);
+  return m ? Number(m[1]) : null;
+}
+
+/** `=== RÓTULO ===` → o rótulo inteiro, em maiúsculas; qualquer outra linha → null. */
+export function rotuloDe(linha) {
+  const t = linha.trim();
+  let inicio = 0;
+  let fim = t.length;
+  while (t[inicio] === '=') inicio++;
+  while (fim > inicio && t[fim - 1] === '=') fim--;
+  const nome = t.slice(inicio, fim).trim();
+  return inicio >= 3 && t.length - fim >= 3 && nome ? nome.toUpperCase().replace(/\s+/g, ' ') : null;
+}
+
+/**
+ * Cada linha vira uma marca: rótulo, cabeçalho ou texto. A linha `---` e a que é só a cerca de
+ * código não contam como texto. Com `comRotulos` false (formato declarado fora da tabela), a
+ * linha `=== RÓTULO ===` é texto comum.
+ */
+export function marcar(corpo, comRotulos = true) {
+  const marcas = [];
+  for (const linha of corpo.split(/\r?\n/)) {
+    if (linha.startsWith('---') && linha.trim() === '---') continue;
+    if (CERCA.test(linha.trim())) continue;
+    const rotulo = comRotulos ? rotuloDe(linha) : null;
+    const h = rotulo ? null : linha.match(/^(#{1,6})\s+(.*)$/s);
+    if (rotulo) marcas.push({ rotulo });
+    else if (h) marcas.push({ nivel: h[1].length, titulo: h[2].trim(), norm: semAcento(h[2]), linha });
+    else marcas.push({ linha });
+  }
+  return marcas;
+}
+
+/**
+ * A que peças o cabeçalho é candidato (regras 3 e 4): casa com a peça pelo próprio texto, ou tem
+ * a palavra da peça e o canal vem do formato declarado ou de um cabeçalho que o contém.
+ * @param {string} t cabeçalho sem acentos e em minúsculas
+ * @param {string[]} acima cabeçalhos que contêm este, na mesma forma
+ * @param {string|null} formato formato declarado da tabela, ou null
+ */
+export function candidaturas(t, acima, formato) {
+  if (BLOG.includes(formato)) return []; // em blog, cabeçalho é conteúdo
+  if (numeroDoSlide(t) != null) return []; // "Slide N" é um slide, com qualquer palavra depois do número
+  if (SO_HASHTAGS.test(t)) return ['hashtags'];
+  const tem = (rx) => rx.test(t);
+  const sob = (rx) => acima.some((a) => rx.test(a));
+  const [ig, li, tw] = [tem(CANAL.instagram), tem(CANAL.linkedin), tem(CANAL.twitter)];
+  const noInstagram = ig || (!li && !tw && (formato === 'instagram-feed' || sob(CANAL.instagram)));
+  const noLinkedin = li || (!ig && !tw && tem(PECA.post) && (formato === 'linkedin-post' || sob(CANAL.linkedin)));
+  const tipos = [];
+  if (noInstagram && tem(PECA.legenda)) tipos.push('legenda');
+  if (noInstagram && tem(PECA.slides)) tipos.push('slides');
+  if (noLinkedin && !tem(PECA.slides)) tipos.push('post');
+  if (tw) tipos.push('tweet');
+  return tipos.length || !tem(PECA.hashtags) ? tipos : ['hashtags'];
+}
+
+/** Formato do canal que o cabeçalho cita (Instagram, LinkedIn ou Twitter, nesta ordem), ou null. */
+const canalDe = (t) => FORMATO_DO_CANAL[Object.keys(CANAL).find((c) => CANAL[c].test(t))] ?? null;
+
+/**
+ * Cabeçalhos de um corpo de blog que casam com outro canal pelos critérios da regra 3 (b), cada
+ * um uma vez: em blog declarado a seção não é medida, mas o relatório diz qual é.
+ */
+export function secoesDeOutroCanal(corpo) {
+  const titulos = new Set();
+  let pilha = [];
+  for (const m of marcar(corpo)) {
+    if (m.rotulo) pilha = [];
+    if (!m.nivel) continue;
+    pilha = pilha.filter((c) => c.nivel < m.nivel);
+    if (candidaturas(m.norm, pilha.map((c) => c.norm), null).some((tipo) => tipo !== 'hashtags')) titulos.add(m.titulo);
+    pilha.push(m);
+  }
+  return [...titulos];
+}
+
+function abrir(trechos, trecho) {
+  trechos.push({ ...trecho, linhas: [] });
+  return trechos.at(-1);
+}
+
+/**
+ * Percorre as marcas e devolve os trechos, na ordem do texto: `{ rotulo, linhas }` para cada
+ * linha de rótulo e `{ titulo, tipos, canal, linhas }` para cada cabeçalho candidato a peça
+ * (`canal`: na seção de hashtags, o formato do canal que o cabeçalho cita; senão null).
+ * A seção de cabeçalho vai até o próximo cabeçalho do mesmo nível ou acima, ou até um rótulo; a
+ * de rótulo, até o próximo rótulo ou até um cabeçalho candidato (regra 2).
+ */
+export function lerTrechos(marcas, formato) {
+  const trechos = [];
+  let pilha = []; // cabeçalhos abertos, do mais externo ao mais interno
+  let rotulo = null; // seção de rótulo aberta
+  for (const m of marcas) {
+    if (m.rotulo) {
+      pilha = [];
+      rotulo = abrir(trechos, { rotulo: m.rotulo });
+      continue;
+    }
+    if (m.nivel) {
+      pilha = pilha.filter((c) => c.nivel < m.nivel);
+      const tipos = candidaturas(m.norm, pilha.map((c) => c.norm), formato);
+      const canal = tipos[0] === 'hashtags' ? canalDe(m.norm) : null;
+      const trecho = tipos.length ? abrir(trechos, { titulo: m.titulo, tipos, canal }) : null;
+      pilha.push({ nivel: m.nivel, norm: m.norm, trecho });
+      if (trecho) {
+        rotulo = null;
+        continue;
+      }
+    }
+    const dono = rotulo ?? pilha.findLast((c) => c.trecho)?.trecho;
+    dono?.linhas.push(m.linha);
+  }
+  return trechos;
+}