primocode 9.8.0-beta.11 → 9.8.0-beta.13

package/lib/estudio/edicao.js

@@ -42,7 +42,7 @@ const ICONES = [
     [['inteligencia', 'ia', 'robo', 'maquina', 'automac'], 'robot'],
     [['cerebro', 'pens', 'raciocin', 'aprend', 'mente'], 'brain'],
     [['ideia', 'criativ', 'inova'], 'light-bulb'],
-    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco'], 'money-bag'],
+    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco', 'financ', 'custo', 'econom', 'receita'], 'money-bag'],
     [['tempo', 'minuto', 'segundo', 'rapid', 'hora'], 'stopwatch'],
     [['cresc', 'result', 'aument', 'melhor'], 'chart-increasing'],
     [['cair', 'caiu', 'perd', 'queda', 'pior'], 'chart-decreasing'],
@@ -70,9 +70,9 @@ const ICONES = [
     [['padr', 'peca', 'encaix'], 'puzzle-piece'],
     [['decid', 'decis', 'escolh', 'duvida', 'pergunta'], 'thinking-face'],
     [['exemplo', 'procur', 'busca', 'pesquis', 'analis'], 'magnifying-glass-tilted-left'],
-    [['assistente', 'convers', 'chat', 'mensag', 'responde'], 'speech-balloon'],
+    [['assistente', 'convers', 'chat', 'mensag', 'responde', 'atend', 'suporte', 'whatsapp'], 'speech-balloon'],
     [['recomend', 'filme', 'serie', 'netflix', 'video'], 'clapper-board'],
-    [['tecnolog', 'algoritm', 'sistema', 'ferrament'], 'gear'],
+    [['tecnolog', 'algoritm', 'sistema', 'ferrament', 'operac', 'process', 'automat'], 'gear'],
     [['cotidian', 'rotina', 'semana', 'calendario', 'agenda'], 'calendar'],
     [['conhecimento', 'formad', 'diploma', 'sabe'], 'graduation-cap'],
     [['sucesso', 'venc', 'ganhador', 'premio', 'campeao'], 'trophy'],
@@ -85,6 +85,23 @@ const ICONES = [
     [['surpre', 'chocad', 'absurd'], 'exploding-head'],
 ];
 
+/* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
+   inglês de propósito: os acervos abertos respondem muito melhor assim. */
+const FOTO = {
+    robot: 'humanoid robot', brain: 'human brain', 'light-bulb': 'light bulb idea', 'money-bag': 'money cash',
+    stopwatch: 'clock time', 'chart-increasing': 'business growth', 'chart-decreasing': 'stock market fall',
+    'bar-chart': 'data analytics', rocket: 'rocket launch', fire: 'fire flames', 'mobile-phone': 'smartphone hand',
+    laptop: 'laptop programming', 'globe-showing-americas': 'earth from space', eyes: 'eye closeup',
+    'speaker-high-volume': 'sound waves', memo: 'writing notebook', 'musical-notes': 'music concert',
+    'dog-face': 'puppy', 'cat-face': 'cat', 'red-heart': 'heart love', 'busts-in-silhouette': 'people crowd',
+    house: 'modern house', automobile: 'car road', books: 'library books', warning: 'warning sign',
+    package: 'objects on table', 'puzzle-piece': 'puzzle pieces', 'thinking-face': 'person thinking',
+    'magnifying-glass-tilted-left': 'magnifying glass', 'speech-balloon': 'smart speaker', 'clapper-board': 'watching tv',
+    gear: 'circuit board', calendar: 'city street people', 'graduation-cap': 'students classroom', trophy: 'trophy',
+    'flexed-biceps': 'strength', handshake: 'handshake', 'shopping-cart': 'shopping', briefcase: 'office work',
+    locked: 'cyber security', 'party-popper': 'party celebration', 'exploding-head': 'surprised face',
+};
+
 function limpa(palavra) {
     return String(palavra || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
         .toLowerCase().replace(/[^a-z0-9]/g, '');
@@ -110,6 +127,33 @@ function peso(palavra) {
     return w.length + (iconeDe(palavra) ? 6 : 0);
 }
 
+/** O termo de busca da imagem de apoio para esta palavra, ou null. */
+function termoDeApoio(palavra) {
+    const ic = iconeDe(palavra);
+    return ic ? FOTO[ic.split(':')[1]] || null : null;
+}
+
+// Em quais cenas entra imagem de apoio: uma a cada três, a partir da segunda.
+const temApoio = (i) => i % 3 === 2;
+
+function forteDe(g) {
+    let forte = null;
+    for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+    return forte;
+}
+
+/** Os termos das imagens de apoio que o plano vai pedir — para baixar antes. */
+function termosDeApoio(palavras) {
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    const termos = [];
+    frases(lista).forEach((g, i) => {
+        const f = forteDe(g);
+        const t = f && temApoio(i) ? termoDeApoio(f.texto) : null;
+        if (t && !termos.includes(t)) termos.push(t);
+    });
+    return termos;
+}
+
 const fimDeFrase = (texto) => /[.!?…]$/.test(String(texto || '').trim());
 const r2 = (n) => Math.round(n * 100) / 100;
 
@@ -164,8 +208,8 @@ function camera(i, dur) {
 }
 
 const ESTILOS = {
-    viral: { icones: true, letreiro: true, sons: true, barra: true, destaque: '#FFD400', forte: '#00E0A4' },
-    limpo: { icones: false, letreiro: false, sons: false, barra: false, destaque: '#FFFFFF', forte: '#FFD400' },
+    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, destaque: '#FFFFFF', forte: '#FFD400' },
 };
 
 /**
@@ -181,7 +225,7 @@ const ESTILOS = {
  * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
  * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
  */
-function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null }) {
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
     const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
     if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
@@ -202,16 +246,35 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         const local = (t) => r2(Math.max(0, t - ini));
 
         // A palavra forte da frase: a que mais carrega a ideia.
-        let forte = null;
-        for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+        const forte = forteDe(g);
 
         const elementos = [{
             tipo: 'video', src, x: 0, y: 0, largura: '100%', altura: '100%',
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
+        /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
+           que está sendo dito, com um zoom lento, e a legenda continua por
+           cima. É o "b-roll" das edições de videomaker. */
+        const apoio = forte && e.apoio && temApoio(i) ? imagens[termoDeApoio(forte.texto)] : null;
+        if (apoio) {
+            const de = local(forte.de - 0.1);
+            const vida = Math.min(2.2, dur - de);
+            if (vida > 0.8) {
+                elementos.push({
+                    tipo: 'imagem', src: apoio, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                    de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.0, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.12, v: 1 }, { t: vida - 0.15, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + de - 0.1)), src: sons.whoosh, volume: 0.55 });
+            }
+        }
+
         // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
-        const icone = forte && e.icones ? iconeDe(forte.texto) : null;
+        const icone = forte && e.icones && !apoio ? iconeDe(forte.texto) : null;
         const temIcone = icone && (!iconesOk || iconesOk.has(icone));
         const x = lado++ % 2 === 0 ? '78%' : '22%';
         if (temIcone) {
@@ -229,7 +292,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                         opacidade: [{ t: vida - 0.2, v: 1 }, { t: vida, v: 0 }],
                     },
                 });
