primocode 10.0.0 → 10.1.0

package/lib/estudio/cinema.js

@@ -27,6 +27,7 @@
 'use strict';
 
 const { caber } = require('./composicao.js');
+const { minimoLeitura, sobra } = require('./legibilidade.js');
 
 const r2 = (n) => Math.round(n * 100) / 100;
 const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
@@ -34,7 +35,8 @@ const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').t
 /** Quanto tempo um texto precisa ficar na tela para ser lido. Nunca menos que
     0,3 s por palavra: a regra de legibilidade do /brag (Arthur, 28/09). */
 const nPalavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
-const leitura = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
+const SAIDA_MIN = 0.1, ENTRA_NUM = 0.4;   // a saída mais curta; o número contando antes de ser lido
+const leituraCheia = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
 
 /** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
 /* A voz lê EXATAMENTE o que está na tela, na ordem da tela ("a narração tem
@@ -94,15 +96,26 @@ function quando(textos, palavras, dur, t0 = 0.25) {
     });
 }
 
-function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {} }) {
+function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {}, ritmoLeitura = 1 }) {
+    /* O tempo de ler cada texto, escalado: o cinema puro dá o tempo inteiro
+       (1); o híbrido, que tem b-roll trocando por baixo e texto curto, dá
+       pouco mais da metade — senão a cena espera muito depois da voz. */
+    const leitura = (t) => leituraCheia(t) * ritmoLeitura;
     const partes = (roteiro && roteiro.partes) || [];
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
     const marca = roteiro.marca || {};
-    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : ['#2E81ED', '#9567DB'];
-    const PRETO = (marca.cores && marca.cores.fundo) || '#07070A';
+    /* O destaque é o da MARCA: sem gradiente declarado, a cor de destaque dela
+       vira o gradiente (antes caía no roxo da Paris em toda marca). */
+    const corD = marca.cores && /^#[0-9a-f]{6}$/i.test(marca.cores.destaque || '') ? marca.cores.destaque : null;
+    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : corD ? [corD, corD] : ['#2E81ED', '#9567DB'];
+    /* O cinema é ESCURO: o texto é branco. Marca de fundo claro (a Anthropic é
+       branca) deixava o texto invisível — o fundo dela só vale se for escuro. */
+    const luz = (h) => { const n = parseInt(String(h).slice(1), 16); return ((n >> 16 & 255) * 0.299 + (n >> 8 & 255) * 0.587 + (n & 255) * 0.114) / 255; };
+    const fundoMarca = marca.cores && /^#[0-9a-f]{6}$/i.test(marca.cores.fundo || '') ? marca.cores.fundo : null;
+    const PRETO = fundoMarca && luz(fundoMarca) < 0.25 ? fundoMarca : '#07070A';
     const BRANCO = '#F5F5F7';
     const DEST = grad[1];
-    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter' };
+    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter', destaque: 'Instrument Serif' };
     const W = largura, H = altura, deitado = W >= H;
     const M = Math.round(Math.min(W, H) * 0.08), W0 = W - 2 * M;
     const base = Math.min(W, H);
@@ -169,26 +182,36 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             fundo: { tipo: 'gradiente', cores: [`rgba(7,7,10,${veu * 0.7})`, `rgba(7,7,10,${veu})`, `rgba(7,7,10,${Math.min(0.95, veu + 0.25)})`], angulo: 180 } });
     };
     // O texto: entra palavra por palavra no tempo da voz e fica; as palavras marcadas no gradiente.
-    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
+    /* SEM CARA DE IA (05/10): o texto sai como a pessoa escreveu (nada de caixa
+       alta forçada), um pouco menor e com mais respiro — e a palavra marcada é
+       UM acento, na serifa em itálico. Caixa alta só com "caixa: true". */
+    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = false, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
+        max *= 0.85; peso = Math.min(peso, 700);
         // Frase longa (a narração na tela) vai em letra normal: em caixa alta ela encolhe e cansa.
-        if (caixa && String(texto).split(/\s+/).length > 7) { caixa = false; peso = Math.min(peso, 700); }
+        if (caixa && String(texto).split(/\s+/).length > 7) caixa = false;
         // Frase longa ganha linhas (no vertical, até 5), para a letra não encolher.
         if (String(texto).split(/\s+/).length > 7) linhas = Math.max(linhas, deitado ? 4 : 5);
         const txt = caixa ? String(texto).toUpperCase() : String(texto);
