@aksp/opencrew 1.7.1 → 1.8.0

package/templates/_opencrew/core/scripts/entrega/leiame.mjs

@@ -0,0 +1,89 @@
+// O LEIA-ME.md da entrega: títulos fixos, na ordem da spec; seção sem conteúdo não aparece.
+// Arquivo da entrega é citado com caminho relativo à pasta do LEIA-ME; o de origem, relativo ao
+// projeto. Sem hora: as mesmas entradas geram os mesmos bytes. PT-BR fixo.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e §6 (repositório do OpenCrew).
+import { CANAIS, EDITAVEIS, OUTROS } from './canais.mjs';
+import { frasesDePendencia } from './pendencias.mjs';
+import { passosDe } from './passos.mjs';
+
+export const TEXTO = {
+  vaiPublicar: 'Esta crew publica este canal sozinha. Antes de postar à mão, confira se já saiu.',
+  pdf: 'Abra o arquivo que você quer (por exemplo, o artigo do blog) no navegador ou no editor de texto e use Imprimir → Salvar como PDF.',
+  semCanal: 'sem canal de publicação; está aqui para você usar como quiser.',
+  sobre: 'Esta pasta é refeita a cada entrega e fica fora do git: o que você editar aqui se perde. Para guardar, copie a pasta para outro lugar do projeto.',
+  pronto: 'Pronto',
+  naoPronto: 'Não está pronto',
+};
+
+const lista = (linhas) => linhas.map((l) => `- ${l}`).join('\n');
+const bloco = (titulo, linhas) => (linhas.length ? [`${titulo}\n${lista(linhas)}`] : []);
+const secao = (titulo, partes) => (partes.length ? [`## ${titulo}\n\n${partes.join('\n\n')}`] : []);
+
+/** Uma linha por arquivo entregue: o caminho na entrega, o título do bloco (se houver) e a origem. */
+function linhaDoArquivo(a) {
+  const titulo = a.titulo ? ` — ${a.titulo}` : '';
+  return `\`${a.pasta}/${a.nome}\`${titulo} — origem: \`${a.origem}\``;
+}
+
+/** Os avisos de uma pasta que o LEIA-ME mostra (o que só vai para a tela não tem `texto`). */
+const avisosDe = (d, pasta) => d.avisos.filter((a) => a.pasta === pasta && a.texto).map((a) => a.texto);
+
+/** `## Antes de usar`: os alertas de tamanho e, por canal que não está pronto, o que falta. */
+function antesDeUsar(d) {
+  const pastas = [...d.pastas, OUTROS].filter((p) => d.pendencias.has(p));
+  const frases = frasesDePendencia(pastas, d.pendencias);
+  const faltas = pastas.map((p, i) => `- ${frases[i]}\n${d.pendencias.get(p).map((l) => `  - ${l}`).join('\n')}`);
+  return secao('Antes de usar', [[...d.alertas.map((a) => `- ${a}`), ...faltas].join('\n')].filter(Boolean));
+}
+
+/** `## {Canal}`: o aviso de publicação, a situação, os arquivos, as pendências, os avisos e os passos. */
+function secaoDoCanal(d, pasta) {
+  const arquivos = d.arquivos.filter((a) => a.pasta === pasta);
+  const pendencias = d.pendencias.get(pasta) ?? [];
+  const passos = passosDe(pasta, arquivos, pendencias.length > 0).map((p, i) => `${i + 1}. ${p}`);
+  return secao(CANAIS[pasta], [
+    ...(d.vaiPublicar.includes(pasta) ? [TEXTO.vaiPublicar] : []),
+    `Situação: ${pendencias.length ? TEXTO.naoPronto : TEXTO.pronto}`,
+    ...bloco('Arquivos:', arquivos.map(linhaDoArquivo)),
+    ...bloco('Pendências:', pendencias),
+    ...bloco('Atenção:', avisosDe(d, pasta)),
+    ...(passos.length ? [`Passos:\n${passos.join('\n')}`] : []),
+  ]);
+}
+
+/** `## Outros arquivos` e `## Editáveis`: cada arquivo com a origem; em `outros`, a linha diz por que está ali. */
+function secaoDaPasta(d, pasta, titulo) {
+  const fim = pasta === OUTROS ? ` — ${TEXTO.semCanal}` : '';
+  const arquivos = d.arquivos.filter((a) => a.pasta === pasta).map((a) => `${linhaDoArquivo(a)}${fim}`);
+  const pendencias = d.pendencias.get(pasta) ?? [];
+  return secao(titulo, [
+    ...(arquivos.length ? [lista(arquivos)] : []),
+    ...bloco('Pendências:', pendencias),
+    ...bloco('Atenção:', avisosDe(d, pasta)),
+  ]);
+}
+
+/**
+ * @param {object} d
+ * @param {string} d.crew nome da crew · @param {string} d.run id da execução
+ * @param {string[]} d.pastas os canais presentes, na ordem das seções
+ * @param {object[]} d.arquivos `{ pasta, nome, tipo, origem, titulo, numerado }`
+ * @param {object[]} d.avisos `{ pasta, texto, tela }` (`tela`: como o aviso sai no resumo da tela)
+ * @param {Map<string, string[]>} d.pendencias por pasta · @param {string[]} d.alertas regra 34
+ * @param {string[]} d.naoConferido · @param {string[]} d.vaiPublicar canais que a crew publica
+ * @returns {string} o LEIA-ME, em UTF-8 sem BOM e com LF
+ */
+export function montarLeiame(d) {
+  const temMd = d.arquivos.some((a) => a.nome.toLowerCase().endsWith('.md'));
+  const partes = [
+    `# Entrega — ${d.crew} — ${d.run}`,
+    ...antesDeUsar(d),
+    ...d.pastas.flatMap((pasta) => secaoDoCanal(d, pasta)),
+    ...secaoDaPasta(d, OUTROS, 'Outros arquivos'),
+    ...secaoDaPasta(d, EDITAVEIS, 'Editáveis'),
+    ...secao('O que não foi conferido', [lista(d.naoConferido)]),
+    ...(temMd ? secao('Para ter um PDF', [TEXTO.pdf]) : []),
+    ...secao('Sobre esta pasta', [TEXTO.sobre]),
+  ];
+  return `${partes.join('\n\n')}\n`;
+}