-                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.45 });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.8 });
             }
         } else if (forte && e.letreiro && i % 2 === 0 && peso(forte.texto) >= 7) {
             const de = local(forte.de);
@@ -245,12 +308,12 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                         rotacao: [{ t: 0, v: -6 }, { t: 0.3, v: -3, e: 'saida' }],
                     },
                 });
-                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.35 });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.7 });
             }
         }
 
         // A legenda palavra por palavra.
-        const fala = blocos(g, deitado ? 4 : 3).map((b, j, todos) => ({
+        const fala = blocos(g, 3).map((b, j, todos) => ({
             de: local(b[0].de - 0.04),
             ate: j < todos.length - 1 ? local(todos[j + 1][0].de - 0.04) : r2(dur),
             texto: b.map((p) => p.texto).join(' '),
@@ -260,10 +323,10 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             })),
         }));
         elementos.push({
-            tipo: 'legenda', x: '50%', y: deitado ? '80%' : '70%', ancora: 'centro', fala,
+            tipo: 'legenda', x: '50%', y: deitado ? '76%' : '68%', ancora: 'centro', fala,
             estilo: {
                 fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
-                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase',
+                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase', largura: '92%',
             },
         });
 
@@ -277,7 +340,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         }
 
         // O whoosh entra no punch-in: é o corte que ele anuncia.
