primocode 10.10.0 → 10.11.0

package/lib/estudio/index.js

@@ -70,10 +70,13 @@ const glifos = require('./glifos.js');
 const personagem = require('./personagem.js');
 const mundo = require('./mundo.js');
 const cenarios = require('./cenarios.js');
+const estilos = require('./estilos.js');
+const { conferirCena } = require('./cena.js');
 const movimentos = require('./movimentos.js');
 const colecao = require('./colecao.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
+const semNarracao = require('./sem-narracao.js');
 const ende = require('./ende.js');
 const producao = require('./producao.js');
 
@@ -403,6 +406,13 @@ async function ferramentaPlano(args) {
         try { original = JSON.parse(typeof args.roteiro === 'string' ? args.roteiro : JSON.stringify(args.roteiro)); } catch { original = args.roteiro; }
         const r = await prepararRoteiro(p, args);
         if (!r.ok) return r;
+        /* SEM NARRAÇÃO: o som sobe de papel — um efeito leve em cada corte e em
+           cada entrada marcante, variando (sem-narracao.js, sons-leves.js). */
+        if (args.__semNarracao) {
+            const n = semNarracao.sonorizarPlano(r, { tempos: args.__semNarracao.tempos, sons: sonsLeves.preparar(p.pasta) });
+            if (r.resumo) r.resumo.semNarracao = true;
+            projeto.anotar(p.id, 'plano', `sem narração: ${n} efeitos leves nos cortes e entradas`);
+        }
         const ic = await variarIcones(r.plano, original);
         if (ic.trocados) projeto.anotar(p.id, 'icones', `coleção ${ic.colecao}: ${ic.trocados} ícones`);
         let conferida = plano.conferir(r.plano, { pasta: p.pasta });
@@ -428,9 +438,13 @@ async function ferramentaPlano(args) {
             const usada = diretor.registrarEstrutura(original || args.roteiro);
             projeto.salvar(args.id, { estrutura: usada.estrutura || '-' });
         }
+        const quebradas = args.__cenasQuebradas || [];
         return {
             ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
-            proximo: 'estudio_render com este id. Para ajustar, mande o roteiro de novo (é rápido) — não edite as cenas à mão.',
+            ...(quebradas.length ? { cenasQuebradas: quebradas } : {}),
+            proximo: quebradas.length
+                ? `${quebradas.length} cena(s) sua(s) não compilaram e ficaram no gerativo: conserte o arquivo (o erro está em cenasQuebradas) e mande o roteiro de novo antes do render.`
+                : 'estudio_render com este id. Para ajustar, mande o roteiro de novo (é rápido) — não edite as cenas à mão.',
         };
     }
 
@@ -530,7 +544,9 @@ async function ferramentaMidia(args) {
     }
 
     // O catálogo de efeitos que a IA escreveu (efeitos.js): guardar, listar, reusar.
-    if (acao === 'efeitos') return { ok: true, efeitos: efeitos.cardapio() };
+    if (acao === 'efeitos') return { ok: true, efeitos: efeitos.cardapio(),
+        // A lista de técnicas mora aqui, e não na skill: a skill vai em todo pedido de vídeo e o teto é curto.
+        tecnicas: 'cor (ondas que inundam, paleta que vira na batida) · luz (faixa no título, bloom que respira, feixes, partículas) · física (antecipa, cai com peso, amassa no pouso, rebote; spring com massa, nunca linear) · 3D (perspective + rotateX: entra deitado e levanta, sombra no chão, câmera que orbita) · tipografia (letras que se montam, peso que pulsa, máscara que revela). Vídeo sobre site: tire a peça que conta a história com estudio_site elemento (PNG sem fundo) e anime ELA — peca-impacto-3d é ponto de partida, não molde.' };
     if (acao === 'guardar-efeito' || acao === 'usar-efeito') {
         if (!p) return { ok: false, error: 'diga em qual projeto (id).' };
         const r = acao === 'guardar-efeito'
@@ -575,6 +591,10 @@ async function ferramentaMidia(args) {
     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) });
     }
+    /* OS ESTILOS (estilos.js, 14/10): as peças do gerativo como cardápio — a IA
+       monta, mistura e cria; guardar só com o sim da pessoa. */
+    if (acao === 'estilos' || acao === 'estilo') return estilos.cardapio();
+    if (acao === 'salvar_estilo') return estilos.salvar({ nome: args.nome, pecas: args.pecas || args.estilo, descricao: args.descricao, autorizado: args.autorizado });
     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);
@@ -1263,6 +1283,15 @@ async function sonsReais(p, video) {
 }
 
 const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