-        const fit = caber(txt, { largura: larg * 0.86, linhas, max, fonte: F.titulo });
-        const h = fit.tamanho * 1.08 * fit.linhas;
+        const fit = caber(txt, { largura: larg * 0.78, linhas, max, fonte: F.titulo });
+        const h = fit.tamanho * 1.14 * fit.linhas;
         const ws = txt.split(/\s+/);
         /* Centralizado, a linha entra inteira: palavra por palavra, as que ainda
            não foram ditas ocupam espaço invisível e o começo da frase aparece
            torto, puxado para a esquerda. Alinhado à esquerda, palavra por palavra. */
         const rev = ws.map((_, k) => (alinhar === 'center' ? 0 : r2(Math.max(0, (pal[k] != null ? pal[k] : de + 0.08 * k) - de))));
-        const idx = ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0);
-        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.08, espacamento: caixa ? 1 : 0,
+        // Uma palavra só, e só em frase de mais de uma palavra (a palavra sozinha não tem com quem contrastar).
+        const idx = ws.length < 2 ? [] : ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0).slice(0, 1);
+        /* Entra rápido, FICA parado o tempo de ler, e só então sai (a lei do
+           /brag). Cena curta encolhe a entrada e a saída, nunca a leitura. */
+        const vida = ate - de, ler = minimoLeitura(txt);
+        const ent = bater ? sobra(vida - SAIDA_MIN, ler, 0.08, 0.22) : 0, fe = ent / 0.22;
+        const saida = r2(sobra(vida - ent, ler, SAIDA_MIN, 0.25));
+        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.14, espacamento: caixa ? 1 : -0.5,
             x: Math.round(x), y: Math.round(y == null ? (H - h) / 2 : y), largura: Math.round(larg), alinhamento: alinhar, de: r2(de), ate: r2(ate),
-            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST } : {}),
-            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
+            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST, fonteDestaque: F.destaque } : {}),
+            anima: { opacidade: [{ t: 0, v: 1 }, { t: r2(Math.max(0.01, vida - saida)), v: 1 }, { t: r2(vida), v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
                 // O texto que BATE no fundo: entra grande e assenta de uma vez.
-                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: 0.12, v: 0.97, e: 'saida' }, { t: 0.22, v: 1 }] } : {}) } });
+                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: r2(0.12 * fe), v: 0.97, e: 'saida' }, { t: r2(ent), v: 1 }] } : {}) } });
         return h;
     };
     const linhaFina = (els, y, de, larg = W * 0.18) => els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - larg) / 2), y: Math.round(y), largura: Math.round(larg), altura: 2,
@@ -231,9 +254,14 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
            com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
            a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
         // Texto curto (um número, "3 DIAS.") se lê de relance: não espera a leitura cheia e não atrasa a voz.
-        const minimo = (x) => Math.max(0.3 * nPalavras(x), Math.min(leitura(x), nPalavras(x) <= 3 ? 0.75 : 1.6));
-        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + minimo(textosDaParte[k - 1])));
-        if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
+        /* E nunca menos que a lei do /brag (0,8 s parado) mais a saída mínima; o
+           número ainda conta antes de ser lido (ENTRA_NUM). */
+        const minimo = (x) => Math.max(minimoLeitura(x) + SAIDA_MIN, Math.min(leitura(x), nPalavras(x) <= 3 ? 0.75 : 1.6)) + (p.tipo === 'numeros' ? ENTRA_NUM : 0);
+        const espacar = (passo = 0) => {
+            for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + Math.max(passo, minimo(textosDaParte[k - 1]))));
+            if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + Math.max(leitura(textosDaParte[inicios.length - 1]), minimo(textosDaParte[inicios.length - 1])) + 0.3));
+        };
+        espacar();
         const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);
         const palDo = (txt) => { const ws = String(txt).split(/\s+/); const a = pals.findIndex((w) => tokens(w.texto)[0] === tokens(ws[0])[0]); return a < 0 ? [] : ws.map((_, k) => (pals[a + k] ? rel(pals[a + k].de) : null)); };
 
@@ -245,11 +273,13 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             const rap = p.tipo === 'climax' ? 0.38 : (p.ritmo || 0.75);
             let fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
             const fz = p.tipo === 'climax' ? fortes[i] : null;