-        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.3 });
+        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
 
         cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
     });
@@ -288,11 +351,18 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             formato: { largura, altura, fps: 30 },
             fundoGeral: '#000',
             cenas,
-            ...(efeitos.length ? { audio: { efeitos } } : {}),
+            ...(efeitos.length || trilha ? { audio: {
+                ...(efeitos.length ? { efeitos } : {}),
+                // A música fica BAIXA: quem fala para a câmera fala o vídeo
+                // inteiro, e a trilha é cama, não disputa.
+                ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
+            } } : {}),
         },
         resumo: {
             cenas: cenas.length,
             icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
+            imagens: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem').length, 0),
+            musica: Boolean(trilha),
             letreiros: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'texto').length, 0),
             efeitos: efeitos.length,
         },
@@ -328,4 +398,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, ESTILOS, ICONES };
+module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };

package/lib/estudio/index.js

@@ -41,6 +41,7 @@ const video = require('./video.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
+const composicao = require('./composicao.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -172,12 +173,31 @@ async function ferramentaPlano(args) {
 
     if (args.voltarPara) return projeto.voltarPara(args.id, args.voltarPara);
 
-    if (!args.plano && !args.cenas) {
+    if (!args.plano && !args.cenas && !args.roteiro) {
         const atual = projeto.lerPlano(args.id);
         if (!atual) return { ok: false, error: 'este projeto ainda não tem plano — mande um.' };
         return { ok: true, plano: atual, resumo: plano.resumo(atual) };
     }
 
+    /* O ROTEIRO: o modelo diz o que cada parte é e o que ela diz, e o código
+       faz o resto — layout, voz com entonação, ícones, imagens, música e
+       sons (lib/estudio/composicao.js). É o caminho para qualquer modelo
+       entregar motion e slides que prestam. */
+    if (args.roteiro) {
+        const r = await prepararRoteiro(p, args);
+        if (!r.ok) return r;
+        const conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        if (!conferida.ok) {
+            return { ok: false, error: 'o roteiro virou um plano com problemas (defeito do PrimoCode, não seu).', problemas: conferida.problemas.slice(0, 12) };
+        }
+        projeto.salvarPlano(args.id, r.plano, args.motivo || 'montado do roteiro');
+        projeto.salvar(args.id, { duracao: conferida.duracao });
+        return {
+            ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
+            proximo: 'estudio_render com este id. Para ajustar, mande o roteiro de novo (é rápido) — não edite as cenas à mão.',
+        };
+    }
+
     // Um plano inteiro, ou só as cenas (que é o caso comum).
     let novo = args.plano || { formato: args.formato, cenas: args.cenas, audio: args.audio };
 
@@ -413,6 +433,15 @@ async function ferramentaVideo(args, ctx = {}) {
             const c = await video.cortarSilencio(alvo, saida, args);
             if (c.ok && !c.semCorte) { fonte = saida; cortes = c.cortes || 0; }
         }
+        /* A VOZ NO VOLUME CERTO. A gravação de celular sai baixa (medido em
+           25/09: -37,6 dB de média no vídeo pronto, e "está sem som"). O
+           loudnorm leva a fala a -15 LUFS, o volume de vídeo de internet; o
+           vídeo em si não é recodificado. */
+        const normal = path.join(p.pasta, 'midia', `voz-normal-${Date.now().toString(36)}.mp4`);
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', fonte, '-c:v', 'copy',
+            '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+        if (ln.ok) fonte = normal;
+
         const m = await video.medir(fonte);
         if (!m.ok) return m;
 
@@ -430,10 +459,36 @@ async function ferramentaVideo(args, ctx = {}) {
         }
         const sons = await edicao.prepararSons(p.pasta, video);
 
+        // As imagens de apoio: uma por termo, a primeira que baixar.
+        const imagens = {};
+        if ((args.estilo || 'viral') !== 'sem-apoio') {
+            for (const termo of edicao.termosDeApoio(palavras).slice(0, 8)) {
+                try {
+                    const b = await assets.procurarImagens(termo, { quantas: 4 });
+                    for (const item of (b.ok ? b.imagens : [])) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                        if (d.ok) { imagens[termo] = d.relativo; break; }
+                    }
+                } catch { /* segue sem esta */ }
+            }
+        }
+
+        // A música de fundo: uma trilha longa, de licença aberta.
+        let trilha = null;
+        if (args.musica !== false) {
+            try {
+                const b = await assets.procurarSom(args.trilha || 'upbeat corporate background', { quantas: 6, duracaoMin: 45 });
+                for (const item of (b.ok ? b.sons : [])) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (d.ok) { trilha = d.relativo; break; }
+                }
+            } catch { /* segue sem música */ }
+        }
+
         const montado = edicao.montarEdicao({
             src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
             duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
-            estilo: args.estilo || 'viral', sons, iconesOk,
+            estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
         });
         if (!montado.ok) return montado;
         const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
@@ -465,6 +520,56 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
+
+/** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
+async function prepararRoteiro(p, args) {
+    const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
+    if (Array.isArray(roteiro)) return prepararRoteiro(p, { ...args, roteiro: { partes: roteiro } });
+    const partes = roteiro.partes || [];
+    const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
+    const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
+
+    const iconesOk = new Set();
+    for (const nome of composicao.iconesDoRoteiro(roteiro)) {
+        try { const r = await assets.icone(nome); if (r && r.ok) iconesOk.add(nome); } catch { /* sem */ }
+    }
+    const imagens = {};
+    for (const [i, parte] of partes.entries()) {
+        if (parte.tipo !== 'imagem' || parte.src || !parte.busca) continue;
+        try {
+            const b = await assets.procurarImagens(parte.busca, { quantas: 4 });
+            for (const item of (b.ok ? b.imagens : [])) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'cena-' + (i + 1) });
+                if (d.ok) { imagens[i] = d.relativo; break; }
+            }
+        } catch { /* a cena sai sem a foto, com o título */ }
+    }
+
+    let tempos = [], narracao = null, sons = {}, trilha = null;
+    if (modo === 'video') {
+        const lista = partes.map((pt, i) => ({ texto: composicao.falaDe(pt), registro: composicao.registroDe(pt, i, partes.length) }));
+        const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+        fs.mkdirSync(path.dirname(arq), { recursive: true });
+        fs.writeFileSync(arq, JSON.stringify(lista));
+        const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+        const v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
+        if (!v.ok) return v;
+        tempos = v.partes;
+        narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
+        projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
+        sons = await edicao.prepararSons(p.pasta, video);
+        try {
+            const b = await assets.procurarSom(roteiro.musica || args.trilha || 'inspiring corporate background', { quantas: 6, duracaoMin: 45 });
+            for (const item of (b.ok ? b.sons : [])) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                if (d.ok) { trilha = d.relativo; break; }
+            }
+        } catch { /* sem música */ }
+    }
+    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk });
+}
+
 /* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
    proporcional ao tamanho de cada uma. */
 function repartirTrechos(trechos) {

package/lib/estudio/plano.js

@@ -165,7 +165,10 @@ function conferirElemento(caminho, el, pasta, problemas, duracao) {
         }
     }
     conferirCor(`${caminho}.cor`, el.cor, problemas);
