primocode 11.4.0 → 11.5.0

package/lib/plugin/estudio/motion-plano/plano.js

@@ -0,0 +1,152 @@
+/**
+ * plano.js — etapa 3 do motion: o PLANO cena por cena.
+ *
+ *   { texto, palavra_chave, heroi, duracao_s, entrada, foto?, tamanho_px, papel }
+ *
+ * O modelo escolhe herói, duração e entrada seguindo a régua do Destrava (regua.js: números, não adjetivos).
+ * O código confere o que dá pra conferir e CONSERTA o resto — foto sem foto real, marca fora do fim, duas cores cheias,
+ * duração fora de 1,2–5,5 s — porque regra no prompt o modelo esquece. O plano que sai daqui é o que o motor recebe.
+ */
+'use strict';
+
+const { pedirJson } = require('./llm.js');
+const { REGUA, tamanho, encaixar, textoDoPrompt } = require('./regua.js');
+const { marcar, contar, MAX_PALAVRAS } = require('./estrutura.js');
+const Fatos = require('./fatos.js');
+
+const HEROIS = ['tipografia', 'foto', 'numero', 'cor_cheia', 'marca'];
+const ENTRADAS = ['mascara-sobe', 'escala-assenta', 'palavra-a-palavra', 'zoom-atravessa', 'cartao-voa', 'cor-expande'];
+const ENTRADA_DO_HEROI = { foto: 'cartao-voa', cor_cheia: 'cor-expande', marca: 'mascara-sobe', numero: 'escala-assenta', tipografia: 'palavra-a-palavra' };
+
+const sistema = () => `Você é o diretor de motion de um vídeo vertical em PT-BR. Recebe as batidas do roteiro e devolve o PLANO cena por cena, uma cena por batida, na mesma ordem.
+Responda SÓ JSON: {"cenas":[{"texto":"a frase, com a palavra-chave entre *asteriscos*","palavra_chave":"...","heroi":"${HEROIS.join('|')}","duracao_s":3,"entrada":"${ENTRADAS.join('|')}","foto":"caminho de uma foto da lista, só se heroi=foto"}]}
+Significado: heroi = o que domina o quadro. tipografia = a palavra gigante. foto = cartão de foto real. numero = um número real dos fatos em tamanho enorme. cor_cheia = o fundo vira cor cheia (uma única vez no vídeo). marca = a marca real (só na última).
+entrada: mascara-sobe = a linha varre para cima; escala-assenta = nasce grande e assenta; palavra-a-palavra = a frase se monta em pedaços; zoom-atravessa = a câmera atravessa a palavra (use no máximo uma vez); cartao-voa = o cartão de foto voa em 3D; cor-expande = o círculo de cor cresce.
+Não troque o sentido nem o assunto das batidas; pode apertar o texto. NÃO invente fato: datas, nomes, números, lugares e marca só dos fatos.
+
+${textoDoPrompt()}`;
+
+const txt = (v, n) => String(v || '').replace(/\s+/g, ' ').trim().slice(0, n);
+
+/** Conserta o plano do modelo contra as regras. Puro. Devolve { cenas, ajustes[] }. */
+function consertar(bruto, batidas, { fotos = [], marca = '', alvoS = [15, 30], fonte = null } = {}) {
+    const ajustes = [];
+    const brutas = Array.isArray(bruto && bruto.cenas) ? bruto.cenas : [];
+    const n = batidas.length;
+    let cenas = batidas.map((b, i) => {
+        const c = brutas[i] || {};
+        let texto = txt(c.texto, 120) || b.frase;
+        if (contar(texto) > MAX_PALAVRAS) { ajustes.push(`cena ${i + 1}: texto longo, voltou pra frase da batida`); texto = b.frase; }
+        if (fonte) {
+            const l = Fatos.limpar(texto, fonte);
+            if (!l.removidos.length && l.frase && Fatos.norm(l.frase) !== Fatos.norm(texto)) { ajustes.push(`cena ${i + 1}: o fato do usuário voltou inteiro (${l.frase})`); texto = l.frase; }
+            if (l.removidos.length) { ajustes.push(`cena ${i + 1}: fato que o usuário não disse (${l.removidos.join(', ')}), ${l.frase ? 'tirado' : 'voltou pra frase da batida'}`); texto = l.frase || b.frase; }
+        }
+        const m = marcar(texto, c.palavra_chave || b.palavra_chave);
+        return {
+            papel: b.papel, texto: m.frase, palavra_chave: m.chave,
+            heroi: HEROIS.includes(c.heroi) ? c.heroi : 'tipografia',
+            duracao_s: Number(c.duracao_s) || REGUA.cena.media_s,
+            entrada: ENTRADAS.includes(c.entrada) ? c.entrada : null,
+            foto: c.foto ? String(c.foto) : undefined,
+        };
+    });
+    // regra 4: foto só com foto real; no máximo 3 de 9 (≈ 1/3) das cenas
+    const maxFoto = fotos.length ? Math.max(1, Math.round(n * REGUA.foto.cenas_com_foto / REGUA.foto.de)) : 0;
+    let usadas = 0;
+    cenas.forEach((c, i) => {
+        if (c.heroi === 'foto') {
+            if (!fotos.length || usadas >= maxFoto) { ajustes.push(`cena ${i + 1}: ${fotos.length ? 'foto demais' : 'sem foto real'}, virou tipografia`); c.heroi = 'tipografia'; c.foto = undefined; }
+            else { c.foto = fotos.includes(c.foto) ? c.foto : fotos[usadas % fotos.length]; usadas++; }
+        } else c.foto = undefined;
+    });
+    // a pessoa mandou foto real e o modelo não usou nenhuma: a melhor cena de prova (nem a primeira, nem a última) vira o cartão de foto
+    if (fotos.length && n >= 4 && !cenas.some((c) => c.heroi === 'foto')) {
+        const k = [cenas.findIndex((c, i) => i > 0 && i < n - 1 && c.papel === 'prova' && c.heroi === 'tipografia'), cenas.findIndex((c, i) => i > 0 && i < n - 1 && c.heroi === 'tipografia')].find((i) => i >= 0);
+        if (k != null) { cenas[k].heroi = 'foto'; cenas[k].foto = fotos[0]; ajustes.push(`cena ${k + 1}: a foto real não foi usada, entrou aqui`); }
+    }
+    // regra 6: marca real só na última (e só se existe)
+    cenas.forEach((c, i) => {
+        const ultima = i === n - 1;
+        if (c.heroi === 'marca' && (!ultima || !marca)) { ajustes.push(`cena ${i + 1}: marca fora do fim, virou tipografia`); c.heroi = 'tipografia'; }
+    });
+    if (marca && cenas[n - 1].heroi !== 'marca') { cenas[n - 1].heroi = 'marca'; ajustes.push('última cena: marca real entrou no fim'); }
+    // regra 5: exatamente 1 quadro de cor cheia (quando há ≥ 5 cenas); nunca na primeira nem na marca
+    const cheias = cenas.map((c, i) => (c.heroi === 'cor_cheia' ? i : -1)).filter((i) => i >= 0);
+    if (n >= 5) {
+        let manter = cheias.find((i) => i > 0 && i < n - 1);
+        if (manter == null) {
+            manter = cenas.findIndex((c, i) => c.papel === 'virada' && i > 0 && c.heroi === 'tipografia');
+            if (manter < 0) manter = Math.floor(n * 0.6);
+            cenas[manter].heroi = 'cor_cheia';
+            ajustes.push(`cena ${manter + 1}: virou o quadro de cor cheia`);
+        }
+        cenas.forEach((c, i) => { if (c.heroi === 'cor_cheia' && i !== manter) { c.heroi = 'tipografia'; ajustes.push(`cena ${i + 1}: só uma cor cheia, virou tipografia`); } });
+    } else cenas.forEach((c) => { if (c.heroi === 'cor_cheia') c.heroi = 'tipografia'; });
+    // tempo: 1,2–5,5 s por cena; o total entre 15 e 30 s (escala proporcional, depois reclampa)
+    cenas.forEach((c) => { c.duracao_s = Math.min(REGUA.cena.max_s, Math.max(REGUA.cena.min_s, c.duracao_s)); });
+    let total = cenas.reduce((a, c) => a + c.duracao_s, 0);
+    if (total < alvoS[0] || total > alvoS[1]) {
+        const k = (total < alvoS[0] ? alvoS[0] : alvoS[1]) / total;
+        cenas.forEach((c) => { c.duracao_s = Math.min(REGUA.cena.max_s, Math.max(REGUA.cena.min_s, c.duracao_s * k)); });
+        ajustes.push(`duração total ${total.toFixed(1)} s reescalada para o intervalo de ${alvoS[0]} a ${alvoS[1]} s`);
+    }
+    cenas.forEach((c, i) => {
+        c.duracao_s = Math.round(c.duracao_s * 10) / 10;
+        if (!c.entrada) c.entrada = ENTRADA_DO_HEROI[c.heroi];
+        if (c.heroi === 'foto') c.entrada = 'cartao-voa';
+        if (c.heroi === 'cor_cheia') c.entrada = 'cor-expande';
+        if (c.heroi === 'foto' || c.heroi === 'marca') c.tamanho_px = REGUA.texto.apoio_px[1];   // apoio: nunca abaixo de 56 px
+        else {
+            // o herói nunca fica abaixo do mínimo da régua (150 px) e cabe em até 3 linhas: sobrou palavra, ela sai (a palavra-chave fica)
+            const e = encaixar(c.texto);
+            if (e.cortou) { ajustes.push(`cena ${i + 1}: texto longo pro herói (150 px, 3 linhas), ficou "${e.texto.replace(/\*/g, '')}"`); c.texto = e.texto; }
+            c.tamanho_px = e.tam;
+        }
+    });
+    // variedade: se quase tudo entra do mesmo jeito, cada papel ganha o seu (a régua tem um movimento por cena)
+    const POR_PAPEL = { gancho: 'mascara-sobe', virada: 'escala-assenta', prova: 'palavra-a-palavra', fecho: 'mascara-sobe' };
+    const freq = {};
+    cenas.forEach((c) => { freq[c.entrada] = (freq[c.entrada] || 0) + 1; });
+    if (Math.max(...Object.values(freq)) > cenas.length * 0.6) {
+        cenas.forEach((c) => { if (!['foto', 'cor_cheia'].includes(c.heroi)) c.entrada = POR_PAPEL[c.papel] || c.entrada; });
+        ajustes.push('entradas iguais demais: cada papel ganhou a sua');
+    }
+    // zoom-atravessa no máximo uma vez
+    let z = 0;
+    cenas.forEach((c, i) => { if (c.entrada === 'zoom-atravessa' && ++z > 1) { c.entrada = 'escala-assenta'; ajustes.push(`cena ${i + 1}: só um zoom-atravessa`); } });
+    total = Math.round(cenas.reduce((a, c) => a + c.duracao_s, 0) * 10) / 10;
+    return { cenas, total_s: total, ajustes };
+}
+
+/** O que a régua ainda reprova depois do conserto (deve ser vazio). Puro. */
+function conferir(plano, { fotos = [], marca = '' } = {}) {
+    const erros = [];
+    const cs = plano.cenas;
+    if (cs.filter((c) => c.heroi === 'cor_cheia').length > 1) erros.push('mais de uma cor cheia');
+    if (cs.length >= 5 && cs.filter((c) => c.heroi === 'cor_cheia').length !== 1) erros.push('falta o quadro de cor cheia');
+    if (cs.some((c, i) => c.heroi === 'marca' && i !== cs.length - 1)) erros.push('marca fora do fim');
+    if (cs.some((c) => c.heroi === 'foto' && !fotos.length)) erros.push('foto sem foto real');
+    if (marca && cs[cs.length - 1].heroi !== 'marca') erros.push('sem marca no fim');
+    if (cs.some((c) => c.duracao_s < REGUA.cena.min_s || c.duracao_s > REGUA.cena.max_s)) erros.push('cena fora de 1,2 a 5,5 s');
+    if (cs.some((c) => !/\*[^*]+\*/.test(c.texto))) erros.push('frase sem palavra-chave');
+    return erros;
+}
+
+/** @param {object} briefing  @param {Array} batidas  @param {object} deps { llm } */
+async function montarPlano(briefing, batidas, deps = {}) {
+    const llm = deps.llm;
+    if (!llm) return { ok: false, error: 'sem modelo para montar o plano.' };
+    const fotos = (briefing.fotos || []).map(String);
+    const marca = (briefing.fatos && briefing.fatos.marca) || '';
+    const corpo = JSON.stringify({ batidas: batidas.map((b) => ({ papel: b.papel, frase: b.frase, palavra_chave: b.palavra_chave })), fatos: briefing.fatos, tom: briefing.tom, fotos_reais: fotos, marca_real: marca || null });
+    const bruto = await pedirJson(llm, [{ role: 'system', content: sistema() }, { role: 'user', content: corpo }], { temperatura: 0.6, maxTokens: 4000 });
+    const alvoS = deps.alvoS || [15, 30];
+    const r = consertar(bruto, batidas, { fotos, marca, alvoS, fonte: deps.fonte });
+    const plano = { assunto: briefing.pedido, objetivo: briefing.objetivo, tom: briefing.tom, virada: briefing.virada, marca: marca || null, cenas: r.cenas, total_s: r.total_s, ajustes: r.ajustes };
+    const erros = conferir(plano, { fotos, marca });
+    if (erros.length) return { ok: false, error: `plano reprovado pela régua: ${erros.join('; ')}`, plano };
+    return { ok: true, plano };
+}
+
+module.exports = { montarPlano, consertar, conferir, HEROIS, ENTRADAS, sistema };

