primocode 10.11.1 → 10.13.0

package/lib/estudio/gerativo.js

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

package/lib/estudio/index.js

@@ -65,6 +65,7 @@ const gerativo = require('./gerativo.js');
 const fluido = require('./fluido.js');
 const vox = require('./vox.js');
 const kokoro = require('./kokoro.js');
+const voicestudio = require('./voicestudio.js');
 const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
 const personagem = require('./personagem.js');
@@ -77,6 +78,7 @@ const colecao = require('./colecao.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
 const semNarracao = require('./sem-narracao.js');
+const camadas = require('./camadas.js');
 const ende = require('./ende.js');
 const producao = require('./producao.js');
 
@@ -862,6 +864,80 @@ async function ferramentaVideo(args, ctx = {}) {
         };
     }
 
+    /* O VÍDEO EM CAMADAS (camadas.js, 14/10: "quero uma edição nesse nível"):
+       a pessoa só gravou a fala; a IA passa as batidas (forma do rosto, cena
+       de motion, destaque) e o Estúdio monta o bolo por cima. Sem batidas,
+       devolve uma proposta pela transcrição — a IA aceita ou muda. */
+    if (acao === 'camadas') {
+        const m = await video.medir(alvo);
+        if (!m.ok) return m;
+        // A transcrição fica guardada: a proposta e a montagem não pagam duas vezes.
+        const guardada = path.join(p.pasta, 'midia', `transcricao-${path.basename(alvo).replace(/\.[^.]+$/, '')}.json`);
+        let palavras = Array.isArray(args.palavras) && args.palavras.length ? args.palavras : null;
+        if (palavras) { try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ } }
+        if (!palavras && fs.existsSync(guardada)) { try { palavras = JSON.parse(fs.readFileSync(guardada, 'utf8')); } catch { palavras = null; } }
+        if (!palavras) {
+            const tr = await transcrever(p, alvo, ctx);
+            if (!tr.ok) return tr;
+            palavras = (tr.palavras && tr.palavras.length) ? tr.palavras : repartirTrechos(tr.trechos || []);
+            try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ }
+        }
+        const batidas = Array.isArray(args.batidas) && args.batidas.length ? args.batidas : null;
+        if (!batidas) {
+            return {
+                ok: true, proposta: camadas.propor(palavras, m.segundos), duracao: m.segundos,
+                comoUsar: 'é uma SUGESTÃO pela transcrição. Decida você: mude as formas, junte ou separe batidas, '
+                    + 'escreva a cena de motion de cada ideia (componentes/x.jsx, recebe {el, t, fps}; el.dados traz largura/altura do espaço livre, '
+                    + 'palavras com t, destaque, cores e fontes; a LEGENDA da fala já está no quadro, então a cena NÃO escreve a fala: desenha a ideia) ou use um efeito de fábrica pelo nome (estudio_midia acao:"efeitos"), '
+                    + 'e chame de novo com batidas:[{de, ate, rosto, cena?, destaque?, canto?, dados?}].',
+            };
+        }
+        // A cena: arquivo da pasta (conferido antes do render) ou efeito de fábrica pelo nome.
+        const problemas = [];
+        const prontas = batidas.map((b, i) => {
+            if (!b || !b.cena) return b;
+            const cena = String(b.cena).trim();
+            if (/[\\/]|\.(jsx|tsx|js)$/i.test(cena)) {
+                const cheio = dentro(cena);
+                if (!cheio || !fs.existsSync(cheio)) { problemas.push(`batidas[${i}]: a cena "${cena}" não está na pasta do projeto.`); return { ...b, cena: null }; }
+                const conf = conferirCena(cheio);
+                if (!conf.ok) { problemas.push(`batidas[${i}]: ${cena} — ${conf.erro}`); return { ...b, cena: null }; }
+                return { ...b, cena };
+            }
+            const r = efeitos.reusar({ pasta: p.pasta, nome: cena });
+            if (!r.ok) { problemas.push(`batidas[${i}]: ${r.error}`); return { ...b, cena: null }; }
+            return { ...b, cena: r.src };
+        });
+        if (problemas.length) return { ok: false, error: 'as cenas têm problema — conserte e mande de novo.', problemas };
+
+        /* A voz no volume de vídeo de internet (-15 LUFS), como na edição
+           automática; o vídeo em si não é recodificado. */
+        let fonte = alvo;
+        if (args.normalizar !== false) {
+            const normal = path.join(p.pasta, 'midia', `voz-normal-${path.basename(alvo).replace(/\.[^.]+$/, '')}.mp4`);
+            if (!fs.existsSync(normal)) {
+                await video.rodar(video.ffmpeg(), ['-y', '-i', alvo, '-c:v', 'copy',
+                    '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+            }
+            if (fs.existsSync(normal)) fonte = normal;
+        }
+        const deitado = m.largura > m.altura;
+        const montado = camadas.montar({
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'), duracao: m.segundos, palavras, batidas: prontas,
+            largura: deitado ? 1920 : 1080, altura: deitado ? 1080 : 1920, fps: 30,
+            origem: { largura: m.largura, altura: m.altura }, rosto: args.rosto || {}, acento: args.acento,
+            sons: sonsLeves.preparar(p.pasta),
+        });
+        if (!montado.ok) return montado;
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `vídeo em camadas (${montado.resumo.batidas} batidas)` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `camadas: ${montado.resumo.batidas} batidas, ${montado.resumo.cenas} cenas de motion, ${montado.resumo.trocasDeForma} trocas de forma`);
+        return {
+            ok: true, ...montado.resumo, batidas: montado.batidas, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Para mudar uma batida, chame camadas de novo com a lista inteira.',
+        };
+    }
+
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
         const r = await rodarPessoa([
@@ -1102,6 +1178,35 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     }
 }
 
+/* A VOZ DO VOICESTUDIO (15/10): o app local fala o roteiro inteiro, e o resto
+   é o caminho do Gemini — volume de Reels, a transcrição para achar as partes.
+   Fechado ou falhando, devolve ok:false e a cadeia segue para o Gemini. */
+async function narrarComVoiceStudio(lista, mp3, { voz } = {}) {
+    if (process.env.PRIMOCODE_SEM_VOICESTUDIO) return { ok: false, indisponivel: true, error: 'voicestudio desligado' };
+    try {
+        const texto = lista.map((x) => x.texto).join('\n\n');
+        // A voz do Gemini ("Kore", "Charon") não existe lá: só um perfil do próprio app.
+        const perfil = /^vs:/i.test(String(voz || '')) ? String(voz).slice(3) : undefined;
+        const r = await voicestudio.falar(texto, { voz: perfil });
+        if (!r.ok) return r;
+        const bruto = mp3.replace(/\.mp3$/, '-vs.mp3');
+        fs.writeFileSync(bruto, r.audio);
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-i', bruto, '-af', 'loudnorm=I=-14:TP=-1.5:LRA=9', '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+        try { fs.unlinkSync(bruto); } catch { /* fica */ }
+        if (!c.ok) return { ok: false, error: 'voicestudio: não consegui converter a voz' };
+        const med = await video.medir(mp3);
+        const chars = lista.reduce((n, x) => n + x.texto.length, 0);
+        if (med.segundos < chars / 22) return { ok: false, error: `voicestudio: a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
+        const cfg = require('../config').loadConfig();
+        const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+        const palavras = (tr && tr.palavras) || [];
+        if (!palavras.length) return { ok: false, error: 'voicestudio: sem a transcrição da voz para achar as partes' };
+        return { ok: true, voz: `voicestudio ${perfil || 'default'}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+    } catch (e) {
+        return { ok: false, error: 'voicestudio: ' + e.message };
+    }
+}
+
 /* Onde estão os rostos em cada foto (studio/rostos.py, pelo uv). Guardado no
    projeto: a mesma foto não é analisada duas vezes. */
 async function acharRostos(p, srcs) {
@@ -1195,7 +1300,9 @@ async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
     if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
     // A voz local pedida (voz: 'kokoro'): direto nela, sem gastar a cota do Gemini.
     if (kokoro.querKokoro(voz)) return kokoro.narrar(lista, mp3, { voz, uv: acharUv() });
-    const v = await narrarComGemini(lista, mp3, { voz, direcao });
+    // O VoiceStudio local primeiro (15/10); fechado ou falhando, o Gemini.
+    let v = await narrarComVoiceStudio(lista, mp3, { voz });
+    if (!v.ok) v = await narrarComGemini(lista, mp3, { voz, direcao });
     if (v.ok) { try { fs.mkdirSync(dir, { recursive: true }); fs.copyFileSync(mp3, cm); fs.writeFileSync(cj, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ } }
     return v;
 }
@@ -1214,6 +1321,7 @@ async function produzirNecessidade(p, roteiro, pedido, provedores) {
    direção dele), o Kokoro local e o Edge. A falha de uma passa para a próxima. */
 function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini, escolha } = {}) {
     const todos = {
+        voicestudio: () => narrarComVoiceStudio(lista, mp3, { voz }),
         gemini: () => gemini(),
         kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
         edge: () => {
@@ -1232,7 +1340,7 @@ function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini
 /* A VOZ DE RESERVA, quando o Gemini falha: o Kokoro (local, sem cota) e
    depois o Edge. A falha de uma passa para a próxima, nunca derruba. */
 function narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge = false, semKokoro = false } = {}) {
-    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && !(semKokoro && n === 'kokoro'));
+    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && n !== 'voicestudio' && !(semKokoro && n === 'kokoro'));
     return kokoro.corrente(passos, {
         kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
         edge: () => rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', kokoro.vozNoEdge(voz, vozEdge)], { timeout: 10 * 60000 }),

package/lib/estudio/kit/gerativo.jsx

@@ -295,6 +295,21 @@ function geometria(a, b, L, P) {
     for (let i = 0; i < N; i++) { const q = -2.3 + (i / (N - 1)) * Math.PI * 2 * 1.1; const e = 1 + (i / N) * 0.07; pts.push([ccx + Math.cos(q) * rx * e, ccy + Math.sin(q) * ry * e]); }
     return { pts, larg: Math.max(4 * base, cx.s * 0.03), alfa: 1, frente: true, cx: ccx, cy: ccy };
   }
+  if (f === 'visto') {
+    /* O ✓ de caneta (15/10, as referências): depois do círculo, ao lado da
+       palavra, em dois traços; se não cabe à direita, encosta na margem. */
+    const pw = alvoPalavra();
+    const s = cx.s, cy0 = cx.y + cx.h * 0.5;
+    const A = [pw.x + pw.w + s * 0.16, cy0], B = [pw.x + pw.w + s * 0.27, cy0 + s * 0.2], C = [pw.x + pw.w + s * 0.52, cy0 - s * 0.3];
+    const dx = Math.min(0, P.largura - 24 * base - C[0]);
+    const q = 0.3;
+    for (let i = 0; i < N; i++) {
+      const k = i / (N - 1);
+      const [p0, p1, u] = k < q ? [A, B, k / q] : [B, C, (k - q) / (1 - q)];
+      pts.push([lerp(p0[0], p1[0], u) + dx, lerp(p0[1], p1[1], u)]);
+    }
+    return { pts, larg: Math.max(5 * base, s * 0.045), alfa: 1, frente: true, tampa: 'round', cx: B[0] + dx, cy: B[1] };
+  }
   if (f === 'barra') {
     // O vão da barra é o respiro do vídeo (margem.js): colada, ela riscava a primeira letra.
     // A deriva da vida abre as letras até 3% da linha para fora: a barra recua junto.

package/lib/estudio/kit/index.jsx

@@ -12,6 +12,7 @@ import { FLUIDO } from './fluido';
 import { PERSONAGEM } from './personagem';
 import { VOXEL } from './voxel';
 import { ANIMACAO } from './animacao';
+import { ROSTO } from './rosto';
 
-export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, ...VOXEL, ...ANIMACAO, papel: Papel };
+export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, ...VOXEL, ...ANIMACAO, ...ROSTO, papel: Papel };
 export { Filtros, Acabamento, Hud, CURVAS_KIT, bolhaCaminho } from './base';

package/lib/estudio/kit/rosto.jsx

@@ -0,0 +1,108 @@
+/* kit/rosto.jsx — o rosto de quem fala, que muda de forma (camadas.js).
+ *
+ *   "o vídeo da pessoa é contínuo, mas o ROSTO muda de forma: tela cheia,
+ *    cartão com borda que brilha, bolinha no canto, some" (Joel, 14/10)
+ *
+ * Duas peças:
+ *  - palco: o fundo escuro com brilho que respira e grão (o que aparece
+ *    quando o rosto não ocupa a tela);
+ *  - rosto: a gravação dentro de uma caixa que vai de `antes` para `agora`
+ *    com mola (kit/natural.js): recua um tico (antecipação), vai, passa do
+ *    ponto e assenta. A gravação começa em `deOrigem` e NÃO reinicia: cada
+ *    cena pega do ponto em que a anterior parou, e o áudio dela é a fala do
+ *    vídeo. Quando "some", o vídeo continua tocando, só invisível.
+ * A geometria (onde fica cada caixa) vem pronta do camadas.js; aqui só se
+ * interpola. Nada de sorteio: o mesmo quadro sai igual sempre. */
+import React from 'react';
+import { AbsoluteFill, Video, staticFile, useVideoConfig } from 'remotion';
+import { mola, ruido } from './natural';
+
+const lerp = (a, b, k) => a + (b - a) * k;
+const clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+const CAMPOS = ['x', 'y', 'w', 'h', 'raio', 'anel', 'zoom', 'fx', 'fy'];
+
+/** A caixa no instante t (s) da cena. */
+export function caixaNoTempo(el, t) {
+  const B = el.agora || el.antes || {};
+  const A = el.antes || B;
+  if (!el.mudou) return { ...B };
+  const s = t - 0.05;
+  // A mola com peso: um pouco de sobra, e assenta em ~0,6 s.
+  const k = mola(s, { freq: 1.55, amort: 0.62 });
+  const kc = clamp(k, 0, 1);
+  // A antecipação: antes de ir, a caixa encolhe um tico (o "respiro" do gesto).
+  const prep = s > 0 && s < 0.14 ? Math.sin(Math.PI * (s / 0.14)) * 0.035 : 0;
+  const o = {};
+  for (const c of CAMPOS) o[c] = lerp(A[c] ?? B[c] ?? 0, B[c] ?? A[c] ?? 0, k);
+  o.raio = Math.max(0, o.raio);
+  o.anel = Math.max(0, o.anel);
+  o.w = Math.max(1, o.w); o.h = Math.max(1, o.h);
+  o.opacidade = lerp(A.opacidade ?? 1, B.opacidade ?? 1, kc);
+  o.escala = Math.max(0, lerp(A.escala ?? 1, B.escala ?? 1, k)) * (1 - prep);
+  return o;
+}
+
+export function Rosto({ el, t, fps }) {
+  const c = caixaNoTempo(el, t);
+  const ac = el.acento || '#8B7CF6';
+  const origem = el.origem || {};
+  const sw = origem.largura || 1080, sh = origem.altura || 1920;
+  // A gravação cobre a caixa (cover) com o zoom, e o rosto (fx, fy) vai para o centro, acima do meio (o queixo longe da legenda).
+  const s = Math.max(c.w / sw, c.h / sh) * Math.max(1, c.zoom || 1);
+  const vw = sw * s, vh = sh * s;
+  const left = clamp(c.w * 0.5 - (c.fx ?? 0.5) * vw, c.w - vw, 0);
+  const top = clamp(c.h * 0.38 - (c.fy ?? 0.4) * vh, c.h - vh, 0);
+  // A bolinha e o cartão flutuam de leve: parado de todo parece colado.
+  const flutua = el.forma === 'bolinha' || el.forma === 'cartao' ? ruido(t * 0.35, 11) * 4 : 0;
+  const anel = c.anel;
+  const brilho = anel > 0
+    ? `0 0 ${Math.round(18 + anel * 5)}px ${ac}88, 0 0 ${Math.round(60 + anel * 10)}px ${ac}33, 0 26px 70px rgba(0,0,0,.6)`
+    : 'none';
+  return (
+    <div style={{
+      position: 'absolute', left: c.x, top: c.y + flutua, width: c.w, height: c.h,
+      transform: `scale(${c.escala})`, transformOrigin: '50% 50%', opacity: c.opacidade,
+      borderRadius: c.raio, padding: anel,
+      // A borda que brilha: um degradê do acento ao branco, por trás do vídeo.
+      background: anel > 0 ? `linear-gradient(150deg, #ffffffcc, ${ac} 38%, ${ac}aa 70%, #ffffff88)` : 'transparent',
+      boxShadow: brilho, boxSizing: 'border-box',
+    }}>
+      <div style={{ position: 'relative', width: '100%', height: '100%', overflow: 'hidden', borderRadius: Math.max(0, c.raio - anel), background: '#000' }}>
+        <Video
+          src={staticFile(el.src)}
+          startFrom={el.deOrigem ? Math.round(el.deOrigem * fps) : undefined}
+          volume={el.volume ?? 1}
+          style={{ position: 'absolute', left, top, width: vw, height: vh, maxWidth: 'none' }}
+        />
+      </div>
+    </div>
+  );
+}
+
+/** O palco: preto azulado, dois brilhos que derivam devagar, vinheta e grão. */
+export function Palco({ el, t }) {
+  const { width: W, height: H } = useVideoConfig();
+  const ac = el.acento || '#8B7CF6';
+  const dx = ruido(t * 0.12, 3 + (el.semente || 0)) * 7;
+  const dy = ruido(t * 0.1, 7 + (el.semente || 0)) * 5;
+  const quadro = Math.floor(t * 24);
+  const id = 'grao-' + (el.semente || 0);
+  return (
+    <AbsoluteFill style={{ background: '#07060c', overflow: 'hidden' }}>
+      <div style={{ position: 'absolute', inset: 0, background:
+        `radial-gradient(55% 38% at ${50 + dx}% ${58 + dy}%, ${ac}40, transparent 72%),`
+        + `radial-gradient(45% 30% at ${16 - dx}% ${16 - dy}%, #4f46e526, transparent 70%),`
+        + `radial-gradient(70% 45% at ${80 + dy}% ${96}%, #1d4ed838, transparent 72%)` }} />
+      <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(120% 80% at 50% 45%, transparent 55%, rgba(0,0,0,.55) 100%)' }} />
+      <svg width={W} height={H} style={{ position: 'absolute', inset: 0, opacity: el.grao ?? 0.13, mixBlendMode: 'screen' }}>
+        <filter id={id}>
+          <feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves="2" seed={quadro % 61} stitchTiles="stitch" />
+          <feColorMatrix type="matrix" values="0 0 0 0 1  0 0 0 0 1  0 0 0 0 1  0 0 0 1.1 -0.45" />
+        </filter>
+        <rect width="100%" height="100%" filter={`url(#${id})`} />
+      </svg>
+    </AbsoluteFill>
+  );
+}
+
+export const ROSTO = { rosto: Rosto, palco: Palco };

package/lib/estudio/kit.js

@@ -65,9 +65,12 @@ const PECAS = {
     voxel: { precisa: ['partitura'] },
     // A animação pronta da biblioteca (kit/animacao.jsx, colecao.js): o Lottie tocado quadro a quadro.
     animacao: { precisa: ['src'] },
+    // O vídeo em camadas (kit/rosto.jsx, camadas.js): a gravação que muda de forma, e o palco escuro atrás dela.
+    rosto: { precisa: ['src'] },
+    palco: {},
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'natural.js', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'rosto.jsx', 'natural.js', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/kokoro.js

@@ -94,7 +94,9 @@ async function narrar(lista, mp3, { voz, uv, espeak = acharEspeak(), executar =
     roteiro pula as outras. */
 function ordem(voz, env = process.env, { soEdge = false } = {}) {
     if (soEdge) return ['edge'];
-    return querKokoro(voz, env) ? ['kokoro', 'edge'] : ['gemini', 'edge', 'kokoro'];
+    if (querKokoro(voz, env)) return ['kokoro', 'edge'];
+    // O VoiceStudio local vem primeiro (15/10); fechado, a cadeia segue para o Gemini na hora.
+    return env.PRIMOCODE_SEM_VOICESTUDIO ? ['gemini', 'edge', 'kokoro'] : ['voicestudio', 'gemini', 'edge', 'kokoro'];
 }
 
 /* A voz do Gemini no Edge: o narrar.py só conhece antonio, francisca e

package/lib/estudio/remotion.js

@@ -108,9 +108,9 @@ import { KIT, CURVAS_KIT, Filtros } from './kit';
 import { COMPONENTES } from './componentes';
 
 /* ── SUAVIZAÇÃO ──────────────────────────────────────────────────────────
- * Cada curva é uma função de 0..1 em 0..1. "suave" é o padrão porque
- * movimento linear é o que mais denuncia animação feita por máquina: nada no
- * mundo físico começa e para na mesma velocidade. */
+ * Cada curva é uma função de 0..1 em 0..1. A "editorial" é o padrão (15/10):
+ * movimento linear denuncia máquina, e o entra-e-sai devagar da "suave" lia
+ * como fade; as referências atacam rápido e desaceleram forte. */
 const CURVAS = {
   linear: (t) => t,
   suave: (t) => (t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2),
@@ -143,7 +143,9 @@ function valorEm(trilha, t, padrao) {
     const a = trilha[i], b = trilha[i + 1];
     if (t >= a.t && t <= b.t) {
       const bruto = b.t === a.t ? 1 : (t - a.t) / (b.t - a.t);
-      const curva = CURVAS[b.e || a.e || 'suave'] || CURVAS.suave;
+      /* (15/10, as referências) Sem curva dita, a editorial: ataque rápido e
+         desaceleração forte. A "suave" (entra e sai devagar) lia como fade. */
+      const curva = CURVAS[b.e || a.e || 'editorial'] || CURVAS.editorial;
       const k = curva(bruto);
       /* Texto no lugar do número: é COR ("#ff6a00") ou CAMINHO (o "d" de um
          SVG). A cor mistura; o caminho se deforma (morfar.js): a bolinha

package/lib/estudio/revisor.js

@@ -16,6 +16,8 @@
  *   avisa     a mesma sequência de elementos em 4+ cenas seguidas (cara de template)
  *   avisa     imagem sem a pessoa pedir, ou imagem em mais da metade das cenas
  *   conserta  efeito sonoro demais (mais de 1 a cada 1,5 s) → ficam os mais altos
+ *   avisa     texto pequeno demais para o celular (< 2% da altura no 9:16)
+ *   avisa     texto com contraste abaixo de 3:1 contra o fundo da cena
  * Puro: o plano entra, o plano consertado e a lista saem.
  */
 
@@ -34,6 +36,62 @@ const palavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
 // Imagem ou vídeo DE FORA: o vídeo da própria gravação (deOrigem) e o recorte da pessoa não contam.
 const imagemDeFora = (el) => el && (el.tipo === 'imagem' || (el.tipo === 'video' && el.deOrigem == null && !/pessoa-/.test(el.src || '')));
 
+/* O TEXTO QUE NÃO SE LÊ (15/10, as referências): rótulo de 1,6% da altura
+   ("NO COADOR") e laranja sobre bege. Nas referências a palavra principal
+   ocupa 55–85% da largura e a segunda voz ~5% da altura, sempre em contraste
+   duro. Contraste é o da WCAG para texto grande (3:1). */
+const hex6 = (c) => {
+    const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(String(c || '').trim());
+    if (!m) return null;
+    const h = m[1].length === 3 ? m[1].split('').map((x) => x + x).join('') : m[1];
+    return [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16) / 255);
+};
+const luminancia = (c) => {
+    const v = hex6(c);
+    if (!v) return null;
+    const [r, g, b] = v.map((x) => (x <= 0.03928 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4)));
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+function contraste(a, b) {
+    const la = luminancia(a), lb = luminancia(b);
+    if (la == null || lb == null) return null;
+    return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+const corDoFundo = (f) => (typeof f === 'string' ? f : f && (f.valor || f.cor)) || null;
+
+function revisarLeitura(plano, avisos) {
+    const W = Number(plano.formato && plano.formato.largura) || 1920, H = Number(plano.formato && plano.formato.altura) || 1080;
+    const piso = H * (W > H ? 0.024 : 0.019);
+    const curto = (t) => String(t || '').slice(0, 24);
+    const pequenos = [], apagados = [];
+    (plano.cenas || []).forEach((c, i) => {
+        const fundo = corDoFundo(c.fundo) || plano.fundoGeral;
+        for (const e of c.elementos || []) {
+            if (!e) continue;
+            if (e.tipo === 'texto') {
+                const tam = Number(e.tamanho || (e.estilo && e.estilo.tamanho));
+                if (tam && tam < piso) pequenos.push(`cena ${i + 1} "${curto(e.texto)}" ${r2((tam / H) * 100)}%`);
+                const k = contraste(e.cor || (e.estilo && e.estilo.cor), fundo);
+                if (k != null && k < 3) apagados.push(`cena ${i + 1} "${curto(e.texto)}" ${r2(k)}:1`);
+            }
+            if (e.tipo === 'kit' && e.peca === 'gerativo' && e.partitura) {
+                const Hp = Number(e.partitura.altura) || H;
+                const pisoP = Hp * ((Number(e.partitura.largura) || W) > Hp ? 0.024 : 0.019);
+                for (const b of e.partitura.batidas || []) {
+                    const cores = b.cores || {};
+                    for (const l of b.linhas || []) {
+                        if (l.tamanho && l.tamanho < pisoP) pequenos.push(`batida ${r2(b.de)}s "${curto(l.texto)}" ${r2((l.tamanho / Hp) * 100)}%`);
+                    }
+                    const k = contraste(cores.texto, cores.fundo);
+                    if (k != null && k < 3) apagados.push(`batida ${r2(b.de)}s ${cores.texto} sobre ${cores.fundo} ${r2(k)}:1`);
+                }
+            }
+        }
+    });
+    if (pequenos.length) avisos.push(`texto pequeno demais para o celular (piso ~2% da altura): ${pequenos.slice(0, 3).join('; ')}${pequenos.length > 3 ? ` e mais ${pequenos.length - 3}` : ''}`);
+    if (apagados.length) avisos.push(`texto com contraste abaixo de 3:1 contra o fundo: ${apagados.slice(0, 3).join('; ')}${apagados.length > 3 ? ` e mais ${apagados.length - 3}` : ''}`);
+}
+
 function revisar(plano, { semImagem = false } = {}) {
     const consertos = [], avisos = [];
     const cenas = (plano && plano.cenas) || [];
@@ -114,6 +172,9 @@ function revisar(plano, { semImagem = false } = {}) {
     if (semImagem && comImagem) avisos.push(`${comImagem} cena(s) com imagem de fora, mas a pessoa não pediu imagem`);
     else if (cenas.length >= 4 && comImagem / cenas.length > 0.5) avisos.push(`imagem em ${comImagem} de ${cenas.length} cenas — a imagem é um momento, não o vídeo inteiro`);
 
+    // 7. O texto que não se lê: pequeno demais ou sem contraste.
+    revisarLeitura(plano, avisos);
+
     return { plano, consertos, avisos };
 }