+            // A virada começa quando as fotos acabam: o texto não perde a leitura para a montagem.
+            if (p.tipo === 'climax' && !fz && inicios.length) { inicios[0] = r2(Math.max(inicios[0], fimFotos)); espacar(1.2); }
             if (fz) {
                 /* A voz forte entra DEPOIS da montagem, junto com o texto que bate. */
                 fimFotos = 1.4;
                 const ini2 = quando(textosDaParte, (fz.palavras || []).map((w) => ({ ...w, de: w.de + fimFotos })), fz.segundos, fimFotos);
-                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + 1.2); });
+                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + Math.max(1.2, minimo(textosDaParte[k - 1]))); });
                 dur = r2(Math.max(fimFotos + fz.segundos + 0.5, inicios[inicios.length - 1] + 1.6));
                 const tr = trechos[trechos.length - 1];
                 if (tr && tr.src === fz.src) tr.t = r2(t + fimFotos - 0.05);
@@ -279,13 +309,21 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             vol(t, 0.3);
             for (let a = 0; a < dur; a += 1.2) pFoto(els, foto(), a, Math.min(dur, a + 1.2), { veu: 0.45 });
             textosDaParte.forEach((x, k) => {
-                const m = String(x).match(/^(\d+)\s+(.*)$/);
+                /* O valor pode vir com prefixo e unidade: "até 30% mais barato", "+120
+                   marcas", "2,5x mais rápido". O contador sobe só a parte numérica e
+                   mantém o resto em volta (contar.antes / contar.depois). */
+                const mv = String(x).match(/^((?:at[ée]|mais de|\+|-)?\s*)(\d+(?:[.,]\d+)?)(\s?(?:%|x|mil|mi|bi|k|h|s|min)?)\s+(.*)$/i);
+                const m = mv ? [x, mv[2], mv[4]] : null;
                 if (k === 0 && p.antes) { pTexto(els, x, inicios[k], fimDe(k), { max: base * 0.08, peso: 700, pal: palDo(x) }); return; }
                 if (!m) { pTexto(els, x, inicios[k], fimDe(k), { pal: palDo(x) }); return; }
-                const tam = Math.round(deitado ? H * 0.24 : W * 0.3);
-                els.push({ tipo: 'texto', texto: m[1], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
-                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1]), dur: 0.45 }, gradienteTexto: undefined,
-                    anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.25, v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: 0.6, v: 1, e: 'saida' }] } });
+                // O número inteiro numa linha: "ATÉ 30%" em pé quebrava em duas, por cima do rótulo.
+                const larguraNum = String(mv[1] + m[1] + mv[3]).length * 0.8;   // serifa larga: 0,62 ainda quebrava
+                const tam = Math.round(Math.min(deitado ? H * 0.24 : W * 0.3, (W0 * 0.96) / Math.max(1, larguraNum)));
+                const casas = /[.,]/.test(m[1]) ? 1 : 0;
+                const entN = r2(sobra(fimDe(k) - inicios[k], minimoLeitura(m[1]), 0.3, 0.6));
+                els.push({ tipo: 'texto', texto: mv[1] + m[1] + mv[3], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
+                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1].replace(',', '.')), dur: entN, casas, antes: mv[1].toUpperCase(), depois: mv[3] }, gradienteTexto: undefined,
+                    anima: { opacidade: [{ t: 0, v: 0 }, { t: Math.min(0.25, entN), v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: entN, v: 1, e: 'saida' }] } });
                 pTexto(els, m[2], inicios[k] + 0.1, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
             });
         } else if (p.tipo === 'escada') {
@@ -312,7 +350,7 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             pFoto(els, foto(), 0, dur, { veu: 0.66, entrada: 'suave' });
             som(t, 'whoosh', 0.3);
             const tamN = Math.round(deitado ? H * 0.34 : W * 0.42);
-            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: 'rgba(149,103,219,0.12)', contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
+            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: `${DEST}1F`, contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
                 x: M, y: Math.round(deitado ? H * 0.12 : H * 0.14), largura: W0, alinhamento: deitado ? 'left' : 'center',
                 anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.6, v: 1 }], x: [{ t: 0, v: -20 }, { t: dur, v: 20, e: 'linear' }] } });
             const yT = deitado ? H * 0.5 : H * 0.42;