package/lib/plugin/estudio/motion-plano/regua.js

@@ -0,0 +1,100 @@
+/**
+ * regua.js — a gramática do vídeo "Destrava Essencial" (aprovada pelo Joel), em NÚMEROS.
+ *
+ * Fonte: ~/www/videos/destrava-essencial-pc/video  (src/style.json, src/lib/anim.ts, src/scenes/Kinetic.tsx,
+ * src/scene-times.json). Canvas 1080×1920, 30 fps, 9 cenas, 27 s. Cada número abaixo aponta de onde veio.
+ * Os frames viram segundos aqui (÷ 30) porque o plano fala em segundos.
+ *
+ * As 6 regras:
+ *  1 tipografia enorme é o herói; só a palavra-chave ganha degradê/cor de destaque
+ *  2 uma ideia por quadro; a frase se monta em pedaços na hora da fala
+ *  3 copy com virada
+ *  4 fotos reais do assunto em cartões arredondados que se mexem; nunca UI/ícone inventado
+ *  5 um único quadro de cor cheia quebra o fundo
+ *  6 marca real só no fim
+ */
+'use strict';
+
+const FPS = 30;
+const s = (frames) => Math.round((frames / FPS) * 100) / 100;
+
+// scene-times.json: [0,101,265,359,395,463,518,605,691] + fim 810 → duração de cada cena
+const CENAS_S = [101, 164, 94, 36, 68, 55, 87, 86, 119].map(s);
+
+const REGUA = Object.freeze({
+    fps: FPS,
+    // — tempo —
+    cena: { min_s: Math.min(...CENAS_S), max_s: Math.round(Math.max(...CENAS_S) * 10) / 10, media_s: s(810 / 9), exemplos_s: CENAS_S },   // 1,2 a 5,5 s; média 3 s
+    video: { cenas: 9, duracao_s: 27 },
+    palavra: { entrada_s: s(12), passo_entre_palavras_s: [s(4), s(5)], blur_px: 10, sobe: 0.28, mola: { damping: 11, stiffness: 140, mass: 0.7 } },   // style.json motion.word
+    linha: { varre_s: s(18), assenta_s: s(22), escala_de: [1.3, 1.7], tracking_em: [0.05, -0.045], blur_px: 9 },                                       // Kinetic.tsx Line
+    cena_entra_s: s(12), cena_sai_s: s(10), cena_sobreposicao_s: s(17), cena_desloca_px: 260, cena_blur_px: 16,                                       // Kinetic.tsx Scn / style.json scene
+    easing: { saida: [0.22, 1, 0.36, 1], entra_e_sai: [0.65, 0, 0.35, 1], e5: '1-(1-t)^5' },                                                          // style.json ease; Kinetic e5
+    batida_s: s(14.4),                                                                                                                                 // 14,4 f ≈ 0,48 s
+    camera: { deriva_zoom: [1.018, 0.012], soco_zoom: 0.03, soco_decai_s: s(7), soco_na_batida: true },                                              // camAt()
+    atravessa: { zoom_final: 12, s: s(17) },                                                                                                           // S7 zoom-through
+    // — tipografia (px em 1080 de largura) —
+    texto: { peso: [800, 900], linhas_max: 2, palavras_por_linha_max: 7, tracking_em: -0.02, entreLinhas: 1.08, destaque_por_frase: 1,
+        apoio_px: [64, 118], heroi_px: [150, 410], heroi_linhas_max: 3, apoio_min_px: 56 },                                                                                                   // style.json font; Kinetic sizes
+    // — cor cheia, foto, marca —
+    cor_cheia: { quadros: 1, de: 9, expande_s: s(16) },                                                                                                // S8: círculo radial, 1 cena
+    foto: { cartao_raio_px: 36, sombra: '0 40px 90px rgba(29,29,31,.28)', cartoes: [[400, 530], [980, 1060], [330, 440]], cenas_com_foto: 3, de: 9, voa_s: s(14) },
+    marca: { cenas: 1, de: 9, posicao: 'ultima', revela_s: s(26) },                                                                                    // S9: logo só no fim
+});
+
+/** Tamanho do herói em px pela contagem de palavras (Destrava: "Não." 410 · "IA." 282 · "Usar IA" 248 · "Mais uma palavra" 180–210 · "Sábado," 150). Nunca abaixo do mínimo da régua (150). */
+function tamanho(nPalavras) {
+    const min = REGUA.texto.heroi_px[0];
+    if (nPalavras <= 1) return 360;
+    if (nPalavras === 2) return 250;
+    if (nPalavras === 3) return 200;
+    return min;
+}
+
+/** Quantas linhas o texto ocupa em `tam` px (Inter 800, tracking -0.02 em ≈ 0,6 em por letra; a palavra-chave, 18% maior). Mesma conta do kit. */
+function linhasDe(texto, tam, { largura = 1080 * (1 - 2 * 0.08) * 0.98 } = {}) {
+    const ps = String(texto || '').split(/\s+/).filter(Boolean);
+    const comKw = ps.length > 1;
+    let linhas = 1, uso = 0;
+    for (const p of ps) {
+        const n = p.replace(/\*/g, '').length, w0 = n * tam * 0.58;
+        const t = Math.min(p.includes('*') && comKw ? tam * Math.min(1.18, Math.max(1, 0.98 * largura / w0)) : tam, REGUA.texto.heroi_px[1]);   // a palavra-chave cresce até 18%, só enquanto cabe
+        const w = n * t * 0.58, esp = tam * 0.27;
+        if (w > largura) return 99;                                    // palavra que não cabe sozinha na linha
+        if (uso && uso + esp + w > largura) { linhas++; uso = w; } else uso = uso ? uso + esp + w : w;
+    }
+    return linhas;
+}
+
+/** O herói que cabe: no mínimo da régua (150 px) ele tem que caber em até 3 linhas; sobrando, tira palavras longe da palavra-chave (começo antes do fim).
+ *  O tamanho é o da contagem de palavras, reduzido em passos de 8% só até caber, e nunca abaixo de 150. Devolve { texto, tam, cortou }. */
+function encaixar(texto, { max = REGUA.texto.heroi_linhas_max } = {}) {
+    const min = REGUA.texto.heroi_px[0];
+    let ps = String(texto || '').split(/\s+/).filter(Boolean), cortou = false;
+    const kw = () => Math.max(0, ps.findIndex((p) => p.includes('*')));
+    while (ps.length > 1 && linhasDe(ps.join(' '), min) > max) {
+        const k = kw();
+        if (k > 0 && k >= ps.length - 1 - k) ps = ps.slice(1); else if (k < ps.length - 1) ps = ps.slice(0, -1); else ps = ps.slice(1);
+        cortou = true;
+    }
+    const t = ps.join(' ');
+    let tam = tamanho(ps.length);
+    while (tam > min && linhasDe(t, tam) > max) tam = Math.max(min, Math.round(tam * 0.92));
+    return { texto: t, tam, cortou };
+}
+
+/** O bloco de regras que vai no prompt do plano. Números, não adjetivos. */
+function textoDoPrompt() {
+    const R = REGUA;
+    return `RÉGUA (medida num vídeo aprovado de 27 s, 9 cenas, 1080×1920, 30 fps):
+1. TIPOGRAFIA É O HERÓI. Texto de herói: ${R.texto.heroi_px[0]} a ${R.texto.heroi_px[1]} px, peso 800 a 900, no máximo ${R.texto.heroi_linhas_max} linhas e ${R.texto.palavras_por_linha_max} palavras por linha; texto de apoio ${R.texto.apoio_px[0]} a ${R.texto.apoio_px[1]} px. Tamanho por palavras: 1 palavra ≈ 360 px, 2 ≈ 250, 3 ≈ 200, 4 ou mais = 150 (nunca abaixo disso; o texto herói é curto, até 3 linhas, com a palavra-chave maior). SÓ a palavra-chave leva a cor de destaque (${R.texto.destaque_por_frase} por frase).
+2. UMA IDEIA POR QUADRO. A frase se monta em pedaços: cada palavra entra em ${R.palavra.entrada_s} s, com ${R.palavra.passo_entre_palavras_s[0]} a ${R.palavra.passo_entre_palavras_s[1]} s entre palavras (blur ${R.palavra.blur_px} px sumindo, sobe ${R.palavra.sobe * 100}% do tamanho). A linha de herói varre para cima em ${R.linha.varre_s} s e assenta em ${R.linha.assenta_s} s, vinda de escala ${R.linha.escala_de[0]} a ${R.linha.escala_de[1]}.
+3. COPY COM VIRADA. A pergunta que o público faria (ou o clichê do assunto) no gancho, depois a resposta curta que quebra a expectativa, específica do assunto. Nada de frase de catálogo.
+4. FOTO REAL EM CARTÃO ARREDONDADO (raio ${R.foto.cartao_raio_px} px, sombra suave) que se mexe: voa em ${R.foto.voa_s} s, carrossel 3D ou grade inclinada. ${R.foto.cenas_com_foto} de ${R.foto.de} cenas levam foto, e SÓ se existe foto real do assunto. Sem foto, a cena é só tipografia. Nunca UI, ícone ou ilustração inventada.
+5. UM ÚNICO QUADRO DE COR CHEIA quebra o fundo (${R.cor_cheia.quadros} de ${R.cor_cheia.de} cenas; o círculo de cor expande em ${R.cor_cheia.expande_s} s). Só um.
+6. MARCA REAL SÓ NO FIM: a última cena (e só ela) mostra a marca, se a marca está nos fatos.
+TEMPO: cena de ${R.cena.min_s} a ${R.cena.max_s} s, média ${R.cena.media_s} s (cena de uma palavra de virada é a mais curta, 1,2 a 1,8 s; cena que explica pode ir a 4 a 5,5 s). Vídeo de 15 a 30 s. Troca de cena: entra em ${R.cena_entra_s} s com deslocamento de ${R.cena_desloca_px} px e blur ${R.cena_blur_px} px, sai em ${R.cena_sai_s} s, sobrepõe ${R.cena_sobreposicao_s} s. Câmera: deriva contínua de ±${R.camera.deriva_zoom[1] * 100}% de zoom e um soco de ${R.camera.soco_zoom * 100}% que decai em ${R.camera.soco_decai_s} s, na batida (a cada ${R.batida_s} s).
+EASING: saída cubic-bezier(${R.easing.saida.join(', ')}); entra-e-sai cubic-bezier(${R.easing.entra_e_sai.join(', ')}); assentar = ${R.easing.e5}. Nunca linear.`;
+}
+
+module.exports = { REGUA, tamanho, linhasDe, encaixar, textoDoPrompt, CENAS_S };

package/lib/plugin/estudio/personagem.js

@@ -485,6 +485,8 @@ function montarPersonagem({ roteiro, largura = 1920, altura = 1080, tempos = [],
     const partitura = partituraDe({ roteiro: { ...roteiro, partes }, largura, altura, tempos });
     if (!partitura.falas.length) return { ok: false, error: 'o roteiro veio sem fala: o personagem precisa de texto em cada parte.' };
     const DUR = partitura.duracao;
+    // motor novo (kits/3d): a mesma partitura, traduzida para o montador de maquete. O plano antigo segue junto.
+    const roteiro3d = roteiro.motor === 'montador' ? require('./dialogo3d.js').roteiroDeDialogo(partitura) : undefined;
     const efeitos = [];
     const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
     for (const f of partitura.falas) if (f.destaque) som(f.de + 0.3, 'pop', 0.16);
@@ -501,7 +503,7 @@ function montarPersonagem({ roteiro, largura = 1920, altura = 1080, tempos = [],
         },
     };
     return {
-        ok: true, plano, partitura,
+        ok: true, plano, partitura, ...(roteiro3d ? { roteiro3d } : {}),
         resumo: { visual: partitura.visual, cenas: 1, segundos: DUR, fps: FPS, cenario: partitura.cenario.nome, elenco: partitura.elenco.map((e) => `${e.rotulo} (${e.tipo === 'animal' ? e.especie : e.tipo})`),
             figurantes: partitura.figurantes.map((e) => (e.tipo === 'animal' ? e.especie : e.tipo)), lugares: partitura.mundos.map((m) => m.nome), planos: partitura.planos.length, falas: partitura.falas.length },
     };

package/lib/plugin/estudio/referencias.js

@@ -87,7 +87,7 @@ function instrucaoDoModo({ modo, escopo, explicito } = ATUAL) {
         + 'CRIE a cena: escreva um React (write_file, ex.: componentes/cena-x.jsx, export default ({el, t}) => …, t em segundos desde o '
         + 'começo da parte; el.dados traz palavras [{texto, t}], cores {fundo, texto, acento}, fontes, largura, altura) e ponha '
         + 'componente:"componentes/cena-x.jsx" naquela parte. A voz, a trilha, os sons e o fundo continuam do Estúdio. '
-        + 'Vídeo inteiro desenhado por você: escreva uma composição Hyperframes (pasta com index.html, data-start/data-duration, GSAP), '
+        + 'Vídeo inteiro desenhado por você: escreva uma composição Hyperframes (pasta com index.html, data-start/data-duration, GSAP: use `gsap.` direto, sem <script src> nem CDN, o motor embute o GSAP local), '
         + 'use a voz do estudio_narrar e os sons de midia/, e estudio_render motor:"hyperframes" html:"<pasta>". '
         /* O ROTEIRO (13/10: "o roteiro que monta é horrível" — eram os títulos da landing em fila). */
         + 'O ROTEIRO é uma história de 15 a 25 s: gancho (a situação de quem assiste) → o que o produto FAZ → UMA prova concreta '

package/lib/provider/catalogo.js

@@ -0,0 +1,161 @@
+/**
+ * catalogo.js — o catálogo de modelos, lido do models.dev (licença MIT).
+ *
+ * Mesma ideia do OpenCode (packages/core/src/models-dev.ts): uma lista pública
+ * de provedores e modelos, com env da chave, URL e capacidades de cada um.
+ * Três camadas, da mais nova para a mais velha:
+ *
+ *   1. rede  — GET https://models.dev/api.json, com ETag (304 não rebaixa 6 MB)
+ *   2. cache — ~/.primocode/cache/models-dev.json, vale 12 h (stale ainda serve)
+ *   3. embutido — lib/provider/local/catalogo-embutido.json.gz, para offline na 1ª vez
+ *
+ * O formato guardado é ENXUTO (só o que o PrimoCode usa), não o JSON cru:
+ *   { provedores: { <id>: { nome, env:[], api, modelos: { <id>: {
+ *       nome, ferr, visao, raciocinio, ctx, saida, custoIn, custoOut } } } } }
+ * Só entram provedores que falam o formato OpenAI (/chat/completions): os que
+ * têm `api` no catálogo (npm openai-compatible) e os que o catálogo deixa sem
+ * `api` mas cuja URL é conhecida (BASES_CONHECIDAS, abaixo).
+ *
+ * Nenhuma chave e nenhuma URL privada moram aqui. Gateway da empresa entra
+ * pelo `~/.primocode/provedores.json` da pessoa (provedor.js), não por este arquivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const zlib = require('zlib');
+const os = require('os');
+const path = require('path');
+
+const URL_CATALOGO = 'https://models.dev/api.json';
+const VALIDADE_MS = 12 * 60 * 60 * 1000;
+const EMBUTIDO = path.join(__dirname, 'local', 'catalogo-embutido.json.gz');   // gzip: 1 MB -> ~150 KB no pacote
+const CACHE = () => path.join(os.homedir(), '.primocode', 'cache', 'models-dev.json');
+
+/* Provedores que o models.dev lista sem `api` (usam um SDK próprio), mas que
+   expõem /chat/completions no formato OpenAI nesta URL pública. */
+const BASES_CONHECIDAS = {
+    groq: 'https://api.groq.com/openai/v1',
+    openai: 'https://api.openai.com/v1',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    xai: 'https://api.x.ai/v1',
+    mistral: 'https://api.mistral.ai/v1',
+    cerebras: 'https://api.cerebras.ai/v1',
+    deepseek: 'https://api.deepseek.com/v1',
+    togetherai: 'https://api.together.xyz/v1',
+    perplexity: 'https://api.perplexity.ai',
+    deepinfra: 'https://api.deepinfra.com/v1/openai',
+    anthropic: 'https://api.anthropic.com/v1',
+};
+
+/** Do JSON cru do models.dev para o formato enxuto. */
+function normalizar(cru) {
+    const provedores = {};
+    for (const [id, p] of Object.entries(cru || {})) {
+        if (!p || typeof p !== 'object' || !p.models) continue;
+        const env = Array.isArray(p.env) ? p.env.filter(Boolean) : [];
+        const api = p.api || BASES_CONHECIDAS[id];
+        if (!api || !env.length) continue;
+        const modelos = {};
+        for (const [mid, m] of Object.entries(p.models)) {
+            if (!m) continue;
+            const saidas = (m.modalities && m.modalities.output) || ['text'];
+            if (!saidas.includes('text') || m.type) continue;          // sem áudio/imagem/embedding
+            if (m.status === 'deprecated') continue;
+            const ent = (m.modalities && m.modalities.input) || ['text'];
+            modelos[mid] = {
+                nome: m.name || mid,
+                ferr: !!m.tool_call,
+                visao: ent.includes('image'),
+                raciocinio: !!m.reasoning,
+                ctx: (m.limit && m.limit.context) || 0,
+                saida: (m.limit && m.limit.output) || 0,
+                custoIn: m.cost && typeof m.cost.input === 'number' ? m.cost.input : null,
+                custoOut: m.cost && typeof m.cost.output === 'number' ? m.cost.output : null,
+            };
+        }
+        if (Object.keys(modelos).length) provedores[id] = { nome: p.name || id, env, api, modelos };
+    }
+    return { provedores };
+}
+
+function lerJson(arq) {
+    try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return null; }
+}
+
+function valido(c) {
+    return !!(c && c.provedores && typeof c.provedores === 'object' && Object.keys(c.provedores).length);
+}
+
+/** Cache + embutido, sem rede (a CLI precisa listar na hora). */
+function carregarSync() {
+    const cache = lerJson(CACHE());
+    if (cache && valido(cache.dados)) return { ...cache.dados, origem: 'cache', baixadoEm: cache.baixadoEm };
+    let emb = null;
+    try { emb = JSON.parse(zlib.gunzipSync(fs.readFileSync(EMBUTIDO)).toString('utf8')); } catch { /* sem embutido */ }
+    return valido(emb) ? { ...emb, origem: 'embutido' } : { provedores: {}, origem: 'vazio' };
+}
+
+function cacheFresco() {
+    const cache = lerJson(CACHE());
+    return !!(cache && valido(cache.dados) && Date.now() - cache.baixadoEm < VALIDADE_MS);
+}
+
+/**
+ * Baixa do models.dev se o cache venceu (ou `forcar`). Nunca lança: offline,
+ * fica o que já havia. Devolve { ok, origem, erro? }.
+ */
+async function atualizar({ forcar = false, buscar = fetch, agora = Date.now } = {}) {
+    if (process.env.PRIMOCODE_CATALOGO_OFFLINE === '1') return { ok: false, origem: carregarSync().origem, erro: 'offline' };
+    if (!forcar && cacheFresco()) return { ok: true, origem: 'cache' };
+    const antigo = lerJson(CACHE());
+    try {
+        const headers = antigo && antigo.etag ? { 'If-None-Match': antigo.etag } : {};
+        const r = await buscar(process.env.PRIMOCODE_CATALOGO_URL || URL_CATALOGO, { headers, signal: AbortSignal.timeout(20000) });
+        if (r.status === 304 && antigo) {
+            gravar({ ...antigo, baixadoEm: agora() });
+            return { ok: true, origem: 'cache' };
+        }
+        if (!r.ok) throw new Error(`HTTP ${r.status}`);
+        const dados = normalizar(await r.json());
+        if (!valido(dados)) throw new Error('catálogo vazio');
+        gravar({ baixadoEm: agora(), etag: (r.headers && r.headers.get && r.headers.get('etag')) || '', dados });
+        return { ok: true, origem: 'rede' };
+    } catch (e) {
+        return { ok: false, origem: carregarSync().origem, erro: e.message };
+    }
+}
+
+function gravar(obj) {
+    const arq = CACHE();
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    const tmp = `${arq}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(obj));
+    fs.renameSync(tmp, arq);
+}
+
+/** Todos os modelos como "provedor/modelo", com as capacidades. */
+function listar({ catalogo = carregarSync(), provedor = '', filtro = '', soFerramentas = false, soGratis = false } = {}) {
+    const f = String(filtro || '').toLowerCase();
+    const saida = [];
+    for (const [pid, p] of Object.entries(catalogo.provedores)) {
+        if (provedor && pid !== provedor) continue;
+        for (const [mid, m] of Object.entries(p.modelos)) {
+            if (soFerramentas && !m.ferr) continue;
+            if (soGratis && !(m.custoIn === 0 && m.custoOut === 0)) continue;
+            const ref = `${pid}/${mid}`;
+            if (f && !`${ref} ${m.nome}`.toLowerCase().includes(f)) continue;
+            saida.push({ ref, provedor: pid, id: mid, ...m });
+        }
+    }
+    return saida.sort((a, b) => a.ref.localeCompare(b.ref));
+}
+
+/** Capacidades de um modelo, ou null se o catálogo não o conhece (aí vale o benefício da dúvida). */
+function capacidades(provedor, modelo, catalogo = carregarSync()) {
+    const p = catalogo.provedores[provedor];
+    const m = p && p.modelos[modelo];
+    return m ? { ferramentas: m.ferr, visao: m.visao, raciocinio: m.raciocinio, contexto: m.ctx, saida: m.saida, custoIn: m.custoIn, custoOut: m.custoOut } : null;
+}
+
+module.exports = { URL_CATALOGO, VALIDADE_MS, BASES_CONHECIDAS, normalizar, carregarSync, atualizar, listar, capacidades, CACHE };