package/templates/_opencrew/core/scripts/entrega/leitor.mjs

@@ -0,0 +1,120 @@
+// Peças que vêm do leitor do verificador (`lerPecas`): legenda, post e tweet, cada um com as
+// suas hashtags no fim — e o primeiro comentário do LinkedIn, que sai do texto do post.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regra 4 (repositório do OpenCrew).
+import { semAcento } from '../verificar/leitura.mjs';
+import { lerPecas, listarHashtags } from '../verificar/pecas.mjs';
+import { lerTrechos, marcar, rotuloDe } from '../verificar/secoes.mjs';
+import { paraColar } from './texto.mjs';
+
+/** Peça principal de cada formato: sem ela, o arquivo vai inteiro. */
+export const PRINCIPAL = { 'instagram-feed': 'legenda', 'linkedin-post': 'post', 'twitter-post': 'tweet', 'twitter-thread': 'tweet' };
+const TITULO = /^(#{1,6})\s+(.*)$/s;
+const COMENTARIO = /(?<![\p{L}\p{N}])(?:comentarios?|comments?)(?![\p{L}\p{N}])/u;
+const marca = (n) => `⟦comentario:${n}⟧`;
+const MARCA = /^⟦comentario:(\d+)⟧$/;
+
+/**
+ * Tira do corpo as seções de comentário (cabeçalho com "comentário" ou "comment", até o próximo
+ * cabeçalho do mesmo nível ou acima, ou até um rótulo). No lugar de cada uma fica uma linha de
+ * marca: ela cai dentro do texto do post que vem antes.
+ * @returns {{ corpo: string, comentarios: string[] }}
+ */
+function tirarComentarios(corpo) {
+  const linhas = [];
+  const comentarios = [];
+  let nivel = 0; // nível do cabeçalho de comentário aberto; 0 = nenhum
+  for (const linha of corpo.split('\n')) {
+    const h = linha.match(TITULO);
+    if (nivel && (rotuloDe(linha) || (h && h[1].length <= nivel))) nivel = 0;
+    if (!nivel && h && COMENTARIO.test(semAcento(h[2]))) {
+      nivel = h[1].length;
+      linhas.push(marca(comentarios.push([]) - 1));
+    } else if (nivel) comentarios.at(-1).push(linha);
+    else linhas.push(linha);
+  }
+  return { corpo: linhas.join('\n'), comentarios: comentarios.map((c) => c.join('\n')) };
+}
+
+/** Texto da peça sem as linhas de marca, e os números dos comentários que estavam nele. */
+function separarMarcas(texto) {
+  const numeros = [];
+  const linhas = texto.split('\n').filter((linha) => {
+    const m = linha.trim().match(MARCA);
+    if (m) numeros.push(Number(m[1]));
+    return !m;
+  });
+  return { texto: linhas.join('\n'), numeros };
+}
+
+/** Cabeçalhos do corpo, na ordem: `[{ titulo, pai }]` (`pai`: o cabeçalho logo acima, ou null). */
+function cabecalhos(corpo) {
+  const lista = [];
+  let pilha = [];
+  for (const linha of corpo.split('\n')) {
+    const h = linha.match(TITULO);
+    if (!h) continue;
+    pilha = pilha.filter((c) => c.nivel < h[1].length);
+    lista.push({ titulo: h[2].trim(), pai: pilha.at(-1)?.titulo ?? null });
+    pilha.push({ nivel: h[1].length, titulo: h[2].trim() });
+  }
+  return lista;
+}
+
+/** Título do bloco de cada peça de cabeçalho: o cabeçalho logo acima do dela, quando houver. */
+function titulosDeBloco(corpo, pecas) {
+  const lista = cabecalhos(corpo);
+  let cursor = 0;
+  return pecas.map((p) => {
+    const i = p.origem === 'cabecalho' ? lista.findIndex((c, n) => n >= cursor && c.titulo === p.cabecalho) : -1;
+    if (i < 0) return null;
+    cursor = p.porParagrafo ? i : i + 1;
+    return lista[i].pai;
+  });
+}
+
+/** Hashtags da seção própria (rótulo ou cabeçalho) da legenda ou do post, sem as que já estão no texto. */
+function hashtagsDaPeca(pecas, p) {
+  const h = pecas.find((x) => x.tipo === 'hashtags' && x.de === p.tipo && x.ordem === p.ordem && x.formato === p.formato);
+  return h ? listarHashtags(h.texto).slice(listarHashtags(p.texto).length) : [];
+}
+
+/** Hashtags das seções `=== HASHTAGS ===` e de cabeçalho "Hashtags" de um arquivo de tweets. */
+export function hashtagsSoltas(corpo, tabela = 'twitter-post') {
+  const trechos = lerTrechos(marcar(corpo), tabela).filter((t) => t.rotulo === 'HASHTAGS' || t.tipos?.[0] === 'hashtags');
+  return trechos.flatMap((t) => listarHashtags(t.linhas.join('\n')));
+}
+
+const comHashtags = (texto, hashtags) => paraColar(hashtags.length ? `${texto}\n\n${hashtags.join(' ')}` : texto);
+
+/** Comentário de cada post: o que caiu no texto dele; os que sobraram vão, na ordem, para os posts sem comentário. */
+function distribuir(marcas, comentarios) {
+  const usados = new Set(marcas.flat());
+  const sobras = comentarios.map((_, n) => n).filter((n) => !usados.has(n));
+  return marcas.map((numeros) => (numeros.length ? numeros : sobras.splice(0, 1)).map((n) => comentarios[n]).join('\n\n'));
+}
+
+/**
+ * Lê as peças do formato num corpo já sem frontmatter e sem blocos de serviço.
+ * @returns {{ unidades: object[], temSlides: boolean, outros: string[] }} `unidades`: uma por
+ *   legenda, post ou tweet, `{ tipo, titulo, ordem, total, partes: [{ nome, sufixo, ext, tipo, texto }] }`
+ *   · `outros`: cabeçalhos das seções de outro canal, que não são separadas
+ */
+export function pecasDoLeitor(corpoOriginal, formato) {
+  const tabela = formato === 'twitter-thread' ? 'twitter-post' : formato;
+  const tipo = PRINCIPAL[formato];
+  const { corpo, comentarios } = tipo === 'post' ? tirarComentarios(corpoOriginal) : { corpo: corpoOriginal, comentarios: [] };
+  const pecas = lerPecas(corpo, tabela);
+  const principais = pecas.filter((p) => p.formato === tabela && p.tipo === tipo);
+  const limpas = principais.map((p) => separarMarcas(p.texto));
+  const doPost = distribuir(limpas.map((l) => l.numeros), comentarios);
+  const titulos = titulosDeBloco(corpo, principais);
+  const soltas = tipo === 'tweet' ? hashtagsSoltas(corpo) : [];
+  const unidades = principais.map((p, i) => {
+    const hashtags = tipo === 'tweet' ? (i === 0 ? soltas : []) : hashtagsDaPeca(pecas, p);
+    const partes = [{ nome: tipo, sufixo: '', ext: 'txt', tipo, texto: comHashtags(limpas[i].texto, hashtags) }];
+    if (doPost[i]?.trim()) partes.push({ nome: tipo, sufixo: '-comentario', ext: 'txt', tipo: 'comentario', texto: paraColar(doPost[i]) });
+    return { tipo, titulo: titulos[i], ordem: i + 1, total: principais.length, partes };
+  });
+  const outros = pecas.filter((p) => p.formato !== tabela && p.tipo !== 'hashtags' && p.cabecalho).map((p) => p.cabecalho);
+  return { unidades, temSlides: pecas.some((p) => p.formato === tabela && p.tipo === 'slides'), outros: [...new Set(outros)] };
+}

package/templates/_opencrew/core/scripts/entrega/longas.mjs

@@ -0,0 +1,109 @@
+// Peças que o leitor do verificador não lê: blog (`seo.txt` e `artigo.md`), e-mail (assunto,
+// prévia e corpo), mensagem de WhatsApp e os tweets de uma thread (`TWEET n/N`).
+// Recebem o texto do arquivo, sem BOM e com LF. Spec: fase-u3a1-pasta-de-entrega.md, §4.
+import { lerFrontmatter, semAcento, semFrontmatter } from '../verificar/leitura.mjs';
+import { lerPecas } from '../verificar/pecas.mjs';
+import { rotuloDe } from '../verificar/secoes.mjs';
+import { fecharMd, paraColar, secoesDeRotulo, semServico } from './texto.mjs';
+
+const parte = (nome, ext, texto) => ({ nome, sufixo: '', ext, tipo: nome, texto });
+const TITULO = /^#{1,6}\s+(.*)$/s;
+const palavra = (formas) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${formas})(?![\\p{L}\\p{N}])`, 'u');
+
+// ── Blog ─────────────────────────────────────────────────────────────────────────────────────
+const FORA_DO_ARTIGO = new Set(['TITLE', 'TITLE TAG', 'META DESCRIPTION', 'TARGET KEYWORD']);
+const emUmaLinha = (valor) => String(valor).replace(/\s+/g, ' ').trim();
+
+/** Palavra-chave: do frontmatter; senão, o que vem depois de `Primary:` em `=== TARGET KEYWORD ===`. */
+function palavraChave(fm, secoes) {
+  const doRotulo = secoes.find((s) => s.rotulo === 'TARGET KEYWORD')?.texto.match(/Primary:[ \t]*([^|\n]+)/i)?.[1];
+  return [fm.palavra_chave, fm.keyword, doRotulo].find((v) => v != null && typeof v !== 'object' && String(v).trim());
+}
+
+/** @returns {object[]} uma unidade com `seo.txt` (só as linhas que existem) e `artigo.md` */
+export function pecasDoBlog(texto, formato) {
+  const fm = lerFrontmatter(texto) ?? {};
+  const secoes = secoesDeRotulo(semServico(semFrontmatter(texto)));
+  const lida = (tipo) => lerPecas(texto, formato).find((p) => p.tipo === tipo)?.texto;
+  const campos = [['Título', lida('titulo')], ['Meta description', lida('meta')], ['Palavra-chave', palavraChave(fm, secoes)], ['Slug', typeof fm.slug === 'object' ? null : fm.slug]];
+  const seo = campos.filter(([, v]) => v != null && emUmaLinha(v)).map(([campo, v]) => `${campo}: ${emUmaLinha(v)}\n`).join('');
+  const artigo = secoes.filter((s) => !FORA_DO_ARTIGO.has(s.rotulo) && s.texto).map((s) => s.texto).join('\n\n');
+  return [{ tipo: 'blog', partes: [parte('seo', 'txt', seo), parte('artigo', 'md', fecharMd(artigo))] }];
+}
+
+// ── E-mail ───────────────────────────────────────────────────────────────────────────────────
+const DO_ROTULO = { 'SUBJECT LINE': 'assunto', 'PREVIEW TEXT': 'previa' };
+const DO_CABECALHO = [['assunto', palavra('assuntos?|subject')], ['previa', palavra('previas?|preview')], ['corpo', /^(?:corpo|body)(?![\p{L}\p{N}])/u]];
+
+/** O que a linha abre: assunto, prévia ou corpo (linha de rótulo ou cabeçalho que nomeia); senão null. */
+function papelDaLinha(linha) {
+  const rotulo = rotuloDe(linha);
+  if (rotulo) return DO_ROTULO[rotulo] ?? 'corpo';
+  const h = linha.match(TITULO);
+  return h ? DO_CABECALHO.find(([, rx]) => rx.test(semAcento(h[1]).trim()))?.[0] ?? null : null;
+}
+
+/** Tira do fim das linhas o cabeçalho que vem logo antes de um assunto: é o título do bloco. */
+function tituloPendente(linhas) {
+  let fim = linhas.length;
+  while (fim && !linhas[fim - 1].trim()) fim--;
+  const h = fim ? linhas[fim - 1].match(TITULO) : null;
+  if (!h) return null;
+  linhas.length = fim - 1;
+  return h[1].trim();
+}
+
+/** Os e-mails do corpo, na ordem: cada assunto abre um. `[{ titulo, assunto, previa, corpo }]` (linhas). */
+function lerEmails(corpo) {
+  const novo = () => ({ titulo: null, assunto: [], previa: [], corpo: [] });
+  const emails = [novo()];
+  let alvo = 'corpo';
+  for (const linha of corpo.split('\n')) {
+    const papel = papelDaLinha(linha);
+    if (papel === 'assunto') {
+      const titulo = tituloPendente(emails.at(-1).corpo);
+      if (emails.at(-1).assunto.length) emails.push(novo());
+      emails.at(-1).titulo = titulo;
+    }
+    if (papel) alvo = papel;
+    else if (TITULO.test(linha) && alvo !== 'corpo') alvo = 'corpo'; // outro cabeçalho: é conteúdo
+    if (!papel) emails.at(-1)[alvo].push(linha);
+  }
+  return emails;
+}
+
+/** @returns {object[]} uma unidade por e-mail, com `assunto.txt`, `previa.txt` e `corpo.md` */
+export function pecasDoEmail(texto) {
+  const emails = lerEmails(semServico(semFrontmatter(texto)));
+  return emails.map((e) => ({
+    tipo: 'email',
+    titulo: e.titulo,
+    partes: [
+      parte('assunto', 'txt', paraColar(e.assunto.join('\n'))),
+      parte('previa', 'txt', paraColar(e.previa.join('\n'))),
+      parte('corpo', 'md', fecharMd(e.corpo.join('\n'))),
+    ],
+  }));
+}
+
+// ── WhatsApp ─────────────────────────────────────────────────────────────────────────────────
+/** @returns {object[]} uma unidade: os textos das seções, na ordem, separados por uma linha em branco */
+export function pecasDoWhatsapp(texto) {
+  const textos = secoesDeRotulo(semServico(semFrontmatter(texto))).map((s) => s.texto).filter(Boolean);
+  return [{ tipo: 'mensagem', partes: [parte('mensagem', 'txt', paraColar(textos.join('\n\n'), { whatsapp: true }))] }];
+}
+
+// ── Thread ───────────────────────────────────────────────────────────────────────────────────
+const TWEET_N = /^[\s*_#>-]{0,8}TWEET\s{1,3}\d{1,3}\s{0,3}\/\s{0,3}(?:\d{1,3}|N)(?![\p{L}\p{N}])/iu;
+
+/** Texto de cada bloco iniciado por `TWEET n/N` (sem essa linha), até o próximo bloco, rótulo ou cabeçalho. */
+export function tweetsDaThread(corpo) {
+  const blocos = [];
+  let atual = null;
+  for (const linha of corpo.split('\n')) {
+    if (TWEET_N.test(linha)) blocos.push((atual = []));
+    else if (rotuloDe(linha) || TITULO.test(linha)) atual = null;
+    else atual?.push(linha);
+  }
+  return blocos.map((b) => b.join('\n').trim()).filter(Boolean);
+}

package/templates/_opencrew/core/scripts/entrega/nomes.mjs

@@ -0,0 +1,78 @@
+// Nome de cada arquivo da entrega: peças do mesmo tipo no mesmo canal são numeradas; cópia cujo
+// nome já existe na pasta ganha o prefixo `2-`, `3-`. Nenhum arquivo é gravado por cima de outro.
+// Spec: fase-u3a-entrega-por-canal.md, regras 7 e 8, citadas pela fatia 1 (repositório do OpenCrew).
+
+export const MSG = {
+  mesmoNome: (arquivo, novo) => `${arquivo} tem o mesmo nome de outro e foi guardado como ${novo}.`,
+};
+
+const chave = (pasta, nome) => `${pasta}/${nome.toLowerCase()}`;
+
+/** Arquivos das unidades: `post.txt` quando há uma só no canal; `post-1.txt`, `post-1-comentario.txt`… com várias. */
+function nomearUnidades(unidades) {
+  const total = {};
+  for (const u of unidades) total[`${u.pasta}|${u.tipo}`] = (total[`${u.pasta}|${u.tipo}`] ?? 0) + 1;
+  const vez = {};
+  return unidades.flatMap((u) => {
+    const grupo = `${u.pasta}|${u.tipo}`;
+    vez[grupo] = (vez[grupo] ?? 0) + 1;
+    const numero = total[grupo] > 1 ? `-${vez[grupo]}` : '';
+    return u.partes.map((parte) => ({
+      pasta: u.pasta, nome: `${parte.nome}${numero}${parte.sufixo}.${parte.ext}`, tipo: parte.tipo, texto: parte.texto,
+      origem: u.origem, formato: u.formato, titulo: numero ? u.titulo ?? null : null, numerado: Boolean(numero), ordem: u.ordem, total: u.total,
+    }));
+  });
+}
+
+/** Cópias agrupadas por pasta da entrega e, dentro dela, por pasta de origem, na ordem da lista. */
+function grupos(copias) {
+  const porChave = new Map();
+  for (const c of copias) {
+    const id = `${c.pasta}|${c.pastaDeOrigem}`;
+    if (!porChave.has(id)) porChave.set(id, { pasta: c.pasta, copias: [] });
+    // O mesmo arquivo listado duas vezes para a mesma pasta é uma cópia só.
+    if (!porChave.get(id).copias.some((outra) => outra.nome === c.nome)) porChave.get(id).copias.push(c);
+  }
+  return [...porChave.values()];
+}
+
+/** O menor prefixo, a partir de `n-`, com que nenhum nome do grupo bate com um nome já usado. */
+function prefixoLivre(grupo, usados, n) {
+  while (grupo.copias.some((c) => usados.has(chave(grupo.pasta, `${n}-${c.nome}`)))) n += 1;
+  return n;
+}
+
+/**
+ * Cópias com o nome original. Quando um arquivo chegaria a uma pasta onde já há outro com esse
+ * nome, todos os que vêm da mesma pasta de origem ganham o prefixo (`2-`; os da pasta seguinte,
+ * `3-`). O aviso sai para cada arquivo cujo nome batia.
+ */
+function nomearCopias(copias, usados) {
+  const arquivos = [];
+  const avisos = [];
+  const proximo = {};
+  for (const grupo of grupos(copias)) {
+    const bate = (c) => usados.has(chave(grupo.pasta, c.nome));
+    const n = grupo.copias.some(bate) ? prefixoLivre(grupo, usados, proximo[grupo.pasta] ?? 2) : null;
+    if (n) proximo[grupo.pasta] = n + 1;
+    for (const c of grupo.copias) {
+      const nome = n ? `${n}-${c.nome}` : c.nome;
+      if (n && bate(c)) avisos.push({ pasta: c.pasta, texto: MSG.mesmoNome(c.origem, nome) });
+      arquivos.push({ ...c, nome });
+    }
+    for (const a of arquivos.slice(-grupo.copias.length)) usados.add(chave(a.pasta, a.nome));
+  }
+  return { arquivos, avisos };
+}
+
+/**
+ * @param {{ unidades: object[], copias: object[], avisos: object[] }} produtos o que `separar` devolve
+ * @returns {{ arquivos: object[], avisos: object[] }} `arquivos`: `{ pasta, nome, tipo, origem,
+ *   texto | de, … }`, na ordem da lista (as peças antes das cópias), sem dois com o mesmo caminho
+ */
+export function nomear({ unidades, copias, avisos }) {
+  const gerados = nomearUnidades(unidades);
+  const usados = new Set(gerados.map((a) => chave(a.pasta, a.nome)));
+  const copiados = nomearCopias(copias, usados);
+  return { arquivos: [...gerados, ...copiados.arquivos], avisos: [...avisos, ...copiados.avisos] };
+}

package/templates/_opencrew/core/scripts/entrega/passos.mjs

@@ -0,0 +1,99 @@
+// Os passos de cada canal no LEIA-ME: o quadro "Passos por canal" da spec, guardado como dado.
+// O texto é literal (aprovado com a spec): não reescreva aqui sem mudar a spec.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 (repositório do OpenCrew).
+
+/** O primeiro passo do canal que não está pronto (ajuste da execução real). */
+export const ANTES_DE_POSTAR = 'Antes de postar, resolva o que está em Pendências. Corrija no arquivo de origem e peça para montar a entrega de novo: o que você mudar nesta pasta se perde.';
+const MARKDOWN = 'Este texto está em markdown: se o seu editor não aceitar, ajuste títulos, negrito e links depois de colar.';
+
+// Cada passo: [o que o faz aparecer, o texto]. null = sempre que o canal tem arquivo; um tipo de
+// arquivo = só quando a entrega tem arquivo desse tipo no canal; `tipo:um` e `tipo:varios` = só
+// quando a peça é uma só, ou quando é numerada. `{arquivo}`: uma linha por arquivo. `{campos}`:
+// os campos que o `seo.txt` daquela entrega tem.
+const PASSOS = {
+  instagram: [
+    [null, 'No computador, abra instagram.com e comece uma publicação nova. Pelo celular, mande os arquivos para ele antes.'],
+    ['imagem', 'Escolha as imagens na ordem dos nomes dos arquivos.'],
+    ['legenda', 'Abra `instagram/legenda.txt`, copie tudo e cole no campo da legenda. As hashtags já estão no fim.'],
+    [null, 'Confira a prévia e publique.'],
+    ['texto', '`instagram/{arquivo}` é para ler e produzir (gravar ou montar os slides): não é texto para colar.'],
+  ],
+  linkedin: [
+    [null, 'No computador, abra linkedin.com e comece uma publicação.'],
+    ['post', 'Abra `linkedin/post.txt`, copie tudo e cole.'],
+    ['imagem', 'Anexe as imagens na ordem dos nomes dos arquivos.'],
+    [null, 'Confira e publique.'],
+    ['comentario', 'Depois de publicar, abra `linkedin/post-comentario.txt`, copie e cole como primeiro comentário.'],
+    ['roteiro', 'Para o artigo, escolha escrever um artigo no LinkedIn e cole o texto de `linkedin/{arquivo}`, seção por seção.'],
+  ],
+  blog: [
+    [null, 'Abra o editor do seu blog e crie um post novo.'],
+    ['seo', 'Abra `blog/seo.txt` e copie cada linha para o campo de mesmo nome ({campos}).'],
+    ['artigo', 'Abra `blog/artigo.md`, copie tudo e cole no corpo do post.'],
+    ['artigo', MARKDOWN],
+    [null, 'Confira a prévia e publique.'],
+  ],
+  email: [
+    [null, 'Abra a sua ferramenta de e-mail e crie uma mensagem nova.'],
+    ['assunto', 'Copie o texto de `email/assunto.txt` para o campo do assunto.'],
+    ['previa', 'Copie o texto de `email/previa.txt` para o campo de prévia (a linha que aparece ao lado do assunto).'],
+    ['corpo', 'Abra `email/corpo.md`, copie tudo e cole no corpo.'],
+    ['corpo', MARKDOWN],
+    [null, 'Envie um teste para você antes de enviar para a lista.'],
+  ],
+  whatsapp: [
+    [null, 'No computador, abra o WhatsApp Web ou o aplicativo. Pelo celular, mande o arquivo para ele antes.'],
+    ['mensagem', 'Abra `whatsapp/mensagem.txt`, copie tudo e cole na conversa ou na lista de transmissão.'],
+    [null, 'Se o texto tiver `{{…}}`, troque pelo dado real, ou confira se a sua ferramenta de envio faz a troca.'],
+    [null, 'Envie primeiro para você, para ver como ficou.'],
+  ],
+  twitter: [
+    [null, 'No computador, abra x.com e comece uma publicação.'],
+    ['tweet:um', 'Abra `twitter/tweet.txt`, copie tudo e cole.'],
+    ['tweet:varios', 'Para a sequência, cole `twitter/tweet-1.txt`, acrescente outra publicação e cole o arquivo seguinte, na ordem dos números.'],
+    ['imagem', 'Anexe as imagens.'],
+    [null, 'Confira e publique.'],
+  ],
+  youtube: [['roteiro', '`youtube/{arquivo}` é o roteiro para gravar: não é texto para colar.']],
+};
+// "texto": o roteiro e o arquivo que foi inteiro (carrossel em texto, peça não encontrada).
+const TIPOS = { texto: ['roteiro', 'inteiro'] };
+
+/** Com várias peças, o passo cita os arquivos numerados no lugar do nome sem número. */
+function citar(texto, pasta, achados) {
+  if (!achados[0].numerado) return texto;
+  const lista = achados.map((a) => `\`${pasta}/${a.nome}\``).join(', ');
+  return texto.replace(new RegExp(`\`${pasta}/[^\`]+\``), lista);
+}
+
+/** Os campos que os arquivos têm (`Título: …` → "título"), cada um uma vez, na ordem das linhas. */
+function camposDe(achados) {
+  const linhas = achados.flatMap((a) => (a.texto ?? '').split('\n')).filter((l) => l.includes(':'));
+  return [...new Set(linhas.map((l) => l.slice(0, l.indexOf(':')).toLowerCase()))].join(', ');
+}
+
+/** Os passos do quadro, só os que citam arquivo que existe nesse canal, na ordem do quadro. */
+function doQuadro(pasta, arquivos) {
+  if (!arquivos.length) return [];
+  return (PASSOS[pasta] ?? []).flatMap(([condicao, texto]) => {
+    if (!condicao) return [texto];
+    const [tipo, quantos] = condicao.split(':');
+    const achados = arquivos.filter((a) => (TIPOS[tipo] ?? [tipo]).includes(a.tipo));
+    if (!achados.length) return [];
+    if (quantos) return Boolean(achados[0].numerado) === (quantos === 'varios') ? [texto] : [];
+    if (texto.includes('{arquivo}')) return achados.map((a) => texto.replace('{arquivo}', a.nome));
+    return [citar(texto, pasta, achados).replace('{campos}', camposDe(achados))];
+  });
+}
+
+/**
+ * Os passos de um canal. No canal que não está pronto, o primeiro manda resolver as pendências.
+ * @param {string} pasta a pasta do canal
+ * @param {object[]} arquivos os arquivos da entrega nessa pasta: `{ nome, tipo, numerado, texto }`
+ * @param {boolean} [comPendencia] o canal tem pendência
+ * @returns {string[]}
+ */
+export function passosDe(pasta, arquivos, comPendencia = false) {
+  const passos = doQuadro(pasta, arquivos);
+  return comPendencia && passos.length ? [ANTES_DE_POSTAR, ...passos] : passos;
+}