+/* A proporção que o PEDIDO disse (14/10: "vertical 9:16" saiu deitado, porque
+   só valia a proporção que o modelo passasse). A do modelo ainda manda. */
+function proporcaoDoPedido(pedido) {
+    const t = String(pedido || '');
+    if (/\b9\s*[:x×]\s*16\b|\bvertical\b|\breels?\b|\bstor(y|ies)\b|\btik\s?tok\b|\bshorts\b/i.test(t)) return '9:16';
+    if (/\b4\s*[:x×]\s*5\b/.test(t)) return '4:5';
+    if (/\b1\s*[:x×]\s*1\b|\bquadrad[oa]\b/i.test(t)) return '1:1';
+    return null;
+}
 
 /** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
 /* A ASSINATURA (assinatura.js): o vídeo é medido e conferido contra as
@@ -1301,7 +1330,8 @@ function importarReferencia(p, arquivo) {
 
 async function prepararRoteiro(p, args) {
     const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
-    if (Array.isArray(roteiro)) return prepararRoteiro(p, { ...args, roteiro: { partes: roteiro } });
+    // O mesmo args (não uma cópia): o __semNarracao e o __cenasQuebradas voltam para quem chamou.
+    if (Array.isArray(roteiro)) { args.roteiro = { partes: roteiro }; return prepararRoteiro(p, args); }
     /* O que o modelo manda e o disco não tem vira problema de render: um
        "src" que é endereço da internet vira busca, e um arquivo que não
        existe na pasta sai. A logo da marca vale só se estiver lá. */
@@ -1326,6 +1356,13 @@ async function prepararRoteiro(p, args) {
             fs.copyFileSync(achado, destino);
             pt.componente = path.relative(p.pasta, destino).replace(/\\/g, '/');
         } else pt.componente = path.relative(p.pasta, achado).replace(/\\/g, '/');
+        // A cena quebrada não derruba o vídeo: sai, a parte fica no gerativo, e o erro volta para a IA (cena.js).
+        const conf = conferirCena(path.join(p.pasta, pt.componente));
+        if (!conf.ok) {
+            (args.__cenasQuebradas = args.__cenasQuebradas || []).push({ componente: pt.componente, erro: conf.erro });
+            projeto.anotar(p.id, 'plano', `componente ${pt.componente} quebrado (${conf.erro}): a parte ficou no gerativo`);
+            delete pt.componente;
+        }
     }
     // As imagens do pedido (o terminal guardou em referencias.imagens) entram sozinhas, uma vez por projeto.
     const jaTem = new Set((p.referencias || []).map((x) => x.de));
