primocode 10.1.0 → 10.3.0-beta.0

package/lib/estudio/falantes.js

@@ -0,0 +1,97 @@
+/**
+ * falantes.js — quem fala cada parte do roteiro.
+ *
+ *   "fiz um teste de um vídeo com duas narrações e ele fez de uma narração
+ *    só, uma voz só" (Joel, 09/10)
+ *
+ * O roteiro tinha UMA voz (roteiro.voz) e nenhum lugar para dizer quem fala o
+ * quê: pedir diálogo ou dois narradores não tinha como chegar na narração. O
+ * contrato agora tem dois campos, os dois opcionais:
+ *   roteiro.vozes  = { "ana": "thalita", "bruno": "antonio" }
+ *   parte.falante  = "ana"
+ * Sem eles, nada muda: roteiro.voz segue valendo para tudo. Quem decide se o
+ * vídeo é diálogo é o modelo, pelo pedido; aqui só se lê o que ele escreveu.
+ */
+
+'use strict';
+
+// As vozes do Studio (thalita | antonio | francisca). Para quem ficou sem voz no mapa.
+const PAR = ['antonio', 'thalita', 'francisca'];
+
+const nomeFalante = (x) => (typeof x === 'string' ? x.trim().toLowerCase().slice(0, 40) : '');
+
+/** Limpa vozes e falantes do roteiro (o que não for texto sai). Devolve o mesmo objeto. */
+function normalizar(roteiro) {
+    const r = roteiro && typeof roteiro === 'object' ? roteiro : {};
+    if (r.vozes && typeof r.vozes === 'object' && !Array.isArray(r.vozes)) {
+        const limpo = {};
+        for (const [k, v] of Object.entries(r.vozes)) if (nomeFalante(k) && typeof v === 'string' && v.trim()) limpo[nomeFalante(k)] = v.trim();
+        if (Object.keys(limpo).length) r.vozes = limpo; else delete r.vozes;
+    } else delete r.vozes;
+    for (const pt of Array.isArray(r.partes) ? r.partes : []) {
+        if (!pt || typeof pt !== 'object' || !('falante' in pt)) continue;
+        if (nomeFalante(pt.falante)) pt.falante = nomeFalante(pt.falante); else delete pt.falante;
+    }
+    return r;
+}
+
+/**
+ * A voz de cada parte, na ordem. Com falante e voz no mapa, a do mapa; com
+ * falante FORA do mapa (o modelo deu nome e esqueceu a voz), a próxima do par
+ * que ainda não fala — dois falantes nunca saem com a mesma voz por esquecimento;
+ * sem falante, a `padrao` (roteiro.voz).
+ */
+function vozesDasPartes(partes, roteiro = {}, padrao = '') {
+    const mapa = { ...((roteiro && roteiro.vozes) || {}) };
+    const ocupadas = new Set(Object.values(mapa).map((v) => String(v).toLowerCase()));
+    if (padrao) ocupadas.add(String(padrao).toLowerCase());
+    return (partes || []).map((pt) => {
+        const f = nomeFalante(pt && pt.falante);
+        if (!f) return padrao || '';
+        if (!mapa[f]) {
+            mapa[f] = PAR.find((v) => !ocupadas.has(v)) || PAR[Object.keys(mapa).length % PAR.length];
+            ocupadas.add(mapa[f]);
+        }
+        return mapa[f];
+    });
+}
+
+/**
+ * A narração por falante: as falas seguidas da mesma voz viram um grupo, cada
+ * grupo é narrado na sua voz (narrarUm — a mesma corrente Gemini → Kokoro →
+ * Edge de sempre), e os mp3 são juntados na ordem (juntar). Os tempos de cada
+ * parte andam pela duração dos grupos de antes: o vídeo segue a voz certa.
+ * Uma voz só: um grupo só, e é exatamente a narração de antes.
+ *
+ * @param {Array<{texto:string, voz?:string}>} lista
+ * @param {(lista, mp3, voz) => Promise<{ok, segundos, partes, voz}>} op.narrarUm
+ * @param {(arquivos, mp3) => Promise<{ok, duracoes?:number[]}>} op.juntar
+ */
+async function narrarPorFalante(lista, mp3, { narrarUm, juntar }) {
+    const grupos = [];
+    for (const { voz = '', ...x } of lista) {
+        const g = grupos[grupos.length - 1];
+        if (g && g.voz === voz) g.itens.push(x); else grupos.push({ voz, itens: [x] });
+    }
+    if (grupos.length <= 1) return narrarUm(grupos.length ? grupos[0].itens : [], mp3, grupos.length ? grupos[0].voz : '');
+    const feitos = [];
+    for (const [i, g] of grupos.entries()) {
+        const arq = mp3.replace(/\.mp3$/, '') + `-falante${i + 1}.mp3`;
+        const v = await narrarUm(g.itens, arq, g.voz);
+        if (!v || !v.ok) return { ok: false, error: `a voz ${g.voz || 'padrão'} falhou: ${(v && v.error) || 'sem resposta'}` };
+        feitos.push({ arq, v });
+    }
+    const j = await juntar(feitos.map((x) => x.arq), mp3);
+    if (!j || !j.ok) return { ok: false, error: (j && j.error) || 'não juntei as vozes' };
+    let antes = 0;
+    const partes = [];
+    feitos.forEach(({ v }, i) => {
+        const mais = (t) => Math.round((t + antes) * 1000) / 1000;
+        for (const pt of v.partes || []) partes.push({ ...pt, de: mais(pt.de), ate: mais(pt.ate), palavras: (pt.palavras || []).map((w) => ({ ...w, de: mais(w.de), ate: mais(w.ate) })) });
+        // A duração MEDIDA do arquivo quando quem juntou mediu; senão a que a voz disse.
+        antes += Number((j.duracoes || [])[i]) || Number(v.segundos) || 0;
+    });
+    return { ok: true, voz: [...new Set(feitos.map((x) => x.v.voz).filter(Boolean))].join(' + '), segundos: Math.round(antes * 1000) / 1000, partes, falantes: grupos.length };
+}
+
+module.exports = { normalizar, vozesDasPartes, narrarPorFalante, PAR };

