primocode 10.6.0 → 10.7.1

package/lib/estudio/index.js

@@ -67,6 +67,8 @@ const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
 const personagem = require('./personagem.js');
 const mundo = require('./mundo.js');
+const cenarios = require('./cenarios.js');
+const movimentos = require('./movimentos.js');
 const colecao = require('./colecao.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
@@ -277,6 +279,28 @@ function projetoRecente() {
     return lista[0] || null;
 }
 
+/* Sem id, o projeto é o que acabou de ser criado. Visto em 12/10: o agente
+   criou o projeto, chamou estudio_narrar sem id e o vídeo morreu ali. Só vale
+   para chamada SEM id (id errado continua sendo erro) e para projeto de até
+   30 minutos, como no estudio_plano. */
+function projetoOuRecente(id) {
+    if (id != null && String(id).trim() !== '') return projeto.ler(id);
+    return projetoRecente();
+}
+
+/* roteiro.objetos: [{nome, src}] com o PNG DENTRO da pasta do projeto (o que
+   o estudio_midia baixou ou recortou). Caminho de fora some: o render só
+   enxerga a pasta do projeto, e a IA não escolhe arquivo da máquina. */
+function objetosDoRoteiro(objetos, pasta) {
+    const raiz = path.resolve(pasta);
+    return (Array.isArray(objetos) ? objetos : []).map((o) => {
+        if (!o || typeof o.src !== 'string') return null;
+        const abs = path.resolve(raiz, o.src);
+        if (!abs.startsWith(raiz + path.sep) || !/\.png$/i.test(abs) || !fs.existsSync(abs)) return null;
+        return { nome: o.nome, src: path.relative(raiz, abs).replace(/\\/g, '/') };
+    }).filter(Boolean);
+}
+
 /** O roteiro é utilizável como veio? (objeto ou JSON, com partes de tipo conhecido) */
 function roteiroValido(r) {
     let x = r;
@@ -527,6 +551,19 @@ async function ferramentaMidia(args) {
     /* A BIBLIOTECA (colecao.js, 11/10): o cardápio inteiro, o ícone 3D e a
        animação pronta. Procurar não usa rede (o índice mora no pacote); com
        id, baixa para o projeto e devolve o elemento pronto. */
+    /* OS MOVIMENTOS (movimentos.js, 12/10): 100+ entradas, saídas, ênfases e loops com nome. */
+    if (acao === 'movimentos' || acao === 'movimento') {
+        return movimentos.procurar({ termo: args.termo, categoria: args.categoria, limite: Number(args.limite) || 30 });
+    }
+    /* OS CENÁRIOS (cenarios.js, 12/10): os lugares prontos + os que a IA criou
+       e a pessoa deixou guardar. Salvar só com o sim dela (autorizado:true). */
+    if (acao === 'cenarios' || acao === 'cenários') {
+        return { ok: true, prontos: Object.keys(mundo.LUGARES), salvos: cenarios.listar(),
+            comoCriar: 'na cena do estilo personagem: lugar (um pronto como base), ceu [cor de cima, cor do horizonte], chao {tipo, cor, cor2}, parede, luz, acento, hora e elementos. Ficou bom? Pergunte se pode salvar e use acao:"salvar_cenario".' };
+    }
+    if (acao === 'salvar_cenario' || acao === 'salvar_cenário') {
+        return cenarios.salvar({ nome: args.nome, cenario: args.cenario, autorizado: args.autorizado, bases: Object.keys(mundo.LUGARES) });
+    }
     if (acao === 'biblioteca' || acao === 'cardapio' || acao === 'cardápio') return colecao.cardapio();
     if (acao === 'icones3d' || acao === 'icone3d' || acao === 'animacoes' || acao === 'animacao' || acao === 'animação' || acao === 'animações') {
         const ehAnim = /^anima/.test(acao);
@@ -585,8 +622,9 @@ async function baixarEscolhido(lista, args, p) {
 async function ferramentaNarrar(args) {
     if (args.vozes) return rodarPython('narrar.py', ['vozes'], { timeout: 30000 });
 
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
     const texto = String(args.texto || '').trim();
     if (!texto) return { ok: false, error: 'não há texto para narrar.' };
 
@@ -616,8 +654,9 @@ async function ferramentaNarrar(args) {
 
 async function ferramentaVideo(args, ctx = {}) {
     const acao = String(args.acao || 'medir').toLowerCase();
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
 
     const pronto = video.conferir();
     if (!pronto.ok) return pronto;
@@ -1871,7 +1910,7 @@ async function prepararRoteiro(p, args) {
         return r;
     }
     if (estilo === 'personagem' && modo === 'video') {
-        const r = personagem.montarPersonagem({ roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt }, largura, altura, tempos, narracao, sons, trilha });
+        const r = personagem.montarPersonagem({ roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt, voz: args.voz || roteiro.voz }, largura, altura, tempos, narracao, sons, trilha });
         if (r.ok) {
             /* O que não é peça do catálogo vira ícone 3D da biblioteca, em blocos
                (kit/mundo.jsx): "uma pizza que fala", "um violão na praia". Sem
@@ -1884,6 +1923,7 @@ async function prepararRoteiro(p, args) {
                 if (b && b.ok) achados[nome] = b.src;
             }
             mundo.aplicarIcones(r.partitura, achados);
+            mundo.adicionarObjetos(r.partitura, objetosDoRoteiro(roteiro.objetos, p.pasta));
             const icones = Object.keys(achados);
             projeto.anotar(p.id, 'plano', `estilo personagem: ${r.resumo.elenco.join(' e ')}${r.resumo.figurantes.length ? ` (+ ${r.resumo.figurantes.join(', ')})` : ''} em ${r.resumo.lugares.join(' → ')}, ${r.resumo.planos} planos, ${r.resumo.segundos}s${icones.length ? `; em blocos: ${icones.join(', ')}` : ''}`);
         }
@@ -1962,8 +2002,9 @@ async function transcrever(p, alvo, ctx) {
 // ── estudio_render ───────────────────────────────────────────────────────
 
 async function ferramentaRender(args, ctx = {}) {
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
     const pl = projeto.lerPlano(args.id);
     if (!pl) return { ok: false, error: 'não há plano neste projeto.' };
 
@@ -2209,7 +2250,7 @@ async function ferramentaSite(args) {
 }
 
 module.exports = {
-    vazamentoNoComeco, variarIcones,
+    vazamentoNoComeco, variarIcones, objetosDoRoteiro,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,

package/lib/estudio/kit/mundo.jsx

@@ -706,13 +706,13 @@ function texturaCartaoUso(titulo, linhas, k, uso) {
     return cv;
   }
   g.fillStyle = '#ff6a2b'; g.beginPath(); g.arc(46, 50, 9, 0, Math.PI * 2); g.fill();
-  g.fillStyle = '#f2f2f7'; g.font = `600 28px ${F}`; g.fillText(`Claude · sessão ${k + 1}`, 66, 60);
+  g.fillStyle = '#f2f2f7'; g.font = `600 28px ${F}`; g.fillText(`Primo · sessão ${k + 1}`, 66, 60);   // a marca é a do PrimoCode, nunca a da referência (12/10)
   g.fillStyle = '#ffffff'; g.font = `700 30px ${F}`; g.fillText(String(titulo).slice(0, 30), 34, 134);
   g.fillStyle = 'rgba(225,225,235,0.75)'; g.font = `400 24px ${F}`;
   (linhas || []).slice(0, 3).forEach((l, i) => g.fillText('· ' + String(l).slice(0, 34), 34, 178 + i * 36));
   g.fillStyle = '#ff6a2b'; g.font = `500 22px ${F}`; g.fillText(`● trabalhando · ${30 + k * 7}:${String(10 + k * 13).slice(0, 2)}`, 34, 312);
   g.fillStyle = 'rgba(255,255,255,0.06)'; g.beginPath(); g.roundRect(34, 336, 572, 40, 12); g.fill();
-  g.fillStyle = 'rgba(225,225,235,0.45)'; g.font = `400 20px ${F}`; g.fillText('Pergunte ao Claude…', 50, 363);
+  g.fillStyle = 'rgba(225,225,235,0.45)'; g.font = `400 20px ${F}`; g.fillText('Peça qualquer coisa…', 50, 363);
   return cv;
 }
 function CartoesDeUso({ paineis = [], t }) {

package/lib/estudio/kit/voxel.jsx

@@ -289,18 +289,32 @@ function CabeloFacetado({ estilo, cor }) {
       const u = hash(i * 3.7 + 1), v = hash(i * 9.1 + 4);
       const az = u * Math.PI * 2;
       const el = estilo === 'longo' ? -0.9 + v * 2.2 : 0.15 + v * 1.25;
-      const atras = Math.cos(az) < 0.35 || el > 0.75;
-      if (!atras) continue;
+      /* O rosto olha para +z (fz = 0.335 na CabecaFacetada). Até a 10.7 o
+         filtro guardava cos(az) < 0.35 — z positivo, a FRENTE — e os cachos
+         caíam no olho e na bochecha (12/10). Agora a pedra fica atrás da linha
+         das orelhas, ou no alto da cabeça, acima da testa. */
+      const z = -Math.cos(az) * Math.cos(el) * 0.34;
+      const y = 0.04 + Math.sin(el) * 0.38;
+      if (z > 0.05 && y < 0.3) continue;
+      if (z > 0.18) continue;
       const r = estilo === 'cacheado' ? 0.105 + hash(i) * 0.05 : 0.09 + hash(i) * 0.03;
-      out.push({ p: [Math.sin(az) * Math.cos(el) * 0.33, 0.04 + Math.sin(el) * 0.38, -Math.cos(az) * Math.cos(el) * 0.34 + (Math.cos(az) > 0 ? 0.0 : -0.02)], r, k: i });
+      out.push({ p: [Math.sin(az) * Math.cos(el) * 0.33, y, z - 0.02], r, k: i });
     }
-    if (estilo === 'coque') out.push({ p: [0, 0.36, -0.3], r: 0.16, k: 99 });
+    // O coque no alto e um pouco para trás: visível de frente (atrás, sumia e virava cabelo curto).
+    if (estilo === 'coque') out.push({ p: [0, 0.46, -0.12], r: 0.17, k: 99 });
     return out;
   }, [estilo]);
   // A franja: a frente do cabelo, um pouco acima da sobrancelha.
   return (
     <group>
       {estilo !== 'careca' && <Faceta p={[0, 0.2, -0.02]} s={[0.36, 0.26, 0.36]} c={cor} det={1} rough={0.9} />}
+      {/* O LONGO cai pelos lados até o ombro, por FORA da cabeça — as pedrinhas
+          ficavam dentro do crânio e, de frente, ela parecia de cabelo curto (12/10). */}
+      {estilo === 'longo' && <>
+        <Faceta p={[-0.33, -0.1, -0.04]} s={[0.11, 0.34, 0.24]} c={cor} det={1} rough={0.9} />
+        <Faceta p={[0.33, -0.1, -0.04]} s={[0.11, 0.34, 0.24]} c={cor} det={1} rough={0.9} />
+        <Faceta p={[0, -0.08, -0.26]} s={[0.34, 0.38, 0.13]} c={cor} det={1} rough={0.9} />
+      </>}
       {pedras.map((x) => <Faceta key={x.k} p={x.p} s={[x.r, x.r * 0.9, x.r]} rot={[hash(x.k) * 3, hash(x.k + 1) * 3, 0]} c={escurecer(cor, 0.85 + hash(x.k + 2) * 0.3)} det={0} rough={0.95} />)}
     </group>
   );
@@ -599,9 +613,11 @@ function alturaDaCabeca(p) {
   return 1.8;
 }
 /* Os figurantes ficam nas pontas do arco, um pouco atrás: estão na cena, mas não roubam o plano. */
-function lugarDoFigurante(el, fig, j) {
+function lugarDoFigurante(el, fig, j, vert = false) {
   const n = Math.max(1, el.length);
-  const borda = n === 1 ? 1.15 : n === 2 ? 1.75 : 2.5;
+  /* No vertical o quadro é estreito: na ponta do arco (1,15) o gato pedido
+     ficava fora da tela o vídeo inteiro (12/10). Vem para perto, aos pés. */
+  const borda = vert ? (n === 1 ? 0.62 : n === 2 ? 1.1 : 1.6) : n === 1 ? 1.15 : n === 2 ? 1.75 : 2.5;
   const lado = j % 2 ? 1 : -1;
   const baixo = fig.tipo === 'animal' || fig.tipo === 'coisa';
   return [lado * (borda + Math.floor(j / 2) * 0.9), 0, baixo ? 0.45 : -0.5];
@@ -836,7 +852,7 @@ export function VoxelCena({ el, t }) {
             </group>
           ))}
           {figurantes.map((p, j) => (
-            <group key={'f' + j} position={lugarDoFigurante(elenco, p, j)} rotation={[0, (j % 2 ? -1 : 1) * 0.5, 0]}>
+            <group key={'f' + j} position={lugarDoFigurante(elenco, p, j, W < H)} rotation={[0, (j % 2 ? -1 : 1) * 0.5, 0]}>
               {desenhar(p, estado(10 + j, true))}
             </group>
           ))}

package/lib/estudio/movimentos.js

@@ -0,0 +1,212 @@
+/**
+ * movimentos.js — a biblioteca de MOVIMENTOS prontos: entradas, saídas,
+ * ênfases e loops, cada um com nome, que viram quadros-chave do `anima`.
+ *
+ *   "preciso que você deixe os motions com + de 100 tipos de animações …
+ *    além da IA poder criar os próprios e pesquisar" (Joel, 12/10)
+ *
+ * Até aqui todo movimento era escrito à mão pelo modelo, quadro a quadro
+ * (`anima: {opacidade: [{t, v}]}`). Modelo grátis escreve sempre os mesmos
+ * dois: esmaecer e subir. Com nome, ele PROCURA ("quique", "desfoque",
+ * "saída para a esquerda"), escolhe e escreve uma palavra:
+ *
+ *   elemento.movimento = "quicar-de-baixo"
+ *   elemento.movimento = {nome: "sair-girando", em: 2.4, duracao: 0.5}
+ *   elemento.movimento = ["surgir-desfocado", {nome: "flutuar", em: 0.6}]
+ *
+ * O plano expande isso em `anima` antes de conferir (plano.js). O que a IA
+ * escreveu em `anima` vence o movimento pronto na mesma propriedade — e ela
+ * continua livre para inventar o seu, quadro a quadro.
+ *
+ * Os números: x/y/z são DESLOCAMENTOS em px (o render soma à posição), as
+ * rotações em graus, o desfoque em px, opacidade/escala/brilho/saturação em
+ * fração. Todo movimento de entrada termina no repouso (0 de deslocamento,
+ * escala 1, opacidade 1); toda saída começa nele.
+ */
+
+'use strict';
+
+// Cada quadro: [fração do tempo 0..1, valor, suavização até ele].
+const DIRECOES = {
+    'de-baixo': { eixo: 'y', sinal: 1 }, 'de-cima': { eixo: 'y', sinal: -1 },
+    'da-esquerda': { eixo: 'x', sinal: -1 }, 'da-direita': { eixo: 'x', sinal: 1 },
+};
+const PARA = { 'de-baixo': 'para-baixo', 'de-cima': 'para-cima', 'da-esquerda': 'para-a-esquerda', 'da-direita': 'para-a-direita' };
+
+/* As entradas com direção: cada estilo × as quatro direções. */
+const ESTILOS_DIRECAO = {
+    deslizar: { d: 0.6, desc: 'desliza e aparece', f: (e, s) => ({ [e]: [[0, 80 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.6, 1, 'suave']] }) },
+    'deslizar-desfocado': { d: 0.7, desc: 'desliza saindo do desfoque', f: (e, s) => ({ [e]: [[0, 70 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.5, 1]], desfoque: [[0, 18], [1, 0, 'saida']] }) },
+    'chegar-elastico': { d: 0.9, desc: 'chega passando do ponto e volta, como mola', f: (e, s) => ({ [e]: [[0, 220 * s], [1, 0, 'elastico']], opacidade: [[0, 0], [0.25, 1]] }) },
+    quicar: { d: 0.9, desc: 'cai e quica', f: (e, s) => ({ [e]: [[0, 260 * s], [1, 0, 'salto']], opacidade: [[0, 0], [0.2, 1]] }) },
+    varrer: { d: 0.8, desc: 'atravessa rápido de longe e freia', f: (e, s) => ({ [e]: [[0, 900 * s], [1, 0, 'arrasto']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'girar-entrando': { d: 0.8, desc: 'entra girando', f: (e, s) => ({ [e]: [[0, 160 * s], [1, 0, 'saida']], rotacao: [[0, -90 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.4, 1]] }) },
+};
+
+/* As entradas sem direção. */
+const ENTRADAS = {
+    surgir: { d: 0.5, desc: 'só aparece (esmaecer)', f: () => ({ opacidade: [[0, 0], [1, 1, 'suave']] }) },
+    crescer: { d: 0.6, desc: 'cresce do nada', f: () => ({ escala: [[0, 0], [1, 1, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'crescer-elastico': { d: 0.9, desc: 'cresce como mola', f: () => ({ escala: [[0, 0], [1, 1, 'elastico']] }) },
+    'pular-pra-dentro': { d: 0.6, desc: 'cresce, passa um pouco e assenta', f: () => ({ escala: [[0, 0], [0.7, 1.15, 'saida'], [1, 1, 'suave']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'encolher-pra-dentro': { d: 0.6, desc: 'vem grande e encolhe até o lugar', f: () => ({ escala: [[0, 1.8], [1, 1, 'saida']], opacidade: [[0, 0], [0.5, 1]] }) },
+    'surgir-desfocado': { d: 0.7, desc: 'sai do desfoque', f: () => ({ desfoque: [[0, 24], [1, 0, 'saida']], opacidade: [[0, 0], [0.6, 1]] }) },
+    'virar-de-lado': { d: 0.7, desc: 'vira em Y como carta', f: () => ({ rotacaoY: [[0, 90], [1, 0, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'virar-de-cima': { d: 0.7, desc: 'tomba em X, de cima para baixo', f: () => ({ rotacaoX: [[0, -90], [1, 0, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'girar-crescendo': { d: 0.8, desc: 'cresce dando meia volta', f: () => ({ rotacao: [[0, -180], [1, 0, 'saida']], escala: [[0, 0], [1, 1, 'saida']] }) },
+    'vir-do-fundo': { d: 0.8, desc: 'avança da profundidade (3D)', f: () => ({ z: [[0, -700], [1, 0, 'saida']], opacidade: [[0, 0], [0.4, 1]] }) },
+    'cair-do-alto': { d: 0.8, desc: 'cai do topo e assenta com um quique', f: () => ({ y: [[0, -500], [1, 0, 'salto']], rotacao: [[0, -12], [1, 0, 'saida']] }) },
+    'estourar-de-luz': { d: 0.6, desc: 'acende estourado e assenta', f: () => ({ brilho: [[0, 3], [1, 1, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'ganhar-cor': { d: 0.8, desc: 'sai do cinza para a cor', f: () => ({ saturacao: [[0, 0], [1, 1, 'suave']], opacidade: [[0, 0], [0.4, 1]] }) },
+    'abrir-letras': { d: 0.8, desc: 'as letras chegam juntas de longe (texto)', f: () => ({ espacamento: [[0, 40], [1, 0, 'saida']], opacidade: [[0, 0], [0.5, 1]] }) },
+    'esticar-de-lado': { d: 0.6, desc: 'estica na horizontal', f: () => ({ escalaX: [[0, 0], [1, 1, 'saida']] }) },
+    'esticar-de-pe': { d: 0.6, desc: 'estica na vertical', f: () => ({ escalaY: [[0, 0], [1, 1, 'saida']] }) },
+    'carimbo': { d: 0.35, desc: 'bate na tela como carimbo', f: () => ({ escala: [[0, 2.4], [1, 1, 'entrada']], opacidade: [[0, 0], [0.2, 1]] }) },
+    'aproximar-editorial': { d: 0.9, desc: 'entra devagar, como revista', f: () => ({ y: [[0, 24], [1, 0, 'editorial']], escala: [[0, 0.96], [1, 1, 'editorial']], opacidade: [[0, 0], [1, 1, 'editorial']] }) },
+};
+
+/* As ênfases: o elemento já está lá e chama atenção (começam e terminam no repouso). */
+const ENFASES = {
+    pulsar: { d: 0.5, desc: 'cresce e volta uma vez', f: () => ({ escala: [[0, 1], [0.5, 1.12, 'suave'], [1, 1, 'suave']] }) },
+    tremer: { d: 0.5, desc: 'treme de lado (erro, negação)', f: () => ({ x: [[0, 0], [0.15, -14], [0.3, 12], [0.45, -10], [0.6, 8], [0.75, -4], [1, 0]] }) },
+    balancar: { d: 0.8, desc: 'balança como pêndulo', f: () => ({ rotacao: [[0, 0], [0.25, 12, 'suave'], [0.5, -8, 'suave'], [0.75, 4, 'suave'], [1, 0, 'suave']] }) },
+    piscar: { d: 0.6, desc: 'pisca duas vezes', f: () => ({ opacidade: [[0, 1], [0.25, 0.1], [0.5, 1], [0.75, 0.1], [1, 1]] }) },
+    'dar-uma-volta': { d: 0.8, desc: 'gira 360°', f: () => ({ rotacao: [[0, 0], [1, 360, 'suave']] }) },
+    'virar-moeda': { d: 0.8, desc: 'gira em Y como moeda', f: () => ({ rotacaoY: [[0, 0], [1, 360, 'suave']] }) },
+    'pular': { d: 0.6, desc: 'dá um pulinho', f: () => ({ y: [[0, 0], [0.4, -40, 'saida'], [1, 0, 'salto']] }) },
+    'tada': { d: 0.9, desc: 'cresce e chacoalha (conquista)', f: () => ({ escala: [[0, 1], [0.2, 0.9], [0.4, 1.12], [0.9, 1.12], [1, 1]], rotacao: [[0, 0], [0.3, -4], [0.45, 4], [0.6, -4], [0.75, 4], [1, 0]] }) },
+    'borracha': { d: 0.8, desc: 'amassa e estica como borracha', f: () => ({ escalaX: [[0, 1], [0.3, 1.25], [0.4, 0.75], [0.5, 1.15], [0.65, 0.95], [1, 1]], escalaY: [[0, 1], [0.3, 0.75], [0.4, 1.25], [0.5, 0.85], [0.65, 1.05], [1, 1]] }) },
+    'gelatina': { d: 0.9, desc: 'treme mole', f: () => ({ escalaX: [[0, 1], [0.2, 1.1], [0.4, 0.92], [0.6, 1.04], [0.8, 0.98], [1, 1]], escalaY: [[0, 1], [0.2, 0.92], [0.4, 1.08], [0.6, 0.97], [0.8, 1.01], [1, 1]] }) },
+    'acenar': { d: 0.8, desc: 'balança curto, como aceno', f: () => ({ rotacao: [[0, 0], [0.2, 14], [0.4, -8], [0.6, 14], [0.8, -4], [1, 0]] }) },
+    'acender': { d: 0.6, desc: 'brilha e apaga uma vez', f: () => ({ brilho: [[0, 1], [0.4, 1.8, 'suave'], [1, 1, 'suave']] }) },
+    'inclinar-3d': { d: 0.9, desc: 'inclina em 3D e volta', f: () => ({ rotacaoX: [[0, 0], [0.5, 18, 'suave'], [1, 0, 'suave']], rotacaoY: [[0, 0], [0.5, -14, 'suave'], [1, 0, 'suave']] }) },
+    'cabecear': { d: 0.6, desc: 'acena com a cabeça (sim)', f: () => ({ rotacaoX: [[0, 0], [0.3, 20], [0.6, -6], [1, 0]] }) },
+    'empurrao': { d: 0.4, desc: 'leva um soco e volta', f: () => ({ escala: [[0, 1], [0.25, 0.86, 'entrada'], [1, 1, 'elastico']] }) },
+    'sublinhar-luz': { d: 0.7, desc: 'fica vivo por um instante', f: () => ({ saturacao: [[0, 1], [0.4, 1.8, 'suave'], [1, 1, 'suave']], brilho: [[0, 1], [0.4, 1.3, 'suave'], [1, 1]] }) },
+};
+
+/* Os loops: repetem pela duração inteira (o padrão é a cena toda, 4 s). */
+const LOOPS = {
+    flutuar: { d: 4, ciclo: 2.4, desc: 'sobe e desce devagar', f: () => ({ y: [[0, 0], [0.5, -16, 'suave'], [1, 0, 'suave']] }) },
+    respirar: { d: 4, ciclo: 2, desc: 'cresce e encolhe de leve', f: () => ({ escala: [[0, 1], [0.5, 1.05, 'suave'], [1, 1, 'suave']] }) },
+    'girar-sem-parar': { d: 4, ciclo: 4, desc: 'gira sem parar', f: () => ({ rotacao: [[0, 0], [1, 360, 'linear']] }) },
+    'oscilar': { d: 4, ciclo: 1.6, desc: 'balança de leve sem parar', f: () => ({ rotacao: [[0, -5], [0.5, 5, 'suave'], [1, -5, 'suave']] }) },
+    'batimento': { d: 4, ciclo: 1, desc: 'pulsa como coração', f: () => ({ escala: [[0, 1], [0.15, 1.12], [0.3, 1], [0.45, 1.08], [0.6, 1], [1, 1]] }) },
+    'piscar-devagar': { d: 4, ciclo: 1.6, desc: 'some e volta devagar', f: () => ({ opacidade: [[0, 1], [0.5, 0.35, 'suave'], [1, 1, 'suave']] }) },
+    'orbitar': { d: 4, ciclo: 3, desc: 'anda em círculo pequeno', f: () => ({ x: [[0, 20], [0.25, 0, 'suave'], [0.5, -20, 'suave'], [0.75, 0, 'suave'], [1, 20, 'suave']], y: [[0, 0], [0.25, 20, 'suave'], [0.5, 0, 'suave'], [0.75, -20, 'suave'], [1, 0, 'suave']] }) },
+    'deriva': { d: 4, ciclo: 4, desc: 'anda de lado bem devagar', f: () => ({ x: [[0, -12], [0.5, 12, 'suave'], [1, -12, 'suave']] }) },
+    'girar-3d': { d: 4, ciclo: 5, desc: 'gira em Y sem parar, como vitrine', f: () => ({ rotacaoY: [[0, 0], [1, 360, 'linear']] }) },
+    'brilho-vivo': { d: 4, ciclo: 2, desc: 'o brilho respira', f: () => ({ brilho: [[0, 1], [0.5, 1.25, 'suave'], [1, 1, 'suave']] }) },
+    'balanco-3d': { d: 4, ciclo: 3, desc: 'inclina em 3D de um lado para o outro', f: () => ({ rotacaoY: [[0, -12], [0.5, 12, 'suave'], [1, -12, 'suave']] }) },
+    'tremor-leve': { d: 4, ciclo: 0.3, desc: 'vibra o tempo todo (tensão, alerta)', f: () => ({ x: [[0, 0], [0.25, -2], [0.5, 2], [0.75, -1], [1, 0]] }) },
+};
+
+/* A SAÍDA é a entrada ao contrário: o mesmo desenho, tempo invertido. */
+function inverter(gerado) {
+    const out = {};
+    for (const [prop, qs] of Object.entries(gerado)) {
+        const ordem = [...qs].reverse();
+        // A suavização de um quadro vale ATÉ ele; invertida, passa ao vizinho.
+        out[prop] = ordem.map(([f, v], i) => [1 - f, v, i > 0 ? inverterE(ordem[i - 1][2]) : undefined]);
+    }
+    return out;
+}
+const inverterE = (e) => ({ saida: 'entrada', entrada: 'saida', arrasto: 'acelera', acelera: 'arrasto', elastico: 'entrada', salto: 'entrada' }[e] || e);
+const nomeDaSaida = (n) => n.replace(/^surgir/, 'sumir').replace(/^crescer/, 'encolher-sumindo').replace(/^chegar/, 'partir')
+    .replace(/^vir-do-fundo/, 'ir-pro-fundo').replace(/^cair-do-alto/, 'cair-pra-fora').replace(/^ganhar-cor/, 'perder-cor')
+    .replace(/^abrir-letras/, 'espalhar-letras').replace(/^estourar-de-luz/, 'apagar-estourando');
+
+function montarCatalogo() {
+    const cat = {};
+    const pore = (nome, categoria, def, gerar) => { cat[nome] = { nome, categoria, descricao: def.desc, duracao: def.d, ciclo: def.ciclo, gerar }; };
+    for (const [estilo, def] of Object.entries(ESTILOS_DIRECAO)) {
+        for (const [dir, { eixo, sinal }] of Object.entries(DIRECOES)) {
+            const gerar = () => def.f(eixo, sinal);
+            pore(`${estilo}-${dir}`, 'entrada', { ...def, desc: `${def.desc}, vindo ${dir.replace('-', ' ')}` }, gerar);
+            pore(`${estilo}-${PARA[dir]}`.replace(/^deslizar-desfocado/, 'sair-desfocando').replace(/^deslizar/, 'sair-deslizando')
+                .replace(/^chegar-elastico/, 'sair-elastico').replace(/^quicar/, 'sair-quicando').replace(/^varrer/, 'sair-varrendo')
+                .replace(/^girar-entrando/, 'sair-girando'), 'saida', { ...def, desc: `sai: ${def.desc.split(',')[0]}, ${PARA[dir].replace(/-/g, ' ')}` },
+            () => inverter(def.f(eixo, sinal)));
+        }
+    }
+    for (const [nome, def] of Object.entries(ENTRADAS)) {
+        pore(nome, 'entrada', def, def.f);
+        pore(nomeDaSaida(nome) === nome ? `${nome}-saindo` : nomeDaSaida(nome), 'saida', { ...def, desc: `sai: ${def.desc}` }, () => inverter(def.f()));
+    }
+    for (const [nome, def] of Object.entries(ENFASES)) pore(nome, 'enfase', def, def.f);
+    for (const [nome, def] of Object.entries(LOOPS)) pore(nome, 'loop', def, def.f);
+    return cat;
+}
+const CATALOGO = montarCatalogo();
+
+const r3 = (n) => Math.round(n * 1000) / 1000;
+const semAcento = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+
+/** Os quadros-chave de um movimento, a partir de `em` segundos. */
+const achar = (nome) => CATALOGO[semAcento(nome).trim().replace(/\s+/g, '-')] || null;
+
+function quadros(nome, { em = 0, duracao } = {}) {
+    const m = achar(nome);
+    if (!m) return null;
+    const d = Number(duracao) > 0 ? Number(duracao) : m.duracao;
+    const gerado = m.gerar();
+    const anima = {};
+    if (m.categoria === 'loop') {
+        const ciclo = Math.min(m.ciclo || d, d);
+        const voltas = Math.max(1, Math.round(d / ciclo));
+        for (const [prop, qs] of Object.entries(gerado)) {
+            const lista = [];
+            for (let k = 0; k < voltas; k++) {
+                for (const [f, v, e] of qs) {
+                    if (k > 0 && f === 0) continue;   // o fim de uma volta é o começo da próxima
+                    // o giro sem parar soma: a 2ª volta vai de 360 a 720
+                    const soma = /rotacao/.test(prop) && qs[qs.length - 1][1] === 360 ? 360 * k : 0;
+                    lista.push({ t: r3(em + (k + f) * ciclo), v: v + soma, ...(e ? { e } : {}) });
+                }
+            }
+            anima[prop] = lista;
+        }
+        return anima;
+    }
+    for (const [prop, qs] of Object.entries(gerado)) anima[prop] = qs.map(([f, v, e]) => ({ t: r3(em + f * d), v, ...(e ? { e } : {}) }));
+    return anima;
+}
+
+/** Procura por palavra (no nome ou na descrição) e por categoria. Sem termo, devolve um pouco de cada. */
+function procurar({ termo = '', categoria = '', limite = 30 } = {}) {
+    const palavras = semAcento(termo).split(/[^a-z0-9]+/).filter(Boolean);
+    const cat = semAcento(categoria).replace('ê', 'e');
+    const lista = Object.values(CATALOGO).filter((m) => (!cat || m.categoria === cat.replace(/s$/, ''))
+        && palavras.every((p) => semAcento(m.nome + ' ' + m.descricao).includes(p)));
+    return {
+        ok: true, total: Object.keys(CATALOGO).length, achados: lista.length,
+        movimentos: lista.slice(0, limite).map((m) => ({ nome: m.nome, categoria: m.categoria, faz: m.descricao, duracao: m.duracao })),
+        comoUsar: 'no elemento do plano: movimento:"<nome>" ou {nome, em (s), duracao (s)} ou uma lista deles. O que você escrever em anima vence na mesma propriedade; pode inventar o seu em anima, quadro a quadro.',
+    };
+}
+
+/**
+ * Troca `movimento` por `anima` em todos os elementos do plano. Muda o plano
+ * no lugar e devolve os nomes que não existem (o plano.js vira problema).
+ */
+function expandir(plano) {
+    const desconhecidos = [];
+    for (const [i, cena] of ((plano && plano.cenas) || []).entries()) {
+        for (const [j, el] of ((cena && cena.elementos) || []).entries()) {
+            if (!el || el.movimento == null) continue;
+            const pedidos = (Array.isArray(el.movimento) ? el.movimento : [el.movimento]).map((m) => (typeof m === 'string' ? { nome: m } : m || {}));
+            const juntado = {};
+            for (const p of pedidos) {
+                const a = quadros(p.nome, { em: Number(p.em) || 0, duracao: p.duracao ?? ((achar(p.nome) || {}).categoria === 'loop' ? cena.duracao : undefined) });
+                if (!a) { desconhecidos.push({ onde: `cenas[${i}].elementos[${j}].movimento`, nome: String(p.nome) }); continue; }
+                // Dois movimentos na mesma propriedade: os quadros se somam na linha do tempo.
+                for (const [prop, qs] of Object.entries(a)) juntado[prop] = [...(juntado[prop] || []), ...qs].sort((x, y) => x.t - y.t);
+            }
+            el.anima = { ...juntado, ...(el.anima || {}) };
+            delete el.movimento;
+        }
+    }
+    return desconhecidos;
+}
+
+module.exports = { CATALOGO, quadros, procurar, expandir, inverter };

package/lib/estudio/mundo.js

@@ -237,7 +237,11 @@ function posicionar(nomes, { semente = 1, agua = false, dentro = false, largura
  *                      pedido da pessoa: as coisas que ele cita entram na cena), semente, nElenco}
  */
 function mundoDe(pedido, { texto = '', pedidoTexto = '', semente = 1, nElenco = 1 } = {}) {
-    const obj = pedido && typeof pedido === 'object' ? pedido : { lugar: String(pedido || '') };
+    let obj = pedido && typeof pedido === 'object' ? pedido : { lugar: String(pedido || '') };
+    /* Um cenário que a IA criou e a pessoa deixou salvar (cenarios.js): o
+       nome dele no lugar traz tudo de volta; o que a cena disser por cima vence. */
+    const salvo = require('./cenarios.js').ler(obj.cenario || obj.lugar);
+    if (salvo) obj = { ...salvo, ...obj, lugar: salvo.base, hora: obj.hora || salvo.hora, elementos: obj.elementos || salvo.elementos };
     const descr = [obj.lugar, obj.descricao, obj.hora].filter(Boolean).join(' ');
     let { lugar, hora } = lerLugar(descr);
     const nomeDireto = sem(obj.lugar).replace(/\s+/g, '_');
@@ -302,4 +306,23 @@ function aplicarIcones(partitura, achados) {
     return partitura;
 }
 
-module.exports = { mundoDe, lerLugar, lerCoisas, lerElenco, iconesPendentes, aplicarIcones, LUGARES, HORAS, PECAS, ESPECIES, sem };
+/**
+ * As peças que a IA TROUXE para a cena: a logo, o botão ou o produto recortado
+ * do site (estudio_midia acao:elemento), um PNG sem fundo que vira blocos como
+ * os ícones 3D. "Imagens e parte de sites devem entrar no motion como ícone
+ * 3D" (Joel, 12/10). Ficam na frente, no centro, um pouco maiores que o resto
+ * do lugar: é o assunto. No máximo três, para não virar vitrine.
+ */
+function adicionarObjetos(partitura, objetos) {
+    const lista = (Array.isArray(objetos) ? objetos : []).filter((o) => o && o.src).slice(0, 3);
+    if (!lista.length) return partitura;
+    for (const m of partitura.mundos || []) {
+        lista.forEach((o, i) => {
+            const x = (i - (lista.length - 1) / 2) * 2.4;
+            m.props.push({ icone: String(o.nome || 'objeto').slice(0, 40), src: o.src, x, z: -1.6, raio: 1, giro: 0, escala: 1.35, trazido: true });
+        });
+    }
+    return partitura;
+}
+
+module.exports = { mundoDe, lerLugar, lerCoisas, lerElenco, iconesPendentes, aplicarIcones, adicionarObjetos, LUGARES, HORAS, PECAS, ESPECIES, sem };

package/lib/estudio/personagem.js

@@ -29,6 +29,7 @@
 
 const { volumesDaTrilha } = require('./ritmo.js');
 const mundo = require('./mundo.js');
+const falantes = require('./falantes.js');
 const colecao = require('./colecao.js');
 
 const FPS = 30;
@@ -110,6 +111,23 @@ function tipoDe(nome, pedido = {}) {
     return 'pessoa';
 }
 
+/* QUEM APRESENTA TEM O GÊNERO DA VOZ (12/10: "Narradora: a Júlia" saiu com
+   voz de mulher e boneco de homem). O pedido manda primeiro ("narradora",
+   "apresentadora", o nome dela), depois a voz escolhida. */
+const VOZES_F = /\b(kore|aoede|leda|zephyr|thalita|francisca|brenda|elza|giovanna|leila|leticia|manuela|yara|camila|vitoria)/i;
+const VOZES_M = /\b(charon|puck|orus|fenrir|antonio|donato|fabio|humberto|julio|nicolau|valerio)/i;
+function generoDoApresentador(roteiro = {}) {
+    const pedido = mundo.sem(roteiro.pedido || '');
+    if (/\b(narradora|apresentadora|locutora)\b/.test(pedido)) return 'f';
+    if (/\b(narrador|apresentador|locutor)\b/.test(pedido)) return 'm';
+    const voz = String(roteiro.voz || '');
+    if (VOZES_F.test(voz)) return 'f';
+    if (VOZES_M.test(voz)) return 'm';
+    return null;
+}
+const CABELOS_F = ['longo'];   // o coque e o cacheado, de frente, liam como homem (12/10); só quando pedidos
+const CABELOS_M = ['curto', 'topete', 'careca', 'cacheado'];
+
 function aparencia(nome, pedido = {}) {
     const k = (s) => hashDe(nome + ':' + s);
     const tipo = tipoDe(nome, pedido);
@@ -128,12 +146,14 @@ function aparencia(nome, pedido = {}) {
     return {
         nome, rotulo, tipo,
         pele: pedido.pele || pegar(PELES, k('pele')),
-        cabelo: CABELOS.includes(pedido.cabelo) ? pedido.cabelo : pegar(CABELOS, k('cabelo')),
+        cabelo: CABELOS.includes(pedido.cabelo) ? pedido.cabelo
+            : pegar(pedido.genero === 'f' ? CABELOS_F : pedido.genero === 'm' ? CABELOS_M : CABELOS, k('cabelo')),
         corCabelo: pedido.corCabelo || pegar(CORES_CABELO, k('corCabelo')),
         roupa: pedido.roupa || pegar(ROUPAS, k('roupa')),
         oculos: pedido.oculos != null ? !!pedido.oculos : k('oculos') < 0.3,
-        barba: !!pedido.barba,   // só quando pedida: sorteada, ficava estranha em quem tem cabelo longo
-        bigode: !!pedido.bigode,
+        barba: !!pedido.barba && pedido.genero !== 'f',   // só quando pedida: sorteada, ficava estranha em quem tem cabelo longo
+        bigode: !!pedido.bigode && pedido.genero !== 'f',
+        ...(pedido.genero ? { genero: pedido.genero } : {}),
         // A cabeça facetada (low-poly) é o padrão; 'cubo' é o rosto de pixel da 10.5.
         ...(pedido.cabeca === 'cubo' ? { cabeca: 'cubo' } : {}),
     };
@@ -316,7 +336,13 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
         return bicho ? { ...dado, tipo: 'animal', especie: bicho[1] } : dado;
     };
     // Até QUATRO falam no set ("três amigos no parque"); do quinto em diante dividem o lugar.
-    const elenco = nomes.slice(0, 4).map((n, i) => ({ ...aparencia(n, pedidoDe(n)), lado: nomes.length > 1 ? (i < nomes.length / 2 ? -1 : 1) : 0, ordem: i }));
+    const comGenero = (n) => {
+        const d = pedidoDe(n);
+        if (d.genero) return d;
+        const g = n === 'apresentador' ? generoDoApresentador(roteiro) : falantes.generoDe(n, d);
+        return g === 'f' || g === 'm' ? { ...d, genero: g } : d;
+    };
+    const elenco = nomes.slice(0, 4).map((n, i) => ({ ...aparencia(n, comGenero(n)), lado: nomes.length > 1 ? (i < nomes.length / 2 ? -1 : 1) : 0, ordem: i }));
     const quemDe = (pt) => {
         const f = typeof pt.falante === 'string' && pt.falante.trim() ? pt.falante.trim().toLowerCase() : 'apresentador';
         return nomes.indexOf(f) % Math.max(1, elenco.length);
@@ -453,4 +479,4 @@ function montarPersonagem({ roteiro, largura = 1920, altura = 1080, tempos = [],
     };
 }
 
-module.exports = { calarBichos, montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, tipoDe, acaoDe, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };
+module.exports = { generoDoApresentador, calarBichos, montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, tipoDe, acaoDe, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };

package/lib/estudio/plano.js

@@ -49,6 +49,7 @@ const fs = require('fs');
 const path = require('path');
 const morfar = require('./morfar.js');
 const kit = require('./kit.js');
+const movimentos = require('./movimentos.js');
 
 // "kit": uma peça pronta do kit de motion (kit.js), pelo nome — ver kit/*.jsx.
 const TIPOS = new Set(['texto', 'forma', 'imagem', 'video', 'icone', 'legenda', 'componente', 'grupo', 'kit']);
@@ -283,6 +284,11 @@ function conferir(plano, { pasta = null } = {}) {
     if (!plano || typeof plano !== 'object') {
         return { ok: false, problemas: [erro('plano', 'o plano é um objeto JSON')], duracao: 0 };
     }
+    /* `movimento: "quicar-de-baixo"` vira quadros-chave (movimentos.js) antes
+       de tudo: o que segue confere o `anima` como se a IA o tivesse escrito. */
+    for (const d of movimentos.expandir(plano)) {
+        problemas.push(erro(d.onde, `o movimento "${d.nome}" não existe — procure com estudio_midia acao:"movimentos" termo:"…"`));
+    }
 
     const f = plano.formato || {};
     const largura = Number(f.largura) || 1920;

package/lib/nuvem.js

@@ -24,13 +24,12 @@
  * A alternativa era o servidor intermediar cada leitura e escrita, com uma
  * autorização própria. Seria um SEGUNDO modelo de permissão ao lado das
  * `firestore.rules`, e os dois divergiriam na primeira mudança delas. Aqui o
- * CLI troca o token do PrimoCode por uma sessão curta (custom token → token de
- * acesso) e usa a API REST: as regras do banco valem para o terminal
- * exatamente como valem para o app e para o celular.
+ * CLI usa o token de acesso da própria conta (lib/conta.js) na API REST: as
+ * regras do banco valem para o terminal exatamente como valem para o site.
  *
  * ── ZERO DEPENDÊNCIA ─────────────────────────────────────────────────────
  * Nada de `firebase-admin` nem do SDK web. O que se usa é o `crypto` e o
- * `https` do Node, contra a API REST do Firestore e a do Identity Toolkit.
+ * `https` do Node, contra a API REST do Firestore.
  */
 
 'use strict';
@@ -41,13 +40,12 @@ const http = require('http');
 
 const conta = require('./conta.js');
 
-/* Os dois endereços saem daqui em vez de estarem escritos no meio do código.
+/* O endereço sai daqui em vez de estarem escritos no meio do código.
    Não é para trocar de nuvem: é para o teste conseguir pôr um Firestore de
    mentira no lugar e CONFERIR O QUE SOBE. Sem isso, a única forma de saber se
    um título vai em claro seria olhar o console do Firebase depois — que é
    exatamente tarde demais. */
 const FIRESTORE = process.env.PRIMOCODE_FIRESTORE || 'https://firestore.googleapis.com';
-const IDENTIDADE = process.env.PRIMOCODE_IDENTITY || 'https://identitytoolkit.googleapis.com';
 
 const VERSAO_CIFRA = 2;          // o mesmo `v` do frontend/crypto.js
 const ITERACOES = 310000;
@@ -132,26 +130,17 @@ function httpsJson(url, metodo, corpo, cabecalhos = {}, timeout = 20000) {
 
 let _sessao = null;   // { uid, idToken, expira, projeto }
 
-/* Abre (ou renova) a sessão. O token de acesso do Firebase dura uma hora;
-   renovar cinco minutos antes evita a escrita que falha no meio de uma
-   conversa longa — e falhar ali perde a mensagem, não só o pedido. */
+/* Abre (ou renova) a sessão. O conta.sessao() já devolve o token de acesso
+   válido por mais 5 minutos no mínimo (renova sozinho): aqui só se guarda,
+   para não ler o plano a cada mensagem. Guardado por 4 minutos. */
 async function abrir() {
-    if (_sessao && Date.now() < _sessao.expira - 300000) return _sessao;
+    if (_sessao && Date.now() < _sessao.expira) return _sessao;
     const s = await conta.sessao();
-    if (!s.ok) return null;
-    if (!s.apiKey || !s.projeto) {
-        // O servidor não está configurado para isto (falta FIREBASE_API_KEY /
-        // FIREBASE_PROJECT_ID no ambiente dele). Dizer é melhor que tentar e
-        // falhar com "requisição inválida" mais adiante.
-        return null;
-    }
-    const r = await httpsJson(
-        `${IDENTIDADE}/v1/accounts:signInWithCustomToken?key=${s.apiKey}`,
-        'POST', { token: s.customToken, returnSecureToken: true });
+    if (!s.ok || !s.idToken) return null;
     _sessao = {
         uid: s.uid, projeto: s.projeto, plano: s.plano, pro: s.pro,
-        idToken: r.idToken,
-        expira: Date.now() + (Number(r.expiresIn || 3600) * 1000),
+        idToken: s.idToken,
+        expira: Date.now() + 240000,
     };
     return _sessao;
 }