@@ -398,4 +436,4 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     };
 }
 
-module.exports = { montarCinema, falaDe, paraFala, quando, leitura };
+module.exports = { montarCinema, falaDe, paraFala, quando, leitura: leituraCheia };

package/lib/estudio/composicao.js

@@ -71,7 +71,8 @@ const FAMILIA_TIPO = (f) => (/condensed|narrow|anton|oswald|bebas|teko|league go
         : /black|bricolage|archivo|sora|grotesk|syne|unbounded/i.test(f) ? 'display' : 'texto');
 
 function caber(texto, { largura, linhas = 2, max = 200, min = 18, fonte = 'Inter' }) {
-    const cw = LARGURA[FAMILIA_TIPO(fonte)];
+    // A fonte da biblioteca sabe a própria largura; a de fora, pelo nome.
+    const cw = require('./biblioteca.js').larguraDe(fonte) || LARGURA[FAMILIA_TIPO(fonte)];
     const palavras = String(texto || '').split(/\s+/).filter(Boolean);
     for (let t = Math.round(max); t >= min; t -= 2) {
         // Quebra de verdade, palavra por palavra: é o que o navegador fará.

package/lib/estudio/diretor.js

@@ -66,8 +66,20 @@ function precisaDeProducao(texto) {
    editor por linha do tempo (`primocode video`, lib/video/), não o roteiro. */
 const PEDE_EDICAO = /\b(edit[ae]r?|edi[cç][aã]o|cort[ae]r?|legend[ae]r?|tir[ae]r?\s+(o|os)\s+sil[eê]ncios?)\b[\s\S]{0,80}\b(grava[cç][aã]o|meu\s+v[ií]deo|esse\s+v[ií]deo|este\s+v[ií]deo|[\w-]+\.(mp4|mov|mkv|webm|m4v))\b|\b[\w-]+\.(mp4|mov|mkv|webm|m4v)\b[\s\S]{0,80}\b(edit|cort|legend|sil[eê]nci)/i;
 
+/* Os pedidos de EFEITO sobre a gravação (lib/video/ops-fx.js): fundo, camadas,
+   estalo, objeto na mão, legenda na cabeça. Falam da pessoa ("me", "minha
+   mão"), não do arquivo — por isso não casavam com a regra de cima. */
+const PEDE_EFEITO = /\b(tir[ae]r?|remov\w*|troc\w*)\s+(o\s+)?fundo\b|\bsepar\w*\s+em\s+camadas\b|\bestal\w*\s+(o\s+)?dedo\b|\b(logo|objeto)\b[\s\S]{0,40}\bm[aã]os?\b|\bjunt\w*\s+as\s+m[aã]os\b|\blegenda\b[\s\S]{0,40}\b(azul|vermelh|verde|amarel|rosa|roxa|branc|cabe[cç]a|em cima|embaixo)/i;
+
+/* "edite: /Users/…/Fototeca do Photo Booth/…/Filme em 30-09-2026 às 23.56.mov": o caminho
+   do Photo Booth tem mais de 80 caracteres, e o pedido ia para o Estúdio de
+   motion — que tratava a gravação como b-roll (01/10). Verbo de editar + um
+   arquivo de vídeo em qualquer lugar da frase é edição. */
+const EDITA_ARQUIVO = /\b(edit\w*|edi[cç][aã]o|p[oõ]e\s+(ele\s+)?pra\s+editar)\b[\s\S]*\.(mp4|mov|mkv|webm|m4v)\b|\.(mp4|mov|mkv|webm|m4v)\b[\s\S]*\b(edit\w*|edi[cç][aã]o)\b/i;
+
 function precisaDeEdicao(texto) {
-    return PEDE_EDICAO.test(String(texto || ''));
+    const t = String(texto || '');
+    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t);
 }
 
 // ── 2. as decisões que não são do modelo ─────────────────────────────────

package/lib/estudio/edicao.js

@@ -389,7 +389,8 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             tipo: 'legenda', x: '50%', y: deitado ? '76%' : '68%', ancora: 'centro', fala,
             estilo: {
                 fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
-                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase', largura: '92%',
+                // Caixa normal (o que a pessoa disse, como disse) e a palavra forte na serifa em itálico.
+                destaque: e.destaque, corForte: e.forte, fonteForte: 'Instrument Serif', largura: '92%',
             },
         });
 