package/templates/_opencrew/core/scripts/entrega/pendencias.mjs

@@ -0,0 +1,87 @@
+// O que a verificação diz da entrega: as pendências de cada canal (bloqueio, [PREENCHER], item
+// que não existe), o que não foi conferido e o alerta de tamanho do texto entregue.
+// Spec: fase-u3a1-pasta-de-entrega.md, regras 17, 19, 20 e 34 (repositório do OpenCrew).
+import path from 'node:path';
+import { lerLimites } from '../verificar/leitura.mjs';
+import { contar, FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from '../verificar/regras.mjs';
+import { OUTROS, nomeDaPasta } from './canais.mjs';
+
+export const MSG = {
+  naoEncontrei: (arquivo) => `Não encontrei ${arquivo}.`,
+  naoPronto: (canal, n) => `${canal} não está pronto: ${n} ${n === 1 ? 'pendência' : 'pendências'}.`,
+  alerta: (arquivo, n, limite) => `ALERTA: \`${arquivo}\` tem ${n} caracteres; o limite é ${limite}. Encurte antes de publicar.`,
+};
+/** A lista fixa do que o script nunca confere. */
+export const NUNCA_CONFERIDO = ['Links e fatos citados no texto.', 'Texto dentro das imagens.', 'Aparência final em cada rede.'];
+
+const ehNaoMedido = (i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO;
+const origem = (arquivo) => `origem: \`${arquivo}\``;
+
+/** Uma linha de pendência ou de alerta, com o trecho (ou a medida) e o arquivo de origem. */
+function linhaDoItem(i, arquivo) {
+  if (i.item === FALTA_INFO) return `Falta preencher "${i.detalhe}" — ${origem(arquivo)}`;
+  if (ehNaoMedido(i)) return `${i.item} — ${i.detalhe} — ${origem(arquivo)}`;
+  if (i.medido != null) return `${i.item}: ${i.medido} (${i.minimo ? 'mínimo' : 'limite'} ${i.limite}) — ${origem(arquivo)}`;
+  return `${i.item}: "${i.detalhe}" — ${origem(arquivo)}`;
+}
+
+/** O resultado do verificador para um item da lista (só os arquivos de texto têm). */
+const resultadoDe = (raiz, r, item) => r.arquivos.find((a) => path.resolve(raiz, a.arquivo) === item.abs && (a.formato ?? null) === (item.formato ?? null));
+
+/**
+ * Pendências por pasta da entrega (canal ou `outros`), na ordem da lista.
+ * @returns {Map<string, string[]>} só as pastas que têm pendência
+ */
+export function pendenciasPorPasta(raiz, itens, r) {
+  const mapa = new Map();
+  const somar = (item, linha) => mapa.set(item.canal ?? OUTROS, [...(mapa.get(item.canal ?? OUTROS) ?? []), linha]);
+  for (const item of itens) {
+    if (item.tipo !== 'arquivo') somar(item, MSG.naoEncontrei(item.rel));
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) if (i.nivel === 'bloqueio') somar(item, linhaDoItem(i, item.rel));
+  }
+  return mapa;
+}
+
+/** As frases "{canal} não está pronto: {n} pendências.", na ordem das pastas dadas. */
+export const frasesDePendencia = (pastas, pendencias) => pastas.filter((p) => pendencias.has(p)).map((p) => MSG.naoPronto(nomeDaPasta(p), pendencias.get(p).length));
+
+/** O que não foi conferido: alertas, "não medido", "não verificado" e a lista fixa. Não muda o final. */
+export function naoConferido(raiz, itens, r) {
+  const linhas = [];
+  for (const item of itens.filter((i) => i.tipo === 'arquivo')) {
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) {
+      if (i.nivel === 'alerta' || ehNaoMedido(i)) linhas.push(linhaDoItem(i, item.rel));
+    }
+  }
+  if (r.naoTexto.length) linhas.push(`${NAO_VERIFICADO} — não é texto: ${r.naoTexto.join(', ')}`);
+  return [...linhas, ...NUNCA_CONFERIDO];
+}
+
+const LIMITE = { legenda: 'caption_max_chars', post: 'post_max_chars', tweet: 'tweet_max_chars' };
+const NOME_NO_RELATORIO = { legenda: 'Legenda Instagram', post: 'Post LinkedIn', tweet: 'Tweet' };
+const NUMERADA = { legenda: 'legenda', post: 'post', tweet: 'Tweet' };
+
+/** O verificador já bloqueou, no arquivo de origem, o tamanho desta mesma peça? */
+function jaApontada(itensDaOrigem, a) {
+  const doTipo = itensDaOrigem.filter((i) => i.nivel === 'bloqueio' && i.item.startsWith(NOME_NO_RELATORIO[a.tipo]) && i.item.endsWith('caracteres'));
+  if (a.total < 2) return doTipo.length > 0;
+  const numero = new RegExp(`${NUMERADA[a.tipo]} ${a.ordem}(?!\\d)`);
+  return doTipo.some((i) => numero.test(i.item));
+}
+
+/**
+ * Regra 34: cada `legenda*.txt`, `post*.txt` (não o comentário) e `tweet*.txt` gerado é contado
+ * como o verificador conta e comparado com o limite do formato do item. Passou: um ALERTA — mas
+ * só quando o verificador não apontou a mesma peça. Não é pendência.
+ */
+export async function alertasDeTamanho(raiz, itens, arquivos, r) {
+  const alertas = [];
+  for (const a of arquivos.filter((x) => LIMITE[x.tipo] && x.texto)) {
+    const limite = (await lerLimites(raiz, a.formato)).limites?.[LIMITE[a.tipo]];
+    const medido = contar(a.texto);
+    const item = itens.find((i) => i.rel === a.origem && i.formato === a.formato);
+    const daOrigem = (item && resultadoDe(raiz, r, item)?.itens) ?? [];
+    if (typeof limite === 'number' && medido > limite && !jaApontada(daOrigem, a)) alertas.push(MSG.alerta(`${a.pasta}/${a.nome}`, medido, limite));
+  }
+  return alertas;
+}