@@ -1354,14 +1391,10 @@ async function prepararRoteiro(p, args) {
     const semImagem = referencias.semImagem(ref);
     let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: true, semImagem });
     if (semImagem && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
-    /* AS FONTES DA CASA (13/10, o primocode-ele-constroi.mp4 que o Joel aprovou):
-       no gerativo, título em Inter e texto em JetBrains Mono, com as CORES da
-       marca. Só muda se o pedido falar de fonte. */
-    if (estilo === 'gerativo' && !/\bfontes?\b|tipografia|\bserifa/i.test(pedidoTxt)) {
-        roteiro.marca = { ...(roteiro.marca || {}), fontes: { titulo: 'Inter', texto: 'JetBrains Mono' } };
-    }
-    // O estilo da casa no gerativo: chão escuro com brilho, frase média, palavra que entra desfocando (gerativo.js).
-    if (estilo === 'gerativo') roteiro.casa = true;
+    /* SEM NARRAÇÃO (14/10, "só o motion e os efeitos sonoros, os barulhinhos"):
+       roteiro.semNarracao ou o pedido. O cinema e o híbrido vivem da voz: caem no gerativo. */
+    const semVoz = semNarracao.ativo(roteiro, pedidoTxt);
+    if (semVoz && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
     /* "O vídeo deve ter um 3D do fone" (30/09): pedido de 3D vira o gerativo
        com o produto modelado girando numa batida (kit/tres.jsx) — a menos que
        o agente tenha escolhido outro estilo pelo nome. */
@@ -1393,10 +1426,27 @@ async function prepararRoteiro(p, args) {
        vídeos (09/10, "vício em cores, músicas, fontes"): por PROJETO, como a semente. */
     // O assunto do vídeo é o rótulo da moldura (quando ela sai): o título do projeto.
     if (estilo === 'gerativo' && !roteiro.titulo && p.titulo) roteiro.titulo = p.titulo;
+    // O estilo que a IA montou (estilos.js) vence o sorteio e o que o projeto tinha guardado.
+    if (estilo === 'gerativo' && roteiro.estiloVisual && !roteiro.escolhasGerativo) {
+        const r = estilos.montar(roteiro.estiloVisual, roteiro);
+        roteiro.escolhasGerativo = r.escolhas;
+        projeto.salvar(p.id, { escolhasGerativo: r.escolhas });
+        if (r.avisos.length) projeto.anotar(p.id, 'estilo', r.avisos.join(' · '));
+    }
     if (estilo === 'gerativo' && !roteiro.escolhasGerativo) {
         roteiro.escolhasGerativo = p.escolhasGerativo || gerativo.escolherVisual(roteiro);
         if (!p.escolhasGerativo) projeto.salvar(p.id, { escolhasGerativo: roteiro.escolhasGerativo });
     }
+    /* O ESTILO DA CASA (13/10, o primocode-ele-constroi.mp4 que o Joel aprovou):
+       chão escuro com brilho, frase média, palavra que entra desfocando, Inter
+       e JetBrains Mono. Vale para o vídeo de TECNOLOGIA (o do PrimoCode) quando
+       a IA não montou estilo: em todo vídeo, a padaria saía igual — "animações
+       tudo igual, cores sempre as mesmas, sem ícones" (14/10). */
+    const casa = estilo === 'gerativo' && !roteiro.estiloVisual && (roteiro.escolhasGerativo || {}).humor === 'tecnologia';
+    if (casa && !/\bfontes?\b|tipografia|\bserifa/i.test(pedidoTxt)) {
+        roteiro.marca = { ...(roteiro.marca || {}), fontes: { titulo: 'Inter', texto: 'JetBrains Mono' } };
+    }
+    if (casa) roteiro.casa = true;
     if (ref.modo === 'fechado' && !roteiro.busca && referencias.termos().length) roteiro.busca = referencias.termos();
     /* A BIBLIOTECA (biblioteca.js): sem fonte e cor da marca, o híbrido, o
        cinema e o impacto caíam sempre no Inter e no azul e roxo — "os vídeos
@@ -1409,7 +1459,7 @@ async function prepararRoteiro(p, args) {
     // Os estilos de motion usam os efeitos leves e a trilha do ende.app; os de corte, os cheios.
     const ehMotion = LEVES.has(estilo);
     const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
-    const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
+    const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'video' && PROPORCOES[proporcaoDoPedido(p.pedido)]) || PROPORCOES['16:9'];
 
     const iconesOk = new Set();
     for (const nome of composicao.iconesDoRoteiro(roteiro)) {
@@ -1737,7 +1787,17 @@ async function prepararRoteiro(p, args) {
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${hib ? 'hibrido' : 'cinema'}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
         return r;
     }
-    if (modo === 'video') {
+    if (modo === 'video' && semVoz) {
+        /* Sem voz, sem tempo medido: cada parte dura o `duracao` dela (ou o que o
+           texto da tela pede), e as palavras são repartidas na parte. Os sons
+           leves entram depois do plano, em cada corte e entrada (sem-narracao.js). */
+        tempos = semNarracao.tempos(partes, { falaDe: composicao.falaDe });
+        args.__semNarracao = { tempos };
+        const total = tempos.length ? tempos[tempos.length - 1].ate : 0;
+        projeto.anotar(p.id, 'narracao', `sem narração: ${Math.round(total * 10) / 10}s em ${partes.length} partes, só motion e efeitos sonoros`);
+        sons = estilo === 'gerativo' ? {} : ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+    }
+    if (modo === 'video' && !semVoz) {
         const lista = partes.map((pt, i) => ({ texto: composicao.falaDe(pt), registro: composicao.registroDe(pt, i, partes.length) }));
         const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
         fs.mkdirSync(path.dirname(arq), { recursive: true });
@@ -1817,6 +1877,9 @@ async function prepararRoteiro(p, args) {
         // O gerativo desenha os sons DEPOIS da partitura (um arquivo por evento, da própria trilha).
         sons = estilo === 'gerativo' ? {}
             : ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+    }
+    // A trilha vale com e sem voz: o vídeo sem narração ainda tem música.
+    if (modo === 'video') {
         // A trilha do motion: ende.app (CC BY 4.0, sem Content ID), clima tecnologia.
         if (ehMotion) {
             try {
@@ -1919,6 +1982,17 @@ async function prepararRoteiro(p, args) {
                 '-af', 'afade=t=in:st=0:d=0.4,loudnorm=I=-18:TP=-2:LRA=11', '-ar', '44100', norm], { timeout: 5 * 60000 });
             if (c.ok && fs.existsSync(norm)) trilha = path.relative(p.pasta, norm).replace(/\\/g, '/');
         }
+        /* SEM ÍCONE NENHUM (14/10, a padaria: "sem ícones"): o modelo grátis não
+           dá herói, e o gerativo de comida não tem forma abstrata — o vídeo
+           saía só com texto. Na parte em que o modelo não disse nada (nem
+           "nenhum"), o ícone 3D que É a coisa que a fala nomeia ("pão" → bread). */
+        const autoHerois = [];
+        for (const pt of partes) {
+            if (!pt || pt.heroi != null || pt.icone != null) continue;
+            const id = colecao.melhorIcone3d([pt.titulo, pt.destaque, pt.fala, pt.texto].filter(Boolean).join(' '), 80);
+            if (id && !autoHerois.includes(id)) { pt.heroi = id; autoHerois.push(id); }
+        }
+        if (autoHerois.length) projeto.anotar(p.id, 'icones', `sem herói do modelo, a biblioteca achou: ${autoHerois.join(', ')}`);
         /* O herói que o roteiro pediu do Iconify ("mdi:bread-slice"): o desenho é
            baixado aqui (fica em midia/icones); o que não baixar, a batida fica sem. */
         const icones = {};
@@ -2402,7 +2476,7 @@ async function ferramentaSite(args) {
     return r;
 }
 
-module.exports = {
+module.exports = { proporcaoDoPedido,
     vazamentoNoComeco, variarIcones, objetosDoRoteiro,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,

package/lib/estudio/kit/gerativo.jsx

@@ -1150,6 +1150,22 @@ export function Gerativo({ el, t, fps }) {
                 return (
                   <div key={l.id} style={{ position: 'absolute', inset: 0, ...eLinha }}>
                     <Linha l={l} b={x} cx={cx} t={t} fps={fps} P={P} frame={frame} alvoSaida={alvo} centroBloco={{ x: (lay.bloco.x + lay.bloco.x1) / 2, y: (lay.bloco.y + lay.bloco.y1) / 2 }} />
+                    {l.riscado && (() => {
+                      /* O RISCO EM TODAS AS LINHAS (14/10, "quando tem quebra de linha no
+                         motion, ele não risca"): o acento é UM traço e só vai a uma linha.
+                         As outras linhas riscadas ganham o próprio risco, na mesma hora. */
+                      const ar = (x.acento || []).find((a) => a.forma === 'risco');
+                      if (ar && ar.alvo && ar.alvo.linha === l.id) return null;
+                      const rs = x.linhas.filter((q) => q.riscado);
+                      const t0 = (ar ? ar.t : l.t + 0.4) + Math.max(0, rs.indexOf(l)) * 0.1;
+                      const k = ed(c01((t - t0) / 0.35));
+                      if (k <= 0) return null;
+                      const s = cx.s, y = cx.y + cx.h * 0.56, x0 = cx.x, x1 = cx.x + cx.w * k;
+                      return <svg style={{ position: 'absolute', inset: 0, overflow: 'visible' }} width="100%" height="100%">
+                        <path d={`M${x0.toFixed(1)} ${(y + s * 0.04).toFixed(1)} L${x1.toFixed(1)} ${(y + s * 0.04 - (x1 - x0) / Math.max(1, cx.w) * s * 0.08).toFixed(1)}`}
+                          stroke={x.cores.acento} strokeWidth={Math.max(4, s * 0.07)} strokeLinecap="round" fill="none" />
+                      </svg>;
+                    })()}
                   </div>
                 );
               })}

package/lib/estudio/kit/mundo.jsx

@@ -13,6 +13,8 @@ import React, { useMemo, useLayoutEffect, useRef, useState } from 'react';
 import * as THREE from 'three';
 import { delayRender, continueRender, staticFile } from 'remotion';
 import { RoundedBoxGeometry } from 'three/examples/jsm/geometries/RoundedBoxGeometry.js';
+// O pulo com peso (agacha, estica, cai acelerando, amassa no pouso): kit/natural.js.
+import { salto, respiracao } from './natural';
 
 const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
 const hash = (n) => { const s = Math.sin(n * 127.1 + 311.7) * 43758.5453; return s - Math.floor(s); };
@@ -903,15 +905,17 @@ function Quadrupede({ e, est, cor }) {
   const [W, H, D] = e.corpo;
   const anda = est.acao === 'andar' || est.acao === 'correr' || est.acao === 'pular';
   const passo = est.acao === 'correr' ? 14 : 8;
-  const pulo = est.acao === 'pular' || est.acao === 'comemorar' ? Math.abs(Math.sin(est.t * 6)) * 0.25 : 0;
-  const respira = Math.sin(est.t * 2.2) * 0.008;
+  const ka = Math.min(1, est.forcaAcao ?? 1);
+  const sl = est.acao === 'pular' || est.acao === 'comemorar' ? salto(est.t, { periodo: 0.85, altura: 0.25 }) : { y: 0, sx: 1, sy: 1 };
+  const pulo = sl.y * ka, sy = 1 + (sl.sy - 1) * ka, sx = 1 + (sl.sx - 1) * ka;
+  const respira = (respiracao(est.t, (est.semente || 0) + 2) - 0.5) * 0.016;
   const y0 = e.perna + H / 2;
   const [cy, cp] = est.cabeca;
   const pescoco = e.pescoco || 0;
   const cabPos = [0, y0 + H * 0.35 + pescoco * 0.85, D / 2 + e.cab * 0.25 + pescoco * 0.25];
   // O corpo vira de lado, e a cabeça volta para a câmera: o bicho se lê inteiro em 3/4.
   return (
-    <group position={[0, pulo, 0]}>
+    <group position={[0, pulo, 0]} scale={[sx, sy, sx]}>
       <group rotation={[0, 0.55, 0]}>
         <B s={[W, H, D]} p={[0, y0 + respira, 0]} c={cor} r={0.06} rough={e.fofo ? 1 : 0.75} />
         {e.fofo && [0, 1, 2].map((i) => <B key={i} s={[W * 1.06, H * 0.32, D * 0.3]} p={[0, y0 + H * 0.2, -D * 0.3 + i * D * 0.3]} c={e.cor} r={0.08} rough={1} />)}
@@ -1044,8 +1048,10 @@ export function Animal({ p, est }) {
 export function Coisa({ p, est, icones = {} }) {
   const [abre] = est.boca;
   const bob = Math.sin(est.t * 1.9 + 0.7) * 0.05;
-  const estica = 1 + abre * 0.08, achata = 1 - abre * 0.04;
-  const pulo = est.acao === 'pular' || est.acao === 'comemorar' ? Math.abs(Math.sin(est.t * 6)) * 0.25 : 0;
+  const ka = Math.min(1, est.forcaAcao ?? 1);
+  const sl = est.acao === 'pular' || est.acao === 'comemorar' ? salto(est.t, { periodo: 0.85, altura: 0.25 }) : { y: 0, sx: 1, sy: 1 };
+  const pulo = sl.y * ka;
+  const estica = (1 + abre * 0.08) * (1 + (sl.sy - 1) * ka), achata = (1 - abre * 0.04) * (1 + (sl.sx - 1) * ka);
   if (!p.src) return null;
   return (
     <group position={[0, 0.45 + bob + pulo, 0]} rotation={[0, est.cabeca[0] * 0.6, Math.sin(est.t * 1.3) * 0.04]}>

package/lib/estudio/kit/natural.js

@@ -0,0 +1,161 @@
+/* kit/natural.js — o movimento com PESO: as curvas que tiram o 3D do robótico.
+ *
+ *   "a animação do boneco, a movimentação, é muito robótico" (Joel, 14/10)
+ *
+ * O boneco mexia em seno puro: todo membro no mesmo tempo, a mesma volta
+ * idêntica para sempre, parada seca quando a ação acabava e o corpo congelado
+ * quando não falava. Aqui moram os princípios de animação, em funções puras
+ * (o node testa, o kit/voxel.jsx e o kit/personagem.jsx desenham):
+ *  - mola: massa e amortecimento — acelera, passa um pouco do ponto e assenta;
+ *  - antecipa: recua antes de ir e passa um tico depois (follow-through);
+ *  - atraso: tronco, cabeça, braço e mão com tempos diferentes (sobreposição);
+ *  - ruido: a micro variação que nunca repete, igual em todo render (semente);
+ *  - respiracao: inspira mais rápido do que expira, o ritmo varia um pouco;
+ *  - salto: agacha, estica no impulso, cai acelerando, amassa no pouso e assenta;
+ *  - passo: o quadril que balança, o corpo que desce no contato, o tronco que
+ *    gira contra o quadril e o braço que vai atrasado da perna.
+ * Nada de Math.random nem Date.now: o mesmo quadro sai igual sempre. */
+'use strict';
+
+const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
+const suave = (x) => { const k = clamp(x); return k * k * (3 - 2 * k); };
+
+/** Um número de 0 a 1 a partir de um número inteiro e de uma semente (texto ou número). */
+function sementeDe(s) {
+    if (typeof s === 'number') return s;
+    let h = 2166136261;
+    for (const c of String(s || '')) { h ^= c.charCodeAt(0); h = Math.imul(h, 16777619); }
+    return (h >>> 0) % 100000;
+}
+function sorte(n, semente = 0) {
+    const x = Math.sin(n * 127.1 + sementeDe(semente) * 311.7) * 43758.5453;
+    return x - Math.floor(x);
+}
+
+/** Ruído suave de -1 a 1 (dois tons somados): a deriva que nunca repete igual. */
+function ruido(t, semente = 0) {
+    const tom = (x, s) => {
+        const i = Math.floor(x), f = x - i;
+        const a = sorte(i, s) * 2 - 1, b = sorte(i + 1, s) * 2 - 1;
+        const k = f * f * f * (f * (f * 6 - 15) + 10);   // o quíntico: sem quina na emenda
+        return a + (b - a) * k;
+    };
+    const s = sementeDe(semente);
+    return tom(t, s) * 0.68 + tom(t * 2.17 + 13.3, s + 7) * 0.32;
+}
+
+/**
+ * A MOLA: a resposta de massa-mola-amortecedor indo de 0 a 1, `s` segundos
+ * depois do gatilho. `freq` em Hz, `amort` < 1 passa do ponto e volta.
+ */
+function mola(s, { freq = 2.2, amort = 0.5 } = {}) {
+    if (s <= 0) return 0;
+    const w = 2 * Math.PI * freq;
+    if (amort >= 1) return 1 - Math.exp(-w * s) * (1 + w * s);
+    const wd = w * Math.sqrt(1 - amort * amort);
+    return 1 - Math.exp(-amort * w * s) * (Math.cos(wd * s) + (amort * w / wd) * Math.sin(wd * s));
+}
+
+/**
+ * A curva de 0 a 1 que RECUA antes de ir (antecipação) e passa um tico do fim
+ * antes de assentar (follow-through). Lenta nas pontas, rápida no meio.
+ */
+function antecipa(x, { recuo = 0.1, passa = 0.06 } = {}) {
+    const k = clamp(x);
+    const base = suave(k);
+    const antes = -recuo * Math.sin(Math.PI * clamp(k / 0.3)) * (k < 0.3 ? 1 : 0);
+    const depois = passa * Math.sin(Math.PI * clamp((k - 0.62) / 0.38)) * (k > 0.62 ? 1 : 0);
+    return base + antes + depois;
+}
+
+/**
+ * O PESO DE UMA AÇÃO entre `de` e `ate` (segundos): entra com mola (passa e
+ * assenta), sai devagar, e nunca corta seco. `atraso` é a sobreposição: o
+ * membro que vem depois (cotovelo depois do ombro, cabeça depois do tronco).
+ */
+function envelope(t, de, ate, { atraso = 0, entra = 2.4, sai = 0.55, amort = 0.55 } = {}) {
+    const tt = t - atraso;
+    if (tt < de) return 0;
+    const dentro = mola(tt - de, { freq: entra, amort });   // passa de 1 e volta: o membro assenta
+    const fora = tt > ate ? 1 - suave((tt - ate) / sai) : 1;
+    return Math.max(0, dentro * fora);
+}
+
+/**
+ * O GESTO de ênfase, `s` segundos depois de começar: o braço cai um pouco
+ * (antecipação), sobe rápido passando do ponto, segura e desce devagar.
+ * Dura ~1,1 s; fora disso é 0.
+ */
+function golpe(s) {
+    if (s <= 0 || s >= 1.15) return 0;
+    const sobe = s < 0.1 ? -0.14 * Math.sin(Math.PI * s / 0.1) : mola(s - 0.1, { freq: 2.6, amort: 0.5 });
+    const desce = 1 - suave((s - 0.55) / 0.6);
+    return sobe * desce;
+}
+
+/**
+ * A RESPIRAÇÃO de 0 a 1: inspira em ~40% do ciclo, expira no resto, e o
+ * ciclo (≈3,4 s) varia um pouco a cada volta, pela semente.
+ */
+function respiracao(t, semente = 0) {
+    const periodo = 3.4;
+    const fase = t / periodo + 0.12 * ruido(t * 0.15, semente) + sorte(1, semente);
+    const p = fase - Math.floor(fase);
+    return p < 0.4 ? suave(p / 0.4) : 1 - suave((p - 0.4) / 0.6);
+}
+
+/**
+ * O SALTO, num ciclo de `periodo` s: agacha (amassa), impulsiona (estica),
+ * sobe e cai em parábola (a gravidade: a queda acelera), amassa no pouso e
+ * assenta. Devolve {y, sx, sy}: a altura e a escala de amassar/esticar
+ * (o volume fica: sx ≈ 1/√sy).
+ */
+function salto(t, { periodo = 0.95, altura = 0.32, fase = 0 } = {}) {
+    const p = ((t / periodo + fase) % 1 + 1) % 1;
+    const AGACHA = 0.16, AR = 0.6, POUSO = 1 - AGACHA - AR;
+    let y = 0, sy = 1;
+    if (p < AGACHA) {
+        const k = p / AGACHA;
+        const amassa = Math.sin(Math.PI * Math.min(1, k * 1.25)) * (k < 0.8 ? 1 : 0);
+        sy = 1 - 0.14 * amassa;
+        y = -0.05 * altura * amassa;
+        if (k >= 0.8) sy = 1 + 0.12 * suave((k - 0.8) / 0.2);   // o impulso: estica antes de sair do chão
+    } else if (p < AGACHA + AR) {
+        const q = (p - AGACHA) / AR;
+        y = altura * 4 * q * (1 - q);                 // a parábola: sobe freando, desce acelerando
+        sy = 1 + 0.12 * Math.pow(Math.abs(1 - 2 * q), 1.5);   // estica com a velocidade, redondo no alto
+    } else {
+        const k = (p - AGACHA - AR) / POUSO;
+        const amortece = Math.exp(-4.2 * k) * Math.cos(k * Math.PI * 2.2);
+        sy = 1 - 0.18 * amortece;                     // o pouso amassa e assenta em mola
+        y = -0.04 * altura * Math.max(0, amortece);
+    }
+    return { y, sy, sx: 1 / Math.sqrt(Math.max(0.5, sy)) };
+}
+
+/**
+ * O PASSO, `t` em s, `ritmo` em passos por segundo (andar ≈ 1,8, correr ≈ 3).
+ * Devolve os ângulos (rad) e o deslocamento do corpo:
+ *  perna[esq,dir]  balanço da coxa (para frente é negativo no eixo X)
+ *  braco[esq,dir]  o braço oposto à perna, atrasado (sobreposição)
+ *  quadril         o rolar do quadril para o lado da perna que apoia
+ *  giro            o tronco que gira contra o quadril
+ *  sobe            o corpo desce no contato e sobe na passagem
+ */
+function passo(t, { ritmo = 1.8, amplitude = 0.42, correr = false, semente = 0 } = {}) {
+    const f = Math.PI * ritmo * t + sorte(3, semente) * 0.3;
+    // A perna vai para frente mais rápido do que volta no apoio: a onda torta.
+    const onda = (x) => Math.sin(x + 0.22 * Math.sin(x));
+    const a = amplitude * (correr ? 1.6 : 1);
+    const atrasoBraco = correr ? 0.18 : 0.32;           // o braço chega depois da perna
+    return {
+        perna: [onda(f) * a, onda(f + Math.PI) * a],
+        braco: [onda(f + Math.PI - atrasoBraco) * a * 0.9, onda(f - atrasoBraco) * a * 0.9],
+        quadril: Math.sin(f - 0.35) * (correr ? 0.03 : 0.055),
+        giro: -Math.sin(f - 0.15) * (correr ? 0.12 : 0.07),
+        sobe: (0.5 + 0.5 * Math.cos(2 * f)) * (correr ? 0.09 : 0.045),
+        inclina: correr ? 0.14 : 0.03,                  // quem corre vai com o tronco para frente
+    };
+}
+
+module.exports = { clamp, suave, sorte, ruido, mola, antecipa, envelope, golpe, respiracao, salto, passo };

package/lib/estudio/kit/personagem.jsx

@@ -16,6 +16,8 @@ import { ThreeCanvas } from '@remotion/three';
 import * as THREE from 'three';
 import { useThree } from '@react-three/fiber';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
+// O movimento com peso (mola, antecipação, sobreposição, respiração): kit/natural.js.
+import { ruido, envelope, golpe, respiracao } from './natural';
 
 const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
 const lerp = (a, b, k) => a + (b - a) * k;
@@ -93,10 +95,10 @@ function gesto(falas, quem, t) {
     if (f.quem !== quem || t < f.de - 0.5 || t > f.ate + 1) continue;
     f.palavras.forEach((w, k) => {
       if (String(w.t).replace(/[^\p{L}\d]/gu, '').length < 6 && !/\d/.test(w.t)) return;
-      const x = (t - (w.de - 0.15)) / 0.9;
-      if (x < 0 || x > 1) return;
-      const b = Math.sin(Math.PI * x);
-      if (k % 2) esq = Math.max(esq, b); else dir = Math.max(dir, b);
+      // Recua, sobe passando do ponto e desce devagar (natural.golpe), não um seno.
+      const b = golpe(t - (w.de - 0.15));
+      if (b === 0) return;
+      if (k % 2) esq = Math.abs(b) > Math.abs(esq) ? b : esq; else dir = Math.abs(b) > Math.abs(dir) ? b : dir;
     });
   }
   return [esq, dir];
@@ -256,12 +258,14 @@ function RostoRobo({ p, est, acento }) {
 }
 
 /* ── O CORPO, OS BRAÇOS E O PERSONAGEM INTEIRO ───────────────────────────── */
-function Braco({ lado, g, cor, pele, robo, t }) {
-  // Repouso: o antebraço deitado na mesa. Gesto: a mão sobe e mexe um pouco.
-  const ombroX = lerp(-0.3, -0.62, g) + Math.sin(t * 6 + lado) * 0.05 * g;
-  const ombroZ = lado * lerp(0.08, 0.28, g);
-  const cotovelo = lerp(-1.17, -1.75, g) + Math.sin(t * 7.3 + lado * 2) * 0.12 * g;
-  const pulso = Math.sin(t * 9 + lado) * 0.25 * g;
+function Braco({ lado, g, gc = g, gp = gc, cor, pele, robo, t, sem = 0 }) {
+  // Repouso: o antebraço deitado na mesa, que deriva de leve (nunca congelado).
+  // Gesto: o ombro leva, o cotovelo (gc) e o pulso (gp) vêm depois — a sobreposição.
+  const deriva = ruido(t * 0.4, sem + lado * 5) * 0.03;
+  const ombroX = lerp(-0.3, -0.62, g) + Math.sin(t * 6 + lado) * 0.05 * Math.max(0, g) + deriva;
+  const ombroZ = lado * lerp(0.08, 0.28, Math.max(0, g));
+  const cotovelo = lerp(-1.17, -1.75, gc) + Math.sin(t * 7.3 + lado * 2 - 0.8) * 0.12 * Math.max(0, gc) + deriva * 0.5;
+  const pulso = Math.sin(t * 9 + lado - 1.4) * 0.25 * Math.max(0, gp) + ruido(t * 0.7, sem + lado) * 0.06;
   const tecido = robo ? <Mat c={cor} r={0.3} m={0.1} cc={1} /> : <Mat c={cor} r={0.85} sheen="#ffffff" />;
   return (
     <group position={[lado * 0.44, 1.18, 0]} rotation={[ombroX, 0, ombroZ]}>
@@ -279,7 +283,8 @@ function Braco({ lado, g, cor, pele, robo, t }) {
 function Personagem({ p, est, acento, pos, giro }) {
   const robo = p.tipo === 'robo';
   const corpo = robo ? p.cor : p.roupa;
-  const resp = 1 + Math.sin(est.t * 1.6 + pos[0]) * 0.012;
+  // O fôlego: inspira rápido, expira devagar, o ritmo varia (natural.respiracao).
+  const resp = 1 + respiracao(est.t, (est.semente || 0) + pos[0]) * 0.016;
   const [cy, cp, cr] = est.cabeca;
   return (
     <group position={pos} rotation={[0, giro, 0]}>
@@ -293,8 +298,7 @@ function Personagem({ p, est, acento, pos, giro }) {
           : <mesh position={[0, 1.27, 0]} rotation={[Math.PI / 2, 0, 0]}><torusGeometry args={[0.15, 0.04, 12, 32]} /><Mat c={new THREE.Color(corpo).multiplyScalar(0.7).getStyle()} r={0.85} /></mesh>}
         <mesh position={[0, 1.3, 0]}><cylinderGeometry args={[0.12, 0.13, 0.25, 24]} />{robo ? <Mat c="#3a3e48" r={0.4} m={0.6} /> : <Mat c={p.pele} r={0.6} sheen="#ff9a8a" />}</mesh>
       </group>
-      <Braco lado={-1} g={est.gesto[0]} cor={corpo} pele={p.pele} robo={robo} t={est.t} />
-      <Braco lado={1} g={est.gesto[1]} cor={corpo} pele={p.pele} robo={robo} t={est.t} />
+      {[-1, 1].map((l) => { const k = l > 0 ? 1 : 0; return <Braco key={l} lado={l} g={est.gesto[k]} gc={(est.gestoAtras || est.gesto)[k]} gp={(est.gestoMao || est.gesto)[k]} cor={corpo} pele={p.pele} robo={robo} t={est.t} sem={est.semente || 0} />; })}
       <group position={[0, 1.62, 0]} rotation={[cp, cy, cr]} castShadow>
         {robo ? <RostoRobo p={p} est={est} acento={acento} /> : <Rosto p={p} est={est} />}
       </group>
@@ -529,19 +533,31 @@ export function PersonagemCena({ el, t }) {
     for (const f of falas) if (f.quem === i && f.de <= t + 0.2) e = t <= f.ate + 2.5 ? f.emocao : 'neutro';
     return e;
   };
+  // O quanto cada um está falando (0 a 1, sem degrau): os acenos trocam com mola.
+  const pesoDaFala = (i, reacao = 0) => falas.reduce((m, f) => (f.quem === i ? Math.max(m, Math.min(1, envelope(t, f.de + reacao, f.ate, { entra: 2.6, sai: 0.45, amort: 0.7 }))) : m), 0);
   const estado = (i) => {
+    const sem = i * 13 + 1;
     const fala = falandoAgora(i);
-    const outro = dois && falandoAgora(1 - i);
+    const wFala = pesoDaFala(i);
+    // Quem ouve reage ~0,2 s depois, com mola, e volta devagar.
+    const wOuve = dois ? pesoDaFala(1 - i, 0.2) : 0;
     const enfase = gesto(falas, i, t);
-    const nod = Math.sin(t * (fala ? 5.2 : 1.4) + i) * (fala ? 0.035 : 0.015) + (outro ? Math.max(0, Math.sin(t * 2.1 + i)) * 0.04 : 0);
+    const nod = lerp(ruido(t * 0.5, sem + 3) * 0.015, Math.sin(t * 5.2 + i) * 0.028 + ruido(t * 2.4, sem + 2) * 0.016, wFala)
+      + wOuve * Math.max(0, Math.sin(t * 2.1 + i)) * 0.04;
     const emo = emocaoDe(i);
-    const e = EMO[emo] || EMO.neutro;
-    const micro = (hash(Math.floor(t * 1.5) + i * 7) - 0.5) * 0.08;
+    // A inclinação da emoção chega e vai embora com peso, não troca no quadro.
+    let inclina = 0;
+    for (const f of falas) {
+      if (f.quem !== i || f.de > t + 0.2) continue;
+      inclina = ((EMO[f.emocao] || EMO.neutro).inclina || 0) * Math.min(1.05, envelope(t, f.de - 0.2, f.ate + 2.5, { entra: 1.4, sai: 0.8, amort: 0.6 }));
+    }
+    const micro = (hash(Math.floor(t * 1.5 + hash(i) * 0.9) + i * 7) - 0.5) * 0.08;
     return {
-      t, falando: fala, emocao: emo, boca: boca(falas, i, t), pisca: piscada(i, t),
-      gesto: enfase, enfase: Math.max(enfase[0], enfase[1]),
+      t, semente: sem, falando: fala, emocao: emo, boca: boca(falas, i, t), pisca: piscada(i, t),
+      gesto: enfase, gestoAtras: gesto(falas, i, t - 0.08), gestoMao: gesto(falas, i, t - 0.15), enfase: Math.max(enfase[0], enfase[1], 0),
       olhar: dois ? [micro, 0.02] : [micro * 0.5, 0.04],
-      cabeca: [Math.sin(t * 0.7 + i * 2) * 0.08 + (outro ? 0.05 : 0), nod + (fala ? 0 : 0.03), (e.inclina || 0) * (i ? -1 : 1) + Math.sin(t * 0.5 + i) * 0.02],
+      // A cabeça deriva pelo ruído (nunca a mesma volta) e vem ~0,06 s atrás do corpo.
+      cabeca: [ruido((t - 0.06) * 0.35, sem + 5) * 0.09 + wOuve * 0.05, nod + (1 - wFala) * 0.03, inclina * (i ? -1 : 1) + ruido((t - 0.06) * 0.25, sem + 7) * 0.025],
     };
   };
   const posDe = (i) => (dois ? [(elenco[i].lado || 0) * 0.95, 0, 0] : [0, 0, 0]);