package/lib/estudio/ende.js

@@ -60,13 +60,18 @@ function lerLista(html) {
     }).filter((f) => f.titulo && f.segundos > 0);
 }
 
-/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null. */
-function escolher(faixas, { clima = 'neutro', segundos = 0 } = {}) {
+/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null.
+ *  Com `semente`, sorteia entre as 5 melhores que não estão em `evitar` e não
+ *  têm voz nas tags — "não repetir a mesma faixa em todo vídeo" (30/09). */
+function escolher(faixas, { clima = 'neutro', segundos = 0, semente = null, evitar = [] } = {}) {
     const palavras = CLIMAS[clima] || CLIMAS.neutro;
     const nota = (f) => f.tags.reduce((n, t) => n + palavras.filter((p) => t.includes(p)).length, 0);
     const cabem = (faixas || []).filter((f) => f.segundos >= segundos);
     if (!cabem.length) return null;
-    return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+    if (semente == null) return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+    const semVoz = cabem.filter((f) => !f.tags.some((t) => /vocal|singing|voice|rap\b|song/.test(t)) && !evitar.includes(f.id));
+    const pool = (semVoz.length ? semVoz : cabem).slice().sort((a, b) => nota(b) - nota(a)).slice(0, 5);
+    return pool[Math.abs(Number(semente) | 0) % pool.length];
 }
 
 async function buscarPadrao(url) {
@@ -93,8 +98,14 @@ function provedor({ buscar = buscarPadrao, baixar, pasta = 'midia' } = {}) {
     const salvar = baixar || baixarEm(pasta);
     return {
         nome: 'ende', tipo: 'musica',
-        async gerar({ clima, segundos = 0 } = {}) {
-            const faixa = escolher(lerLista(await buscar(LISTA)), { clima, segundos });
+        async gerar({ clima, segundos = 0, genero = null, semente = null, evitar = [] } = {}) {
+            // O GÊNERO (ende.app/en/genres/<genero>): jazz, lofi, funk, ambient… — escolhido pelo assunto.
+            const url = genero ? 'https://ende.app/en/genres/' + encodeURIComponent(genero) : LISTA;
+            let faixas = [];
+            // A página do gênero falhou: a busca geral (que, sem rede, lança — e a corrente cai no próximo provedor).
+            if (genero) { try { faixas = lerLista(await buscar(url)); } catch { faixas = []; } }
+            if (!faixas.length) faixas = lerLista(await buscar(LISTA));
+            const faixa = escolher(faixas, { clima, segundos, semente, evitar });
             if (!faixa) return null;
             const meta = {
                 fonte: faixa.pagina, titulo: faixa.titulo, autor: 'Sascha Ende',

package/lib/estudio/estilo.js

@@ -1,13 +1,21 @@
 /**
  * estilo.js — qual estilo de vídeo um roteiro vira.
  *
- *   motion      o padrão: um plano contínuo em 3D, o protagonista que se deforma (motion.js)
+ *   gerativo    O MOTION: sem template, a tipografia é o filme, numa linha do tempo
+ *               contínua sorteada do roteiro (gerativo.js). É o que "motion" e
+ *               "animação" pedem, e o que o modo "sem referências" usa.
+ *   motion      o motion antigo: o protagonista 3D que se deforma (motion.js),
+ *               só pelo nome (classico, limpo).
  *   vox         explainer editorial: tinta sobre papel, os oito dispositivos VOX (vox.js)
  *   marca       brand reveal: o brilho, o vetor, a marca cromada, o padrão (lancamento.js)
  *   lancamento  filme de lançamento de produto: cartões, painel, calendário, mural (lancamento.js)
  *   impacto     anúncio: corte a cada batida (impacto.js)
  *   cinema      filme de marca premium com fotos reais (cinema.js)
+ *   hibrido     O PADRÃO do vídeo: o cinema com o kit por cima — foto e vídeo reais
+ *               que não param, e o motion por cima (hibrido.js)
  *   composicao  a composição antiga, uma cena por parte (composicao.js)
+ *   fluido      minimalista: uma ideia por batida, a forma de uma vira a da próxima,
+ *               sem corte (fluido.js). É o que "fluido", "minimalista", "clean" e "apple" pedem.
  *
  * Quem manda, em ordem: o estilo que o AGENTE pediu; o do roteiro (a menos
  * que o pedido diga motion); o que o pedido descreve; e o motion.
@@ -15,10 +23,18 @@
 
 'use strict';
 
-const ESTILOS = ['motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao'];
+const variedade = require('./variedade.js');
+
+const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao', 'fluido'];
 // Nomes que o modelo usa para os mesmos estilos.
-const APELIDOS = { limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
+/* "motion" agora é o GERATIVO ("não pode ter template", 29–30/09); o motion
+   antigo segue pelo nome "classico" (e "limpo", o nome mais antigo dele). */
+const APELIDOS = { motion: 'gerativo', generativo: 'gerativo', kinetic: 'gerativo', cinetico: 'gerativo', 'cinético': 'gerativo',
+    tipografico: 'gerativo', 'tipográfico': 'gerativo', animacao: 'gerativo', 'animação': 'gerativo',
+    classico: 'motion', 'clássico': 'motion', 'motion-classico': 'motion', motion3d: 'motion',
+    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', minimalista: 'fluido', minimal: 'fluido', clean: 'fluido', apple: 'fluido', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
 
+const PEDE_FLUIDO = /\bfluid[oa]\b|minimalista|\bminimal\b|\bclean\b|\bapple\b/i;
 const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 const PEDE_VOX = /\bvox\b|explica|explainer|document[aá]rio|editorial|hist[oó]ria d[aoe]s?\b/i;
 const PEDE_MARCA = /\bbrand|identidade visual|revela[çc][ãa]o d[ae] marca|\blogo(tipo|marca)?\b|vinheta de marca/i;
@@ -32,20 +48,35 @@ const normal = (e) => {
     return ESTILOS.includes(n) ? n : null;
 };
 
-function escolherEstilo({ pedido = '', agente = null, roteiro = null } = {}) {
+/* O RODÍZIO: quando ninguém escolheu ("vários estilos... que não sejam padrão
+   da IA", Joel 05/10), o padrão não é sempre o híbrido — gira entre os que
+   servem a qualquer roteiro, sem repetir os últimos (memória 'estilo'). */
+const RODIZIO = ['hibrido', 'cinema', 'gerativo', 'impacto', 'fluido'];
+
+function estiloDaVez(aleatorio = Math.random) {
+    return variedade.sortear(RODIZIO, 'estilo', { aleatorio }) || 'hibrido';
+}
+
+function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, aleatorio } = {}) {
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
-    if (doRoteiro && !(doRoteiro !== 'motion' && PEDE_MOTION.test(pedido) && !PEDE_VOX.test(pedido))) return doRoteiro;
+    /* Pedir MOTION (ou animação) é pedir o gerativo — antes do vox, da marca e
+       do lançamento, que são leiaute fixo ("não pode ter template", 30/09). */
+    if (doRoteiro && !(doRoteiro !== 'gerativo' && doRoteiro !== 'fluido' && PEDE_MOTION.test(pedido))) return doRoteiro;
+    // O fluido é um jeito de motion: "motion minimalista" é o fluido, não o gerativo.
+    if (PEDE_FLUIDO.test(pedido)) return 'fluido';
+    if (PEDE_MOTION.test(pedido)) return 'gerativo';
     if (PEDE_VOX.test(pedido)) return 'vox';
     if (PEDE_MARCA.test(pedido)) return 'marca';
     if (PEDE_LANCAMENTO.test(pedido)) return 'lancamento';
-    if (PEDE_MOTION.test(pedido)) return 'motion';
-    if (PEDE_IMPACTO.test(pedido)) return 'impacto';
-    return 'motion';
+    /* Anúncio, reels e o resto: o HÍBRIDO. "Um mix da versão antiga (o reels
+       da imersão, no cinema) e da última (o kit) — absurdo, que nem parece
+       que foi IA" (29/09). Com `girar`, o padrão roda (RODIZIO). */
+    return girar ? estiloDaVez(aleatorio) : 'hibrido';
 }
 
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
-const LEVES = new Set(['motion', 'vox', 'marca', 'lancamento']);
+const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido']);
 
-module.exports = { escolherEstilo, ESTILOS, LEVES, PEDE_MOTION };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO };