primocode 10.10.0 → 10.11.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.10.0
+# PrimoCode v10.10.1
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.10.0
+ ▐▛███▜▌   Primo Code v10.10.1
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/catalogo.js

@@ -93,8 +93,9 @@ const GRUPOS = [
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
-                + 'componente:"componentes/x.jsx" numa parte = a cena que VOCÊ escreveu em React (a voz, a trilha e os sons seguem do Estúdio). '
-                + 'estilo (deixe VAZIO: o estilo da casa, o gerativo com as cores da marca, é o ponto de partida; outro só se a pessoa pedir pelo nome): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega — a COISA que a frase nomeia, 2 a 4 palavras, não a frase inteira; rota:"tipografia" em número/citação, "produto" quando a frase fala do produto; ancora:"palavra" — o clipe troca 0,2 s depois dela) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'componente:"componentes/x.jsx" numa parte = a cena que VOCÊ escreveu em React — é o caminho do motion (skill Motion de primeira): uma ideia desenhada por fala; a voz, a trilha, os sons e o fundo seguem do Estúdio; cena que não compila volta em cenasQuebradas. '
+                + 'semNarracao:true no roteiro (ou pedido "sem narração") = vídeo só com motion, trilha e efeitos sonoros: sem estudio_narrar, cada parte dura o seu "duracao" (s) ou o tempo de ler a tela, e um som leve entra em cada corte e entrada. '
+                + 'estilo (deixe VAZIO: o gerativo, com as suas cenas em componente e o estiloVisual que você montou; outro só se a pessoa pedir pelo nome): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega — a COISA que a frase nomeia, 2 a 4 palavras, não a frase inteira; rota:"tipografia" em número/citação, "produto" quando a frase fala do produto; ancora:"palavra" — o clipe troca 0,2 s depois dela) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som — estiloVisual {humor, paleta, display, texto, mono, genero, ambiente, acento, material} é o estilo que VOCÊ monta pelo assunto (cardápio: estudio_midia acao:estilos; vazio, o PrimoCode sorteia); modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
                 + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (a ANIMAÇÃO 3D de verdade, o vídeo GRAVADO em 3D no visual de blocos/voxel de render de cinema — é a escolha para animação 3D, personagem, bicho, boneco, avatar, mascote, podcast, entrevista ou alguém FALANDO em 3D; cada parte é UMA fala {falante, texto, emocao?, destaque?, acao?, cenario?}, sem tipo). NADA É FIXO, monte o que a pessoa pediu: cena:"texto livre do lugar" (praia, cidade, floresta, parque, fazenda, neve, deserto, espaço, fundo do mar, escritório, sala, cozinha, escola, palco… + hora: "à noite", "ao pôr do sol") ou cena:{lugar, hora, elementos:["palmeira","barraca","violão",…]} — elemento fora do catálogo vira ícone 3D em blocos; parte.cenario muda o lugar a partir daquela fala. Até 4 falantes; personagens:{"nome":{tipo:pessoa|robo|animal|coisa, especie (animal: cachorro|gato|cavalo|vaca|porco|ovelha|raposa|lobo|urso|panda|coelho|leao|tigre|elefante|girafa|tartaruga|galinha|pato|passaro|papagaio|coruja|pinguim|peixe|tubarao|golfinho|dinossauro|sapo|macaco), icone (coisa: "pizza", "café", "polvo" — qualquer objeto/bicho que fala), pessoa: pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba; robo: cor}} — sem tipo, o nome decide (nome de bicho vira bicho, de IA vira o mascote laranja, de objeto vira coisa); figurantes:["cachorro","pessoa"] (quem está na cena sem falar); BICHO NÃO FALA: a fala de um bicho sai da narração e ele fica na cena — só fala se a pessoa pedir ("cachorro falante") ou personagens.x.fala:true; a voz de cada falante sai do GÊNERO do nome (personagens.x.genero:f|m manda), uma voz por personagem do começo ao fim; bigode:true e cabeca:"cubo" (o rosto de pixel antigo) em personagens; sem lugar no pedido, o set é a cobertura à noite (janela da cidade, cartões de interface na frente). acao em cada parte: acenar|apontar|pular|dancar|comemorar|pensar|andar|correr. emocao feliz|serio|surpreso|pensativo|animado|curioso; destaque:"texto curto"; paineis:["título",…] só no set de telas (o padrão quando o pedido não diz lugar); visual:"liso" só se pedirem o boneco liso antigo). '
                 + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
@@ -110,8 +111,11 @@ const GRUPOS = [
                 + 'o render empurra para dentro, encolhe o texto largo e afasta o colado; enfeite de fundo marque decorativo: true.' },
 
             { tool: 'estudio_midia', escreve: true, faz: 'procura e baixa ícone, imagem, música e efeito sonoro da internet, e lista as fontes',
-              args: 'acao: biblioteca | movimentos | cenarios | salvar_cenario | imagem | icones | icones3d | animacoes | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
+              args: 'acao: biblioteca | estilos | salvar_estilo | movimentos | cenarios | salvar_cenario | imagem | icones | icones3d | animacoes | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
                 + 'movimentos termo:"quique" categoria:entrada|saida|enfase|loop: os 100+ movimentos prontos com nome; no elemento, movimento:"<nome>" (ou {nome, em, duracao}, ou uma lista) vira quadros-chave sozinho. Varie: não use o mesmo em todo elemento. Pode inventar o seu em anima. '
+                + 'estilos: as peças do gerativo (humor, paleta, fontes, trilha, ambiente, acento, material) — dezenas de milhares de combinações, e os estilos que a pessoa salvou. '
+                + 'Monte o do vídeo pelo ASSUNTO em roteiro.estiloVisual; misture um salvo com {base:"<nome>", ...}; crie paleta nova com 5 cores. '
+                + 'No fim, pergunte "posso salvar este estilo pra usar nos próximos vídeos?" e, SÓ com o sim, salvar_estilo com nome, pecas {…} e autorizado:true. '
                 + 'cenarios: os lugares prontos do vídeo 3D e os que a pessoa já salvou. Pode CRIAR um cenário novo na cena (lugar base + ceu, chao, parede, luz, acento, hora, elementos); '
                 + 'no fim do vídeo pergunte "posso salvar este cenário pra usar na próxima vez?" e, SÓ com o sim, salvar_cenario com nome, cenario {…} e autorizado:true. Depois, lugar:"<nome>" traz ele de volta. '
                 + 'biblioteca: o cardápio INTEIRO do que existe (ícone 2D, ícone 3D, animação pronta, efeito sonoro, música, fonte, personagem 3D) — olhe antes de escolher. '

package/lib/comandos-extra.js

@@ -466,7 +466,8 @@ const ATALHOS = [
     ['Ctrl+C', 'limpa o que foi digitado; com a caixa vazia, sai'],
     ['Ctrl+D', 'sai (com a caixa vazia)'],
     ['Ctrl+L', 'limpa a tela'],
-    ['PgUp · PgDn', 'rola a conversa'],
+    ['↑ ↓ · roda · PgUp PgDn', 'rolam a conversa (na tela cheia)'],
+    ['Option+↑ · Option+↓', 'o pedido anterior · o próximo (na tela cheia)'],
     ['arrastar o mouse', 'seleciona texto; Cmd+C (Mac) ou Ctrl+Shift+C copia'],
     ['Ctrl+A · Ctrl+E', 'vai para o começo · o fim da linha'],
     ['Ctrl+U · Ctrl+K', 'apaga antes · depois do cursor'],

package/lib/entrada.js

@@ -587,6 +587,20 @@ class Entrada extends EventEmitter {
         this.desenhado = { linhas: q.linhas, cursorLinha: q.cursor.linha };
     }
 
+    /* A RODA QUE VIRAVA HISTÓRICO (13 e 14/10: "quando eu tento subir o
+       histórico ele fica mostrando meus prompts"). Sem capturar o mouse (por
+       causa da seleção de texto), o terminal manda a roda como setas ↑↓. O
+       ritmo não separa as duas coisas: medido no Orca (14/10), a roda devagar
+       chega uma seta a cada 50–250 ms, e o ↑ segurado no teclado a cada 83 ms.
+       Então, na tela cheia, a seta ROLA a conversa (2 linhas), sempre; o
+       pedido anterior fica no Option+↑/↓ (ou Ctrl/Shift, o que o terminal mandar). */
+    _setaNaCheia(dir, key) {
+        // ESC ESC [A é o Option dos terminais com "Option como Meta": o Node entrega como seta pura.
+        const comOption = key && (key.meta || key.ctrl || key.shift || String(key.sequence || '').startsWith('\x1b\x1b'));
+        if (comOption) return this._historico(dir > 0 ? -1 : 1);
+        return this._rolar(dir * 2);
+    }
+
     _rolar(passo) {
         this.rolagem = Math.max(0, this.rolagem + passo);
         this._pintar();
@@ -878,12 +892,14 @@ class Entrada extends EventEmitter {
 
             case 'up':
                 if (this.menu) { this.menu.sel = Math.max(0, this.menu.sel - 1); return this._redesenhar(); }
+                if (this.cheia) return this._setaNaCheia(1, key);
                 return this._historico(-1);
             case 'down':
                 if (this.menu) {
                     this.menu.sel = Math.min(this.menu.itens.length - 1, this.menu.sel + 1);
                     return this._redesenhar();
                 }
+                if (this.cheia) return this._setaNaCheia(-1, key);
                 return this._historico(1);
 
             default:
@@ -893,6 +909,8 @@ class Entrada extends EventEmitter {
 
     _ctrl(key) {
         switch (key.name) {
+            case 'up': return this.cheia ? this._setaNaCheia(1, key) : this._historico(-1);
+            case 'down': return this.cheia ? this._setaNaCheia(-1, key) : this._historico(1);
             case 'c':
                 // Com texto no campo, Ctrl+C limpa o que foi digitado — sair
                 // por acidente no meio de um pedido longo é perder o pedido.

package/lib/estudio/cena.js

@@ -0,0 +1,47 @@
+/**
+ * cena.js — confere a cena que a IA escreveu antes do render.
+ *
+ *   "só quero motions nesse nível" (Joel, 14/10, com as referências: cada
+ *    cena é uma ideia desenhada para a fala, escrita pelo modelo).
+ *
+ * O caminho do motion é a IA escrever cada cena em React (parte.componente).
+ * Um erro de sintaxe num .jsx derrubava o bundle do Remotion e o vídeo
+ * inteiro. Aqui a cena é compilada (o esbuild que já mora no remotion-base)
+ * e os imports são conferidos: a cena quebrada sai, a parte cai no gerativo,
+ * e o erro volta para a IA consertar e mandar de novo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PERMITIDOS = /^(react|remotion|three|@remotion\/[\w-]+|\.{1,2}\/.+)$/;
+
+let esbuild;
+function compilador() {
+    if (esbuild !== undefined) return esbuild;
+    try { esbuild = require(path.join(os.homedir(), '.primocode', 'studio', 'remotion-base', 'node_modules', 'esbuild')); } catch { esbuild = null; }
+    return esbuild;
+}
+
+/** {ok} ou {ok:false, erro} — o erro em uma linha, com a linha do arquivo. */
+function conferirCena(arquivo, { compilar = compilador() } = {}) {
+    let codigo;
+    try { codigo = fs.readFileSync(arquivo, 'utf8'); } catch (e) { return { ok: false, erro: `não li ${path.basename(arquivo)}: ${e.message}` }; }
+    if (!/export\s+default\b/.test(codigo)) return { ok: false, erro: 'falta o export default da função da cena ({el, t, fps}).' };
+    const fora = [...codigo.matchAll(/\bfrom\s+['"]([^'"]+)['"]|\brequire\(\s*['"]([^'"]+)['"]\s*\)/g)].map((m) => m[1] || m[2]).filter((x) => !PERMITIDOS.test(x));
+    if (fora.length) return { ok: false, erro: `import fora do permitido: ${[...new Set(fora)].join(', ')} (só react, remotion, @remotion/*, three).` };
+    if (!compilar) return { ok: true, semCompilador: true };
+    try {
+        compilar.transformSync(codigo, { loader: /\.tsx$/i.test(arquivo) ? 'tsx' : 'jsx', jsx: 'automatic', logLevel: 'silent' });
+        return { ok: true };
+    } catch (e) {
+        const x = (e.errors && e.errors[0]) || {};
+        const onde = x.location ? `linha ${x.location.line}: ` : '';
+        return { ok: false, erro: `${onde}${x.text || String(e.message).split('\n')[0]}` };
+    }
+}
+
+module.exports = { conferirCena, PERMITIDOS };

package/lib/estudio/efeitos-fabrica/brilho-varredura.jsx

@@ -0,0 +1,25 @@
+// Título com uma faixa de luz que atravessa as letras, e um brilho (bloom) que respira depois.
+// el.dados (ou el): titulo, cores {fundo, texto, acento}, fontes {display}, largura, altura.
+import React from 'react';
+import { spring, interpolate, useVideoConfig } from 'remotion';
+
+export default function BrilhoVarredura({ el, t, fps }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const entra = spring({ frame: Math.round(t * fps), fps, config: { damping: 18, stiffness: 120 } });
+  const faixa = interpolate(t, [0.35, 1.25], [-40, 140], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
+  const respira = 0.5 + 0.5 * Math.sin(t * 2.4);
+  const tam = Math.min(W, H) * (d.tamanho || 0.13);
+  const base = { fontFamily: (d.fontes && d.fontes.display) || 'serif', fontSize: tam, lineHeight: 1.02, fontWeight: 800, letterSpacing: '-0.02em', textAlign: 'center', maxWidth: W * 0.84 };
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || '#0a0a0a', display: 'grid', placeItems: 'center' }}>
+      <div style={{ position: 'relative', transform: `translateY(${((1 - entra) * tam * 0.6).toFixed(1)}px)`, opacity: entra }}>
+        <div style={{ ...base, position: 'absolute', inset: 0, color: c.acento || '#ffd166', filter: `blur(${(tam * 0.18).toFixed(0)}px)`, opacity: 0.25 + 0.35 * respira * entra }}>{d.titulo}</div>
+        <div style={{ ...base, position: 'relative', color: 'transparent', WebkitBackgroundClip: 'text', backgroundClip: 'text',
+          backgroundImage: `linear-gradient(105deg, ${c.texto || '#fff'} ${faixa - 18}%, ${c.acento || '#ffd166'} ${faixa - 4}%, #ffffff ${faixa}%, ${c.acento || '#ffd166'} ${faixa + 4}%, ${c.texto || '#fff'} ${faixa + 18}%)` }}>{d.titulo}</div>
+      </div>
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/cor-inunda.jsx

@@ -0,0 +1,30 @@
+// Transição em que três camadas de cor inundam a tela em ondas, e o título aparece por baixo.
+// el.dados (ou el): titulo, cores {fundo, texto, acento}, fontes {display}, largura, altura.
+import React from 'react';
+import { interpolate, useVideoConfig } from 'remotion';
+
+const sai = (x) => 1 - Math.pow(1 - x, 4);
+
+export default function CorInunda({ el, t }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const camadas = [c.texto || '#f4efe6', c.fundo || '#111', c.acento || '#ff4d2e'];
+  const onda = (k, i) => {
+    const pts = [];
+    for (let j = 0; j <= 24; j++) { const x = (j / 24) * W; pts.push(`${x.toFixed(1)},${(H * (1 - k) + Math.sin(j * 0.7 + t * 6 + i) * 40 * (1 - k) * k * 4).toFixed(1)}`); }
+    return `M0,${H} L${pts.join(' L')} L${W},${H} Z`;
+  };
+  const titulo = interpolate(t, [0.75, 1.15], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
+  const tam = Math.min(W, H) * (d.tamanho || 0.12);
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || '#111', overflow: 'hidden' }}>
+      <svg width={W} height={H} style={{ position: 'absolute', inset: 0 }}>
+        {camadas.map((cor, i) => <path key={i} d={onda(sai(Math.max(0, Math.min(1, (t - i * 0.16) / 0.7))) * 1.08, i)} fill={cor} />)}
+      </svg>
+      <div style={{ position: 'absolute', inset: 0, display: 'grid', placeItems: 'center', color: c.fundo || '#111', fontFamily: (d.fontes && d.fontes.display) || 'serif',
+        fontSize: tam, fontWeight: 800, textAlign: 'center', padding: W * 0.08, opacity: titulo, transform: `scale(${(1.08 - 0.08 * titulo).toFixed(4)})`, letterSpacing: `${((1 - titulo) * 0.2).toFixed(3)}em` }}>{d.titulo}</div>
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/mola-com-peso.jsx

@@ -0,0 +1,28 @@
+// Entrada com física: antecipa (recua), cai com peso, amassa no pouso (squash & stretch) e assenta com rebote.
+// el.dados (ou el): titulo (ou imagem), cores, fontes {display}, largura, altura, atraso (s).
+import React from 'react';
+import { Img, staticFile, useVideoConfig } from 'remotion';
+
+export default function MolaComPeso({ el, t }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const u = t - (d.atraso || 0);
+  const queda = 0.42;
+  let y, sx = 1, sy = 1;
+  if (u < 0.12) { y = -H * 0.62 - Math.sin((u / 0.12) * Math.PI) * 18; }
+  else if (u < 0.12 + queda) { const k = (u - 0.12) / queda; y = -H * 0.62 * (1 - k * k); sy = 1 + 0.18 * k; sx = 1 - 0.1 * k; }
+  else { const p = u - 0.12 - queda; const amort = Math.exp(-p * 6); y = -Math.abs(Math.sin(p * 9)) * 60 * amort; sy = 1 - 0.22 * Math.cos(p * 18) * amort; sx = 1 + 0.16 * Math.cos(p * 18) * amort; }
+  const tam = Math.min(W, H) * (d.tamanho || 0.14);
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || '#f4efe6', display: 'grid', placeItems: 'center' }}>
+      <div style={{ transform: `translateY(${y.toFixed(1)}px) scale(${sx.toFixed(4)}, ${sy.toFixed(4)})`, transformOrigin: '50% 100%' }}>
+        {d.imagem ? <Img src={staticFile(d.imagem)} style={{ width: tam * 4, objectFit: 'contain' }} />
+          : <div style={{ fontFamily: (d.fontes && d.fontes.display) || 'serif', fontSize: tam, fontWeight: 900, color: c.texto || '#111' }}>{d.titulo}</div>}
+      </div>
+      <div style={{ position: 'absolute', top: '50%', width: tam * 2.4, height: tam * 0.18, borderRadius: '50%', background: '#000', marginTop: tam * 0.62,
+        opacity: Math.max(0, 0.25 * (1 + y / (H * 0.62))), filter: 'blur(10px)', transform: `scaleX(${(0.4 + 0.6 * (1 + y / (H * 0.62))).toFixed(3)})` }} />
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/peca-impacto-3d.jsx

@@ -0,0 +1,37 @@
+// A peça do site entra em 3D: deitada, sobe, BATE (amassa, treme, flash) e o fundo se abre a partir dela.
+// el.dados (ou el): imagem (PNG sem fundo, do estudio_site elemento), cores {fundo, texto, acento}, largura, altura.
+import React from 'react';
+import { Img, staticFile, spring, interpolate, useVideoConfig } from 'remotion';
+
+export default function PecaImpacto3D({ el, t, fps }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const f = Math.round(t * fps);
+  const sobe = spring({ frame: f, fps, config: { mass: 1.1, damping: 13, stiffness: 90 } });
+  const tBate = 0.9;
+  const pos = Math.max(0, t - tBate);
+  const amassa = pos > 0 ? Math.exp(-pos * 9) * Math.cos(pos * 38) * 0.07 : 0;
+  const treme = pos > 0 ? Math.exp(-pos * 7) * Math.sin(pos * 70) * 14 : 0;
+  const flash = pos > 0 ? Math.exp(-pos * 10) : 0;
+  const abre = interpolate(pos, [0.05, 0.9], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp', easing: (x) => 1 - Math.pow(1 - x, 3) });
+  const deitado = interpolate(sobe, [0, 1], [82, 0]);
+  const y = interpolate(sobe, [0, 1], [H * 0.18, 0]);
+  const lado = Math.min(W, H) * (d.escala || 0.62);
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, overflow: 'hidden', background: c.fundo || '#0b0b0c', perspective: 1400 }}>
+      <div style={{ position: 'absolute', inset: 0, clipPath: `circle(${(abre * 120).toFixed(2)}% at 50% 50%)`,
+        background: `radial-gradient(circle at 50% 50%, ${c.acento || '#ff5a1f'}33, transparent 60%), repeating-linear-gradient(0deg, ${c.texto || '#fff'}0d 0 1px, transparent 1px 48px), repeating-linear-gradient(90deg, ${c.texto || '#fff'}0d 0 1px, transparent 1px 48px)` }} />
+      <div style={{ position: 'absolute', left: '50%', top: '50%', width: lado * (1 + abre * 0.6), height: lado * 0.12, borderRadius: '50%',
+        transform: `translate(-50%, ${lado * 0.42}px)`, background: '#000', opacity: 0.35 * sobe, filter: 'blur(24px)' }} />
+      <div style={{ position: 'absolute', left: '50%', top: '50%', width: lado, height: lado,
+        transform: `translate(-50%, -50%) translate(${treme.toFixed(1)}px, ${y.toFixed(1)}px) rotateX(${deitado.toFixed(2)}deg) scale(${(1 + amassa).toFixed(4)}, ${(1 - amassa).toFixed(4)})`,
+        transformOrigin: '50% 100%', transformStyle: 'preserve-3d' }}>
+        {d.imagem ? <Img src={staticFile(d.imagem)} style={{ width: '100%', height: '100%', objectFit: 'contain', filter: `drop-shadow(0 30px 40px rgba(0,0,0,.45))` }} />
+          : <div style={{ width: '100%', height: '40%', marginTop: '30%', borderRadius: 28, background: c.texto || '#fff' }} />}
+      </div>
+      <div style={{ position: 'absolute', inset: 0, background: `radial-gradient(circle at 50% 55%, ${c.acento || '#fff'}, transparent 45%)`, opacity: flash * 0.55, mixBlendMode: 'screen' }} />
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/raios-de-luz.jsx

@@ -0,0 +1,29 @@
+// Luz volumétrica: feixes giram devagar atrás do título, a cor do acento pulsa e partículas sobem na luz.
+// el.dados (ou el): titulo, cores, fontes {display}, largura, altura.
+import React from 'react';
+import { spring, random, useVideoConfig } from 'remotion';
+
+export default function RaiosDeLuz({ el, t, fps }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const acento = c.acento || '#ffb547';
+  const entra = spring({ frame: Math.round(t * fps), fps, config: { damping: 20, stiffness: 70 } });
+  const tam = Math.min(W, H) * (d.tamanho || 0.12);
+  const giro = t * 6;
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || '#07070a', overflow: 'hidden' }}>
+      <div style={{ position: 'absolute', left: '50%', top: '50%', width: Math.max(W, H) * 2, height: Math.max(W, H) * 2, transform: `translate(-50%,-50%) rotate(${giro}deg)`,
+        background: `repeating-conic-gradient(from 0deg, ${acento}2e 0deg 6deg, transparent 6deg 22deg)`, opacity: entra * (0.7 + 0.3 * Math.sin(t * 1.7)),
+        maskImage: 'radial-gradient(circle, #000 0%, transparent 55%)', WebkitMaskImage: 'radial-gradient(circle, #000 0%, transparent 55%)' }} />
+      {Array.from({ length: 28 }).map((_, i) => {
+        const x = random('x' + i) * W, vel = 30 + random('v' + i) * 70, r = 2 + random('r' + i) * 4;
+        const y = (H + 40 - ((t * vel + random('y' + i) * H) % (H + 80)));
+        return <div key={i} style={{ position: 'absolute', left: x, top: y, width: r, height: r, borderRadius: '50%', background: acento, opacity: 0.25 + 0.5 * random('o' + i), filter: 'blur(1px)' }} />;
+      })}
+      <div style={{ position: 'absolute', inset: 0, display: 'grid', placeItems: 'center', textAlign: 'center', padding: W * 0.08, fontFamily: (d.fontes && d.fontes.display) || 'serif',
+        fontSize: tam, fontWeight: 800, color: c.texto || '#fff', textShadow: `0 0 ${tam * 0.4}px ${acento}88`, opacity: entra, transform: `scale(${(0.92 + 0.08 * entra).toFixed(4)})` }}>{d.titulo}</div>
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/risco-multilinha.jsx

@@ -0,0 +1,30 @@
+// Texto riscado que funciona com quebra de linha: um traço por linha, em sequência, e o texto esmaece.
+// el.dados (ou el): titulo (use \n para quebrar, ou passe linhas: []), cores, fontes {display}, largura, altura.
+import React from 'react';
+import { spring, useVideoConfig } from 'remotion';
+
+export default function RiscoMultilinha({ el, t, fps }) {
+  const d = el.dados || el;
+  const v = useVideoConfig();
+  const W = d.largura || v.width, H = d.altura || v.height;
+  const c = d.cores || {};
+  const linhas = d.linhas || String(d.titulo || '').split('\n');
+  const tam = Math.min(W, H) * (d.tamanho || 0.11);
+  const t0 = d.riscaEm != null ? d.riscaEm : 0.7;
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || '#0d0d0d', display: 'flex', flexDirection: 'column', justifyContent: 'center', alignItems: 'center', gap: tam * 0.1 }}>
+      {linhas.map((ln, i) => {
+        const entra = spring({ frame: Math.round((t - i * 0.08) * fps), fps, config: { damping: 16 } });
+        const k = spring({ frame: Math.round((t - t0 - i * 0.14) * fps), fps, config: { damping: 22, stiffness: 160 } });
+        return (
+          <div key={i} style={{ position: 'relative', fontFamily: (d.fontes && d.fontes.display) || 'serif', fontSize: tam, fontWeight: 700, lineHeight: 1.05,
+            color: c.texto || '#fff', opacity: entra * (1 - 0.45 * k), transform: `translateY(${((1 - entra) * 30).toFixed(1)}px)` }}>
+            {ln}
+            <div style={{ position: 'absolute', left: '-3%', top: '54%', height: Math.max(6, tam * 0.08), width: `${(106 * k).toFixed(2)}%`, borderRadius: 99,
+              background: c.acento || '#ff3b30', transform: `rotate(${-2 + i * 1.5}deg)`, transformOrigin: '0 50%' }} />
+          </div>
+        );
+      })}
+    </div>
+  );
+}

package/lib/estudio/efeitos.js

@@ -33,6 +33,21 @@ const catalogoArq = () => path.join(pasta(), 'catalogo.json');
 const PACOTES = /^(react|react\/jsx-runtime|remotion|@remotion\/[a-z-]+|three|three\/examples\/jsm\/.+|@react-three\/fiber)$/;
 const TETO = 150 * 1024;
 
+/* OS DE FÁBRICA (14/10, "a IA pega sempre os mesmos; quero motions bem
+   profissionais e diversificados"): o cardápio nascia vazio, e a IA voltava
+   aos mesmos três truques. Estes vêm com o PrimoCode e entram no mesmo
+   cardápio, com a mesma memória de variedade. Guardado com o mesmo nome vence. */
+const fabricaPasta = path.join(__dirname, 'efeitos-fabrica');
+const FABRICA = [
+    { nome: 'peca-impacto-3d', descricao: 'a peça do site (PNG sem fundo do estudio_site elemento) entra deitada em 3D, sobe, BATE (amassa, treme, flash) e o fundo se abre a partir dela', tags: ['3d', 'site', 'impacto'] },
+    { nome: 'brilho-varredura', descricao: 'título com uma faixa de luz que atravessa as letras e um brilho que respira', tags: ['brilho', 'titulo'] },
+    { nome: 'cor-inunda', descricao: 'três ondas de cor inundam a tela e o título surge por baixo — transição de cor', tags: ['cor', 'transicao'] },
+    { nome: 'risco-multilinha', descricao: 'texto riscado com quebra de linha: um traço por linha, em sequência, e o texto esmaece (o "não" do contraste)', tags: ['risco', 'contraste'] },
+    { nome: 'mola-com-peso', descricao: 'entrada com física: antecipa, cai com peso, amassa no pouso e assenta com rebote (texto ou imagem)', tags: ['fisica', 'entrada'] },
+    { nome: 'raios-de-luz', descricao: 'feixes de luz giram atrás do título, o acento pulsa e partículas sobem na luz', tags: ['luz', 'brilho', 'titulo'] },
+];
+const deFabrica = (nome) => FABRICA.find((x) => x.nome === nome && fs.existsSync(path.join(fabricaPasta, x.nome + '.jsx')));
+
 function ler() {
     try { const c = JSON.parse(fs.readFileSync(catalogoArq(), 'utf8')); return Array.isArray(c) ? c : []; } catch { return []; }
 }
@@ -72,7 +87,8 @@ function guardar({ pasta: proj, arquivo, nome, descricao, tags = [] } = {}) {
 
 /** O cardápio: os guardados, os menos usados primeiro (memória da variedade). */
 function cardapio({ aleatorio = Math.random } = {}) {
-    const itens = ler().filter((x) => fs.existsSync(path.join(pasta(), x.nome + '.jsx')));
+    const meus = ler().filter((x) => fs.existsSync(path.join(pasta(), x.nome + '.jsx')));
+    const itens = [...meus, ...FABRICA.filter((f) => deFabrica(f.nome) && !meus.some((m) => m.nome === f.nome))];
     return variedade.pontuar(itens, 'efeito', { chave: (x) => x.nome })
         .map((p) => ({ ...p, pontos: p.pontos + aleatorio() * 0.05 }))
         .sort((a, b) => b.pontos - a.pontos)
@@ -81,8 +97,9 @@ function cardapio({ aleatorio = Math.random } = {}) {
 
 /** Copia o efeito para o projeto e devolve o elemento pronto. Marca o uso. */
 function reusar({ pasta: proj, nome } = {}) {
-    const item = ler().find((x) => x.nome === nome);
-    const de = item && path.join(pasta(), item.nome + '.jsx');
+    const meu = ler().find((x) => x.nome === nome && fs.existsSync(path.join(pasta(), x.nome + '.jsx')));
+    const item = meu || deFabrica(nome);
+    const de = item && path.join(meu ? pasta() : fabricaPasta, item.nome + '.jsx');
     if (!item || !fs.existsSync(de)) return { ok: false, error: `não há efeito "${nome}" guardado — veja o cardápio (acao: efeitos).` };
     if (!proj) return { ok: false, error: 'diga o projeto (id).' };
     const src = `efeitos/${item.nome}.jsx`;
@@ -92,4 +109,4 @@ function reusar({ pasta: proj, nome } = {}) {
     return { ok: true, src, descricao: item.descricao, elemento: { tipo: 'componente', src, x: 0, y: 0 } };
 }
 
-module.exports = { guardar, cardapio, reusar, conferirFonte, pasta };
+module.exports = { guardar, cardapio, reusar, conferirFonte, pasta, FABRICA };

package/lib/estudio/estilos.js

@@ -0,0 +1,147 @@
+/**
+ * estilos.js — os milhares de estilos do gerativo, montados por peça.
+ *
+ *   "volta pro remotion, terão 10 mil estilos e a IA pode misturar eles e
+ *    criar novos." (Joel, 14/10)
+ *
+ * Um estilo é uma combinação de peças: humor, paleta (o sistema de 5 campos),
+ * fonte de título, de texto e mono, gênero da trilha, ambiente, acento e o
+ * material dos ícones. As peças são as do gerativo.js, então a conta sai do
+ * código (total()), e não de uma lista escrita à mão.
+ *
+ * Quem escolhe é a IA: ela pede o cardápio (estudio_midia acao:"estilos"),
+ * monta o estilo pelo assunto e passa roteiro.estiloVisual. O que ela deixar
+ * vazio, o sorteio com memória completa (escolherVisual). Ela também pode
+ * misturar um estilo salvo (base:"<nome>") e criar uma paleta nova (5 cores).
+ * O estilo que ficou bom só é guardado com o sim da pessoa, como os cenários.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const gerativo = require('./gerativo.js');
+const { chave } = require('./cenarios.js');
+
+const arquivo = () => path.join(os.homedir(), '.primocode', 'estilos.json');
+const ehCor = (c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c);
+const unicos = (campo) => [...new Set(Object.values(gerativo.HUMORES).flatMap((h) => h[campo]))];
+
+/** As paletas com nome: "comida-1" é o primeiro sistema de 5 campos do humor comida. */
+function paletas() {
+    const out = {};
+    for (const [h, lista] of Object.entries(gerativo.CAMPOS)) lista.forEach((k, i) => { out[`${h}-${i + 1}`] = k; });
+    return out;
+}
+
+function pecas() {
+    return {
+        humor: Object.keys(gerativo.HUMORES),
+        paleta: Object.keys(paletas()),
+        display: unicos('displays').filter((f) => !gerativo.BANIDAS.includes(f) && gerativo.VARIAVEIS[f]),
+        texto: unicos('textos'),
+        mono: unicos('monos'),
+        genero: unicos('generos'),
+        ambiente: gerativo.AMBIENTES,
+        acento: gerativo.ACENTOS_JEITO,
+        material: gerativo.MATERIAIS_ICONE,
+    };
+}
+
+/** Quantos estilos dá pra montar só com as peças prontas (sem contar as paletas que a IA cria). */
+function total() {
+    return Object.values(pecas()).reduce((n, lista) => n * lista.length, 1);
+}
+
+/**
+ * Confere as peças que a IA escolheu. Peça que não existe vira aviso, com as
+ * opções, e não entra (o sorteio cobre). A paleta pode ser um nome ou 5 cores.
+ */
+function validar(pedido) {
+    const P = pecas(), out = {}, avisos = [];
+    for (const [campo, v] of Object.entries(pedido || {})) {
+        if (campo === 'base' || v == null || v === '') continue;
+        if (campo === 'paleta') {
+            if (Array.isArray(v)) {
+                if (v.length !== 5 || !v.every(ehCor)) avisos.push('paleta nova precisa de 5 cores #rrggbb: escura, assinatura, papel e duas ousadas.');
+                else if (v.some(gerativo.corGenerica)) avisos.push(`paleta ${v.join(' ')}: tem cor de cara de IA (violeta de SaaS ou neon); troque.`);
+                else out.paleta = v.map((c) => c.toUpperCase());
+            } else if (paletas()[v]) out.paleta = paletas()[v];
+            else avisos.push(`paleta "${v}" não existe: ${P.paleta.join(', ')} ou 5 cores suas.`);
+            continue;
+        }
+        if (!P[campo]) { avisos.push(`"${campo}" não é peça de estilo: ${Object.keys(P).join(', ')}.`); continue; }
+        if (P[campo].includes(v)) out[campo] = v;
+        else avisos.push(`${campo} "${v}" não existe: ${P[campo].join(', ')}.`);
+    }
+    return { pecas: out, avisos };
+}
+
+/**
+ * O estilo do vídeo a partir do que a IA pediu (objeto, ou o nome de um salvo).
+ * Devolve as escolhasGerativo prontas: o que ela não disse, o sorteio completa.
+ */
+function montar(pedido, roteiro = {}, { aleatorio } = {}) {
+    let p = typeof pedido === 'string' ? { base: pedido } : { ...(pedido || {}) };
+    const avisos = [];
+    if (p.base) {
+        const salvo = ler(p.base);
+        if (salvo) p = { ...salvo.pecas, ...p };
+        else avisos.push(`não existe estilo salvo "${p.base}".`);
+    }
+    const v = validar(p);
+    avisos.push(...v.avisos);
+    const humor = v.pecas.humor;
+    const sorteio = gerativo.escolherVisual(humor ? { ...roteiro, pedido: `${roteiro.pedido || ''} ${gerativo.HUMORES[humor].palavras}` } : roteiro, { aleatorio });
+    const escolhas = { ...sorteio };
+    for (const campo of ['humor', 'paleta', 'display', 'texto', 'mono', 'genero', 'ambiente', 'acento']) if (v.pecas[campo]) escolhas[campo] = v.pecas[campo];
+    if (v.pecas.material) escolhas.icones = { ...(sorteio.icones || {}), material: v.pecas.material };
+    return { escolhas, escolhidas: Object.keys(v.pecas), avisos };
+}
+
+function lerTudo() {
+    try { const j = JSON.parse(fs.readFileSync(arquivo(), 'utf8')); return j && typeof j === 'object' ? j : {}; } catch { return {}; }
+}
+
+function ler(nome) {
+    const k = chave(nome);
+    return k ? lerTudo()[k] || null : null;
+}
+
+function listar() {
+    return Object.entries(lerTudo()).map(([k, e]) => ({ chave: k, nome: e.nome, descricao: e.descricao || '', pecas: e.pecas }));
+}
+
+/** Guarda o estilo. `autorizado` é a resposta da pessoa: sem ela, nada é escrito. */
+function salvar({ nome, pecas: pedido, descricao, autorizado } = {}) {
+    if (autorizado !== true) {
+        return { ok: false, error: 'falta o sim da pessoa.', comoResolver: 'pergunte "posso salvar este estilo pra usar nos próximos vídeos?" e só chame de novo com autorizado:true se ela disser que sim.' };
+    }
+    const k = chave(nome);
+    if (!k) return { ok: false, error: 'dê um nome ao estilo (ex: "padaria de manhã").' };
+    const v = validar(pedido);
+    if (!Object.keys(v.pecas).length) return { ok: false, error: 'nenhuma peça válida para guardar.', avisos: v.avisos };
+    const tudo = lerTudo();
+    const novo = { nome: String(nome).slice(0, 60), pecas: v.pecas, salvo: new Date().toISOString() };
+    if (typeof descricao === 'string' && descricao.trim()) novo.descricao = descricao.slice(0, 200);
+    tudo[k] = novo;
+    fs.mkdirSync(path.dirname(arquivo()), { recursive: true });
+    fs.writeFileSync(arquivo(), JSON.stringify(tudo, null, 2));
+    return { ok: true, chave: k, estilo: novo, avisos: v.avisos, comoUsar: `no próximo vídeo, roteiro.estiloVisual:"${k}" traz este estilo (ou {base:"${k}", ...} para misturar).` };
+}
+
+/** O cardápio que a IA lê antes de montar o estilo. */
+function cardapio() {
+    return {
+        ok: true,
+        total: total(),
+        pecas: { ...pecas(), paleta: paletas() },
+        salvos: listar(),
+        comoUsar: 'monte o estilo pelo ASSUNTO e passe roteiro.estiloVisual {humor, paleta, display, texto, mono, genero, ambiente, acento, material} no estilo gerativo. '
+            + 'Paleta: um nome da lista ou 5 cores suas [escura, assinatura, papel, ousada, ousada]. Misture: {base:"<salvo>", display:"..."} troca só uma peça. '
+            + 'Peça vazia, o PrimoCode completa sem repetir os últimos vídeos. Ficou bom? Pergunte se pode salvar e use acao:"salvar_estilo".',
+    };
+}
+
+module.exports = { pecas, paletas, total, validar, montar, salvar, ler, listar, cardapio, arquivo };

package/lib/estudio/gerativo.js

@@ -192,6 +192,15 @@ const HUMORES = {
         paletas: [['#2A0E12', '#F0E6D6', '#C9A24A'], ['#F1EBE1', '#1B1A17', '#8C1C13']],
         generos: ['jazz', 'soul-rnb', 'classical'], som: 'papel',
     },
+    /* (14/10) A padaria caía no editorial — música clássica e mono de jornal —
+       porque nenhum humor era de comida. */
+    comida: {
+        palavras: 'pao paes padaria padeiro cafe cafeteria bolo bolos doce doces confeitaria forno fornada fermentacao massa farinha receita cozinha comida restaurante pizza lanche almoco jantar sabor chef croissant',
+        displays: ['Fraunces', 'Playfair Display', 'Bricolage Grotesque'], textos: ['Hanken Grotesk', 'Familjen Grotesk'], monos: ['Space Mono', 'Martian Mono'],
+        serifas: ['Instrument Serif', 'Fraunces'], cineticas: ['Anybody', 'Archivo'],
+        paletas: [['#F3E6CF', '#3B2416', '#B5651D'], ['#EFE3D0', '#2A1A12', '#C8553D']],
+        generos: ['acoustic', 'jazz', 'soul-rnb'], som: 'organico',
+    },
 };
 /* A cor que o próprio assunto diz ("por que o céu é AZUL") vira o acento. */
 const CORES_DITAS = { azul: '#2546D9', vermelho: '#C8291E', verde: '#2F7D4F', laranja: '#FF5F1F', amarelo: '#E8B92F', dourado: '#C9A24A', rosa: '#E86A8A', coral: '#FF6F59' };
@@ -208,11 +217,15 @@ const ICONE_DE = {
     notebook: 'celular', pronto: 'check', feito: 'check', certo: 'check', proximo: 'seta', passo: 'seta', adiante: 'seta', ricocheteia: 'seta',
 };
 
+/* O humor novo (comida, 14/10) só entra quando o roteiro diz as palavras dele:
+   não gasta a semente (a mesma semente segue dando o mesmo vídeo nos projetos
+   que já existem) nem tira a vez dos outros num roteiro que não é de comida. */
+const SO_COM_PALAVRA = new Set(['comida']);
 /** O humor do roteiro: as palavras dele contra as de cada humor (empate: a semente). */
 function humorDe(roteiro, s) {
     const n = acertosDeHumor(roteiro);
     const nota = {};
-    for (const h of Object.keys(HUMORES)) nota[h] = n[h] + s.prox() * 0.5;
+    for (const h of Object.keys(HUMORES)) nota[h] = SO_COM_PALAVRA.has(h) ? (n[h] ? n[h] + 0.25 : -1) : n[h] + s.prox() * 0.5;
     return Object.entries(nota).sort((a, b) => b[1] - a[1])[0][0];
 }
 /** Quantas palavras de cada humor o roteiro diz. */
@@ -241,7 +254,7 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
     const marca = require('./marca.js').marcaEmObjeto(roteiro.marca);
     const n = acertosDeHumor(roteiro);
     const max = Math.max(...Object.values(n));
-    const humor = variedade.sortear(Object.keys(HUMORES), 'humor-gerativo', { aleatorio, adequacao: (h) => (n[h] + 1) / (max + 1) });
+    const humor = variedade.sortear(Object.keys(HUMORES).filter((h) => !SO_COM_PALAVRA.has(h) || n[h]), 'humor-gerativo', { aleatorio, adequacao: (h) => (n[h] + 1) / (max + 1) });
     const de = (campo, outros) => { const m = {}; for (const [h, d] of Object.entries(HUMORES)) for (const x of d[campo]) if (!BANIDAS.includes(x) && (m[x] == null || h === humor)) m[x] = h === humor ? 1 : outros; return m; };
     const escolher = (m, tipo, prefixo) => variedade.sortear(Object.keys(m), tipo, { aleatorio, prefixo, adequacao: m });
     const out = { humor };
@@ -524,7 +537,8 @@ function pesosDe(c, { curto, palavras, primeira, ultima, tem3d, pergunta, exclam
         case 'contraste': return { divisao: 5, duelo: 2.6 };
         case 'citacao': return { citacao: 5, pilha: 1 };
         case 'marca': return { marca: primeira || ultima ? 4.5 : 3, gigante: 2.4, parede: curto ? 2 : 0 };
-        case 'cta': return { pilha: 3, gigante: curto ? 2.6 : 0.6, parede: c.titulo.length <= 16 ? 1.6 : 0, marca: 1, produto: tem3d ? 3.5 : 0 };
+        // A marca é UMA linha: "Todo dia às 7h – Padaria Pão Quente" saía em 40 px (14/10). Chamada longa empilha.
+        case 'cta': return { pilha: 3, gigante: curto ? 2.6 : 0.6, parede: c.titulo.length <= 16 ? 1.6 : 0, marca: c.titulo.length <= 18 ? 1 : 0, produto: tem3d ? 3.5 : 0 };
         case 'produto': return tem3d ? { produto: 9, pilha: 0.5 } : { pilha: 3, gigante: curto ? 2.5 : 0.5, parede: c.titulo.length <= 12 ? 1.2 : 0 };
         case 'falado': return { palavras: 4, gigante: palavras <= 3 ? 2.6 : 0, pilha: palavras <= 9 ? 1.2 : 0 };
         default: return {
@@ -628,6 +642,7 @@ const CAMPOS = {
     energia: [['#0B0B0B', '#FF4F00', '#F2EEE6', '#1D3BD1', '#C9F23A'], ['#101010', '#E8C547', '#F4EBDD', '#E5322D', '#2A57FF']],
     natureza: [['#0F2A2A', '#F2A541', '#F2EDE2', '#2546D9', '#E4573D'], ['#13233F', '#2546D9', '#F2EDE2', '#F2A541', '#C8553D']],
     luxo: [['#120D0B', '#C9A24A', '#F0E6D6', '#5B1A1F', '#2F4F4F']],
+    comida: [['#2A1A12', '#C47A2C', '#F3E6CF', '#7A2E1C', '#E8C27A'], ['#1F1611', '#B5651D', '#F5ECDD', '#5E7D3A', '#E9B44C']],
 };
 function camposDe(marca, humor, s, dita = null, fixa = null) {
     const c = marca.cores || {};
@@ -2024,4 +2039,5 @@ function contarAcentos(b) {
 module.exports = { tituloDaFala,
     montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, escolherVisual, MOLDURAS, AMBIENTES, ACENTOS_JEITO, ARRANJOS_ICONE, RITMOS_ICONE, MATERIAIS_ICONE, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
     especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO, HEROIS_3D, FAMILIA_HEROI,
+    CAMPOS, escolhasValidas,
 };