-    conferirCor(`${caminho}.fundo`, el.fundo, problemas);
+    // O fundo do elemento é cor, ou o mesmo objeto do fundo da cena (um
+    // gradiente sobre a foto, por exemplo).
+    if (el.fundo && typeof el.fundo === 'object') conferirFundo(`${caminho}.fundo`, el.fundo, pasta, problemas);
+    else conferirCor(`${caminho}.fundo`, el.fundo, problemas);
     conferirAnima(`${caminho}.anima`, el.anima, problemas);
 
     // `de` e `ate` recortam o elemento no tempo DA CENA. Um elemento que

package/lib/estudio/remotion.js

@@ -234,7 +234,39 @@ function Elemento({ el, t, dados }) {
   }
 
   switch (el.tipo) {
-    case 'texto':
+    case 'texto': {
+      /* O NÚMERO QUE CONTA: "contar": {ate: 9, dur: 1.2} faz o texto subir
+         de 0 até o valor, com a curva de saída. Casas decimais e o que vem
+         antes/depois do número (R$, %, mil) ficam como estão. */
+      let conteudo = el.texto;
+      if (el.contar) {
+        const alvo = Number(el.contar.ate) || 0;
+        const dur = el.contar.dur || 1.2;
+        const k = CURVAS.saida(Math.min(1, Math.max(0, tLocal / dur)));
+        const casas = el.contar.casas || 0;
+        const v = (alvo * k).toLocaleString('pt-BR', { minimumFractionDigits: casas, maximumFractionDigits: casas });
+        conteudo = (el.contar.antes || '') + v + (el.contar.depois || '');
+      }
+      /* O TEXTO QUE SE REVELA: "revelar": [t0, t1, …] é o instante (no tempo
+         do elemento) em que cada palavra entra — o da narração. A palavra
+         sobe e aparece; as que ainda não foram ditas esperam invisíveis, e o
+         bloco não muda de tamanho quando elas entram. */
+      if (Array.isArray(el.revelar) && typeof el.texto === 'string') {
+        const palavras = el.texto.split(' ');
+        conteudo = palavras.map((w, i) => {
+          const t0 = el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0;
+          const k = Math.min(1, Math.max(0, (tLocal - t0) / 0.28));
+          const e = CURVAS.saida(k);
+          // O espaço fica FORA do span: é ali que a linha pode quebrar.
+          return (
+            <React.Fragment key={i}>
+              <span style={{ display: 'inline-block', opacity: e, transform: 'translateY(' + (1 - e) * 0.35 + 'em)',
+                color: el.destaques && el.destaques.includes(i) ? (el.corDestaque || el.cor) : undefined }}>{w}</span>
+              {i < palavras.length - 1 ? ' ' : null}
+            </React.Fragment>
+          );
+        });
+      }
       return (
         <div style={{
           ...estilo,
@@ -250,8 +282,13 @@ function Elemento({ el, t, dados }) {
           background: el.gradienteTexto || undefined,
           WebkitBackgroundClip: el.gradienteTexto ? 'text' : undefined,
           WebkitTextFillColor: el.gradienteTexto ? 'transparent' : undefined,
-        }}>{el.texto}</div>
+          fontStyle: el.italico ? 'italic' : undefined,
+          textDecoration: el.riscado ? 'line-through' : undefined,
+          textDecorationThickness: el.riscado ? '0.08em' : undefined,
+          wordBreak: 'normal', overflowWrap: 'break-word',
+        }}>{conteudo}</div>
       );
+    }
 
     case 'forma': {
       const forma = el.forma || 'retangulo';
@@ -260,7 +297,7 @@ function Elemento({ el, t, dados }) {
           ...estilo,
           width: medida(el.largura, '200px'),
           height: forma === 'linha' ? medida(el.espessura, '4px') : medida(el.altura, '200px'),
-          background: el.fundo || el.cor || '#fff',
+          ...(el.fundo && typeof el.fundo === 'object' ? fundoCSS(el.fundo) : { background: el.fundo || el.cor || '#fff' }),
           borderRadius: forma === 'circulo' ? '50%' : medida(a.raio ?? el.raio, '0px'),
           border: el.contorno || undefined,
         }} />
