@aksp/opencrew 1.6.0 → 1.6.1

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

@@ -1,104 +1,171 @@
-// Leitura para o verificador automático: frontmatter, limites dos formatos (constraints:),
-// seções de um texto e proibições da memória da crew. Node puro, sem dependências.
+// Leitura para o verificador automático: texto sem a marca de início de arquivo (BOM),
+// frontmatter, limites dos formatos (constraints:) e domínio do site. Node puro, sem dependências.
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 
+/** Tira a marca invisível de início de arquivo (BOM), se houver. */
+export const semBom = (texto) => (texto.charCodeAt(0) === 0xfeff ? texto.slice(1) : texto);
+
+/** Lê um arquivo de texto em UTF-8, sem o BOM. */
+export async function lerTexto(arquivo) {
+  return semBom(await readFile(arquivo, 'utf8'));
+}
+
+/** Sem acentos, mantendo maiúsculas e minúsculas. */
+export const semDiacritico = (s) => s.normalize('NFD').replace(/\p{Diacritic}/gu, '');
+
+/** Sem acentos e em minúsculas: a forma em que cabeçalhos e termos são comparados. */
+export const semAcento = (s) => semDiacritico(s).toLowerCase();
+
+// As expressões que leem o resto de uma linha levam a flag `s`: com ela o `(.*)$` nunca falha e
+// não há retrocesso, mesmo com um `\r` solto no meio de milhares de espaços.
+const ENTRE_ASPAS = [/^"((?:[^"\\]|\\.)*)"(?:\s+#.*)?$/s, /^'((?:[^']|'')*)'(?:\s+#.*)?$/s, /^"(.*)"$/s, /^'(.*)'$/s];
+
+/** Valor de uma linha: sem as aspas; fora delas, sem o comentário do fim (` # …`) e número vira número. */
 function valorYaml(bruto) {
   const v = bruto.trim();
-  const aspas = v.match(/^"(.*)"$/) ?? v.match(/^'(.*)'$/);
-  if (aspas) return aspas[1].replace(/\\"/g, '"');
-  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
-  return v;
+  for (const rx of ENTRE_ASPAS) {
+    const aspas = v.match(rx);
+    if (aspas) return aspas[1].replace(/\\"/g, '"');
+  }
+  const semComentario = v.replace(/\s#.*$/s, '').trimEnd();
+  return /^-?\d+(\.\d+)?$/.test(semComentario) ? Number(semComentario) : semComentario;
 }
 
-/** Frontmatter YAML simples: `chave: valor` e um nível de bloco (ex.: `constraints:`). */
-export function lerFrontmatter(texto) {
-  const m = texto.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!m) return null;
+const quantas = (texto, aspa) => texto.replace(/\\./g, '').split(aspa).length - 1;
+
+/**
+ * Valor que continua nas linhas de baixo: bloco `>` ou `|` (as linhas recuadas) ou aspas ainda
+ * abertas (até a linha que as fecha). Devolve o valor e a última linha usada, ou null.
+ */
+function valorLongo(v, linhas, i) {
+  if (/^[>|][+-]?$/.test(v)) {
+    let fim = i + 1;
+    while (fim < linhas.length && (linhas[fim].trim() === '' || /^\s/.test(linhas[fim]))) fim++;
+    const partes = linhas.slice(i + 1, fim).map((l) => l.trim());
+    return { valor: partes.join(v[0] === '>' ? ' ' : '\n').trim(), ultima: fim - 1 };
+  }
+  const aspa = v[0];
+  const aberta = (aspa === '"' || aspa === "'") && !(v.length > 1 && v.endsWith(aspa)) && quantas(v, aspa) % 2 === 1;
+  const fecha = aberta ? linhas.findIndex((l, n) => n > i && quantas(l, aspa) % 2 === 1) : -1;
+  if (fecha < 0) return null;
+  return { valor: valorYaml([v, ...linhas.slice(i + 1, fecha + 1).map((l) => l.trim())].join(' ')), ultima: fecha };
+}
+
+const CHAVE = /^([\p{L}\p{N}_-]+)\s*:\s*(.*)$/su;
+const FILHO = /^\s+([\w-]+)\s*:\s*(.*)$/s;
+// Linha que cabe num frontmatter: recuada, comentário, item de lista ou `chave: valor`.
+const DE_YAML = /^(?:\s|#|-(?:\s|$)|[\p{L}\p{N}_-]+\s*:|[^\s:#-][^:]{0,60}:(?:\s|$))/u;
+
+/** `chave: valor` e um nível de bloco (ex.: `constraints:`); null quando alguma linha não é YAML. */
+function lerYaml(linhas) {
   const dados = {};
   let bloco = null;
-  for (const linha of m[1].split(/\r?\n/)) {
-    const topo = linha.match(/^([\w-]+):\s*(.*)$/);
-    if (topo) {
-      const [, chave, valor] = topo;
-      bloco = valor.trim() === '' ? chave : null;
-      dados[chave] = bloco ? {} : valorYaml(valor);
-      continue;
-    }
-    const filho = linha.match(/^\s+([\w-]+):\s*(.*)$/);
+  let chaves = 0;
+  for (let i = 0; i < linhas.length; i++) {
+    if (linhas[i] !== '' && !DE_YAML.test(linhas[i])) return null;
+    const topo = linhas[i].match(CHAVE);
+    const filho = topo ? null : linhas[i].match(FILHO);
     if (filho && bloco) dados[bloco][filho[1]] = valorYaml(filho[2]);
+    if (!topo) continue;
+    chaves += 1;
+    const longo = valorLongo(topo[2].trim(), linhas, i);
+    bloco = !longo && topo[2].trim() === '' ? topo[1] : null;
+    dados[topo[1]] = bloco ? {} : longo ? longo.valor : valorYaml(topo[2]);
+    if (longo) i = longo.ultima;
   }
-  return dados;
+  return chaves ? dados : null;
+}
+
+/**
+ * O frontmatter do começo do arquivo: `{ dados, fim }`, ou null. Um bloco entre duas linhas `---`
+ * só é frontmatter se parece YAML (ao menos uma chave e nenhuma linha de prosa); senão o `---` é
+ * um separador e o texto fica inteiro.
+ */
+function acharFrontmatter(texto) {
+  const m = texto.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const dados = m && lerYaml(m[1].split(/\r?\n/));
+  return dados ? { dados, fim: m[0].length } : null;
 }
 
+/** Frontmatter YAML simples: `chave: valor` e um nível de bloco (ex.: `constraints:`). */
+export const lerFrontmatter = (texto) => acharFrontmatter(texto)?.dados ?? null;
+
 /** Corpo do texto sem o frontmatter. */
 export function semFrontmatter(texto) {
-  return texto.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+  const fm = acharFrontmatter(texto);
+  return fm ? texto.slice(fm.fim) : texto;
 }
 
-/**
- * Limites do formato: `constraints:` do best-practice — primeiro o do usuário
- * (`_opencrew/best-practices.local/<id>.md`, nunca tocado pelo update), depois o do core.
- */
-export async function lerLimites(raiz, formatoId) {
-  for (const pasta of [['best-practices.local'], ['core', 'best-practices']]) {
-    const arquivo = path.join(raiz, '_opencrew', ...pasta, `${formatoId}.md`);
-    if (existsSync(arquivo)) return lerFrontmatter(await readFile(arquivo, 'utf8'))?.constraints ?? {};
-  }
-  return null;
+const PASTA_LOCAL = '`_opencrew/best-practices.local/`';
+const PASTA_CORE = '`_opencrew/core/best-practices/`';
+const NOTA = {
+  semFormato: (id) => `Formato "${id}" não encontrado em ${PASTA_LOCAL} nem em ${PASTA_CORE}.`,
+  overlaySemLimites: (id) => `O arquivo \`_opencrew/best-practices.local/${id}.md\` não declara limites (\`constraints:\`); usei os do core.`,
+  limiteInvalido: (id, escritos) => `O arquivo \`_opencrew/best-practices.local/${id}.md\` tem um limite que não é número inteiro (${escritos}); usei o do core.`,
+};
+// Limites que o verificador mede: no overlay local só valem com número inteiro a partir de 0.
+const MEDIDOS = new Set('title_max_chars meta_description_chars min_internal_links min_external_links caption_max_chars hashtags_max carousel_max_slides post_max_chars tweet_max_chars'.split(' '));
+
+/** Limite escrito entre aspas (`hashtags_max: "5"`) vale como número. */
+const comoNumero = ([chave, v]) => [chave, typeof v === 'string' && /^\d+$/.test(v) ? Number(v) : v];
+
+/** `constraints:` de um best-practice; `declarados` é null quando o arquivo não os declara. */
+async function constraintsDe(raiz, pasta, formatoId) {
+  const arquivo = path.join(raiz, '_opencrew', ...pasta, `${formatoId}.md`);
+  if (!existsSync(arquivo)) return { existe: false, declarados: null };
+  const texto = await lerTexto(arquivo);
+  const c = lerFrontmatter(texto)?.constraints;
+  return { existe: true, texto, declarados: c && typeof c === 'object' ? Object.fromEntries(Object.entries(c).map(comoNumero)) : null };
+}
+
+/** O valor de `chave:` como está escrito no arquivo, sem o comentário do fim da linha. */
+function comoEscrito(texto, chave) {
+  const linha = texto.split(/\r?\n/).map((l) => l.match(FILHO)).find((m) => m?.[1] === chave);
+  return linha ? linha[2].replace(/\s#.*$/s, '').trim() : '';
 }
 
 /**
- * Seções por cabeçalho markdown. O corpo vai até o próximo cabeçalho de nível igual ou
- * maior, ou até uma linha `---` (separador).
+ * Limites do overlay local que cobrem os do core. O limite medido que não é número inteiro a
+ * partir de 0 ("2.200", "dois mil") fica de fora e é devolvido em `invalidos`, como foi escrito.
  */
-export function lerSecoes(texto) {
-  const linhas = semFrontmatter(texto).split(/\r?\n/);
-  const secoes = [];
-  linhas.forEach((linha, i) => {
-    const h = linha.match(/^(#{1,6})\s+(.*)$/);
-    if (!h) return;
-    const nivel = h[1].length;
-    const corpo = [];
-    for (const seguinte of linhas.slice(i + 1)) {
-      const h2 = seguinte.match(/^(#{1,6})\s/);
-      if ((h2 && h2[1].length <= nivel) || /^---\s*$/.test(seguinte)) break;
-      corpo.push(seguinte);
-    }
-    secoes.push({ titulo: h[2].trim(), nivel, corpo: corpo.join('\n').trim() });
-  });
-  return secoes;
+function limitesDoOverlay({ declarados, texto }) {
+  const invalido = ([chave, v]) => MEDIDOS.has(chave) && !(Number.isInteger(v) && v >= 0);
+  const pares = Object.entries(declarados ?? {});
+  return {
+    validos: Object.fromEntries(pares.filter((p) => !invalido(p))),
+    invalidos: pares.filter(invalido).map(([chave]) => `\`${chave}: ${comoEscrito(texto, chave)}\``),
+  };
 }
 
-const semAcento = (s) => s.normalize('NFD').replace(/\p{Diacritic}/gu, '').toLowerCase();
-export { semAcento };
-
-const ASPAS = /"([^"]+)"|“([^”]+)”|‘([^’]+)’|`([^`]+)`|(?<![\p{L}])'([^']+)'(?![\p{L}])/gu;
-
 /**
- * Termos proibidos: o que estiver entre aspas nos itens de `## Proibições Explícitas`
- * do `memories.md` da crew. Itens sem aspas são contados, mas não verificados.
+ * Limites do formato: os `constraints:` do core com as chaves que o arquivo do usuário
+ * (`_opencrew/best-practices.local/<id>.md`, nunca tocado pelo update) declarar por cima; o
+ * limite medido que lá não é número inteiro não cobre o do core e vira nota.
+ * @returns {Promise<{ limites: object|null, nota: string|null }>} `limites` null = formato não
+ *   encontrado; `nota` = aviso para a seção "Notas" do relatório
  */
-export async function lerProibicoes(raiz, crew) {
-  const arquivo = path.join(raiz, crew, '_memory', 'memories.md');
-  if (!existsSync(arquivo)) return { existe: false, termos: [], semAspas: 0 };
-  const secao = lerSecoes(await readFile(arquivo, 'utf8'))
-    .find((s) => s.nivel === 2 && semAcento(s.titulo).startsWith('proibicoes explicitas'));
-  const termos = [];
-  let semAspas = 0;
-  for (const linha of (secao?.corpo ?? '').split('\n').filter((l) => /^\s*[-*]\s+/.test(l))) {
-    const achados = [...linha.matchAll(ASPAS)].map((m) => m.slice(1).find(Boolean));
-    if (achados.length) termos.push(...achados);
-    else semAspas += 1;
-  }
-  return { existe: true, termos, semAspas };
+export async function lerLimites(raiz, formatoId) {
+  const id = String(formatoId);
+  if (!/^[a-z0-9-]+$/.test(id)) return { limites: null, nota: NOTA.semFormato(id) };
+  const core = await constraintsDe(raiz, ['core', 'best-practices'], id);
+  const local = await constraintsDe(raiz, ['best-practices.local'], id);
+  if (!core.existe && !local.existe) return { limites: null, nota: NOTA.semFormato(id) };
+  const semLimites = local.existe && !local.declarados && core.existe;
+  const { validos, invalidos } = limitesDoOverlay(local);
+  const nota = semLimites ? NOTA.overlaySemLimites(id) : invalidos.length ? NOTA.limiteInvalido(id, invalidos.join('; ')) : null;
+  return { limites: { ...core.declarados, ...validos }, nota };
 }
 
 /** Domínio do site da empresa (para separar links internos de externos), se houver. */
 export async function lerDominioDoSite(raiz) {
   const arquivo = path.join(raiz, '_opencrew', '_memory', 'company.md');
   if (!existsSync(arquivo)) return null;
-  const m = (await readFile(arquivo, 'utf8')).match(/(?:site|website)[^\n]*?https?:\/\/([^\s/)>\]]+)/i);
-  return m ? m[1].replace(/^www\./, '').toLowerCase() : null;
+  for (const linha of (await lerTexto(arquivo)).split('\n')) {
+    const palavra = linha.search(/site|website/i);
+    const m = palavra < 0 ? null : linha.slice(palavra).match(/https?:\/\/([^\s/)>\]]+)/i);
+    if (m) return m[1].replace(/^www\./, '').toLowerCase();
+  }
+  return null;
 }

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

@@ -0,0 +1,142 @@
+// Medição das peças: compara cada peça com o limite do seu formato (`constraints:`) e diz o que
+// não foi medido. Máximos bloqueiam (fácil de corrigir: encurtar); mínimos alertam (podem
+// depender do usuário). Spec: fase-r1-reparos-1-6-1.md, regras 3 e 6.
+import { BLOG, secoesDeOutroCanal } from './secoes.mjs';
+import { contarSlides, listarHashtags } from './pecas.mjs';
+import { contar, item, NAO_MEDIDO } from './regras.mjs';
+
+const NOME = { titulo: 'Título (SEO)', meta: 'Meta description', legenda: 'Legenda Instagram', slides: 'Carrossel Instagram', post: 'Post LinkedIn', tweet: 'Tweet' };
+const NUMERADA = { legenda: 'legenda', slides: 'carrossel', post: 'post' };
+const DITA = { titulo: 'título', meta: 'meta description', legenda: 'legenda', hashtags: 'hashtags', slides: 'slides', post: 'post', tweet: 'tweet' };
+const LIMITE = {
+  titulo: 'title_max_chars',
+  meta: 'meta_description_chars',
+  legenda: 'caption_max_chars',
+  hashtags: 'hashtags_max',
+  slides: 'carousel_max_slides',
+  post: 'post_max_chars',
+  tweet: 'tweet_max_chars',
+};
+// Peça principal de cada formato da tabela: sem ela, o arquivo sai como "Não medido".
+const PRINCIPAL = {
+  'blog-post': [['titulo'], 'o título'],
+  'blog-seo': [['titulo'], 'o título'],
+  'instagram-feed': [['legenda', 'slides'], 'legenda nem slides'],
+  'linkedin-post': [['post'], 'o post'],
+  'twitter-post': [['tweet'], 'o tweet'],
+};
+
+// O cabeçalho entra no relatório até 120 caracteres: a linha não cresce com ele.
+const curto = (cabecalho) => (cabecalho?.length > 120 ? `${cabecalho.slice(0, 120).trimEnd()}…` : cabecalho);
+
+/** Com mais de uma peça do mesmo tipo, o nome traz o número de ordem e o cabeçalho da seção. */
+function nomeDaPeca(p, total) {
+  const base = NOME[p.tipo];
+  if (p.origem === 'arquivo') return `${base} (arquivo inteiro)`;
+  if (p.tipo === 'tweet') return p.porParagrafo || total > 1 ? `Tweet ${p.ordem}` : base;
+  if (total < 2) return base;
+  const cabecalho = curto(p.cabecalho);
+  return `${base} — ${NUMERADA[p.tipo]} ${p.ordem}${cabecalho ? ` (${cabecalho})` : ''}`;
+}
+
+function nomeDoItem(p, totais) {
+  const total = (tipo) => totais[`${tipo}|${p.formato}`] ?? 0;
+  if (p.tipo !== 'hashtags') return `${nomeDaPeca(p, total(p.tipo))} — ${p.tipo === 'slides' ? 'slides' : 'caracteres'}`;
+  const canal = p.formato === 'instagram-feed' ? 'Instagram' : 'LinkedIn';
+  return `${p.de ? nomeDaPeca({ ...p, tipo: p.de }, total(p.de)) : canal} — hashtags`;
+}
+
+function medir(p) {
+  if (p.tipo === 'slides') return contarSlides(p.texto);
+  return p.tipo === 'hashtags' ? listarHashtags(p.texto).length : contar(p.texto);
+}
+
+// Âncora da própria página (`#seção`), e-mail, telefone e WhatsApp não são link interno nem externo.
+const NAO_CONTA = /^(#|mailto:|tel:|https?:\/\/(wa\.me|api\.whatsapp\.com)\/)/i;
+
+/** O `]` da posição `fecha` fecha uma imagem (`![alt](…)`)? Procura o `[` par até 500 caracteres atrás. */
+function ehImagem(corpo, fecha) {
+  let nivel = 0;
+  for (let i = fecha - 1; i >= 0 && i >= fecha - 500; i--) {
+    if (corpo[i] === ']') nivel += 1;
+    else if (corpo[i] === '[' && nivel-- === 0) return corpo[i - 1] === '!';
+  }
+  return false;
+}
+
+/** Alvos dos links markdown `](alvo)` ou `](alvo "título")`. Imagem não é link. */
+function alvosDeLinks(corpo) {
+  const fecho = /(?:[ \t][^)\n]{0,300})?\)/y;
+  const alvos = [];
+  for (const m of corpo.matchAll(/\]\(([^)\s]{1,2000})/g)) {
+    fecho.lastIndex = m.index + m[0].length;
+    if (fecho.test(corpo) && !ehImagem(corpo, m.index)) alvos.push(m[1]);
+  }
+  return alvos;
+}
+
+/** Link relativo é interno; http(s) é interno quando o domínio é o do site. Malformado: fora. */
+function ehInterno(url, dominio) {
+  if (!/^https?:\/\//i.test(url)) return true;
+  try {
+    return new URL(url).hostname.replace(/^www\./, '') === dominio;
+  } catch {
+    return null;
+  }
+}
+
+function itensDeLinks(corpo, limites, dominio) {
+  const tipos = alvosDeLinks(corpo).filter((u) => !NAO_CONTA.test(u)).map((u) => ehInterno(u, dominio));
+  const minimo = (nome, medido, limite) =>
+    (typeof limite === 'number' ? [{ ...item(nome, medido, limite, medido < limite ? 'alerta' : 'ok'), minimo: true }] : []);
+  return [
+    ...minimo('Links internos', tipos.filter((t) => t === true).length, limites?.min_internal_links),
+    ...minimo('Links externos', tipos.filter((t) => t === false).length, limites?.min_external_links),
+  ];
+}
+
+/**
+ * Linhas "Não medido" do arquivo: peça principal ausente, peça sem limite, seção de outro canal
+ * em blog declarado (cabeçalho é conteúdo: não é medida), formato fora da tabela.
+ */
+function naoMedidos({ pecas, corpo, formato, limites }, semLimite, medidas) {
+  const linhas = [];
+  const [tipos, dita] = PRINCIPAL[formato] ?? [];
+  const achou = tipos && pecas.some((p) => p.formato === formato && tipos.includes(p.tipo));
+  if (tipos && !achou) linhas.push(item(NAO_MEDIDO, null, null, 'alerta', `não encontrei ${dita} neste arquivo (formato ${formato})`));
+  for (const detalhe of semLimite) linhas.push(item(NAO_MEDIDO, null, null, null, detalhe));
+  for (const cabecalho of BLOG.includes(formato) ? secoesDeOutroCanal(corpo) : []) {
+    linhas.push(item(NAO_MEDIDO, null, null, null, `seção de outro canal num arquivo de blog: ${curto(cabecalho)}`));
+  }
+  if (formato && !tipos && limites[formato] && !medidas) {
+    linhas.push(item(NAO_MEDIDO, null, null, null, `o verificador ainda não mede os limites do formato ${formato}`));
+  }
+  return linhas;
+}
+
+/**
+ * Mede as peças de um arquivo `.md` ou `.txt`.
+ * @param {{ pecas: object[], corpo: string, formato: string|null, limites: object, dominio: string|null }} o
+ *   `formato`: o declarado, ou null · `limites`: `{ [formato]: constraints | null }`
+ * @returns {{ itens: object[], medidas: number }} `medidas`: quantas peças tinham limite numérico
+ */
+export function medirPecas(o) {
+  const totais = {};
+  for (const p of o.pecas) totais[`${p.tipo}|${p.formato}`] = (totais[`${p.tipo}|${p.formato}`] ?? 0) + 1;
+  const itens = [];
+  const semLimite = new Set();
+  let medidas = 0;
+  for (const p of o.pecas) {
+    const limite = o.limites[p.formato]?.[LIMITE[p.tipo]];
+    if (typeof limite !== 'number') semLimite.add(`${DITA[p.tipo]}: sem limite definido no formato ${p.formato}`);
+    else {
+      medidas += 1;
+      const medido = medir(p);
+      // Nos tweets por parágrafo, só o que passa do limite gera linha.
+      if (!p.porParagrafo || medido > limite) itens.push(item(nomeDoItem(p, totais), medido, limite, medido > limite ? 'bloqueio' : 'ok'));
+    }
+  }
+  const blog = BLOG.includes(o.formato) ? o.formato : o.pecas.find((p) => p.tipo === 'titulo')?.formato;
+  if (blog) itens.push(...itensDeLinks(o.corpo, o.limites[blog], o.dominio));
+  return { itens: [...itens, ...naoMedidos(o, semLimite, medidas)], medidas };
+}

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

@@ -0,0 +1,190 @@
+// Leitor de peças do verificador: acha, num texto, os trechos que têm limite próprio no formato
+// (título, meta description, legenda, hashtags, slides, post, tweet), nos dois jeitos de
+// escrever — cabeçalho markdown e rótulo `=== RÓTULO ===`. Sem estado global e sem depender do
+// relatório: recebe o texto e o formato declarado e devolve as peças.
+// Spec: specs/fase-r1-reparos-1-6-1.md, regras 1 a 5 (repositório do OpenCrew).
+import { lerFrontmatter, semFrontmatter } from './leitura.mjs';
+import { BLOG, marcar, lerTrechos, numeroDoSlide } from './secoes.mjs';
+
+/** Formatos que o verificador mede (a tabela da regra 3). */
+export const FORMATOS_DA_TABELA = [...BLOG, 'instagram-feed', 'linkedin-post', 'twitter-post'];
+
+const FORMATO_DA_PECA = { legenda: 'instagram-feed', slides: 'instagram-feed', post: 'linkedin-post', tweet: 'twitter-post' };
+// O que cada rótulo faz, por formato declarado. Sem formato declarado valem todos: os
+// inconfundíveis abrem peça e os outros só se juntam a uma peça já aberta.
+const ROTULOS = {
+  'instagram-feed': { CAPTION: 'legenda', SLIDES: 'slides', HASHTAGS: 'hashtags' },
+  'linkedin-post': { HOOK: 'post', BODY: 'parte', INSIGHTS: 'parte', CTA: 'parte', HASHTAGS: 'hashtags' },
+  'twitter-post': { TWEET: 'tweet' },
+};
+const TODOS_OS_ROTULOS = Object.assign({}, ...Object.values(ROTULOS));
+
+/** Hashtags de um texto, na ordem em que aparecem. Âncora de URL e entidade `'` não contam. */
+export const listarHashtags = (texto) => texto.replace(/https?:\/\/\S+/gi, ' ').match(/(?<!&)#[\p{L}\p{N}_]+/gu) ?? [];
+
+/** Quantos números N diferentes aparecem em linhas que começam por "Slide N". */
+export function contarSlides(texto) {
+  const numeros = texto.split('\n').map(numeroDoSlide).filter((n) => n != null);
+  return new Set(numeros).size;
+}
+
+/** Parágrafos: blocos de linhas separados por linha em branco. */
+function paragrafos(texto) {
+  const blocos = [[]];
+  for (const linha of texto.split('\n')) {
+    if (linha.trim()) blocos.at(-1).push(linha);
+    else if (blocos.at(-1).length) blocos.push([]);
+  }
+  return blocos.filter((b) => b.length).map((b) => b.join('\n'));
+}
+
+/** Abre uma peça. Legenda e post ganham, logo a seguir, a peça das suas hashtags. */
+function abrir(e, tipo, origem, extra = {}) {
+  const peca = { tipo, formato: FORMATO_DA_PECA[tipo], texto: '', origem, cabecalho: null, ordem: 0, ...extra };
+  const entrada = { peca, partes: [], dono: null, hashtags: null };
+  e.entradas.push(entrada);
+  if (tipo === 'legenda' || tipo === 'post') {
+    entrada.hashtags = { peca: { ...peca, tipo: 'hashtags', de: tipo }, partes: [], dono: entrada };
+    e.entradas.push(entrada.hashtags);
+    e.dono = entrada;
+    e.donos[peca.formato] = entrada;
+  }
+  return entrada;
+}
+
+/**
+ * Hashtags de rótulo ou de cabeçalho somam à legenda ou ao post aberto por último; quando o
+ * cabeçalho cita um canal (`canal`), à legenda ou ao post desse canal aberto por último.
+ */
+function juntarHashtags(e, texto, origem, cabecalho = null, canal = null) {
+  const dono = canal ? e.donos[canal] : e.dono;
+  const formato = canal ?? e.tabela;
+  if (dono) dono.hashtags.partes.push(texto);
+  else if (e.tabela && (formato === 'instagram-feed' || formato === 'linkedin-post')) {
+    abrir(e, 'hashtags', origem, { formato, cabecalho, de: null }).partes.push(texto);
+  }
+}
+
+function pecaDoRotulo(e, papel, texto) {
+  if (papel === 'hashtags') juntarHashtags(e, texto, 'rotulo');
+  else if (papel === 'parte') {
+    // BODY, INSIGHTS e CTA pertencem ao post aberto por último; sem HOOK antes, abrem o primeiro.
+    if (!e.post && e.tabela === 'linkedin-post') e.post = abrir(e, 'post', 'rotulo');
+    e.post?.partes.push(texto);
+  } else if (papel) {
+    const aberta = abrir(e, papel, 'rotulo');
+    aberta.partes.push(texto);
+    if (papel === 'post') e.post = aberta;
+  }
+}
+
+function pecasDoCabecalho(e, tipo, texto, { titulo: cabecalho, canal }) {
+  if (tipo === 'hashtags') juntarHashtags(e, texto, 'cabecalho', cabecalho, canal);
+  else if (tipo === 'tweet') {
+    for (const p of paragrafos(texto)) abrir(e, 'tweet', 'cabecalho', { cabecalho, porParagrafo: true }).partes.push(p);
+  } else abrir(e, tipo, 'cabecalho', { cabecalho }).partes.push(texto);
+}
+
+/** Cabeçalho de legenda e de slides ao mesmo tempo abre uma peça só: slides, se o texto tem "Slide N". */
+function semPecaDupla(tipos, texto) {
+  if (!tipos.includes('legenda') || !tipos.includes('slides')) return tipos;
+  const sobra = contarSlides(texto) ? 'legenda' : 'slides';
+  return tipos.filter((tipo) => tipo !== sobra);
+}
+
+function pecasDoTrecho(e, trecho, rotulos) {
+  const texto = trecho.linhas.join('\n').trim();
+  if (trecho.rotulo) pecaDoRotulo(e, rotulos[trecho.rotulo], texto);
+  else for (const tipo of semPecaDupla(trecho.tipos, texto)) pecasDoCabecalho(e, tipo, texto, trecho);
+}
+
+/** Blog: título e meta description do frontmatter; senão, da primeira ocorrência do rótulo. */
+function pecasDoBlog(e, texto, trechos, formato, lerRotulos) {
+  const fm = lerFrontmatter(texto) ?? {};
+  const achar = (tipo, chaves, rotulos) => {
+    const valor = chaves.map((c) => fm[c]).find((v) => v != null && typeof v !== 'object' && String(v).trim());
+    const trecho = valor == null && lerRotulos ? trechos.find((t) => rotulos.includes(t.rotulo)) : null;
+    if (valor == null && !trecho) return false;
+    // Título escrito como cabeçalho logo abaixo do rótulo: o "# " não é texto.
+    const escrito = trecho ? trecho.linhas.join('\n').trim().replace(/^#{1,6}\s+/, '') : String(valor);
+    abrir(e, tipo, trecho ? 'rotulo' : 'frontmatter', { formato }).partes.push(escrito);
+    return true;
+  };
+  const temTitulo = achar('titulo', ['title', 'titulo'], ['TITLE', 'TITLE TAG']);
+  if (temTitulo || lerRotulos) achar('meta', ['meta_description', 'meta_descricao'], ['META DESCRIPTION']);
+}
+
+/** Arquivo que é só o texto (sem cabeçalho nem rótulo): o corpo inteiro é o post ou o tweet. */
+function pecaDoArquivoInteiro(e, marcas) {
+  const tipo = { 'linkedin-post': 'post', 'twitter-post': 'tweet' }[e.tabela];
+  if (!tipo || marcas.some((m) => m.rotulo || m.nivel)) return;
+  abrir(e, tipo, 'arquivo').partes.push(marcas.map((m) => m.linha).join('\n').trim());
+}
+
+/**
+ * `instagram-feed` sem peça de slides: os cabeçalhos "Slide N" do arquivo inteiro são o
+ * carrossel, quando trazem 2 ou mais números diferentes.
+ */
+function slidesDoArquivoInteiro(e, marcas) {
+  const temSlides = ({ peca, partes }) => peca.tipo === 'slides' && contarSlides(partes.join('\n')) > 0;
+  if (e.tabela !== 'instagram-feed' || e.entradas.some(temSlides)) return;
+  const titulos = marcas.filter((m) => m.nivel && numeroDoSlide(m.linha) != null).map((m) => m.linha).join('\n');
+  if (contarSlides(titulos) >= 2) abrir(e, 'slides', 'arquivo').partes.push(titulos);
+}
+
+/** Texto final e número de ordem de cada peça. Sem texto próprio, a peça não entra. */
+function fechar(entradas) {
+  const contagem = {};
+  const proxima = ({ tipo, formato }) => {
+    const chave = `${tipo}|${formato}`;
+    contagem[chave] = (contagem[chave] ?? 0) + 1;
+    return contagem[chave];
+  };
+  const pecas = [];
+  for (const { peca, partes, dono } of entradas) {
+    const proprio = partes.filter(Boolean).join('\n\n');
+    const comDono = Boolean(dono?.peca.ordem);
+    if (peca.tipo === 'hashtags') {
+      peca.texto = listarHashtags(`${comDono ? dono.peca.texto : ''}\n${proprio}`).join(' ');
+      if (!comDono) peca.de = null;
+    } else peca.texto = peca.tipo === 'slides' && !contarSlides(proprio) ? '' : proprio;
+    if (!peca.texto && !comDono) continue;
+    peca.ordem = comDono ? dono.peca.ordem : proxima(peca);
+    pecas.push(peca);
+  }
+  return pecas;
+}
+
+/**
+ * Lê as peças de um texto, na ordem em que aparecem.
+ * @param {string} texto conteúdo de um arquivo `.md` ou `.txt`, já sem o BOM
+ * @param {string|null} [formato] formato declarado (`caminho=formato`); null = sem formato declarado
+ * @param {{ formatoDeBlog?: string }} [opcoes] sem formato declarado, o formato em que o título do
+ *   frontmatter é medido (`--formato`)
+ * @returns {object[]} peças `{ tipo, formato, texto, origem, cabecalho, ordem }`
+ *   · `tipo`: titulo, meta, legenda, hashtags, slides, post ou tweet
+ *   · `formato`: o formato cujo limite vale para a peça
+ *   · `texto`: o texto da peça (nas hashtags, as hashtags achadas, separadas por espaço)
+ *   · `origem`: de onde veio — cabecalho, rotulo, frontmatter ou arquivo (o arquivo inteiro)
+ *   · `cabecalho`: texto do cabeçalho da seção, ou null
+ *   · `ordem`: número da peça entre as do mesmo tipo e formato; as hashtags levam o da legenda
+ *   ou do post a que pertencem (dito em `de`; null quando não pertencem a nenhum)
+ *   · `porParagrafo`: true no tweet tirado de um parágrafo de uma seção de cabeçalho
+ */
+export function lerPecas(texto, formato = null, { formatoDeBlog = 'blog-post' } = {}) {
+  const tabela = FORMATOS_DA_TABELA.includes(formato) ? formato : null;
+  // Formato declarado fora da tabela: a linha `=== RÓTULO ===` é texto comum (regra 3 c).
+  const marcas = marcar(semFrontmatter(texto), formato == null || tabela != null);
+  const trechos = lerTrechos(marcas, tabela);
+  const e = { entradas: [], tabela, dono: null, donos: {}, post: null };
+  if (BLOG.includes(tabela)) pecasDoBlog(e, texto, trechos, tabela, true);
+  else {
+    // Fora da tabela os rótulos não são lidos; sem formato declarado, título no frontmatter é blog.
+    if (formato == null) pecasDoBlog(e, texto, trechos, formatoDeBlog, false);
+    const rotulos = tabela ? ROTULOS[tabela] : formato == null ? TODOS_OS_ROTULOS : {};
+    for (const trecho of trechos) pecasDoTrecho(e, trecho, rotulos);
+    pecaDoArquivoInteiro(e, marcas);
+    slidesDoArquivoInteiro(e, marcas);
+  }
+  return fechar(e.entradas);
+}