primocode 11.0.0 → 11.2.0

package/lib/plugin/entregaveis/nucleo.js

@@ -0,0 +1,243 @@
+/**
+ * nucleo.js — a parte que slides, cartaz e documento dividem.
+ *
+ *   brief → direção de arte → conferência numérica → exportação
+ *
+ * Nada aqui sabe de "slide": só cor, texto, contagem e o corredor de checagem.
+ * Cada tipo de entregável (slides.js, depois cartaz.js e documento.js) entrega
+ * ao `conferir` uma lista de REGRAS, e recebe de volta { nota, falhas }.
+ * Sem modelo, sem rede: tudo é número que dá para testar.
+ */
+'use strict';
+
+/** Palavras de um texto (hífen e apóstrofo ficam dentro da palavra). */
+function palavras(t) {
+    return (String(t || '').match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) || []).length;
+}
+
+function hex(h) {
+    const m = /^#?([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(String(h || '').trim());
+    if (!m) return null;
+    let s = m[1];
+    if (s.length === 3) s = s.split('').map((c) => c + c).join('');
+    return [0, 2, 4].map((i) => parseInt(s.slice(i, i + 2), 16));
+}
+
+/** Luminância relativa WCAG 2.x. */
+function luminancia(h) {
+    const rgb = hex(h);
+    if (!rgb) return null;
+    const [r, g, b] = rgb.map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/** Razão de contraste WCAG (1 a 21). null se uma das cores não for hex. */
+function contraste(a, b) {
+    const la = luminancia(a); const lb = luminancia(b);
+    if (la == null || lb == null) return null;
+    const [claro, escuro] = la >= lb ? [la, lb] : [lb, la];
+    return (claro + 0.05) / (escuro + 0.05);
+}
+
+/** O brief mínimo: sem tema e sem público não há o que desenhar. Devolve { ok, faltam }. */
+function conferirBrief(brief) {
+    const b = brief || {};
+    const faltam = ['tema', 'publico', 'objetivo'].filter((k) => !String(b[k] || '').trim());
+    return { ok: faltam.length === 0, faltam };
+}
+
+/**
+ * Direção de arte escolhida pela IA a partir de material solto, não de modelo pronto.
+ * A direção válida tem: conceito (a ideia visual, ligada ao assunto), paleta com
+ * fundo/texto/destaque, e duas fontes. Aqui só se confere; quem escolhe é o modelo.
+ */
+function conferirDirecao(d) {
+    const falhas = [];
+    const x = d || {};
+    if (palavras(x.conceito) < 6) falhas.push({ regra: 'direcao-conceito', msg: 'conceito visual com menos de 6 palavras: diga por que este visual é DESTE assunto' });
+    const p = x.paleta || {};
+    for (const k of ['fundo', 'texto', 'destaque']) if (!hex(p[k])) falhas.push({ regra: 'direcao-paleta', msg: `paleta.${k} não é cor hex` });
+    if (!x.fonteTitulo || !x.fonteCorpo) falhas.push({ regra: 'direcao-fontes', msg: 'faltam fonteTitulo e fonteCorpo' });
+    const c = contraste(p.texto, p.fundo);
+    if (c != null && c < 4.5) falhas.push({ regra: 'contraste', msg: `texto sobre fundo: contraste ${c.toFixed(2)} < 4.5` });
+    const cd = contraste(p.destaque, p.fundo);
+    if (cd != null && cd < 3) falhas.push({ regra: 'contraste-destaque', msg: `destaque sobre fundo: contraste ${cd.toFixed(2)} < 3 (texto grande)` });
+    return falhas;
+}
+
+/**
+ * O corredor de checagem. `regras` é uma lista de { id, peso, testa(alvo) → falhas[] }.
+ * Nota = 100 menos o peso de cada regra que falhou; passa quando nenhuma regra de
+ * peso 'bloqueia' falha e a nota é >= minimo.
+ */
+function conferir(alvo, regras, { minimo = 80 } = {}) {
+    const falhas = [];
+    let nota = 100;
+    for (const r of regras) {
+        const f = r.testa(alvo) || [];
+        if (f.length) {
+            nota -= r.peso;
+            for (const item of f) falhas.push({ regra: r.id, ...item });
+        }
+    }
+    nota = Math.max(0, nota);
+    const bloqueia = regras.some((r) => r.bloqueia && falhas.some((f) => f.regra === r.id));
+    return { nota, falhas, passou: !bloqueia && nota >= minimo };
+}
+
+/** Slug de arquivo: afirmação curta vira nome seguro. */
+function slug(t) {
+    return String(t || 'entrega').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'entrega';
+}
+
+/** O caminho do Chrome/Chromium para imprimir PDF, ou null. */
+function acharNavegador(env = process.env, existe = require('fs').existsSync) {
+    const lista = [env.PRIMO_CHROME, '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium', '/usr/bin/google-chrome', '/usr/bin/chromium',
+        '/usr/bin/chromium-browser', 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'];
+    return lista.find((c) => c && existe(c)) || null;
+}
+
+/** HTML → PDF com o Chrome sem cabeça. Devolve { ok, erro }. */
+function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
+    if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
+    const { spawnSync } = require('child_process');
+    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+        `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
+    return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
+}
+
+
+// ───────────────────────── fonte embutida, degradê no PDF, PNG ─────────────────────────
+
+const FONTES_EMBUTIDAS = { inter: 'inter.woff2', anton: 'anton.woff2', montserrat: 'montserrat.woff2', 'jetbrains mono': 'jetbrains-mono.woff2', caveat: 'caveat.woff2' };
+
+/**
+ * @font-face com o arquivo DENTRO do HTML (base64), para o PDF não depender da fonte da máquina.
+ * Só embute as fontes OFL que vêm no pacote (vendor/fontes, licença em LICENSES/fontes-OFL.txt);
+ * qualquer outra fonte cai no `system-ui` da pilha. Devolve { css, embutidas }.
+ */
+function fontesEmbutidas(nomes) {
+    const fs = require('fs'); const path = require('path');
+    const css = []; const embutidas = [];
+    for (const nome of [...new Set((nomes || []).filter(Boolean))]) {
+        const arq = FONTES_EMBUTIDAS[String(nome).trim().toLowerCase()];
+        const caminho = arq && path.join(__dirname, '..', '..', '..', 'vendor', 'fontes', arq);
+        if (!caminho || !fs.existsSync(caminho)) continue;
+        css.push(`@font-face{font-family:'${nome}';font-weight:100 900;font-style:normal;src:url(data:font/woff2;base64,${fs.readFileSync(caminho).toString('base64')}) format('woff2')}`);
+        embutidas.push(nome);
+    }
+    return { css: css.join('\n'), embutidas };
+}
+
+let _gradId = 0;
+const escX = (t) => String(t == null ? '' : t).replace(/[&<>"]/g, (m) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[m]));
+
+/** Quebra o texto em linhas que cabem em `larguraPx` (estimativa conservadora: 0,56 em por letra). */
+function quebrar(texto, tamPx, larguraPx) {
+    const maxCh = Math.max(4, Math.floor(larguraPx / (tamPx * 0.56)));
+    const linhas = [];
+    for (const par of String(texto || '').split('\n')) {
+        let atual = '';
+        for (const w of par.split(/\s+/).filter(Boolean)) {
+            if (atual && (atual + ' ' + w).length > maxCh) { linhas.push(atual); atual = w; } else atual = atual ? atual + ' ' + w : w;
+        }
+        linhas.push(atual);
+    }
+    return linhas;
+}
+
+/**
+ * Título com degradê que SOBREVIVE ao PDF. `background-clip:text` vira um retângulo cheio no
+ * print-to-pdf do Chrome; o texto SVG com `fill="url(#g)"` é desenhado como texto de verdade.
+ * Devolve um <svg> do tamanho da caixa (w x h px). Sem segunda cor, vira cor sólida (sem svg).
+ * `estilo`: { familia, peso, tam (px), entrelinha (1 = tam), cor1, cor2, alinhar: 'start'|'end'|'middle', baseV: 'cima'|'baixo'|'meio' }.
+ */
+function tituloGradiente(texto, w, h, estilo) {
+    const { familia, peso = 800, tam, entrelinha = 0.92, cor1, cor2, alinhar = 'start', baseV = 'cima' } = estilo;
+    const linhas = quebrar(texto, tam, w);
+    const alturaLinha = tam * entrelinha;
+    const total = alturaLinha * linhas.length;
+    const y0 = baseV === 'baixo' ? h - total : baseV === 'meio' ? (h - total) / 2 : 0;
+    const x = alinhar === 'end' ? w : alinhar === 'middle' ? w / 2 : 0;
+    const id = 'g' + (++_gradId);
+    const tspans = linhas.map((l, i) => `<text x="${x}" y="${(y0 + alturaLinha * (i + 0.8)).toFixed(1)}" text-anchor="${alinhar}" fill="url(#${id})">${escX(l)}</text>`).join('');
+    return `<svg width="${w}" height="${h}" viewBox="0 0 ${w} ${h}" style="display:block;overflow:visible" font-family="${escX(familia)}" font-size="${tam}" font-weight="${peso}">`
+        + `<defs><linearGradient id="${id}" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="${w}" y2="${h}"><stop offset="0" stop-color="${cor1}"/><stop offset="1" stop-color="${cor2}"/></linearGradient></defs>${tspans}</svg>`;
+}
+
+/**
+ * Uma imagem PNG por página do HTML. Cada página é um <section> (largura x altura em px);
+ * o Chrome tira um screenshot com só aquela seção visível. Devolve { arquivos, erro }.
+ */
+function htmlParaPngs(htmlPath, baseSemExt, n, w, h, { escala = 1, navegador = acharNavegador() } = {}) {
+    if (!navegador) return { arquivos: [], erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
+    const fs = require('fs'); const { spawnSync } = require('child_process');
+    const html = fs.readFileSync(htmlPath, 'utf8');
+    const arquivos = []; let erro = null;
+    for (let i = 1; i <= n; i++) {
+        const tmp = `${baseSemExt}.tmp-${i}.html`;
+        const alvo = `${baseSemExt}-${String(i).padStart(2, '0')}.png`;
+        fs.writeFileSync(tmp, html.replace('</head>', `<style>section:not(:nth-of-type(${i})){display:none!important}html,body{height:${h}px;overflow:hidden}</style></head>`));
+        spawnSync(navegador, ['--headless=new', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
+            `--window-size=${w},${h}`, `--screenshot=${alvo}`, 'file://' + tmp], { encoding: 'utf8', timeout: 90000 });
+        try { fs.unlinkSync(tmp); } catch {}
+        if (fs.existsSync(alvo)) arquivos.push(alvo); else erro = `PNG ${i} não saiu`;
+    }
+    return { arquivos, erro };
+}
+
+/** PDF → um PNG por página com pdftoppm (poppler), se existir. Devolve { arquivos, erro }. */
+function pdfParaPngs(pdfPath, baseSemExt, { dpi = 80 } = {}) {
+    const fs = require('fs'); const path = require('path'); const { spawnSync } = require('child_process');
+    const r = spawnSync('pdftoppm', ['-png', '-r', String(dpi), pdfPath, baseSemExt], { encoding: 'utf8', timeout: 90000 });
+    if (r.error) return { arquivos: [], erro: 'pdftoppm não encontrado (instale poppler) — PNG do documento pulado' };
+    const dir = path.dirname(baseSemExt); const pre = path.basename(baseSemExt) + '-';
+    return { arquivos: fs.readdirSync(dir).filter((f) => f.startsWith(pre) && f.endsWith('.png')).sort().map((f) => path.join(dir, f)), erro: null };
+}
+
+/** Confere o plano com as regras do tipo e junta a checagem do brief. Plano sem o campo `exige` reprova sem estourar. */
+function conferirPlano(plano, regras, opcoes, { exige, vazio } = {}) {
+    if (!plano || typeof plano !== 'object' || (exige && !(Array.isArray(plano[exige]) ? plano[exige].length : plano[exige]))) {
+        return { nota: 0, passou: false, falhas: [{ regra: 'plano', msg: vazio || 'plano vazio' }] };
+    }
+    const brief = conferirBrief(plano.brief);
+    const r = conferir(plano, regras, opcoes);
+    if (!brief.ok) { r.falhas.unshift({ regra: 'brief', msg: `brief sem: ${brief.faltam.join(', ')}` }); r.nota = Math.max(0, r.nota - 10); r.passou = false; }
+    return r;
+}
+
+/** Resumo para o agente ler e consertar: uma linha por falha (com slide/seção/página quando houver). */
+function relatorio(r) {
+    const linhas = r.falhas.map((f) => `- [${f.regra}]${f.slide ? ` slide ${f.slide}:` : f.secao ? ` seção ${f.secao}:` : ''} ${f.msg}`);
+    return `nota ${r.nota}/100 — ${r.passou ? 'PASSOU' : 'REPROVADO'}${linhas.length ? '\n' + linhas.join('\n') : ''}`;
+}
+
+/** Cabe o texto em `n` linhas de largura `larguraPx` com letra `tamPx`? Devolve o maior tamanho (<= maxPx) que cabe em hPx. */
+function ajustarTamanho(texto, wPx, hPx, maxPx, { entrelinha = 1.05, minPx = 6 } = {}) {
+    for (let t = Math.floor(maxPx); t >= minPx; t--) {
+        const linhas = quebrar(texto, t, wPx);
+        const maiorPalavra = Math.max(...String(texto).split(/\s+/).map((w) => w.length), 1);
+        if (linhas.length * t * entrelinha <= hPx && maiorPalavra * t * 0.56 <= wPx) return t;
+    }
+    return minPx - 1;
+}
+
+const NUM = (n) => Math.round(n * 100) / 100;
+
+/** O HTML base de uma peça em páginas: fontes embutidas, @page do tamanho exato, uma <section> por página. */
+function htmlDePaginas({ titulo, direcao, w, h, secoes, css = '' }) {
+    const c = direcao.paleta;
+    const f = fontesEmbutidas([direcao.fonteTitulo, direcao.fonteCorpo]);
+    return `<!doctype html><html lang="pt-BR"><head><meta charset="utf-8"><title>${escX(titulo)}</title>
+<style>${f.css}
+@page{size:${w}px ${h}px;margin:0}*{box-sizing:border-box}html,body{margin:0;background:${c.fundo}}
+section{position:relative;width:${w}px;height:${h}px;overflow:hidden;page-break-after:always;break-after:page;-webkit-print-color-adjust:exact;print-color-adjust:exact;background:${c.fundo};color:${c.texto};font-family:'${escX(direcao.fonteCorpo)}',system-ui,sans-serif}
+section:last-of-type{page-break-after:auto;break-after:auto}
+section>*{position:absolute}${css}</style></head><body>
+${secoes.join('\n')}
+</body></html>`;
+}
+
+module.exports = { conferirPlano, relatorio, ajustarTamanho, htmlDePaginas, escX, NUM, fontesEmbutidas, tituloGradiente, quebrar, htmlParaPngs, pdfParaPngs, palavras, hex, luminancia, contraste, conferirBrief, conferirDirecao, conferir, slug, acharNavegador, htmlParaPdf };

package/lib/plugin/entregaveis/slides.js

@@ -0,0 +1,232 @@
+/**
+ * slides.js — o deck de ponta a ponta: plano → conferência numérica → .pptx + PDF.
+ *
+ * O MODELO escreve o plano (JSON): brief, direção de arte e os slides. Este
+ * arquivo NÃO escolhe cor nem texto. Ele (1) confere o plano com números,
+ * (2) desenha o mesmo plano em duas saídas: .pptx editável (pptxgenjs, MIT)
+ * e PDF (HTML → Chrome sem cabeça).
+ *
+ * Os layouts abaixo são GEOMETRIA (onde cabe o quê), não estilo: cor, fonte e
+ * conceito vêm sempre da direção que a IA escolheu para aquele assunto.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const nucleo = require('./nucleo');
+
+const LARGURA = 13.333; const ALTURA = 7.5; // polegadas, 16:9
+const PX = 144; // 13.333 pol * 144 = 1920 px
+
+/** Geometria por layout: caixas em polegadas e tamanho da letra em pt. */
+const LAYOUTS = {
+    capa: { titulo: { x: 0.8, y: 1.5, w: 11.7, h: 3.6, pt: 80 }, sub: { x: 0.8, y: 5.3, w: 11.7, h: 1.2, pt: 28 } },
+    gigante: { titulo: { x: 0.8, y: 0.9, w: 11.7, h: 3.6, pt: 66 }, corpo: { x: 0.8, y: 4.7, w: 11.7, h: 2.2, pt: 28 } },
+    numero: { numero: { x: 0.6, y: 1.0, w: 6.4, h: 4.6, pt: 190 }, titulo: { x: 7.2, y: 1.6, w: 5.5, h: 2.6, pt: 40 }, corpo: { x: 7.2, y: 4.3, w: 5.5, h: 2.4, pt: 26 } },
+    colunas: { titulo: { x: 0.8, y: 0.6, w: 11.7, h: 1.4, pt: 40 }, col1: { x: 0.8, y: 2.3, w: 5.6, h: 4.2, pt: 26 }, col2: { x: 6.9, y: 2.3, w: 5.6, h: 4.2, pt: 26 } },
+    citacao: { citacao: { x: 1.3, y: 1.4, w: 10.7, h: 3.9, pt: 44 }, autor: { x: 1.3, y: 5.6, w: 10.7, h: 0.8, pt: 24 } },
+    lista: { titulo: { x: 0.8, y: 0.6, w: 11.7, h: 1.4, pt: 44 }, corpo: { x: 0.8, y: 2.3, w: 11.7, h: 4.4, pt: 28 } },
+    divisor: { titulo: { x: 0.8, y: 2.4, w: 11.7, h: 2.4, pt: 60 } },
+    fechamento: { titulo: { x: 0.8, y: 1.2, w: 11.7, h: 3.0, pt: 64 }, acao: { x: 0.8, y: 4.8, w: 11.7, h: 1.4, pt: 34 } },
+};
+const NOMES_LAYOUT = Object.keys(LAYOUTS);
+
+/** Cabe o texto na caixa? Estimativa conservadora (0,52 em por letra, entrelinha 1,2). */
+function cabe(texto, pt, wIn, hIn) {
+    const t = String(texto || '');
+    if (!t) return true;
+    const porLinha = Math.max(1, Math.floor((wIn * 72) / (pt * 0.52)));
+    let linhas = 0;
+    for (const par of t.split('\n')) linhas += Math.max(1, Math.ceil(par.length / porLinha));
+    return linhas * pt * 1.2 / 72 <= hIn;
+}
+
+function itens(s) { return Array.isArray(s.corpo) ? s.corpo : (s.corpo ? [String(s.corpo)] : []); }
+
+function textoDoSlide(s) {
+    return [s.titulo, s.subtitulo, s.numero, s.legenda, s.citacao, s.autor, s.acao, ...itens(s)].filter(Boolean).join(' ');
+}
+
+const REGRAS = [
+    { id: 'tamanho-do-deck', peso: 10, testa: (p) => (p.slides.length < 5 || p.slides.length > 20) ? [{ msg: `${p.slides.length} slides: o deck tem de ter entre 5 e 20` }] : [] },
+    { id: 'layout-valido', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => NOMES_LAYOUT.includes(s.layout) ? [] : [{ slide: i + 1, msg: `layout "${s.layout}" não existe (${NOMES_LAYOUT.join(', ')})` }]) },
+    { id: 'palavras-por-slide', peso: 15, testa: (p) => p.slides.flatMap((s, i) => {
+        const max = ['capa', 'divisor', 'fechamento', 'numero', 'citacao'].includes(s.layout) ? 30 : 40;
+        const n = nucleo.palavras(textoDoSlide(s));
+        return n > max ? [{ slide: i + 1, msg: `${n} palavras (máx ${max}): corte ou divida em dois slides` }] : [];
+    }) },
+    { id: 'titulo-afirmacao', peso: 10, testa: (p) => p.slides.flatMap((s, i) => {
+        if (s.layout === 'citacao' || s.layout === 'divisor' || s.layout === 'numero') return [];
+        const n = nucleo.palavras(s.titulo);
+        return n < 3 ? [{ slide: i + 1, msg: `título com ${n} palavra(s): escreva a afirmação (3 a 12 palavras), não o tema` }]
+            : n > 12 ? [{ slide: i + 1, msg: `título com ${n} palavras (máx 12)` }] : [];
+    }) },
+    { id: 'uma-ideia', peso: 10, testa: (p) => p.slides.flatMap((s, i) => {
+        const it = itens(s); const out = [];
+        if (it.length > 4) out.push({ slide: i + 1, msg: `${it.length} itens (máx 4): uma ideia por slide` });
+        it.forEach((x) => { if (nucleo.palavras(x) > 14) out.push({ slide: i + 1, msg: `item com ${nucleo.palavras(x)} palavras (máx 14): "${String(x).slice(0, 30)}…"` }); });
+        return out;
+    }) },
+    { id: 'layout-repetido', peso: 15, testa: (p) => p.slides.flatMap((s, i) => (i && s.layout === p.slides[i - 1].layout) ? [{ slide: i + 1, msg: `layout "${s.layout}" igual ao slide anterior` }] : []) },
+    { id: 'variedade', peso: 10, testa: (p) => {
+        const n = p.slides.length; const dist = new Set(p.slides.map((s) => s.layout)).size; const meta = Math.min(4, Math.ceil(n / 2));
+        return n >= 6 && dist < meta ? [{ msg: `${dist} layouts diferentes em ${n} slides (mínimo ${meta})` }] : [];
+    } },
+    { id: 'abertura-e-fim', peso: 10, testa: (p) => {
+        const f = []; const a = p.slides[0]; const z = p.slides[p.slides.length - 1];
+        if (!a || a.layout !== 'capa') f.push({ slide: 1, msg: 'o primeiro slide tem de ser a capa' });
+        if (!z || z.layout !== 'fechamento') f.push({ slide: p.slides.length, msg: 'o último slide tem de ser o fechamento' });
+        else if (nucleo.palavras(z.acao) < 2) f.push({ slide: p.slides.length, msg: 'o fechamento precisa de uma ação (campo "acao"): o que o público faz agora' });
+        return f;
+    } },
+    { id: 'notas-do-orador', peso: 5, testa: (p) => p.slides.flatMap((s, i) => (s.layout === 'divisor' || nucleo.palavras(s.nota) >= 8) ? [] : [{ slide: i + 1, msg: 'sem nota do orador (mín 8 palavras): o texto do slide é o que se lê, a fala vai na nota' }]) },
+    { id: 'tamanho-da-letra', peso: 10, bloqueia: true, testa: (p) => {
+        const t = (p.direcao || {}).tamanhoCorpo || 28;
+        return t < 24 ? [{ msg: `corpo com ${t}pt (mín 24pt): lê-se de longe` }] : [];
+    } },
+    { id: 'encaixe', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => {
+        const g = LAYOUTS[s.layout]; if (!g) return [];
+        const mapa = { titulo: s.titulo, sub: s.subtitulo, numero: s.numero, citacao: s.citacao, autor: s.autor, acao: s.acao,
+            corpo: itens(s).join('\n'), col1: itens(s).filter((_, k) => k % 2 === 0).join('\n'), col2: itens(s).filter((_, k) => k % 2 === 1).join('\n') };
+        return Object.keys(g).filter((k) => mapa[k] && !cabe(mapa[k], g[k].pt, g[k].w, g[k].h))
+            .map((k) => ({ slide: i + 1, msg: `${k} não cabe na caixa (${g[k].pt}pt em ${g[k].w}x${g[k].h} pol): encurte` }));
+    }) },
+    { id: 'visual-com-motivo', peso: 10, testa: (p) => p.slides.flatMap((s, i) => (s.visual && nucleo.palavras(s.visual.motivo) < 4)
+        ? [{ slide: i + 1, msg: 'visual sem "motivo": todo elemento tem de ter a ver com o conteúdo do slide' }] : []) },
+    { id: 'direcao-de-arte', peso: 15, bloqueia: true, testa: (p) => nucleo.conferirDirecao(p.direcao).map((f) => ({ msg: f.msg })) },
+];
+
+/** Confere o plano. Devolve { nota, falhas, passou }. Plano malformado reprova sem estourar. */
+function conferirDeck(plano, opcoes) {
+    if (!plano || !Array.isArray(plano.slides) || !plano.slides.length) {
+        return { nota: 0, passou: false, falhas: [{ regra: 'plano', msg: 'plano sem slides' }] };
+    }
+    const brief = nucleo.conferirBrief(plano.brief);
+    const r = nucleo.conferir(plano, REGRAS, opcoes);
+    if (!brief.ok) { r.falhas.unshift({ regra: 'brief', msg: `brief sem: ${brief.faltam.join(', ')}` }); r.nota = Math.max(0, r.nota - 10); r.passou = false; }
+    return r;
+}
+
+/** Resumo para o agente ler e consertar: uma linha por falha. */
+function relatorio(r) {
+    const linhas = r.falhas.map((f) => `- [${f.regra}]${f.slide ? ` slide ${f.slide}:` : ''} ${f.msg}`);
+    return `nota ${r.nota}/100 — ${r.passou ? 'PASSOU' : 'REPROVADO'}${linhas.length ? '\n' + linhas.join('\n') : ''}`;
+}
+
+// ───────────────────────── .pptx editável ─────────────────────────
+
+const semHash = (c) => String(c).replace('#', '').toUpperCase();
+
+async function gerarPptx(plano, destino) {
+    const PptxGenJS = require('../../../vendor/pptxgenjs/carregar.js');
+    const pptx = new PptxGenJS();
+    pptx.defineLayout({ name: 'W169', width: LARGURA, height: ALTURA });
+    pptx.layout = 'W169';
+    pptx.title = (plano.brief || {}).tema || 'Apresentação';
+    pptx.author = 'PrimoCode';
+    const d = plano.direcao; const c = d.paleta;
+    const fundo = semHash(c.fundo); const texto = semHash(c.texto); const dest = semHash(c.destaque);
+    const suave = semHash(c.suave || c.texto);
+    const T = (s, caixa, extra) => s.addText(extra.text, { x: caixa.x, y: caixa.y, w: caixa.w, h: caixa.h, fontSize: caixa.pt,
+        fontFace: extra.face || d.fonteCorpo, color: extra.color || texto, bold: !!extra.bold, italic: !!extra.italic,
+        valign: extra.valign || 'top', margin: 0, fit: 'none', align: extra.align || 'left', lineSpacingMultiple: extra.ls || 1 });
+    plano.slides.forEach((sl) => {
+        const s = pptx.addSlide();
+        s.background = { color: fundo };
+        const g = LAYOUTS[sl.layout];
+        // Cada layout carrega UM gesto visual feito só de forma + cor da direção.
+        if (sl.layout === 'capa') s.addShape('rect', { x: 0, y: 0, w: 0.35, h: ALTURA, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'gigante') s.addShape('rect', { x: 0.8, y: 0.5, w: 1.6, h: 0.12, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'numero') s.addShape('rect', { x: 7.0, y: 1.2, w: 0.06, h: 5.2, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'divisor') s.addShape('rect', { x: 0, y: 0, w: LARGURA, h: ALTURA, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'fechamento') s.addShape('rect', { x: 0.8, y: 4.55, w: 3, h: 0.1, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.visual && sl.visual.imagem && fs.existsSync(sl.visual.imagem)) {
+            s.addImage({ path: sl.visual.imagem, x: 9.0, y: 4.6, w: 3.8, h: 2.6, sizing: { type: 'cover', w: 3.8, h: 2.6 } });
+        }
+        const sobreDestaque = sl.layout === 'divisor' ? { color: fundo } : {};
+        if (sl.layout === 'capa') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: texto, valign: 'bottom', ls: 0.9 }); if (sl.subtitulo) T(s, g.sub, { text: sl.subtitulo, color: dest }); }
+        else if (sl.layout === 'gigante') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: dest, ls: 0.9 }); if (itens(sl).length) T(s, g.corpo, { text: itens(sl).join('\n') }); }
+        else if (sl.layout === 'numero') { T(s, g.numero, { text: sl.numero, face: d.fonteTitulo, bold: true, color: dest, valign: 'middle' }); T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); if (sl.legenda || itens(sl).length) T(s, g.corpo, { text: sl.legenda || itens(sl).join('\n'), color: suave }); }
+        else if (sl.layout === 'colunas') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); T(s, g.col1, { text: itens(sl).filter((_, k) => k % 2 === 0).join('\n') }); T(s, g.col2, { text: itens(sl).filter((_, k) => k % 2 === 1).join('\n') }); }
+        else if (sl.layout === 'citacao') { T(s, g.citacao, { text: '“' + sl.citacao + '”', face: d.fonteTitulo, italic: true, color: dest, valign: 'middle' }); if (sl.autor) T(s, g.autor, { text: '— ' + sl.autor, color: suave }); }
+        else if (sl.layout === 'lista') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); s.addText(itens(sl).map((t) => ({ text: t, options: { bullet: { code: '25A0', color: dest }, breakLine: true, paraSpaceAfter: 10 } })), { x: g.corpo.x, y: g.corpo.y, w: g.corpo.w, h: g.corpo.h, fontSize: g.corpo.pt, fontFace: d.fonteCorpo, color: texto, margin: 0, valign: 'top', fit: 'none' }); }
+        else if (sl.layout === 'divisor') T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: sobreDestaque.color, valign: 'middle' });
+        else if (sl.layout === 'fechamento') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, valign: 'bottom', ls: 0.9 }); T(s, g.acao, { text: sl.acao, color: dest, bold: true }); }
+        if (sl.nota) s.addNotes(sl.nota);
+    });
+    await pptx.writeFile({ fileName: destino });
+    return destino;
+}
+
+// ───────────────────────── HTML → PDF ─────────────────────────
+
+const esc = (t) => String(t == null ? '' : t).replace(/[&<>"]/g, (m) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[m]));
+const px = (pol) => Math.round(pol * PX) + 'px';
+const pt2px = (pt) => Math.round(pt * PX / 72) + 'px';
+
+function gerarHtml(plano) {
+    const d = plano.direcao; const c = d.paleta;
+    const dest2 = c.destaque2 || c.destaque;
+    const caixa = (g, extra = '') => `position:absolute;left:${px(g.x)};top:${px(g.y)};width:${px(g.w)};height:${px(g.h)};font-size:${pt2px(g.pt)};${extra}`;
+    const grad = `color:${c.destaque};--grad:1;`; // marca o título gigante: com destaque2 vira degradê SVG
+    // background-clip:text vira retângulo cheio no print-to-pdf do Chrome (visto em 29/10). O degradê
+    // sai como <text fill="url(#g)"> em SVG (nucleo.tituloGradiente), que o PDF desenha como texto de verdade.
+    const comGradiente = !!c.destaque2 && c.destaque2.toLowerCase() !== c.destaque.toLowerCase();
+    const fam = (f) => `'${esc(f)}',system-ui,sans-serif`;
+    const fontes = nucleo.fontesEmbutidas([d.fonteTitulo, d.fonteCorpo]);
+    const secoes = plano.slides.map((s) => {
+        const g = LAYOUTS[s.layout]; let h = '';
+        const t = (k, txt, extra = '') => {
+            if (!txt) return '';
+            if (comGradiente && extra.includes('--grad:1')) {
+                const lh = /line-height:([\d.]+)/.exec(extra);
+                const pesoM = /font-weight:(\d+)/.exec(extra);
+                const baseV = extra.includes('align-items:flex-end') ? 'baixo' : extra.includes('align-items:center') ? 'meio' : 'cima';
+                const svg = nucleo.tituloGradiente(txt, Math.round(g[k].w * PX), Math.round(g[k].h * PX), {
+                    familia: fam(d.fonteTitulo).replace(/'/g, ''), peso: pesoM ? +pesoM[1] : 800, tam: Math.round(g[k].pt * PX / 72),
+                    entrelinha: lh ? +lh[1] : 0.92, cor1: c.destaque, cor2: c.destaque2, baseV });
+                return `<div style="${caixa(g[k], '')}">${svg}</div>`;
+            }
+            return `<div style="${caixa(g[k], extra)}">${esc(txt).replace(/\n/g, '<br>')}</div>`;
+        };
+        if (s.layout === 'capa') h = `<i style="position:absolute;left:0;top:0;width:${px(0.35)};height:100%;background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;display:flex;align-items:flex-end;${grad}`) + t('sub', s.subtitulo, `color:${c.destaque}`);
+        else if (s.layout === 'gigante') h = `<i style="position:absolute;left:${px(0.8)};top:${px(0.5)};width:${px(1.6)};height:${px(0.12)};background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;${grad}`) + t('corpo', itens(s).join('\n'));
+        else if (s.layout === 'numero') h = `<i style="position:absolute;left:${px(7.0)};top:${px(1.2)};width:${px(0.06)};height:${px(5.2)};background:${c.destaque}"></i>` + t('numero', s.numero, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:1;display:flex;align-items:center;${grad}`) + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + t('corpo', s.legenda || itens(s).join('\n'), `color:${c.suave || c.texto}`);
+        else if (s.layout === 'colunas') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + t('col1', itens(s).filter((_, k) => k % 2 === 0).join('\n')) + t('col2', itens(s).filter((_, k) => k % 2 === 1).join('\n'));
+        else if (s.layout === 'citacao') h = t('citacao', '“' + s.citacao + '”', `font-family:${fam(d.fonteTitulo)};font-style:italic;display:flex;align-items:center;color:${c.destaque}`) + t('autor', s.autor && '— ' + s.autor, `color:${c.suave || c.texto}`);
+        else if (s.layout === 'lista') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + `<ul style="${caixa(LAYOUTS.lista.corpo, 'margin:0;padding:0;list-style:none')}">${itens(s).map((x) => `<li style="margin-bottom:${px(0.14)};padding-left:${px(0.5)};position:relative"><b style="position:absolute;left:0;color:${c.destaque}">■</b>${esc(x)}</li>`).join('')}</ul>`;
+        else if (s.layout === 'divisor') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;display:flex;align-items:center;color:${c.fundo}`);
+        else if (s.layout === 'fechamento') h = `<i style="position:absolute;left:${px(0.8)};top:${px(4.55)};width:${px(3)};height:${px(0.1)};background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;display:flex;align-items:flex-end;${grad}`) + t('acao', s.acao, `color:${c.destaque};font-weight:700`);
+        if (s.visual && s.visual.imagem && fs.existsSync(s.visual.imagem)) {
+            const b64 = fs.readFileSync(s.visual.imagem).toString('base64');
+            const ext = path.extname(s.visual.imagem).slice(1).toLowerCase().replace('jpg', 'jpeg');
+            h += `<img alt="" src="data:image/${ext};base64,${b64}" style="position:absolute;left:${px(9)};top:${px(4.6)};width:${px(3.8)};height:${px(2.6)};object-fit:cover">`;
+        }
+        const fundo = s.layout === 'divisor' ? c.destaque : c.fundo;
+        return `<section style="background:${fundo};color:${c.texto};font-family:${fam(d.fonteCorpo)}">${h}</section>`;
+    }).join('\n');
+    return `<!doctype html><html lang="pt-BR"><head><meta charset="utf-8"><title>${esc((plano.brief || {}).tema || 'Apresentação')}</title>
+<style>${fontes.css}\n@page{size:1920px 1080px;margin:0}*{box-sizing:border-box}html,body{margin:0;background:${c.fundo}}
+section{position:relative;width:1920px;height:1080px;overflow:hidden;page-break-after:always;break-after:page;-webkit-print-color-adjust:exact;print-color-adjust:exact}
+section>div{line-height:1.2}</style></head><body>\n${secoes}\n</body></html>`;
+}
+
+/**
+ * Exporta o deck: confere, escreve .pptx, .html e (se houver Chrome) .pdf e um .png por slide.
+ * Plano reprovado não exporta, a menos que { forcar: true }.
+ */
+async function exportarDeck(plano, pasta, { forcar = false, pdf = true, png = true, nome } = {}) {
+    const resultado = conferirDeck(plano);
+    if (!resultado.passou && !forcar) return { exportado: false, conferencia: resultado, arquivos: [] };
+    fs.mkdirSync(pasta, { recursive: true });
+    const base = path.join(pasta, nome || nucleo.slug((plano.brief || {}).tema || plano.titulo));
+    const arquivos = [];
+    await gerarPptx(plano, base + '.pptx'); arquivos.push(base + '.pptx');
+    fs.writeFileSync(base + '.html', gerarHtml(plano)); arquivos.push(base + '.html');
+    let erroPdf = null;
+    if (png) { const r = nucleo.htmlParaPngs(base + '.html', base, plano.slides.length, 1920, 1080); arquivos.push(...r.arquivos); if (r.erro) erroPdf = (erroPdf ? erroPdf + '; ' : '') + r.erro; }
+    if (pdf) { const r = nucleo.htmlParaPdf(base + '.html', base + '.pdf'); if (r.ok) arquivos.push(base + '.pdf'); else erroPdf = r.erro; }
+    return { exportado: true, conferencia: resultado, arquivos, erroPdf };
+}
+
+module.exports = { LAYOUTS, NOMES_LAYOUT, cabe, conferirDeck, relatorio, gerarPptx, gerarHtml, exportarDeck };