package/lib/estudio/fluido.js

@@ -38,11 +38,43 @@ const ANTES = 0.12;                      // a batida troca isto antes da primeir
    NO MÁXIMO dois acentos (o da palavra e o brilho difuso). */
 const PALETAS = {
     noite: { escuro: true, fundo: ['#020615', '#061a5c', '#1240c9'], tinta: '#eef2ff', suave: '#9fb0d9', acentos: ['#8fb8ff', '#2f6bff'] },
+    /* As CHAPADAS das referências boas (08/10): fundo de uma cor só, sem o
+       gradiente — o laranja da "criatividade", o branco com azul, o preto puro
+       e o cobalto. O "sempre o mesmo azul" era vício. */
+    laranja: { escuro: false, fundo: ['#f2621f', '#f06a28', '#ec7a3c'], tinta: '#1a0d05', suave: '#5a2a10', acentos: ['#fff4ea', '#ffd2b0'] },
+    branco: { escuro: false, fundo: ['#ffffff', '#f6f7fa', '#eceff6'], tinta: '#0b0d12', suave: '#6b7180', acentos: ['#1f4bff', '#9fb3ff'] },
+    preto: { escuro: true, fundo: ['#000000', '#050505', '#121212'], tinta: '#f5f5f5', suave: '#8a8a8a', acentos: ['#ff7a3d', '#ff9a66'] },
+    cobalto: { escuro: true, fundo: ['#1238e6', '#1640f0', '#2350ff'], tinta: '#ffffff', suave: '#c8d4ff', acentos: ['#ffe14d', '#ffffff'] },
     breu: { escuro: true, fundo: ['#030304', '#0b0a12', '#2a2156'], tinta: '#f4f4f6', suave: '#8d8a9c', acentos: ['#b4a6ff', '#5b45ff'] },
     lavanda: { escuro: false, fundo: ['#f5f4ff', '#e4e1ff', '#b9b2ff'], tinta: '#17153a', suave: '#6e6a92', acentos: ['#4a3ce0', '#8f86ff'] },
     creme: { escuro: false, fundo: ['#fbf8f2', '#f2e8d8', '#e7c9a5'], tinta: '#1e1a15', suave: '#857a6c', acentos: ['#c2502a', '#f0a36b'] },
 };
-const ESCURAS = ['noite', 'breu'], CLARAS = ['lavanda', 'creme'];
+const ESCURAS = ['noite', 'breu', 'preto', 'cobalto'], CLARAS = ['lavanda', 'creme', 'laranja', 'branco'];
+
+/* AS FONTES (09/10): "vício em fontes" (Joel) — todo fluido saía em Inter +
+   Instrument Serif + JetBrains Mono. Agora é um TRIO do cardápio: o grotesco
+   leve das palavras (o kit usa 300 a 600), a serifa itálica do acento e o mono
+   do terminal. A memória da variedade ('fonte-fluido') não repete o trio dos
+   últimos vídeos; o modelo pode pedir um pelo nome (roteiro.fontesFluido) e o
+   pedido vale, menos quando acabou de sair. `css` é o pedido ao Google Fonts
+   (conferido: todos respondem 200). Sem escolha salva, o trio aprovado. */
+const TRIOS = {
+    aprovado: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono', css: ['wght@300..700', 'ital@0;1', 'wght@400;500'] },
+    editorial: { texto: 'Hanken Grotesk', serifa: 'Fraunces', mono: 'Martian Mono', css: ['wght@300..700', 'ital,wght@0,400;1,400', 'wght@400;500'] },
+    revista: { texto: 'Figtree', serifa: 'Playfair Display', mono: 'IBM Plex Mono', css: ['wght@300..700', 'ital,wght@0,400;1,400', 'wght@400;500'] },
+    carater: { texto: 'Bricolage Grotesque', serifa: 'Bodoni Moda', mono: 'Space Mono', css: ['wght@300..700', 'ital,wght@0,400;1,400', 'wght@400'] },
+    tecnico: { texto: 'Mona Sans', serifa: 'Instrument Serif', mono: 'Fragment Mono', css: ['wght@300..700', 'ital@0;1', 'ital@0;1'] },
+    classico: { texto: 'Albert Sans', serifa: 'DM Serif Display', mono: 'DM Mono', css: ['wght@300..700', 'ital@0;1', 'wght@400;500'] },
+};
+
+/** O trio de um projeto novo, pelos pontos da variedade. Roda uma vez por projeto (index.js guarda). */
+function escolherFontes(pedido = null, { aleatorio = Math.random } = {}) {
+    const variedade = require('./variedade.js');
+    const nome = TRIOS[String(pedido || '').toLowerCase()] ? String(pedido).toLowerCase() : null;
+    // O pedido do modelo vale mais (1), os outros servem (0,5): penaliza o recente, não proíbe.
+    return variedade.sortear(Object.keys(TRIOS), 'fonte-fluido', { aleatorio, adequacao: (k) => (!nome || k === nome ? 1 : 0.5) });
+}
+const trioDe = (roteiro) => TRIOS[roteiro.fontesFluido] || TRIOS.aprovado;
 
 const hash = (s) => { let h = 2166136261; for (const c of String(s)) h = Math.imul(h ^ c.charCodeAt(0), 16777619); return h >>> 0; };
 
@@ -51,9 +83,9 @@ function paletaDe(roteiro, semente) {
     const pedida = String(roteiro.paleta || '').toLowerCase();
     const tema = String(roteiro.tema || '').toLowerCase();
     const nome = PALETAS[pedida] ? pedida
-        : /claro|light/.test(tema) ? CLARAS[semente % 2]
-            : /escuro|dark/.test(tema) ? ESCURAS[semente % 2]
-                : Object.keys(PALETAS)[semente % 4];
+        : /claro|light/.test(tema) ? CLARAS[semente % CLARAS.length]
+            : /escuro|dark/.test(tema) ? ESCURAS[semente % ESCURAS.length]
+                : Object.keys(PALETAS)[semente % Object.keys(PALETAS).length];
     const p = { nome, ...PALETAS[nome], acentos: [...PALETAS[nome].acentos] };
     // A cor da marca vira o acento da palavra (e só ela: a paleta não cresce).
     const dest = roteiro.marca && roteiro.marca.cores && roteiro.marca.cores.destaque;
@@ -106,7 +138,7 @@ const TIPO = { logo: 'abertura', imagem: 'titulo', produto: 'titulo', grafico: '
  * A partitura: as batidas, cada uma com as frases (e quando cada uma entra),
  * a forma do portador e a transição. Sem áudio nem plano — é o que os testes olham.
  */
-function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
+function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], imagens = {} }) {
     const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object');
     const semente = Number.isFinite(roteiro.semente) ? roteiro.semente : hash(JSON.stringify(partes.map((p) => [p.tipo, p.titulo, p.valor])));
     const paleta = paletaDe(roteiro, semente);
@@ -116,9 +148,15 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
     const link = (partes.find((p) => p.tipo === 'cta') || {}).link || '';
     const cmd = /^(npm|npx|pnpm|yarn|pip|brew|curl|git|bun)\b/.test(link) ? link : String(marca.nome || 'app').toLowerCase().replace(/\s+/g, '-');
     let comCartao = 0;
+    /* O cartão de produto só quando o vídeo É de produto: tem marca, um
+       comando de instalar ou um link. Um vídeo sobre sono saía com um
+       terminal "$ app" ao lado do título (teste de 08/10). `p.ui` explícito vale sempre. */
+    const deProduto = !!(marca.nome || link || /\b(app|software|plataforma|ferramenta|produto|sistema|saas|api|cli)\b/i.test(String(roteiro.pedido || '')));
 
     const batidas = partes.map((p, i) => {
-        const tipo = TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
+        /* Fecho sem marca não monta a "marca de bolinhas" (vício, 08/10): vira
+           uma frase — e, curta, a gigante do fim. */
+        const tipo = p.tipo === 'cta' && !marca.nome ? 'titulo' : TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
         const titulo = p.titulo || p.texto || '';
         const fr = [];
         const poe = (papel, texto, o = {}) => { if (String(texto || '').trim()) fr.push({ id: `${i}-${fr.length}`, papel, palavras: frase(texto, o) }); };
@@ -126,7 +164,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         /* O CARTÃO DE PRODUTO que flutua ao lado (terminal, chat, painel), feito
            de forma e texto — e o texto vai para o outro lado. `ui: false` tira. */
         const ui = p.ui === false ? null : typeof p.ui === 'string' ? p.ui
-            : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
+            : !deProduto ? null
+                : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
         if (ui) {
             b.lado = comCartao++ % 2 ? 'dir' : 'esq';
             b.ui = ui === 'terminal' ? { tipo: ui, linhas: ['$ ' + cmd, '✓ ' + caixaNormal(p.sub || titulo)] }
@@ -165,6 +204,53 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         return b;
     });
 
+    /* ── A PALAVRA GIGANTE e a VIRADA (08/10): nas referências boas, o
+       momento forte é uma frase curta que ENCHE a tela, e o fundo vira
+       (o ponto cresce até cobrir tudo de cor). Sem isso o vídeo era a mesma
+       pílula pequena no mesmo azul por 36 s — "horríveis". Regras de editor:
+       só frase de até 4 palavras, abertura ou com destaque (a palavra-tese)
+       primeiro; gigante em até metade das batidas; a virada só nas que têm
+       destaque, 1 em 3 e nunca seguida. `p.gigante` explícito manda. */
+    const curta = (b) => { const f = b.frases.find((x) => x.papel === 'principal'); return f && f.palavras.length <= 4 && b.frases.length <= 2; };
+    const candidatas = batidas.map((b, i) => ({ b, i, p: partes[i] }))
+        .filter(({ b, p }) => p.gigante !== false && (b.tipo === 'titulo' || b.tipo === 'abertura') && !b.ui && !b.imagem && curta(b))
+        .sort((x, y) => (y.p.gigante === true) - (x.p.gigante === true) || !!y.p.destaque - !!x.p.destaque || (x.b.tipo === 'abertura' ? -1 : 0) || x.i - y.i);
+    /* ── AS IMAGENS, quando a pessoa pediu (08/10: "deve ser misto com imagens
+       e motion, e com variadas animações"; o híbrido era "10 mil imagens de
+       banco e a mesma animação"). A imagem é UM momento: só nas batidas que
+       têm imagem baixada, no máximo 1 em 3, nunca duas seguidas. E cada uma
+       entra de um JEITO diferente, sem repetir no vídeo:
+         janela   a foto abre da esquerda e cobre a tela, o texto por cima
+         circulo  o ponto cresce em círculo com a foto dentro
+         cartao   a foto num cartão que gira em 3D, o texto acima
+         faixa    uma faixa da foto abre na altura, o texto abaixo
+         vazado   o título gigante com a foto por DENTRO das letras        */
+    const JEITOS = ['janela', 'circulo', 'cartao', 'faixa', 'vazado'];
+    const ordemJeitos = JEITOS.map((j, k) => ({ j, o: hash(j + semente) })).sort((a, b) => a.o - b.o).map((x) => x.j);
+    const tetoImagem = Math.max(1, Math.floor(batidas.length / 3));
+    let nImagem = 0;
+    for (const b of batidas) {
+        const img = imagens[b.i];
+        if (!img || !img.src || b.tipo === 'cta' || nImagem >= tetoImagem) continue;
+        if (batidas[b.i - 1] && batidas[b.i - 1].imagem) continue;
+        const pr = b.frases.find((f) => f.papel === 'principal');
+        let jeito = ordemJeitos[nImagem % ordemJeitos.length];
+        if (jeito === 'vazado' && !(pr && pr.palavras.length <= 3)) jeito = ordemJeitos[(nImagem + 1) % ordemJeitos.length] === 'vazado' ? 'janela' : ordemJeitos[(nImagem + 1) % ordemJeitos.length];
+        b.imagem = { src: img.src, jeito };
+        b.ui = null; b.lado = 'centro';
+        nImagem++;
+    }
+
+    // A gigante pode seguir outra (as referências fazem isso); a VIRADA é o golpe: 1 em 3, nunca seguida.
+    const teto = Math.max(1, Math.ceil(batidas.length / 2)), tetoVirada = Math.max(1, Math.floor(batidas.length / 3));
+    for (const { b, i, p } of candidatas) {
+        if (batidas.filter((x) => x.gigante).length >= teto && p.gigante !== true) break;
+        b.gigante = true;
+        const viradas = batidas.filter((x) => x.virada).length;
+        const vizinha = (batidas[i - 1] && batidas[i - 1].virada) || (batidas[i + 1] && batidas[i + 1].virada);
+        if (i > 0 && viradas < tetoVirada && !vizinha && (p.destaque || p.gigante === true)) b.virada = true;
+    }
+
     /* ── o tempo: a VOZ manda. A batida troca na fronteira da frase (um
        pouco antes da primeira palavra da parte) e cada palavra na tela
        aparece no instante em que é dita (os tempos por palavra da narração).
@@ -185,13 +271,16 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
                cada palavra (a frase da tela pode vir em outra ordem que a falada)
                e fica com o casamento que acha mais palavras. */
             const casa = (k, d) => d === k || (k.length >= 4 && d.length >= 4 && d.slice(0, 5) === k.slice(0, 5));
+            /* Cada frase procura as suas palavras na fala INTEIRA da batida: com
+               um cursor só, o título que casava com o fim da fala deixava o
+               subtítulo sem achar as dele (entrava 0,45 s atrasado, 08/10). */
             let ts = f.palavras.map(() => null), fim = cursor;
             for (let ini = 0; ini < f.palavras.length; ini++) {
-                let c = cursor;
+                let c = 0;
                 const tt = f.palavras.map((w, j) => {
                     const k = limpa(w.t);
                     if (j < ini || !k) return null;
-                    for (let q = c; q < Math.min(ditas.length, c + 12); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
+                    for (let q = c; q < Math.min(ditas.length, c + 40); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
                     return null;
                 });
                 if (tt.filter((x) => x != null).length > ts.filter((x) => x != null).length) { ts = tt; fim = c; }
@@ -201,7 +290,11 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
             const ach = ts.findIndex((x) => x != null);
             /* O que a voz não diz entra cedo o bastante para ser lido antes de a
                frase acabar (e nunca antes da batida). */
-            let t = ach >= 0 ? ts[ach] - ach * STAGGER
+            /* O que a voz DIZ entra quando ela diz — nunca antes. Antes de 08/10
+               a frase entrava no começo da batida se a voz demorasse: "ontem à
+               noite" aparecia 2,8 s antes de ser dito, e o Joel viu "atrasos
+               entre a narração e o vídeo". */
+            let t = ach >= 0 && ts[ach] != null ? ts[ach] - ach * STAGGER
                 : tp ? Math.max(b.de + 0.25, Math.min(livre, fimVoz - leitura(f.palavras.length) - 0.05)) : livre;
             f.palavras.forEach((w, j) => {
                 const falada = ts[j];
@@ -226,7 +319,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
 
     return {
         versao: 2, semente, fps: FPS, atraso, sincronia, largura, altura, duracao: ult.ate, paleta,
-        fontes: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono' },
+        marcador: roteiro.marcador || ['brilho', 'numero', 'traco', 'ponto', 'nenhum'][hash('marcador' + semente) % 5],
+        fontes: (({ texto, serifa, mono }) => ({ texto, serifa, mono }))(trioDe(roteiro)),
         logo: marca.logo || null,
         batidas,
     };
@@ -238,10 +332,10 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
  * @param {Array}  op.tempos    [{de, ate, palavras}] por parte (da narração)
  * @param {object} op.sons      os efeitos leves (sons-leves.js)
  */
-function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null }) {
+function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, imagens = {} }) {
     const partes = ((roteiro && roteiro.partes) || []).filter((p) => p && typeof p === 'object');
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
-    const partitura = partituraDe({ roteiro: { ...roteiro, partes }, largura, altura, tempos });
+    const partitura = partituraDe({ roteiro: { ...roteiro, partes }, largura, altura, tempos, imagens });
     const DUR = partitura.duracao;
     /* O SOM segue o movimento (sons-leves.js, tudo sintetizado): whoosh em
        cada transformação, pop quando pílula ou cartão assenta, clique na roda e
@@ -265,7 +359,7 @@ function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     const plano = {
         formato: { largura, altura, fps: FPS },
         fundoGeral: P.fundo[0],
-        fontesVariaveis: { Inter: 'wght@300..700', 'Instrument Serif': 'ital@0;1', 'JetBrains Mono': 'wght@400;500' },
+        fontesVariaveis: (({ texto, serifa, mono, css }) => ({ [texto]: css[0], [serifa]: css[1], [mono]: css[2] }))(trioDe(roteiro)),
         cenas: [{
             duracao: DUR,
             fundo: P.fundo[0],
@@ -277,7 +371,7 @@ function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             efeitos,
         },
     };
-    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
+    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, imagens: partitura.batidas.filter((b) => b.imagem).map((b) => b.imagem.jeito), segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
 }
 
-module.exports = { montarFluido, partituraDe, caixaNormal, PALETAS, POR_PALAVRA, MINIMO };
+module.exports = { montarFluido, partituraDe, caixaNormal, escolherFontes, PALETAS, TRIOS, POR_PALAVRA, MINIMO };