primocode 10.12.0 → 10.14.0

package/lib/estudio/effectcraft.js

@@ -0,0 +1,152 @@
+/**
+ * effectcraft.js — o motor After Effects do Estúdio.
+ *
+ * O EffectCraft (github.com/storytold/effectcraft, MIT/Apache-2.0) roda JSX
+ * (ExtendScript) no modelo de objetos do After Effects, sem o After Effects:
+ * `script` monta o projeto (.ecproj), `render` gera o mp4 e `render-frame` um
+ * quadro para a IA conferir. O PrimoCode baixa o binário uma vez, confere o
+ * sha256 e guarda em ~/.primocode/bin/effectcraft-<versão>/.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const VERSAO = '0.11.1';
+const BASE = 'https://github.com/storytold/effectcraft/releases/download/v' + VERSAO + '/';
+const SHA_MAC = '8eae2e1e9c13e03d1bc2460501a90d43fc570b37e9b386294c0720eb12aad0f0';
+const PASTA_BIN = () => path.join(os.homedir(), '.primocode', 'bin', 'effectcraft-' + VERSAO);
+
+/** O asset da release para esta máquina: { arquivo, sha (null = ler do SHA256SUMS.txt) }. */
+function asset(plataforma = process.platform, arq = process.arch) {
+    if (plataforma === 'darwin') return { arquivo: `effectcraft-cli-${VERSAO}-macos-universal.zip`, sha: SHA_MAC };
+    if (plataforma === 'linux') return { arquivo: `effectcraft-${VERSAO}-linux-${arq === 'arm64' ? 'aarch64' : 'x86_64'}.tar.gz`, sha: null };
+    if (plataforma === 'win32') return { arquivo: `effectcraft-${VERSAO}-windows-${arq === 'arm64' ? 'arm64' : 'x64'}-portable.zip`, sha: null };
+    return null;
+}
+
+function achar(dir, nome) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory()) { const r = achar(p, nome); if (r) return r; }
+        else if (e.name === nome || e.name === nome + '.exe') return p;
+    }
+    return null;
+}
+
+async function baixar(url) {
+    const r = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(180000) });
+    if (!r.ok) throw new Error('HTTP ' + r.status + ' em ' + url);
+    return Buffer.from(await r.arrayBuffer());
+}
+
+/** O caminho do executável (baixa se faltar). `{ok, bin}` ou `{ok:false, error}`. */
+async function garantir({ bin } = {}) {
+    const dado = bin || process.env.PRIMOCODE_EFFECTCRAFT_BIN;
+    if (dado) return fs.existsSync(dado) ? { ok: true, bin: dado } : { ok: false, error: 'binário do EffectCraft não existe: ' + dado };
+    const dir = PASTA_BIN();
+    const ja = fs.existsSync(dir) ? achar(dir, 'effectcraft-cli') : null;
+    if (ja) return { ok: true, bin: ja };
+    const a = asset();
+    if (!a) return { ok: false, error: 'o EffectCraft não tem binário para ' + process.platform };
+    try {
+        let sha = a.sha;
+        if (!sha) {
+            const sums = (await baixar(BASE + 'SHA256SUMS.txt')).toString('utf8');
+            const linha = sums.split('\n').find((l) => l.trim().endsWith(a.arquivo));
+            sha = linha && linha.trim().split(/\s+/)[0];
+            if (!sha) return { ok: false, error: 'SHA256SUMS.txt da release não lista ' + a.arquivo };
+        }
+        const buf = await baixar(BASE + a.arquivo);
+        const got = crypto.createHash('sha256').update(buf).digest('hex');
+        if (got !== sha) return { ok: false, error: `sha256 do EffectCraft não confere (esperado ${sha}, veio ${got})` };
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = path.join(dir, a.arquivo);
+        fs.writeFileSync(tmp, buf);
+        const x = a.arquivo.endsWith('.zip')
+            ? (process.platform === 'win32' ? spawnSync('tar', ['-xf', tmp, '-C', dir]) : spawnSync('unzip', ['-oq', tmp, '-d', dir]))
+            : spawnSync('tar', ['-xzf', tmp, '-C', dir]);
+        fs.rmSync(tmp, { force: true });
+        if (x.status !== 0) return { ok: false, error: 'não consegui extrair o EffectCraft: ' + String(x.stderr || x.error || '').slice(0, 300) };
+        const exe = achar(dir, 'effectcraft-cli');
+        if (!exe) return { ok: false, error: 'o executável effectcraft-cli não estava no pacote' };
+        if (process.platform !== 'win32') fs.chmodSync(exe, 0o755);
+        return { ok: true, bin: exe };
+    } catch (e) {
+        return { ok: false, error: 'não consegui baixar o EffectCraft (sem rede?): ' + (e && e.message || e) };
+    }
+}
+
+function rodar(bin, args, env, timeout) {
+    const r = spawnSync(bin, args, { encoding: 'utf8', env, timeout, maxBuffer: 32 * 1024 * 1024 });
+    const saida = ((r.stdout || '') + (r.stderr || '')).trim();
+    if (r.error) return { ok: false, saida: (r.error.code === 'ETIMEDOUT' ? 'estourou o tempo' : r.error.message) + '\n' + saida };
+    return { ok: r.status === 0, saida };
+}
+
+/**
+ * Roda o JSX, renderiza o mp4 e os quadros de conferência.
+ * `fontes`: [{familia, peso}] baixadas do Google Fonts e passadas em EFFECTCRAFT_FONT_DIRS.
+ * `previa`: rascunho em meia resolução e qualidade draft (segundos, não minutos), para aprovar antes do final.
+ */
+async function renderizar({ pasta, script, comp, fontes = [], audio, conferir = [], bin, timeouts = {}, semVideo = false, previa = false } = {}) {
+    if (!pasta || !script || !comp) return { ok: false, error: 'faltou pasta, script ou comp' };
+    const g = await garantir({ bin });
+    if (!g.ok) return g;
+    const ae = path.join(pasta, 'ae');
+    fs.mkdirSync(ae, { recursive: true });
+    const jsx = path.join(ae, 'cena.jsx');
+    const projeto = path.join(ae, 'projeto.ecproj');
+    fs.writeFileSync(jsx, script);
+
+    const env = { ...process.env };
+    const dirs = [];
+    if (fontes && fontes.length) {
+        const glifos = require('./glifos.js');
+        for (const f of fontes) {
+            try { if (await glifos.baixarFonte(f.familia, f.peso || 400)) dirs.push(glifos.CACHE); } catch { /* sem rede: segue com a fonte do sistema */ }
+        }
+    }
+    if (dirs.length) env.EFFECTCRAFT_FONT_DIRS = [...new Set(dirs)].join(path.delimiter);
+
+    const s = rodar(g.bin, ['script', jsx, '--empty', '--save-as', projeto], env, timeouts.script || 120000);
+    if (!s.ok || !fs.existsSync(projeto)) return { ok: false, error: 'o script JSX falhou:\n' + s.saida.slice(-1500) };
+
+    const bruto = path.join(pasta, audio ? 'video-ae-mudo.mp4' : 'video-ae.mp4');
+    if (semVideo) {   // só a conferência: o script rodou (avisos, auditoria) e os quadros saem; o vídeo fica para a passada final
+        const quadros0 = [];
+        for (const t of conferir || []) {
+            const png = path.join(ae, `quadro-${t}.png`);
+            const q = rodar(g.bin, ['render-frame', '--project', projeto, '--comp', comp, '--time', String(t), '--out', png, '--max-side', '640'], env, timeouts.quadro || 60000);
+            if (q.ok && fs.existsSync(png)) quadros0.push(png);
+        }
+        return { ok: true, video: null, quadros: quadros0, projeto, saida: s.saida, semVideo: true };
+    }
+    const r = rodar(g.bin, ['render', '--project', projeto, '--comp', comp, '--out', bruto, '--format', 'h264', ...(previa ? ['--resolution', 'half', '--quality', 'draft'] : [])], env, timeouts.render || (previa ? 180000 : 600000));
+    if (!r.ok || !fs.existsSync(bruto)) return { ok: false, error: 'o render falhou:\n' + r.saida.slice(-1500) };
+
+    const quadros = [];
+    for (const t of conferir || []) {
+        const png = path.join(ae, `quadro-${t}.png`);
+        const q = rodar(g.bin, ['render-frame', '--project', projeto, '--comp', comp, '--time', String(t), '--out', png, '--max-side', '640'], env, timeouts.quadro || 60000);
+        if (q.ok && fs.existsSync(png)) quadros.push(png);
+    }
+
+    let video = bruto;
+    const aud = audio ? path.resolve(pasta, audio) : null;
+    if (aud && fs.existsSync(aud)) {
+        const final = path.join(pasta, 'video-ae.mp4');
+        const m = rodar('ffmpeg', ['-y', '-i', bruto, '-i', aud, '-c:v', 'copy', '-c:a', 'aac', '-shortest', final], process.env, timeouts.audio || 120000);
+        if (m.ok && fs.existsSync(final)) { video = final; fs.rmSync(bruto, { force: true }); }
+    } else if (audio) {
+        fs.renameSync(bruto, path.join(pasta, 'video-ae.mp4'));
+        video = path.join(pasta, 'video-ae.mp4');
+    }
+    return { ok: true, video, quadros, projeto, saida: s.saida };
+}
+
+module.exports = { VERSAO, asset, garantir, renderizar };

package/lib/estudio/exportar.js

@@ -0,0 +1,181 @@
+'use strict';
+/**
+ * exportar.js — o PACOTE PRA POSTAR do estudio_motion, depois do render.
+ *   exportar({video, pasta, assunto, formatos, cenas, palavras, trilha, sfx, assinatura}) → {ok, dir, arquivos}
+ *   srt(palavras)            → texto .srt (usa os mesmos pedaços da legenda do vídeo)
+ *   postTxt({...})           → gancho + 3 linhas + CTA + 5 hashtags + créditos CC BY
+ *   creditosDe(trilha, sfx)  → linhas de atribuição (só licenças que exigem)
+ *   galeria: registrar / listar / abrir / main(['abrir'|'pasta', n])
+ * Nunca estica: 9:16, 1:1 e 16:9 saem com o fundo desfocado e o vídeo centralizado.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DIMS = { '9:16': [1080, 1920], '1:1': [1080, 1080], '16:9': [1920, 1080] };
+const ARQ_GALERIA = () => process.env.PRIMOCODE_VIDEOS || path.join(os.homedir(), '.primocode', 'studio', 'videos.json');
+const PARADAS = new Set('para como uma umas uns com que dos das nos nas por mais sobre entre seu sua isso esse essa este esta pelo pela muito tudo cada sem'.split(' '));
+
+const ff = (args) => spawnSync('ffmpeg', ['-y', '-v', 'error', ...args], { encoding: 'utf8' });
+function sondar(arq) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height:format=duration', '-of', 'json', arq], { encoding: 'utf8' });
+    try { const j = JSON.parse(r.stdout); const s = j.streams[0]; return { w: s.width, h: s.height, dur: parseFloat(j.format.duration) }; } catch { return null; }
+}
+
+// ── legenda .srt ─────────────────────────────────────────────────────────
+const tempoSrt = (s) => {
+    const ms = Math.max(0, Math.round(s * 1000));
+    const p = (n, l = 2) => String(n).padStart(l, '0');
+    return `${p(Math.floor(ms / 3600000))}:${p(Math.floor(ms / 60000) % 60)}:${p(Math.floor(ms / 1000) % 60)},${p(ms % 1000, 3)}`;
+};
+function srt(palavras, { max = 3 } = {}) {
+    if (!Array.isArray(palavras) || !palavras.length) return '';
+    // agrupamento próprio (a legenda do vídeo junta frases inteiras; o .srt das redes quebra em trechos curtos de até `max` palavras)
+    const chunks = [];
+    palavras.forEach((p, i) => {
+        const prev = palavras[i - 1], atual = chunks[chunks.length - 1];
+        if (!atual || !prev || atual.palavras.length >= max || /[.!?;:]$/.test(prev.w) || p.t - prev.t2 > 0.25) chunks.push({ t: p.t, t2: p.t2, palavras: [p] });
+        else { atual.palavras.push(p); atual.t2 = p.t2; }
+    });
+    return chunks.map((c, i) => {
+        const fim = Math.max(c.t2, c.t + 0.4);
+        return `${i + 1}\n${tempoSrt(c.t)} --> ${tempoSrt(fim)}\n${c.palavras.map((p) => String(p.w).replace(/\*/g, '')).join(' ')}\n`;
+    }).join('\n');
+}
+
+// ── os créditos que exigem atribuição (CC BY, BY-SA...) ──────────────────
+function fichaDe(arq) {
+    if (!arq) return null;
+    for (const f of [arq.replace(/\.[a-z0-9]+$/i, '') + '.licenca.json', arq + '.licenca.json']) {
+        try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { /* próxima */ }
+    }
+    return null;
+}
+const exigeCredito = (lic) => /^(cc[- ]?by|by)/i.test(String(lic || '').trim()) && !/^(cc0|zero)/i.test(String(lic || ''));
+function creditosDe(trilha, sfx = []) {
+    const out = [];
+    const fichaT = trilha && fichaDe(trilha.arquivo);
+    if (trilha && trilha.creditos && !(fichaT && !exigeCredito(fichaT.licenca) && !/by/i.test(String(trilha.creditos)))) out.push(`Trilha: ${typeof trilha.creditos === 'string' ? trilha.creditos : (trilha.titulo || '') + (trilha.autor ? ' — ' + trilha.autor : '')}`);
+    else if (fichaT && exigeCredito(fichaT.licenca)) out.push(`Trilha: "${fichaT.titulo}"${fichaT.autor ? ' — ' + fichaT.autor : ''} (${String(fichaT.licenca).toUpperCase()}${fichaT.origem ? ', ' + fichaT.origem : ''})`);
+    const vistos = new Set();
+    for (const arq of sfx) {
+        const f = fichaDe(arq);
+        if (!f || !exigeCredito(f.licenca)) continue;
+        const l = `SFX: "${f.titulo}"${f.autor ? ' — ' + f.autor : ''} (${String(f.licenca).toUpperCase()}${f.origem ? ', ' + f.origem : ''})`;
+        if (!vistos.has(l)) { vistos.add(l); out.push(l); }
+    }
+    return out;
+}
+
+// ── o texto do post ──────────────────────────────────────────────────────
+const limpo = (s) => String(s || '').replace(/\*/g, '').replace(/\s+/g, ' ').trim();
+function hashtags(assunto, n = 5) {
+    const norm = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    const tags = [];
+    for (const w of limpo(assunto).split(/\s+/)) { const t = norm(w); if (t.length >= 4 && !PARADAS.has(t) && !tags.includes(t)) tags.push(t); }
+    for (const t of ['motion', 'video', 'reels', 'design', 'criatividade']) if (!tags.includes(t)) tags.push(t);
+    return tags.slice(0, n).map((t) => '#' + t);
+}
+function postTxt({ assunto, cenas = [], creditos = [] } = {}) {
+    const txt = (c) => limpo(c.titulo || c.texto || c.fala || '');
+    const gancho = cenas.find((c) => c.papel === 'gancho') || cenas[0] || {};
+    const cta = [...cenas].reverse().find((c) => c.papel === 'cta') || null;
+    const meio = cenas.filter((c) => c !== gancho && c !== cta).map(txt).filter(Boolean);
+    const linhas = meio.slice(0, 3);
+    while (linhas.length < 3) linhas.push(['Feito em motion, do roteiro ao corte.', 'Cada cena no tempo da batida.', 'Salve pra rever depois.'][linhas.length]);
+    const chamada = cta ? limpo(cta.botao || cta.titulo || cta.texto) : '';
+    const partes = [txt(gancho) || limpo(assunto), '', ...linhas.map((l) => '• ' + l), '', chamada ? `${chamada} 👇` : 'Curtiu? Salva e manda pra quem precisa.', '', hashtags(assunto).join(' ')];
+    if (creditos.length) partes.push('', 'Créditos:', ...creditos);
+    return partes.join('\n') + '\n';
+}
+
+// ── as versões de formato (fundo desfocado + vídeo centralizado) ─────────
+function recompor(video, saida, [W, H]) {
+    const vf = `split[a][b];[a]scale=${W}:${H}:force_original_aspect_ratio=increase,crop=${W}:${H},boxblur=30:5[bg];[b]scale=${W}:${H}:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2,setsar=1,format=yuv420p`;
+    const r = ff(['-i', video, '-vf', vf, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20', '-c:a', 'copy', '-movflags', '+faststart', saida]);
+    return r.status === 0 && fs.existsSync(saida);
+}
+
+// ── a capa: o quadro de maior contraste, com título (meio de cada cena) ──
+function capa(video, saida, { cenas = [], dur } = {}) {
+    const layout = require('./maquina-layout.js');
+    const total = dur || (sondar(video) || {}).dur || 0;
+    let t = 0;
+    const tempos = cenas.length ? cenas.map((c) => { const x = t + (c.dur || 1) * 0.6; t += c.dur || 1; return x; }) : [0.2, 0.4, 0.6, 0.8].map((k) => k * total);
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'capa-'));
+    let melhor = null;
+    try {
+        tempos.filter((x) => x < total).forEach((x, i) => {
+            const png = path.join(tmp, `q${i}.png`);
+            if (ff(['-ss', x.toFixed(2), '-i', video, '-frames:v', '1', png]).status !== 0 || !fs.existsSync(png)) return;
+            let m; try { m = layout.medirQuadro(png); } catch { m = null; }
+            if (!m) return;
+            const pontos = m.contraste + Math.min(m.variancia, 60) / 30 - (i === 0 ? 0.3 : 0);   // título legível + algo na tela
+            if (!melhor || pontos > melhor.pontos) melhor = { png, pontos, t: x };
+        });
+        if (!melhor) return null;
+        const r = ff(['-i', melhor.png, '-vf', 'scale=1080:-2', '-q:v', '2', saida]);
+        return r.status === 0 && fs.existsSync(saida) ? { arquivo: saida, t: melhor.t } : null;
+    } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+}
+
+// ── o pacote ─────────────────────────────────────────────────────────────
+function exportar(o = {}) {
+    const { video, pasta, assunto = '', formatos = [], cenas = [], palavras = [], trilha = null, sfx = [] } = o;
+    if (!video || !fs.existsSync(video)) return { ok: false, error: 'sem vídeo para exportar.' };
+    const dir = path.join(pasta || path.dirname(video), 'entrega');
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivos = [], avisos = [];
+    const final = path.join(dir, 'video.mp4');
+    fs.copyFileSync(video, final); arquivos.push(final);
+    const info = sondar(video);
+    for (const f of [...new Set(formatos || [])]) {
+        if (!DIMS[f]) { avisos.push(`formato desconhecido: ${f}`); continue; }
+        const s = path.join(dir, `video-${f.replace(':', 'x')}.mp4`);
+        if (recompor(video, s, DIMS[f])) arquivos.push(s); else avisos.push(`não consegui gerar o ${f}`);
+    }
+    const legenda = srt(palavras);
+    if (legenda) { const s = path.join(dir, 'legenda.srt'); fs.writeFileSync(s, legenda); arquivos.push(s); }
+    const c = capa(video, path.join(dir, 'capa.jpg'), { cenas, dur: info && info.dur });
+    if (c) arquivos.push(c.arquivo); else avisos.push('a capa não saiu');
+    const creditos = creditosDe(trilha, sfx);
+    const post = path.join(dir, 'post.txt');
+    fs.writeFileSync(post, postTxt({ assunto, cenas, creditos })); arquivos.push(post);
+    return { ok: true, dir, arquivos, creditos, ...(avisos.length ? { avisos } : {}) };
+}
+
+// ── a galeria: ~/.primocode/studio/videos.json ───────────────────────────
+function ler(arq = ARQ_GALERIA()) { try { const j = JSON.parse(fs.readFileSync(arq, 'utf8')); return Array.isArray(j) ? j : []; } catch { return []; } }
+function registrar({ id, assunto, caminho, formato, duracao, assinatura, entrega }, arq = ARQ_GALERIA()) {
+    const l = ler(arq).filter((v) => v.caminho !== caminho);
+    const item = { id: id || path.basename(path.dirname(caminho)), assunto: limpo(assunto), data: new Date().toISOString(), caminho, formato, duracao, assinatura: assinatura || null, entrega: entrega || null };
+    l.push(item);
+    try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(l.slice(-200), null, 2)); } catch { /* sem disco: segue */ }
+    return item;
+}
+const listar = (arq) => ler(arq).filter((v) => v.caminho && fs.existsSync(v.caminho)).sort((a, b) => String(b.data).localeCompare(String(a.data)));
+function abrirNoSistema(alvo) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '""', alvo] : [alvo];
+    return spawnSync(cmd, args, { stdio: 'ignore' }).status === 0;
+}
+const mmss = (s) => `${Math.floor(s / 60)}:${String(Math.round(s % 60)).padStart(2, '0')}`;
+function formatarLista(l) {
+    if (!l.length) return '  Nenhum vídeo ainda. Peça um ao estúdio de motion.';
+    return ['', ...l.map((v, i) => `  ${String(i + 1).padStart(2)}. ${limpo(v.assunto).slice(0, 44).padEnd(44)} ${String(v.formato || '').padEnd(5)} ${mmss(v.duracao || 0).padStart(5)}  ${String(v.data).slice(0, 10)}`), '', '  primocode videos abrir <n> · primocode videos pasta <n>'].join('\n');
+}
+/** `primocode videos [abrir|pasta <n>]` e /videos. Devolve o texto; `abrir` é injetável nos testes. */
+function main(args = [], { arq, abrir = abrirNoSistema } = {}) {
+    const l = listar(arq);
+    const [acao, n] = args;
+    if (acao === 'abrir' || acao === 'pasta') {
+        const v = l[parseInt(n, 10) - 1];
+        if (!v) return { ok: false, texto: `  Não achei o vídeo ${n || ''}. Veja a lista com: primocode videos` };
+        const alvo = acao === 'abrir' ? v.caminho : (v.entrega || path.dirname(v.caminho));
+        return { ok: abrir(alvo), alvo, texto: `  Abrindo ${alvo}` };
+    }
+    return { ok: true, texto: formatarLista(l) };
+}
+
+module.exports = { exportar, srt, postTxt, creditosDe, hashtags, capa, recompor, registrar, listar, ler, main, formatarLista, DIMS };

package/lib/estudio/gerativo.js

@@ -510,7 +510,9 @@ function tituloDaFala(fala) {
 
 function conteudoDe(p, marca = {}) {
     const titulo = p.titulo || p.texto || tituloDaFala(p.fala);
-    const itens = itensDe(p);
+    // O item que repete o título ("Sem troco" / "sem troco", 15/10) sai: o quadro dizia a mesma coisa duas vezes.
+    const igual = (a, b) => tokens(a).join(' ') === tokens(b).join(' ');
+    const itens = itensDe(p).filter((it) => !igual(it, titulo));
     if (p.tipo === 'numero' && numeroDe(p.valor)) return { tipo: 'numero', valor: String(p.valor), rotulo: p.rotulo || titulo, sub: p.sub || '' };
     if (itens.length >= 2) return { tipo: 'lista', titulo: p.tipo === 'cores' ? titulo : titulo, itens: itens.slice(0, 5), numerada: p.tipo === 'passos' };
     if (p.tipo === 'contraste' && (p.nao || p.sim)) return { tipo: 'contraste', nao: p.nao || '', sim: p.sim || titulo };
@@ -528,7 +530,7 @@ const textoDoConteudo = (c) => [c.titulo, c.sub, c.valor, c.rotulo, c.nao, c.sim
 const COMPOSICOES = ['gigante', 'pilha', 'divisao', 'contador', 'cascata', 'parede', 'citacao', 'marca', 'palavras', 'produto'];
 const COMPORTAMENTOS = ['carimbo', 'mascara', 'onda', 'decodifica', 'peso', 'largura', 'tracking', 'desfoque', 'flap', 'pontos', 'contorno', 'monta'];
 const SAIDAS = ['pontos', 'evapora', 'atravessa', 'desliza', 'comprime', 'explode', 'chicote', 'inunda', 'corte'];
-const ACENTOS = ['ponto', 'sublinha', 'anel', 'risco', 'barra', 'bala', 'marca', 'moldura', 'seta'];
+const ACENTOS = ['ponto', 'sublinha', 'anel', 'risco', 'barra', 'bala', 'marca', 'moldura', 'seta', 'visto'];
 
 function pesosDe(c, { curto, palavras, primeira, ultima, tem3d, pergunta, exclama, numeroNoTitulo }) {
     switch (c.tipo) {
@@ -1055,13 +1057,18 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
     const M = Math.round(W * (deitado ? 0.085 : 0.095));
     const larguraUtil = W - 2 * M;
     const base = Math.min(W, H) / 1080;
-    const tamRotulo = Math.round((deitado ? 24 : 30) * base);
+    /* (15/10, as referências) O rótulo de 24–30 px (1,6% da altura no 9:16)
+       não se lia no celular ("NO COADOR", "pra você, de graça"). O rótulo
+       fica em ~2% da altura, e a segunda voz (o sub, a frase de apoio) em
+       3–4%, como a anotação das referências. */
+    const tamRotulo = Math.round(Math.max((deitado ? 24 : 30) * base, H * (deitado ? 0.026 : 0.02)));
     const tem3d = !!roteiro.modelo3d;
     const ws = temposDasPartes(partes, tempos);
 
     // ── os limites de cada parte na linha do tempo ────────────────────────
     const inicio = [];
-    partes.forEach((_, i) => inicio.push(i === 0 ? 0 : r3(Math.max(inicio[i - 1] + 1.4, ws[i].de - 0.12))));
+    // 0,9 s (eram 1,4): nas referências a cena dura 1 a 2 s; com fala rápida a parte segue a voz.
+    partes.forEach((_, i) => inicio.push(i === 0 ? 0 : r3(Math.max(inicio[i - 1] + 0.9, ws[i].de - 0.12))));
     const ultimaFala = ws[ws.length - 1];
     const duracao = r1(Math.max(inicio[inicio.length - 1] + 2.0, (ultimaFala.ate || 0) + 1.15));
     const fimParte = partes.map((_, i) => (i < partes.length - 1 ? inicio[i + 1] : duracao));
@@ -1544,14 +1551,18 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
        resto); no fim, cada gesto vira o seu par limpo. */
     /* O substituto é um limpo que não aparece nas 3 batidas de cada lado: a
        passagem e o gesto da tese não voltam antes de 3 batidas. */
-    const TORTOS = ['decodifica', 'flap', 'onda', 'monta'];
-    const GESTOS_LIMPOS = ['mascara', 'desfoque', 'tracking', 'pontos', 'contorno', 'carimbo'];
-    const SAIDAS_LIMPAS = ['evapora', 'desliza', 'comprime', 'pontos', 'atravessa'];
+    /* (15/10, as referências) Os pontos, o evapora e o comprime também
+       espalhavam as letras ("dad|o", "· p o n d e", parecia glitch). Nas
+       referências a frase sai inteira: desliza, atravessa ou corta seco. */
+    const TORTOS = ['decodifica', 'flap', 'onda', 'monta', 'pontos'];
+    const GESTOS_LIMPOS = ['mascara', 'desfoque', 'tracking', 'contorno', 'carimbo'];
+    const SAIDAS_LIMPAS = ['desliza', 'atravessa', 'corte'];
+    const SAIDAS_SUJAS = ['explode', 'chicote', 'pontos', 'evapora', 'comprime'];
     const vizinhas = (i) => batidas.filter((_, j) => j !== i && Math.abs(j - i) <= 3);
     const principal = (b) => (b.linhas || []).find((l) => (l.papel === 'tese' || l.papel === 'numero') && !l.marca);
     const comGesto = batidas.filter(principal);
     batidas.forEach((b, i) => {
-        if (b.saida === 'explode' || b.saida === 'chicote') {
+        if (SAIDAS_SUJAS.includes(b.saida)) {
             const perto = vizinhas(i).map((x) => x.saida);
             b.saida = SAIDAS_LIMPAS.find((x) => !perto.includes(x)) || 'corte';
             if (batidas[i + 1]) batidas[i + 1].entrada = b.saida;
@@ -1626,6 +1637,11 @@ function molduraDe(roteiro, E, { W, H, deitado, marca, secoes }) {
 const pesoDe = (fonte) => (VARIAVEIS[fonte] && VARIAVEIS[fonte].eixos.wght) || [400, 400];
 
 // ── as composições: de conteúdo + contexto, uma batida ─────────────────
+/** A segunda voz (sub, a frase de apoio): 3–4% da altura, como a anotação das referências. */
+function tamSegunda({ H, deitado, tamRotulo }) {
+    return Math.round(Math.max(tamRotulo, H * (deitado ? 0.042 : 0.03)));
+}
+
 function compor(comp, br, ctx) {
     const { s, W, H, M, deitado, base, larguraUtil, tamRotulo, fontes } = ctx;
     const c = br.conteudo;
@@ -1739,6 +1755,8 @@ function compor(comp, br, ctx) {
                 else {
                     const lt = comTese || teses[teses.length - 1];
                     b.acento.push({ forma, alvo: { linha: lt.id, palavra: comTese ? lt.palavras.findIndex((p) => p.papel === 'tese') : null } });
+                    // O círculo de caneta na tese ganha o ✓ (15/10, as referências), sem gastar sorteio.
+                    if (forma === 'anel' && comTese) b.acento.push({ forma: 'visto', alvo: { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese') } });
                 }
             }
             // O ThreeCanvas só aceita pixel inteiro; ele ocupa a altura toda, para o chão não cortar.
@@ -1759,7 +1777,13 @@ function compor(comp, br, ctx) {
             }
             for (const t of fit.linhas) { const l = linha(t, 'apoio', { tamanho: fit.tamanho, eixos: { wght: 560 } }); misturarPesos(l, { maiorTese: 1.14 }); }
             const lt = b.linhas.find((l) => l.palavras.some((p) => p.papel === 'tese'));
-            if (lt) { tese(lt); b.acento.push({ forma: s.chance(0.6) ? 'sublinha' : 'anel', alvo: { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese') } }); }
+            if (lt) {
+                tese(lt);
+                const alvo = { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese') };
+                const forma = s.chance(0.6) ? 'sublinha' : 'anel';
+                b.acento.push({ forma, alvo });
+                if (forma === 'anel') b.acento.push({ forma: 'visto', alvo: { ...alvo } });
+            }
             else pontoFinal(b.linhas[b.linhas.length - 1]);
             break;
         }
@@ -1774,7 +1798,7 @@ function compor(comp, br, ctx) {
             const l = linha(c.valor, 'numero', { fonte, tamanho: tam, eixos });
             const tRot = Math.max(30 * base, Math.min(tam * 0.22, 64 * base));
             if (c.rotulo) linha(c.rotulo, 'apoio', { tamanho: tRot, eixos: { wght: 600 }, fonte: fontes.display });
-            if (c.sub) linha(c.sub, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.08, eixos: { wght: 400 } });
+            if (c.sub) linha(c.sub, 'rotulo', { fonte: fontes.mono, tamanho: tamSegunda(ctx), tracking: 0.02, eixos: { wght: 400 } });
             b.contador = { linha: l.id, ...n, dur: 0.9 };
             b.acento.push({ forma: c.valor.length <= 4 ? 'anel' : 'sublinha', alvo: { linha: l.id } });
             break;
@@ -1844,7 +1868,7 @@ function compor(comp, br, ctx) {
             const tam = tamanhoQueCabe(nome, lg, (deitado ? 0.3 : 0.16) * H, { fonte, wght: 800 });
             b.bloco = { x: W / 2 + tam * 0.3, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: lg, gap: 0.2 };
             linha(nome, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(800, pesoDe(fonte)[1]) }, comportamento: 'contorno' }).marca = true;
-            if (c.sub || c.link) linha(c.sub || c.link, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.2, maiusc: true, eixos: { wght: 400 } });
+            if (c.sub || c.link) linha(c.sub || c.link, 'rotulo', { fonte: fontes.mono, tamanho: tamSegunda(ctx), tracking: 0.06, eixos: { wght: 400 } });
             b.acento.push({ forma: 'ponto', alvo: { linha: b.linhas[0].id, antes: true } });
             break;
         }
@@ -1952,9 +1976,10 @@ function tempoDaBatida(b, palavras, ctx) {
         l.t = r3(Math.max(i === 0 ? b.de + 0.1 : t + REGRAS.stagger[0] * Q, falado != null ? falado : (i === 0 ? b.de + 0.12 : t + passo)));
         t = l.t;
     });
-    /* Quadro morto não: a primeira coisa da batida entra em até 0,35 s, mesmo
-       que a voz ainda não a tenha dito (o resto segue a voz). */
-    if (ordem[0] && ordem[0].t > b.de + 0.35) ordem[0].t = r3(b.de + 0.35);
+    /* Quadro morto não: a primeira coisa da batida entra em até 0,12 s, mesmo
+       que a voz ainda não a tenha dito (o resto segue a voz). Eram 0,35 s, e
+       com a saída da anterior o teste de 15/10 tinha 23% de quadro vazio. */
+    if (ordem[0] && ordem[0].t > b.de + 0.12) ordem[0].t = r3(b.de + 0.12);
     for (let i = 1; i < ordem.length; i++) if (ordem[i].t < ordem[i - 1].t + REGRAS.stagger[0] * Q) ordem[i].t = r3(ordem[i - 1].t + REGRAS.stagger[0] * Q);
     // Nada entra tarde demais para ser lido: de trás para frente, com o stagger mínimo.
     for (let i = ordem.length - 1; i >= 0; i--) {
@@ -1985,7 +2010,11 @@ function tempoDaBatida(b, palavras, ctx) {
         let tw = l.t;
         l.palavras.forEach((p, j) => {
             const alvo = qs[j] != null ? qs[j] : (j === 0 ? l.t : tw + 2 * Q);
-            p.t = r3(Math.min(Math.max(j === 0 ? l.t : tw + 2 * Q, alvo), Math.max(l.t, fim)));
+            /* Quadro morto não, também na palavra (15/10): a voz pode dizer
+               outra coisa antes ("Aponta a câmera, paga, e o pão…"); a primeira
+               palavra da batida entra com a linha, as outras seguem a voz. */
+            const abre = j === 0 && l === ordem[0];
+            p.t = r3(abre ? l.t : Math.min(Math.max(j === 0 ? l.t : tw + 2 * Q, alvo), Math.max(l.t, fim)));
             tw = p.t;
         });
     }