@@ -375,10 +412,11 @@ function Elemento({ el, t, dados }) {
   }
 }
 
-export function Cena({ cena, dados }) {
+export function Cena({ cena, dados, tFixo }) {
   const frame = useCurrentFrame();
   const { fps } = useVideoConfig();
-  const t = frame / fps;
+  // A página parada é a cena num instante só: tFixo manda no tempo.
+  const t = tFixo != null ? tFixo : frame / fps;
 
   const cam = animado(cena.camera, t);
   const camTransform = [
@@ -439,6 +477,21 @@ function Transicao({ tipo, progresso, children }) {
   return <AbsoluteFill style={estilo}>{children}</AbsoluteFill>;
 }
 
+/* AS PÁGINAS: um quadro por cena, cada uma congelada no meio dela. Os
+ * slides saem num render só — antes era um "remotion still" por página, e
+ * cada um empacotava o projeto inteiro de novo (onze páginas, onze
+ * empacotamentos: é a demora de 25 minutos medida em 25/09). */
+export const Paginas = () => {
+  const { fps } = useVideoConfig();
+  const frame = useCurrentFrame();
+  const cena = plano.cenas[Math.min(frame, plano.cenas.length - 1)];
+  return (
+    <AbsoluteFill style={{ backgroundColor: plano.fundoGeral || '#000' }}>
+      <Cena cena={cena} dados={{ fps, icones }} tFixo={cena.duracao / 2} />
+    </AbsoluteFill>
+  );
+};
+
 export const Video = () => {
   const { fps } = useVideoConfig();
   const frame = useCurrentFrame();
@@ -478,6 +531,7 @@ export const Video = () => {
         <Audio
           src={staticFile(plano.audio.trilha.src || plano.audio.trilha)}
           volume={plano.audio.trilha.volume ?? 0.18}
+          loop={plano.audio.trilha.loop !== false}
         />
       )}
       {(plano.audio && plano.audio.efeitos ? plano.audio.efeitos : []).map((e, i) => (
@@ -494,7 +548,7 @@ function rootJsx(plano) {
     const f = plano.formato || {};
     return `import React from 'react';
 import { Composition } from 'remotion';
-import { Video } from './Video';
+import { Video, Paginas } from './Video';
 import plano from './plano.json';
 import './fontes.css';
 
@@ -505,14 +559,24 @@ const quadros = Math.max(1, Math.round(
 ));
 
 export const RemotionRoot = () => (
-  <Composition
-    id="Video"
-    component={Video}
-    durationInFrames={quadros}
-    fps={fps}
-    width={${Number(f.largura) || 1920}}
-    height={${Number(f.altura) || 1080}}
-  />
+  <>
+    <Composition
+      id="Video"
+      component={Video}
+      durationInFrames={quadros}
+      fps={fps}
+      width={${Number(f.largura) || 1920}}
+      height={${Number(f.altura) || 1080}}
+    />
+    <Composition
+      id="Paginas"
+      component={Paginas}
+      durationInFrames={plano.cenas.length}
+      fps={fps}
+      width={${Number(f.largura) || 1920}}
+      height={${Number(f.altura) || 1080}}
+    />
+  </>
 );
 `;
 }

package/lib/estudio/slides.js

@@ -48,41 +48,45 @@ const { spawn } = require('child_process');
 function renderizarPaginas({ raiz, destino, plano, aoFalar = () => {} }) {
     return new Promise((resolve) => {
         fs.mkdirSync(destino, { recursive: true });
-        const fps = Number((plano.formato || {}).fps) || 30;
-
-        // Onde começa cada cena, em quadros — a mesma conta do Video.jsx.
-        const inicios = [];
-        let cursor = 0;
-        for (const cena of plano.cenas || []) {
-            const dur = Math.max(1, Math.round(cena.duracao * fps));
-            const t = cena.transicao || {};
-            const cruz = (t.tipo || t) === 'corte' ? 0 : Math.round((t.duracao ?? 0.4) * fps);
-            inicios.push({ de: cursor, dur });
-            cursor += dur - cruz;
-        }
+        for (const f of fs.readdirSync(destino)) if (/\.(jpe?g|png)$/i.test(f)) fs.rmSync(path.join(destino, f));
+        const n = (plano.cenas || []).length;
+        const shell = process.platform === 'win32';
+        const cita = (a) => (shell && /\s/.test(a) ? `"${a}"` : a);
+
+        /* Projeto novo não tem o Remotion instalado: o caminho de slides
+           rodava o npx direto e morria em "could not determine executable". */
+        const passos = fs.existsSync(path.join(raiz, 'node_modules')) ? [] : [['npm', ['install', '--no-audit', '--no-fund']]];
+        // Todas as páginas num render só: a composição "Paginas" tem um quadro por cena.
+        /* O Remotion recusa pasta de sequência com ponto no caminho ("cannot
+           have an extension") — e ~/.primocode tem. A sequência sai numa pasta
+           temporária sem ponto e as páginas são movidas depois. */
+        const tmp = fs.mkdtempSync(path.join(require('os').tmpdir(), 'primo-paginas-'));
+        passos.push(['npx', ['remotion', 'render', 'Paginas', tmp, '--sequence',
+            '--image-format=jpeg', '--jpeg-quality=95', '--log=warn']]);
 
-        const paginas = [];
         const correr = (i) => {
-            if (i >= inicios.length) return resolve({ ok: true, paginas });
-            const { de, dur } = inicios[i];
-            const quadro = de + Math.floor(dur / 2);
-            const arquivo = path.join(destino, `pagina-${String(i + 1).padStart(3, '0')}.jpeg`);
-            aoFalar(`página ${i + 1} de ${inicios.length}`);
-
-            const p = spawn('npx', [
-                'remotion', 'still', 'Video', arquivo,
-                '--frame=' + quadro, '--image-format=jpeg', '--quality=95', '--log=warn',
-            ], { cwd: raiz, shell: process.platform === 'win32' });
-
+            if (i >= passos.length) {
+                // Pelo NÚMERO: em ordem alfabética, element-10 vem antes de element-2.
+                const num = (f) => Number((f.match(/(\d+)\.jpe?g$/i) || [])[1] || 0);
+                const saidas = fs.readdirSync(tmp).filter((f) => /\.jpe?g$/i.test(f)).sort((a, b) => num(a) - num(b));
+                const paginas = saidas.map((f, k) => {
+                    const final = path.join(destino, `pagina-${String(k + 1).padStart(3, '0')}.jpeg`);
+                    fs.copyFileSync(path.join(tmp, f), final);
+                    return final;
+                });
+                try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* fica no temporário */ }
+                if (paginas.length !== n) return resolve({ ok: false, error: `saíram ${paginas.length} páginas de ${n}.` });
+                return resolve({ ok: true, paginas });
+            }
+            const [cmd, args] = passos[i];
+            aoFalar(cmd === 'npm' ? 'instalando o Remotion nesta pasta (uma vez só)' : `desenhando ${n} páginas`);
+            const p = spawn(cmd, args.map(cita), { cwd: raiz, shell });
             let erro = '';
-            p.stderr.on('data', (d) => { erro += d.toString().slice(0, 1000); });
-            const relogio = setTimeout(() => { try { p.kill(); } catch {} }, 5 * 60000);
+            p.stderr.on('data', (d) => { erro += d.toString().slice(0, 2000); });
+            const relogio = setTimeout(() => { try { p.kill(); } catch {} }, 15 * 60000);
             p.on('close', (code) => {
                 clearTimeout(relogio);
-                if (code !== 0) {
-                    return resolve({ ok: false, error: `a página ${i + 1} falhou: ${erro.slice(-400).trim()}` });
-                }
-                paginas.push(arquivo);
+                if (code !== 0) return resolve({ ok: false, error: `${cmd} saiu com ${code}: ${erro.slice(-400).trim()}` });
                 correr(i + 1);
             });
             p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });