primocode 10.2.0 → 10.3.0-beta.0

package/lib/estudio/fluido.js

@@ -51,6 +51,31 @@ const PALETAS = {
 };
 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; };
 
 /** A paleta: a pedida pelo nome; senão o tema (claro/escuro); senão a semente. */
@@ -295,7 +320,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], imag
     return {
         versao: 2, semente, fps: FPS, atraso, sincronia, largura, altura, duracao: ult.ate, paleta,
         marcador: roteiro.marcador || ['brilho', 'numero', 'traco', 'ponto', 'nenhum'][hash('marcador' + semente) % 5],
-        fontes: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono' },
+        fontes: (({ texto, serifa, mono }) => ({ texto, serifa, mono }))(trioDe(roteiro)),
         logo: marca.logo || null,
         batidas,
     };
@@ -334,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],
@@ -349,4 +374,4 @@ function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     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 };

package/lib/estudio/gerativo.js

@@ -209,12 +209,132 @@ const ICONE_DE = {
 
 /** O humor do roteiro: as palavras dele contra as de cada humor (empate: a semente). */
 function humorDe(roteiro, s) {
-    const txt = new Set(tokens((roteiro.partes || []).map((p) => [p.titulo, p.texto, p.fala, p.sub, ...(p.itens || [])].filter(Boolean).join(' ')).join(' ')
-        + ' ' + ((roteiro.marca && roteiro.marca.nome) || '') + ' ' + (roteiro.pedido || '')));
+    const n = acertosDeHumor(roteiro);
     const nota = {};
-    for (const [h, d] of Object.entries(HUMORES)) nota[h] = d.palavras.split(' ').filter((w) => txt.has(w)).length + s.prox() * 0.5;
+    for (const h of Object.keys(HUMORES)) nota[h] = n[h] + s.prox() * 0.5;
     return Object.entries(nota).sort((a, b) => b[1] - a[1])[0][0];
 }
+/** Quantas palavras de cada humor o roteiro diz. */
+function acertosDeHumor(roteiro) {
+    const txt = new Set(tokens((roteiro.partes || []).map((p) => [p.titulo, p.texto, p.fala, p.sub, ...(p.itens || [])].filter(Boolean).join(' ')).join(' ')
+        + ' ' + ((roteiro.marca && roteiro.marca.nome) || '') + ' ' + (roteiro.pedido || '')));
+    return Object.fromEntries(Object.entries(HUMORES).map(([h, d]) => [h, d.palavras.split(' ').filter((w) => txt.has(w)).length]));
+}
+
+/* AS ESCOLHAS DO PROJETO (09/10): "vício em cores, músicas, fontes… ele
+   escolhe sempre as mesmas coisas" (Joel). A paleta, as fontes e o gênero
+   saíam só da semente — sem lembrar do vídeo anterior — e o humor caía em
+   "tecnologia" com uma palavra só ("dados", "rápido"), porque é a lista mais
+   longa. Agora as quatro escolhas passam pela memória da variedade.js:
+   - o humor: adequação (acertos + 1) / (máximo + 1). Com o assunto claro
+     (6 palavras de IA), os outros valem ~0,15 e a tecnologia fica; com uma
+     palavra só, os outros valem 0,5 e a memória gira. Penaliza, não proíbe;
+   - paleta, fontes e gênero: as do humor valem 1, as dos outros humores
+     valem menos (ainda curadas, nunca as de cara de IA) — o que é do assunto
+     vem primeiro, e quando já saiu nos últimos vídeos a vizinha ganha.
+   Roda UMA vez por projeto (index.js guarda em p.escolhasGerativo): mandar
+   o roteiro de novo não sorteia outro vídeo. A partitura segue pura — ela só
+   lê roteiro.escolhasGerativo, e a marca continua mandando por cima. */
+function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
+    const variedade = require('./variedade.js');
+    const marca = roteiro.marca || {};
+    const n = acertosDeHumor(roteiro);
+    const max = Math.max(...Object.values(n));
+    const humor = variedade.sortear(Object.keys(HUMORES), 'humor-gerativo', { aleatorio, adequacao: (h) => (n[h] + 1) / (max + 1) });
+    const de = (campo, outros) => { const m = {}; for (const [h, d] of Object.entries(HUMORES)) for (const x of d[campo]) if (!BANIDAS.includes(x) && (m[x] == null || h === humor)) m[x] = h === humor ? 1 : outros; return m; };
+    const escolher = (m, tipo, prefixo) => variedade.sortear(Object.keys(m), tipo, { aleatorio, prefixo, adequacao: m });
+    const out = { humor };
+    // A paleta é o sistema de 5 campos (é o que aparece). Com o fundo da marca, nem sorteia.
+    if (!ehCor((marca.cores || {}).fundo)) {
+        const m = {};
+        for (const [h, lista] of Object.entries(CAMPOS)) for (const k of lista) m[k.join(' ')] = h === humor ? 1 : 0.6;
+        out.paleta = escolher(m, 'paleta-gerativo', '').split(' ');
+    }
+    const fontesMarca = marca.fontes || {};
+    if (!fontesMarca.titulo) out.display = escolher(de('displays', 0.5), 'fonte-gerativo', 'display:');
+    if (!fontesMarca.texto) out.texto = escolher(de('textos', 0.5), 'fonte-gerativo', 'texto:');
+    out.mono = escolher(de('monos', 0.5), 'fonte-gerativo', 'mono:');
+    out.genero = escolher(de('generos', 0.35), 'genero-gerativo', '');
+    const um = (lista, tipo, prefixo) => variedade.sortear(lista, tipo, { aleatorio, prefixo });
+    const o3d = OBJETO3D_DO_HUMOR[humor] != null ? OBJETO3D_DO_HUMOR[humor] : 0.7;
+    // Um pouco de acaso na adequação: sem ele, a memória vira rodízio fixo (esfera+explosão, polígono+toro, de novo).
+    const fitH = (h) => (HEROIS_OBJETO.includes(h) ? o3d : 1 - o3d / 2) * (0.75 + 0.25 * aleatorio());
+    /* A FORMA ABSTRATA (09/10, "partículas girando numa conversa de padaria?"):
+       só no assunto abstrato ou de tecnologia, e com força pelo quanto o
+       roteiro É do assunto (uma palavra só não basta). UMA forma por vídeo —
+       é identidade, não sorteio por batida — ou 'nenhum', que a memória também gira. */
+    const forca = (ABSTRATO_DO_HUMOR[humor] || 0) * Math.min(1, n[humor] / 3);
+    const h1 = forca > 0 ? variedade.sortear([...HEROIS_OBJETO, ...HEROIS_CAMPO, 'nenhum'], 'heroi-gerativo', { aleatorio, adequacao: (h) => (h === 'nenhum' ? 1 - forca : forca * fitH(h)) }) : 'nenhum';
+    out.herois = { favoritos: h1 === 'nenhum' ? [] : [h1] };
+    // 'produto' e 'marca' quem decide é o conteúdo (o 3D pedido, a marca), não o gosto do projeto.
+    const favC = [];
+    for (let k = 0; k < 3; k++) favC.push(variedade.sortear(COMPOSICOES.filter((c) => c !== 'produto' && c !== 'marca' && !favC.includes(c)), 'composicao-gerativo', { aleatorio }));
+    out.composicoes = { favoritas: favC };
+    /* A MOLDURA (09/10): o quadro fixo do reel de referência — cantos, o assunto
+       no alto, a seção, o tempo embaixo — é identidade, mas em todo vídeo vira
+       vício. Sai do cardápio com memória: 'sem' pesa um pouco mais. */
+    out.moldura = variedade.sortear(MOLDURAS, 'moldura-gerativo', { aleatorio, adequacao: { sem: 1, cantos: 0.95, completa: 0.95 } });
+    // O bokeh combina com luz de tela (tecnologia, energia, natureza); numa padaria, quase nunca.
+    const bokeh = ['tecnologia', 'energia', 'natureza'].includes(humor) ? 0.6 : 0.2;
+    out.ambiente = variedade.sortear(AMBIENTES, 'ambiente-gerativo', { aleatorio, adequacao: { limpo: 1, luz: 0.85, bokeh } });
+    out.acento = variedade.sortear(ACENTOS_JEITO, 'acento-gerativo', { aleatorio, adequacao: { traco: 1, viagem: 0.7 } });
+    out.icones = { arranjo: um(ARRANJOS_ICONE, 'arranjo-icone', 'arranjo:'), ritmo: um(RITMOS_ICONE, 'arranjo-icone', 'ritmo:'), material: um(MATERIAIS_ICONE, 'material-icone', '') };
+    return out;
+}
+/* OS ÍCONES (09/10, "vício na forma que os ícones são distribuídos"): o
+   ícone ia sempre à direita (deitado) ou acima (em pé), nas primeiras batidas
+   que tinham palavra-chave, num de 3 materiais. Agora o projeto escolhe:
+   - o ARRANJO: 'lado' (o de antes), 'outro-lado' (esquerda / abaixo),
+     'alterna' (um de cada lado, batida a batida) ou 'canto' (menor, no canto);
+   - o RITMO: 'seguidos' (o de antes), 'alternados' (uma batida sem ícone entre
+     dois) ou 'esparsos' (duas);
+   - o MATERIAL do kit/tres.jsx.
+   O kit tenta o lugar pedido e, sem espaço, o próximo da lista (nunca por cima do texto). */
+/* O HERÓI E AS COMPOSIÇÕES entre vídeos (09/10, "vício no 3D… efeitos mais 3D
+   dependendo do vídeo"): dentro do vídeo eles já não se repetiam, mas o vídeo
+   seguinte recomeçava igual. Cada projeto escolhe 2 heróis e 3 composições
+   FAVORITOS pela memória (pesam mais no sorteio; os outros continuam valendo).
+   O assunto decide quanto 3D: tecnologia e energia puxam os objetos (esfera,
+   toro, polígono, explosão); editorial e luxo, os campos. */
+const HEROIS_OBJETO = ['explosao', 'poligono', 'esfera', 'toro'], HEROIS_CAMPO = ['truchet', 'aneis', 'grade', 'rastro'];
+const OBJETO3D_DO_HUMOR = { tecnologia: 1, energia: 1, natureza: 0.8, luxo: 0.6, editorial: 0.4 };
+/* Quanto o assunto aceita forma abstrata (o resto: a tipografia e o ícone do conteúdo). */
+const ABSTRATO_DO_HUMOR = { tecnologia: 1, energia: 0.7, natureza: 0.5, luxo: 0, editorial: 0 };
+const ARRANJOS_ICONE = ['lado', 'outro-lado', 'alterna', 'canto'];
+const MOLDURAS = ['sem', 'cantos', 'completa'];
+/* A BOLINHA (09/10): "todo vídeo tem aquela bolinha" (Joel). O ambiente:
+   'limpo' (só grão e vinheta), 'luz' (o brilho e o feixe que varre) ou
+   'bokeh' (as manchas de luz desfocadas na frente). O acento: 'traco' (cada
+   traço se desenha e some) ou 'viagem' (o ponto que nasce no meio, viaja
+   entre as batidas e se recolhe — o de antes). */
+const AMBIENTES = ['limpo', 'luz', 'bokeh'];
+const ACENTOS_JEITO = ['traco', 'viagem'];
+const RITMOS_ICONE = ['seguidos', 'alternados', 'esparsos'];
+const MATERIAIS_ICONE = ['argila', 'verniz', 'metal', 'perola', 'acetinado'];
+
+/** Só o que existe nos cardápios: um p.escolhasGerativo velho ou editado à mão não quebra o vídeo. */
+function escolhasValidas(e) {
+    if (!e || typeof e !== 'object') return { herois: [], composicoes: [] };
+    const todas = (campo) => Object.values(HUMORES).flatMap((d) => d[campo]);
+    return {
+        humor: HUMORES[e.humor] ? e.humor : null,
+        moldura: MOLDURAS.includes(e.moldura) ? e.moldura : null,
+        ambiente: AMBIENTES.includes(e.ambiente) ? e.ambiente : null,
+        acento: ACENTOS_JEITO.includes(e.acento) ? e.acento : null,
+        paleta: Array.isArray(e.paleta) && e.paleta.length === 5 && e.paleta.every(ehCor) ? e.paleta : null,
+        display: VARIAVEIS[e.display] && todas('displays').includes(e.display) ? e.display : null,
+        texto: todas('textos').includes(e.texto) ? e.texto : null,
+        mono: todas('monos').includes(e.mono) ? e.mono : null,
+        genero: todas('generos').includes(e.genero) ? e.genero : null,
+        herois: (e.herois && Array.isArray(e.herois.favoritos) ? e.herois.favoritos : []).filter((h) => HEROIS_OBJETO.includes(h) || HEROIS_CAMPO.includes(h)),
+        composicoes: (e.composicoes && Array.isArray(e.composicoes.favoritas) ? e.composicoes.favoritas : []).filter((c) => COMPOSICOES.includes(c)),
+        icones: e.icones && ARRANJOS_ICONE.includes(e.icones.arranjo) ? {
+            arranjo: e.icones.arranjo,
+            ritmo: RITMOS_ICONE.includes(e.icones.ritmo) ? e.icones.ritmo : 'seguidos',
+            material: MATERIAIS_ICONE.includes(e.icones.material) ? e.icones.material : null,
+        } : null,
+    };
+}
 /* As que têm largura (wdth): é nelas que a palavra estica. */
 const CINETICAS = ['Roboto Flex', 'Anybody', 'Archivo', 'Mona Sans'];
 
@@ -452,10 +572,13 @@ const luz = (h) => { const n = parseInt(String(h).slice(1), 16); return ((n >> 1
 const contraste = (a, b) => { const la = luz(a) + 0.05, lb = luz(b) + 0.05; return la > lb ? la / lb : lb / la; };
 const PALETAS = HUMORES.tecnologia.paletas;
 
-function paletaDe(marca, s, humor = null, roteiro = {}) {
+function paletaDe(marca, s, humor = null, roteiro = {}, fixa = null) {
     const c = marca.cores || {};
     const op = humor ? HUMORES[humor].paletas : PALETAS;
-    const [f0, t0, a0] = op[Math.floor(s.prox() * op.length) % op.length];
+    // O sorteio acontece sempre: a sequência da semente não muda com ou sem escolha salva.
+    const sorteada = op[Math.floor(s.prox() * op.length) % op.length];
+    // A escolha do projeto (escolherVisual) é um sistema de 5 campos: 0 = tinta escura, 1 = assinatura, 2 = papel.
+    const [f0, t0, a0] = fixa ? [fixa[0], fixa[2], fixa[1]] : sorteada;
     let base = { fundo: f0, tinta: t0, acento: a0 };
     // A cor que o assunto diz manda no acento (se não sumir no fundo).
     const ditas = tokens((roteiro.partes || []).map((p) => [p.titulo, p.destaque].join(' ')).join(' ')).filter((w) => CORES_DITAS[w]);
@@ -478,9 +601,10 @@ const CAMPOS = {
     natureza: [['#0F2A2A', '#F2A541', '#F2EDE2', '#2546D9', '#E4573D'], ['#13233F', '#2546D9', '#F2EDE2', '#F2A541', '#C8553D']],
     luxo: [['#120D0B', '#C9A24A', '#F0E6D6', '#5B1A1F', '#2F4F4F']],
 };
-function camposDe(marca, humor, s, dita = null) {
+function camposDe(marca, humor, s, dita = null, fixa = null) {
     const c = marca.cores || {};
-    let k = [...s.um(CAMPOS[humor] || CAMPOS.tecnologia)];
+    const sorteado = s.um(CAMPOS[humor] || CAMPOS.tecnologia);
+    let k = [...(fixa || sorteado)];
     // A cor que o assunto diz vira a assinatura (se não for a de outro papel).
     if (dita && !ehCor(c.destaque)) { const j = k.indexOf(dita); if (j > 0) k[j] = k[1]; k[1] = dita; }
     // A marca: o fundo dela, o destaque dela e a tinta dela tomam os lugares de mesmo papel.
@@ -492,15 +616,56 @@ function camposDe(marca, humor, s, dita = null) {
     if (ehCor(c.destaque) && k[1] !== c.destaque) k[1] = c.destaque;
     return k;
 }
-/** As cores de uma batida pelo campo dela: texto no contraste máximo, acento noutra cor do sistema. */
-function coresDoCampo(campos, i, s) {
+/* A IDENTIDADE TRAVADA (09/10): "as cores do nada estão preto e do nada estão
+   branco, cores nada a ver uma diferente da outra" (Joel, sobre o Pix na
+   padaria). O sistema de 5 campos virava 4 fundos trocando quase toda batida.
+   Agora o vídeo usa UMA identidade: 2 chãos (o escuro e o claro do sistema) e
+   1 acento (a assinatura), e mais nada. Os campos 3 e 4 ficam de fora. */
+function identidadeDe(campos, marca = {}) {
+    const c = marca.cores || {};
+    let chaos = [campos[0], campos[2]];
+    // O fundo da marca é sempre um chão (mesmo o de meio-tom, que o camposDe punha na assinatura).
+    if (ehCor(c.fundo) && !chaos.includes(c.fundo)) chaos[luz(c.fundo) < 0.5 ? 0 : 1] = c.fundo;
+    chaos = chaos.sort((a, b) => luz(a) - luz(b));
+    return { chaos, acento: campos[1] };
+}
+/** O acento no chão: se some nele, escurece (chão claro) ou clareia (chão escuro) no MESMO matiz. */
+function acentoNoChao(acento, fundo) {
+    if (contraste(acento, fundo) >= 2.6) return acento;
+    const alvo = luz(fundo) > 0.5 ? '#000000' : '#ffffff';
+    for (let k = 0.1; k <= 0.9; k += 0.05) { const x = misturarCor(acento, alvo, k); if (contraste(x, fundo) >= 2.6) return x; }
+    return misturarCor(acento, alvo, 0.9);
+}
+/** As cores de uma batida pelo chão dela: texto no outro chão, acento o da identidade. */
+function coresDoCampo(campos, i, s, id = null) {
+    const I = id || identidadeDe(campos);
     const fundo = campos[i];
-    const tintas = [campos[0], campos[2]].sort((a, b) => contraste(b, fundo) - contraste(a, fundo));
-    const texto = tintas[0];
-    const outras = campos.filter((c, j) => j !== i && c !== texto && contraste(c, fundo) >= 2.2);
-    const acento = outras.length ? (outras.includes(campos[1]) && i !== 1 ? campos[1] : s.um(outras)) : texto;
+    const texto = [...I.chaos].sort((a, b) => contraste(b, fundo) - contraste(a, fundo))[0];
+    const acento = acentoNoChao(I.acento, fundo);
     return { fundo, texto, fraco: misturarCor(texto, fundo, 0.45), acento, contorno: misturarCor(texto, fundo, 0.6) };
 }
+/* AS SEÇÕES: o fundo troca só na virada de seção. Quem diz a seção é o
+   roteiro (parte.secao, o nome dela); sem isso, as partes se dividem em 1 a 4
+   blocos seguidos, uns 3 por bloco. Devolve o índice de cada parte e os nomes. */
+function secoesDe(partes) {
+    const n = partes.length;
+    if (partes.some((p) => p && typeof p.secao === 'string' && p.secao.trim())) {
+        const nomes = [], idx = [];
+        let atual = null;
+        partes.forEach((p, i) => {
+            const nome = (p.secao && String(p.secao).trim()) || atual || '';
+            if (i === 0 || nome !== atual) nomes.push(nome);
+            atual = nome;
+            idx.push(nomes.length - 1);
+        });
+        return { idx, nomes };
+    }
+    const k = n <= 3 ? 1 : n <= 6 ? 2 : n <= 10 ? 3 : 4;
+    const idx = partes.map((_, i) => Math.floor((i * k) / n));
+    // Sem nome dado, a seção leva o título da primeira parte dela.
+    const nomes = Array.from({ length: k }, (_, j) => { const p = partes[idx.indexOf(j)] || {}; return String(p.titulo || p.texto || p.sim || p.rotulo || p.valor || '').trim(); });
+    return { idx, nomes };
+}
 
 /** As cores de uma batida pelo fundo dela: base (a marca) ou acento (o fundo vira a cor). */
 function coresDaBatida(P, fundo) {
@@ -523,7 +688,9 @@ const NOTAS = [220, 246.94, 261.63, 293.66, 329.63, 349.23, 392, 440];
 function sonsDoVideo(roteiro = {}) {
     const semente = hash('som:' + JSON.stringify((roteiro.partes || []).map((p) => [p.titulo, p.fala])) + ((roteiro.marca && roteiro.marca.nome) || ''));
     const s = sorteador(semente);
-    const timbre = HUMORES[humorDe(roteiro, sorteador(hash('humor')))] ? HUMORES[humorDe(roteiro, s)].som : 'analogico';
+    const humorSom = humorDe(roteiro, s);
+    const E = escolhasValidas(roteiro.escolhasGerativo);
+    const timbre = HUMORES[E.humor || humorSom] ? HUMORES[E.humor || humorSom].som : 'analogico';
     const raiz = s.um(NOTAS);
     const escala = [1, 1.189, 1.335, 1.498, 1.782, 2];               // pentatônica menor sobre a raiz
     const nota = () => Math.round(raiz * s.um(escala) * (s.chance(0.3) ? 2 : 1));
@@ -587,8 +754,11 @@ function sonsDoVideo(roteiro = {}) {
 function musicaDe(roteiro = {}) {
     const semente = hash('musica:' + JSON.stringify((roteiro.partes || []).map((p) => [p.titulo, p.fala])));
     const s = sorteador(semente);
-    const h = humorDe(roteiro, s);
-    return { humor: h, genero: s.um(HUMORES[h].generos), semente };
+    const E = escolhasValidas(roteiro.escolhasGerativo);
+    const sorteado = humorDe(roteiro, s);
+    const h = E.humor || sorteado;
+    const genero = s.um(HUMORES[h].generos);
+    return { humor: h, genero: E.genero || genero, semente };
 }
 /* ── O SOM DESENHADO (30/09, terceira volta): "os efeitos repetem e são os
    genéricos que toda IA usa". Então:
@@ -697,10 +867,10 @@ const LEGADO = { passagem: ['whoosh', 'sopro'], golpe: ['impacto', 'toque'], nas
  * @param {Array}  op.tempos    [{de, ate, palavras:[{texto,de,ate}]}] por parte
  * @returns {{ok, plano, partitura, resumo}}
  */
-function montarGerativo({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null }) {
+function montarGerativo({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, icones = {} }) {
     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, icones });
     const DUR = partitura.duracao;
 
     // ── o som: efeitos nas transformações, a música abaixa sob a voz ─────
@@ -741,16 +911,21 @@ function montarGerativo({ roteiro, largura = 1920, altura = 1080, tempos = [], n
 }
 
 /** A partitura, 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 = [], icones = {} }) {
     const partes = roteiro.partes || [];
     const marca = roteiro.marca || {};
     const W = largura, H = altura, deitado = W >= H;
     const semente = roteiro.semente != null ? hash('semente:' + roteiro.semente)
         : hash(JSON.stringify([partes.map((p) => [p.tipo, p.titulo, p.texto, p.fala, p.valor, p.itens, p.nao, p.sim, p.destaque]), marca.nome || '']));
     const s = sorteador(semente);
-    const humor = humorDe(roteiro, s);
+    /* As escolhas do projeto (escolherVisual, com memória entre vídeos). Sem
+       elas — projeto antigo, teste — vale a semente, como antes. Os sorteios
+       da semente acontecem igual nos dois casos: o resto do vídeo não muda. */
+    const E = escolhasValidas(roteiro.escolhasGerativo);
+    const humorSorteado = humorDe(roteiro, s);
+    const humor = E.humor || humorSorteado;
     const H0 = HUMORES[humor];
-    const P = paletaDe(marca, s, humor, roteiro);
+    const P = paletaDe(marca, s, humor, roteiro, E.paleta);
 
     /* ── as fontes: NADA de cara de IA. A da marca vale se tiver caráter (e
        eixos para animar); a genérica da marca vira texto, e o título ganha
@@ -758,11 +933,16 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
     const pedida = (marca.fontes && marca.fontes.titulo) || '';
     const pedidaTexto = (marca.fontes && marca.fontes.texto) || '';
     const boa = (f) => f && VARIAVEIS[f] && !BANIDAS.includes(f) && VARIAVEIS[f].eixos.wght;
-    const display = boa(pedida) ? pedida : s.um(H0.displays);
+    const ou = (salva, sorteada) => salva || sorteada;
+    const display = boa(pedida) ? pedida : ou(E.display, s.um(H0.displays));
     const cinetica = eixoDe(display, 'wdth') && eixoDe(display, 'wdth')[0] <= 75 ? display : s.um(H0.cineticas);
-    const texto = pedidaTexto ? pedidaTexto : (pedida && BANIDAS.includes(pedida) ? pedida : s.um(H0.textos));
+    const texto = pedidaTexto ? pedidaTexto : (pedida && BANIDAS.includes(pedida) ? pedida : ou(E.texto, s.um(H0.textos)));
     const serifa = VARIAVEIS[display].serifa ? display : s.um(H0.serifas);
-    const fontes = { display, cinetica, texto, mono: s.um(H0.monos), serifa };
+    /* DUAS FONTES (09/10, a identidade): o título e o texto. A cinética, a
+       serifa da citação e o rótulo eram mais três faces — o vídeo saía com 4
+       ou 5 famílias. Os sorteios continuam (a semente não muda o resto). */
+    void cinetica; void serifa; void ou(E.mono, s.um(H0.monos));
+    const fontes = { display, cinetica: display, texto, mono: texto, serifa: display };
 
     // ── o quadro: margens e respiro ─────────────────────────────────────
     // A margem conta com a câmera: ela empurra até ~8% e desliza, e nada pode sair do quadro.
@@ -821,6 +1001,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
             if (recentes.slice(-3).includes(comp)) q *= 0.35;
             q *= Math.pow(0.72, usadas[comp] || 0);
             if (comp === 'parede' && (usadas.parede || 0) >= 1) q *= 0.25;
+            if (E.composicoes.includes(comp)) q *= 2.2;   // a favorita do projeto (escolherVisual)
             w[nome] = q;
         }
         return s.pesado(w) || s.pesado({ pilha: anterior === 'pilha' ? 0 : 1, gigante: anterior === 'gigante' ? 0 : 1, palavras: anterior === 'palavras' ? 0 : 1 });
@@ -879,72 +1060,92 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         registra(compor(nome, br, ctx));
     });
 
-    /* ── os campos: o fundo inteiro troca de cor a cada batida (quase sempre),
-       nunca igual ao anterior nem ao de duas antes; a fala e o conteúdo da
-       mesma parte às vezes dividem o campo. O produto 3D pede o campo escuro. */
+    /* ── os chãos: a identidade do vídeo (2 chãos e 1 acento) e o fundo que
+       troca só na virada de seção, sempre entre os dois chãos. Quem começa é
+       o fundo da marca; sem marca, a semente. ─────────────────────────────── */
     const ditaCor = tokens(partes.map((p) => [p.titulo, p.destaque].join(' ')).join(' ')).map((w) => CORES_DITAS[w]).find(Boolean) || null;
-    const campos = camposDe(marca, humor, s, ditaCor);
-    batidas.forEach((b, i) => {
-        if (i === 0) { b.campo = 0; return; }
-        const a = batidas[i - 1];
-        if (a.parte === b.parte && s.chance(0.4)) { b.campo = a.campo; return; }
-        if (b.produto3d) { b.campo = a.campo === 0 ? 3 : 0; return; }
-        const evita = [a.campo, i > 1 ? batidas[i - 2].campo : -1];
-        const op = campos.map((_, j) => j).filter((j) => !evita.includes(j));
-        b.campo = s.um(op);
-    });
-    for (const b of batidas) { b.fundo = 'campo' + b.campo; b.cores = coresDoCampo(campos, b.campo, s); }
+    const campos = camposDe(marca, humor, s, ditaCor, E.paleta);
+    const ident = identidadeDe(campos, marca);
+    // O campo continua um índice (o kit e as passagens leem): 0 = o chão escuro, 2 = o claro.
+    campos[0] = ident.chaos[0]; campos[2] = ident.chaos[1];
+    const fm = (marca.cores || {}).fundo;
+    const comeca = ehCor(fm) ? (fm === campos[0] ? 0 : 2) : (s.chance(0.5) ? 0 : 2);
+    const secoes = secoesDe(partes);
+    batidas.forEach((b) => { b.secao = secoes.idx[b.parte] || 0; b.campo = b.secao % 2 === 0 ? comeca : 2 - comeca; });
+    for (const b of batidas) { b.fundo = 'campo' + b.campo; b.cores = coresDoCampo(campos, b.campo, s, ident); }
 
-    /* ── os ÍCONES 3D: onde a parte pediria um ícone (lista, número,
-       recurso), um objeto de geometria no material do vídeo. A palavra
-       decide qual; nunca o mesmo duas vezes, e no máximo em ~45% das batidas
-       — ícone em toda batida vira papel de parede de IA. ───────────────── */
-    const material = s.um(['argila', 'verniz', 'metal']);
+    /* ── O HERÓI DE CADA BATIDA VEM DO CONTEÚDO (09/10): "é uma conversa sobre
+       pão e ele vai naquela bolinha" (Joel). Quem diz é o roteiro: parte.heroi
+       (ou parte.icone) — um ícone do Iconify ("mdi:bread-slice", o desenho
+       chega em `icones`), um 3D do kit (raio, relogio…), uma forma abstrata
+       pelo nome, ou "nenhum". Sem isso: o ícone 3D quando a fala cita um
+       objeto do catálogo (ICONE_DE, sugestão), no máximo em ~45% das batidas;
+       e a forma abstrata só no assunto abstrato, a escolhida do projeto, em
+       até 1 de cada 3 batidas. Nada serve: a tipografia carrega a batida. ── */
+    const pedidoDe = partes.map((p) => { const h = p.heroi != null ? p.heroi : p.icone; return typeof h === 'string' && h.trim() ? h.trim() : null; });
+    const ABSTRATOS = [...HEROIS_OBJETO, ...HEROIS_CAMPO];
+    const ICONES3D = new Set(Object.values(ICONE_DE));
+    const materialSorteado = s.um(['argila', 'verniz', 'metal']);
+    // O arranjo do projeto (escolherVisual); sem ele, o de antes: um lado só, ícones seguidos.
+    const EI = E.icones || { arranjo: 'lado', ritmo: 'seguidos' };
+    const material = EI.material || materialSorteado;
+    const lado1 = deitado ? 'direita' : 'acima', lado2 = deitado ? 'esquerda' : 'abaixo';
+    const reserva = deitado ? ['direita', 'acima', 'abaixo', 'esquerda'] : ['acima', 'abaixo', 'direita', 'esquerda'];
+    const folga = { seguidos: 1, alternados: 2, esparsos: 3 }[EI.ritmo] || 1;
     const iconesUsados = new Set();
     const tetoIcones = Math.ceil(batidas.length * 0.45);
-    for (const b of batidas) {
-        if (iconesUsados.size >= tetoIcones) break;
+    let ultimoIcone = -99, nIcones = 0;
+    const atendidas = new Set();
+    // O svg do Iconify vem com 1em de lado: sai do tamanho da caixa.
+    const svgLimpo = (svg) => String(svg).replace(/\swidth="[^"]*"/, ' width="100%"').replace(/\sheight="[^"]*"/, ' height="100%"');
+    const porIcone = (b, ic, extra = {}) => {
+        const primeiro = { lado: lado1, 'outro-lado': lado2, canto: 'canto', alterna: nIcones % 2 ? lado2 : lado1 }[EI.arranjo] || lado1;
+        const lados = [primeiro, ...reserva.filter((l) => l !== primeiro)];
+        const prim = b.linhas[0];
+        const escala = primeiro === 'canto' ? 0.6 : 1;
+        b.icone3d = { icone: ic, lado: primeiro, lados, tamanho: Math.round((deitado ? 0.4 * H : 0.38 * W) * escala), material,
+            cor: b.cores.texto, cor2: b.cores.acento, luz: b.cores.acento, t: r3(Math.min(b.ate - 1, (prim ? prim.t : b.de) + 0.15)), ...extra };
+        b.acentos += 1;
+        if (b.acentos > REGRAS.acentos) { b.icone3d.cor2 = misturarCor(b.cores.texto, b.cores.fundo, 0.3); b.acentos -= 1; }
+        iconesUsados.add(ic); nIcones++;
+    };
+    for (const [bi, b] of batidas.entries()) {
+        const pedido = pedidoDe[b.parte];
+        if (pedido) {
+            // O pedido vale numa batida só da parte: a do conteúdo (a fala solta fica com a tipografia).
+            if (b.origem !== 'conteudo' || atendidas.has(b.parte) || b.produto3d) continue;
+            atendidas.add(b.parte);
+            if (/^(nenhum|nenhuma|nada|none)$/i.test(pedido)) continue;
+            if (ABSTRATOS.includes(pedido)) { b.heroiPedido = pedido; continue; }
+            if (ICONES3D.has(pedido)) { porIcone(b, pedido); ultimoIcone = bi; continue; }
+            if (/^[a-z0-9-]+:[a-z0-9-]+$/i.test(pedido) && icones[pedido]) {
+                porIcone(b, pedido, { svg: svgLimpo(icones[pedido]), cor: b.cores.acento, cor2: b.cores.texto });
+                ultimoIcone = bi;
+            }
+            continue;
+        }
+        if (nIcones >= tetoIcones) continue;
+        if (bi - ultimoIcone < folga) continue;
         if (b.produto3d || ['parede', 'marca', 'citacao', 'divisao'].includes(b.comp)) continue;
         const ditas = tokens(b.linhas.map((l) => l.texto).join(' ') + ' ' + ((partes[b.parte] && partes[b.parte].fala) || ''));
         const ic = ditas.map((w) => ICONE_DE[w]).find((x) => x && !iconesUsados.has(x));
         if (!ic) continue;
-        iconesUsados.add(ic);
-        const prim = b.linhas[0];
-        b.icone3d = { icone: ic, lado: deitado ? 'direita' : 'acima', tamanho: Math.round(deitado ? 0.4 * H : 0.38 * W), material,
-            cor: b.cores.texto, cor2: b.cores.acento, luz: b.cores.acento, t: r3(Math.min(b.ate - 1, (prim ? prim.t : b.de) + 0.15)) };
-        b.acentos += 1;
-        if (b.acentos > REGRAS.acentos) { b.icone3d.cor2 = misturarCor(b.cores.texto, b.cores.fundo, 0.3); b.acentos -= 1; }
+        porIcone(b, ic);
+        ultimoIcone = bi;
     }
 
-    /* ── o HERÓI GRÁFICO: toda batida tem uma ideia visual grande além do
-       texto, como no reel de referência — a explosão radial que nasce de um
-       ponto, o polígono que vira estrela e quadrado com partículas em órbita,
-       o campo de truchet com uma onda de cor, a esfera e o toro de pontos em
-       3D, os anéis de órbita, a grade que deforma, os rastros de velocidade.
-       Procedurais, da semente, na paleta da batida; nunca o mesmo seguido. ── */
-    const OBJETOS = ['explosao', 'poligono', 'esfera', 'toro'], CAMPOS_H = ['truchet', 'aneis', 'grade', 'rastro'];
-    const usosH = {};
-    let ultimoH = null;
-    const recentesH = [];
+    // A forma abstrata: a que o modelo pediu, ou a do projeto no assunto que aceita.
+    const OBJETOS = HEROIS_OBJETO;
+    const favorito = (ABSTRATO_DO_HUMOR[humor] || 0) > 0 ? E.herois[0] : null;
+    const tetoH = Math.ceil(batidas.length / 3);
+    let nH = 0, ultimoH = -9;
     batidas.forEach((b, i) => {
-        const ocupado = b.icone3d || b.produto3d;
-        let op = ocupado || ['gigante', 'parede', 'divisao'].includes(b.comp) ? CAMPOS_H : [...OBJETOS, ...CAMPOS_H];
-        if (b.comp === 'parede') op = ['aneis', 'rastro', 'grade'];
-        const w = {};
-        for (const h of op) {
-            let q = OBJETOS.includes(h) ? 2.2 : 1;
-            if (recentesH.slice(-3).includes(h)) q = 0;
-            if (h === 'truchet' && (usosH.truchet || 0) >= 1) q = 0;
-            if ((h === 'esfera' || h === 'toro') && (usosH[h] || 0) >= 1) q = 0;
-            q *= Math.pow(0.5, usosH[h] || 0);
-            w[h] = q;
-        }
-        // Tudo recente: o menos recente de todos os de campo.
-        const reserva = () => CAMPOS_H.filter((x) => !recentesH.slice(-3).includes(x))[0] || CAMPOS_H[0];
-        let h = i === 0 && b.comp === 'marca' ? 'explosao' : s.pesado(w) || reserva();
-        usosH[h] = (usosH[h] || 0) + 1;
-        ultimoH = h;
-        recentesH.push(h);
+        let h = b.heroiPedido || null;
+        if (!h && favorito && !b.icone3d && !b.produto3d && !pedidoDe[b.parte] && nH < tetoH && i - ultimoH >= 2
+            && !(OBJETOS.includes(favorito) && ['gigante', 'parede', 'divisao'].includes(b.comp))) h = favorito;
+        delete b.heroiPedido;
+        if (!h) return;
+        nH++; ultimoH = i;
         const comCor = b.acentos < REGRAS.acentos;
         if (comCor) b.acentos += 1;
         b.heroi = { tipo: h, modo: OBJETOS.includes(h) ? 'objeto' : 'campo', semente: hash(b.id + h) % 9973,
@@ -959,7 +1160,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         const a = batidas[i - 1];
         let tr;
         // O campo troca por corte seco, por cortina ou pela inundação do acento — independente do gesto do texto.
-        b.troca = a.campo === b.campo ? null : s.pesado({ corte: 5, cortina: 2.5, inunda: 1.5 });
+        // A primeira virada de seção é um corte seco (o reel corta); as outras, sorteadas.
+        b.troca = a.campo === b.campo ? null : !batidas.slice(1, i).some((x) => x.troca) ? 'corte' : s.pesado({ corte: 5, cortina: 2.5, inunda: 1.5 });
         if (b.troca === 'inunda' && s.chance(0.5)) tr = 'inunda';
         else {
             const tese = b.linhas.find((l) => l.papel === 'tese' || l.papel === 'numero');
@@ -1067,13 +1269,34 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         // Partículas em três profundidades: o espaço respira mesmo no repouso.
         particulas: Array.from({ length: 34 }, (_, i) => ({ x: r1(s.prox() * W), y: r1(s.prox() * H), z: [0.25, 0.5, 0.85][i % 3], r: r1((1.2 + s.prox() * 2.4) * base), v: r1(s.entre(6, 22) * base) })) };
     if (roteiro.particulas !== true) fundo.particulas = [];
+    // O ambiente e o jeito do acento: o roteiro, a escolha do projeto, ou o limpo e o traço.
+    fundo.ambiente = AMBIENTES.includes(roteiro.ambiente) ? roteiro.ambiente : E.ambiente || 'limpo';
+    fundo.acento = ACENTOS_JEITO.includes(roteiro.acento) ? roteiro.acento : E.acento || 'traco';
 
     return {
         versao: 1, semente, fps: FPS, humor,
-        musica: { genero: s.um(H0.generos), generos: H0.generos }, largura: W, altura: H, duracao, regras: REGRAS,
+        musica: { genero: ou(E.genero, s.um(H0.generos)), generos: H0.generos }, largura: W, altura: H, duracao, regras: REGRAS,
         paleta: { ...P, fundo: campos[0], tinta: campos[2], acento: campos[1] }, campos, fontes, eixos: Object.fromEntries(Object.values(fontes).map((f) => [f, (VARIAVEIS[f] || {}).eixos || { wght: [400, 700] }])),
         margem: M, fundo, batidas, camera, produtos,
-        hud: roteiro.hud === true ? { marca: String((marca.nome || roteiro.titulo || 'PrimoCode')).toUpperCase().slice(0, 24), ano: '2026' } : null,
+        identidade: { chaos: ident.chaos, acento: ident.acento, comeca: campos[comeca], fontes: [display, texto] }, secoes: secoes.nomes,
+        hud: molduraDe(roteiro, E, { W, H, deitado, marca, secoes: secoes.nomes }),
+    };
+}
+
+/* A moldura do vídeo: o pedido do roteiro (moldura, ou o hud antigo) manda;
+   sem pedido, a escolha do projeto; sem as duas, nenhuma. A ÁREA SEGURA: no
+   9:16 o celular cobre o alto (status, nome do perfil) e o pé (legenda,
+   botões) — a moldura fica dentro; no 16:9, margem fina e igual. */
+function molduraDe(roteiro, E, { W, H, deitado, marca, secoes }) {
+    const m = roteiro.moldura;
+    const tipo = m === false ? 'sem' : m === true ? 'completa' : MOLDURAS.includes(m) ? m : roteiro.hud === true ? 'completa' : E.moldura || 'sem';
+    if (tipo === 'sem') return null;
+    const assunto = String(marca.nome || roteiro.titulo || 'PrimoCode').split(/\s+[—–-]\s+/)[0];
+    const d = Math.round(Math.min(W, H) * 0.04);
+    return {
+        tipo, marca: assunto.toUpperCase().slice(0, deitado ? 32 : 22), ano: '2026',
+        secoes: secoes.map((n, i) => (String(n || '').toUpperCase().slice(0, deitado ? 26 : 16) || 'PARTE ' + (i + 1))),
+        area: deitado ? { x: d, topo: d, base: d } : { x: Math.round(W * 0.06), topo: Math.round(H * 0.08), base: Math.round(H * 0.15) },
     };
 }
 
@@ -1290,7 +1513,8 @@ function compor(comp, br, ctx) {
             b.bloco = { x: W / 2, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: larguraUtil, gap: 0.1 };
             linha(txt, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(900, VARIAVEIS[fonte].eixos.wght[1]) }, maiusc });
             b.textura = { texto: (maiusc ? txt.toUpperCase() : txt), tamanho: tam, fonte, linhas: Math.ceil(H / (tam * 1.02)) + 3, velocidade: Math.round(s.entre(40, 90) * base) };
-            b.acento.push({ forma: s.chance(0.5) ? 'moldura' : 'sublinha', alvo: { linha: b.linhas[0].id } });
+            // Moldura em volta da palavra é vício de "cara de IA" (a caixa na palavra-chave); sai em 08/10.
+            b.acento.push({ forma: s.chance(0.5) ? 'ponto' : 'sublinha', alvo: { linha: b.linhas[0].id } });
             break;
         }
         default: throw new Error('composição desconhecida: ' + comp);
@@ -1466,6 +1690,6 @@ function contarAcentos(b) {
 }
 
 module.exports = {
-    montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
-    especEixos, sorteador, hash, larguraEm, conteudoDe, casar,
+    montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, escolherVisual, MOLDURAS, AMBIENTES, ACENTOS_JEITO, ARRANJOS_ICONE, RITMOS_ICONE, MATERIAIS_ICONE, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
+    especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO,
 };

package/lib/estudio/hibrido.js

@@ -49,7 +49,7 @@ function traduzir(roteiro) {
     partes.forEach((p, i) => {
         const tipo = p.tipo || 'frase';
         const marcar = [p.destaque, ...(p.marcar || [])].filter(Boolean);
-        const base = { fala: p.fala, ...(p.mudo ? { mudo: true } : {}), ...(p.falaForte ? { falaForte: p.falaForte } : {}), marcar };
+        const base = { fala: p.fala, ...(p.mudo ? { mudo: true } : {}), ...(p.falaForte ? { falaForte: p.falaForte } : {}), ...(p.falante ? { falante: p.falante } : {}), marcar };
         let q;
         // Os tipos que o cinema já conhece passam como estão.
         if (['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'].includes(tipo)) q = { ...p };