primocode 10.10.1 → 10.11.0

package/lib/catalogo.js

@@ -94,6 +94,7 @@ const GRUPOS = [
                 + '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 — é 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. '

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/index.js

@@ -76,6 +76,7 @@ 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');
 
@@ -405,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 });
@@ -536,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'
@@ -1320,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á. */
@@ -1380,6 +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';
+    /* 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. */
@@ -1772,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 });
@@ -1852,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 {

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]);

package/lib/estudio/kit/voxel.jsx

@@ -31,6 +31,8 @@ import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
 import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
 import { Mundo, Animal, Coisa, alturaDoBicho, frenteDoBicho, useIcones } from './mundo.jsx';
+// O movimento com peso (mola, antecipação, sobreposição, respiração, salto, passo): kit/natural.js.
+import { ruido, envelope, golpe, respiracao, salto, passo } 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;
@@ -144,10 +146,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)) / 1.0;
-      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);
+      // O braço 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];
@@ -372,26 +374,36 @@ function CabecaFacetada({ p, est }) {
 /* A AÇÃO da fala mexe o braço por cima do gesto: acenar (a mão direita no
    alto, abanando), apontar (o braço esticado para a frente), comemorar (os
    dois para cima), pensar (a mão no queixo), dançar (os dois balançando). */
-function poseDoBraco(acao, lado, t, k) {
+function poseDoBraco(acao, lado, t, k, sem = 0) {
   if (!acao || k <= 0) return null;
   const dir = lado > 0;
-  if (acao === 'acenar' && dir) return { x: -0.25, z: 2.55 + Math.sin(t * 9) * 0.25, c: -0.55 + Math.sin(t * 9) * 0.35 };
-  if (acao === 'apontar' && dir) return { x: -1.45, z: 0.12, c: -0.05 };
-  if (acao === 'comemorar') return { x: -0.2, z: lado * (2.7 + Math.sin(t * 8 + lado) * 0.15), c: -0.25 };
-  if (acao === 'pensar' && dir) return { x: -1.5, z: -0.35, c: -2.1 };
-  if (acao === 'dancar') return { x: -0.6 + Math.sin(t * 6 + lado) * 0.5, z: lado * (0.6 + Math.sin(t * 6) * 0.3), c: -1.1 };
-  if (acao === 'correr') return { x: Math.sin(t * 13 + (lado > 0 ? 0 : Math.PI)) * 0.9, z: lado * 0.1, c: -1.3 };
-  if (acao === 'andar') return { x: Math.sin(t * 7 + (lado > 0 ? 0 : Math.PI)) * 0.45, z: lado * 0.06, c: -0.25 };
+  // O antebraço vem ATRASADO do braço (sobreposição): a mesma onda, a fase depois.
+  if (acao === 'acenar' && dir) return { x: -0.25, z: 2.55 + Math.sin(t * 9) * 0.22, c: -0.55 + Math.sin(t * 9 - 1.1) * 0.4 };
+  if (acao === 'apontar' && dir) return { x: -1.45 + ruido(t * 0.8, sem + 3) * 0.04, z: 0.12, c: -0.05 };
+  if (acao === 'comemorar') return { x: -0.2, z: lado * (2.7 + Math.sin(t * 8 + lado) * 0.15), c: -0.25 + Math.sin(t * 8 + lado - 1) * 0.2 };
+  if (acao === 'pensar' && dir) return { x: -1.5 + ruido(t * 0.5, sem + 4) * 0.05, z: -0.35, c: -2.1 };
+  if (acao === 'dancar') return { x: -0.6 + Math.sin(t * 6 + lado) * 0.5, z: lado * (0.6 + Math.sin(t * 6 - 0.5) * 0.3), c: -1.1 + Math.sin(t * 6 + lado - 0.9) * 0.3 };
+  // Andar e correr: o braço oposto à perna, atrasado dela (natural.passo).
+  if (acao === 'correr' || acao === 'andar') {
+    const ps = passo(t, { correr: acao === 'correr', semente: sem });
+    const b = ps.braco[dir ? 1 : 0];
+    return acao === 'correr' ? { x: b * 1.2, z: lado * 0.1, c: -1.3 + b * 0.25 } : { x: b, z: lado * 0.06, c: -0.25 + Math.min(0, b) * 0.5 };
+  }
   return null;
 }
 
-function BracoBloco({ lado, g, cor, pele, t, acao, k = 1 }) {
-  // Repouso: o braço caído, um tico para fora. Gesto: o antebraço sobe e a mão mexe.
-  let ombroX = lerp(0.08, -0.85, g) + Math.sin(t * 6 + lado) * 0.06 * g;
-  let ombroZ = lado * lerp(0.06, 0.22, g);
-  let cotovelo = lerp(-0.12, -1.05, g) + Math.sin(t * 7.3 + lado * 2) * 0.14 * g;
-  const pose = poseDoBraco(acao, lado, t, k);
-  if (pose) { ombroX = lerp(ombroX, pose.x, k); ombroZ = lerp(ombroZ, pose.z, k); cotovelo = lerp(cotovelo, pose.c, k); }
+function BracoBloco({ lado, g, gc = g, cor, pele, t, acao, k = 1, kc = k, ar = 0, sem = 0 }) {
+  // Repouso: o braço caído, um tico para fora — e nunca parado: ele acompanha o
+  // fôlego (abre na inspiração) e deriva pelo ruído. O cotovelo vem depois do
+  // ombro (gc e kc são o gesto e a ação de ~0,1 s antes): a sobreposição.
+  const deriva = ruido(t * 0.45, sem + lado * 5) * 0.035;
+  let ombroX = lerp(0.08, -0.85, g) + Math.sin(t * 6 + lado) * 0.06 * Math.max(0, g) + deriva;
+  let ombroZ = lado * (lerp(0.06, 0.22, Math.max(0, g)) + ar * 0.025);
+  let cotovelo = lerp(-0.12, -1.05, gc) + Math.sin(t * 7.3 + lado * 2 - 0.8) * 0.14 * Math.max(0, gc) + deriva * 0.6;
+  const pose = poseDoBraco(acao, lado, t, k, sem);
+  const poseC = poseDoBraco(acao, lado, t - 0.09, kc, sem);
+  if (pose) { ombroX = lerp(ombroX, pose.x, k); ombroZ = lerp(ombroZ, pose.z, k); }
+  if (poseC) cotovelo = lerp(cotovelo, poseC.c, kc);
   return (
     <group position={[lado * 0.47, 1.4, 0]} rotation={[ombroX, 0, ombroZ]}>
       <Bloco s={[0.2, 0.36, 0.2]} p={[0, -0.17, 0]} c={cor} r={0.04} rough={0.8} />
@@ -404,42 +416,65 @@ function BracoBloco({ lado, g, cor, pele, t, acao, k = 1 }) {
 }
 
 function PessoaBloco({ p, est }) {
-  const resp = Math.sin(est.t * 1.7) * 0.008;
+  const t = est.t, sem = est.semente || 0;
+  // O fôlego: inspira rápido, expira devagar, o ritmo varia (natural.respiracao).
+  const ar = respiracao(t, sem);
+  const resp = ar * 0.012;
   const [cy, cp, cr] = est.cabeca;
   const calca = escurecer(p.roupa, 0.35);
   const a = est.acao, ka = est.forcaAcao || 0;
-  // O corpo inteiro: pular e comemorar sobem, dançar balança, andar e correr marcham.
-  const pulo = (a === 'pular' || a === 'comemorar') ? Math.abs(Math.sin(est.t * 6.5)) * 0.32 * ka : 0;
-  const balanco = a === 'dancar' ? Math.sin(est.t * 6) * 0.14 * ka : 0;
-  const marcha = (a === 'andar' || a === 'correr') ? (a === 'correr' ? 13 : 7) : 0;
+  // O corpo inteiro. Pular e comemorar: agacha, estica, cai acelerando e amassa
+  // no pouso (natural.salto). Dançar: o quadril leva, o tronco e a cabeça vêm
+  // atrasados. Andar e correr: o passo com quadril, contato e contragiro.
+  const pula = a === 'pular' || a === 'comemorar';
+  const sl = pula ? salto(t, a === 'comemorar' ? { periodo: 0.8, altura: 0.22 } : { periodo: 0.95, altura: 0.36 }) : null;
+  const anda = a === 'andar' || a === 'correr';
+  const ps = anda ? passo(t, { correr: a === 'correr', semente: sem }) : null;
+  const danca = a === 'dancar';
+  // Parado, o peso troca de perna devagar: nunca congelado.
+  const peso = ruido(t * 0.22, sem + 11) * 0.018;
+  const y = (sl ? sl.y * ka : 0) + (ps ? ps.sobe * ka : 0) + (danca ? (0.5 + 0.5 * Math.cos(t * 12)) * 0.04 * ka : 0);
+  const sy = sl ? lerp(1, sl.sy, Math.min(1, ka)) : 1, sx = sl ? lerp(1, sl.sx, Math.min(1, ka)) : 1;
+  const quadril = peso + (ps ? ps.quadril * ka : 0) + (danca ? Math.sin(t * 6) * 0.14 * ka : 0);
+  // O tronco gira contra o quadril (andar) ou vem atrasado dele (dançar).
+  const troncoZ = danca ? -Math.sin(t * 6 - 0.6) * 0.07 * ka : -peso * 0.5;
+  const troncoY = ps ? ps.giro * ka : 0;
+  const troncoX = (ps ? ps.inclina * ka : 0) + ar * -0.006;
+  // A cabeça segura o olhar: desfaz parte do giro do tronco, e balança por último.
+  const cabecaZ = cr + (danca ? Math.sin(t * 6 - 1.2) * 0.08 * ka : 0) - quadril * 0.4;
   return (
-    <group position={[0, pulo, 0]} rotation={[0, 0, balanco]}>
+    <group position={[0, y, 0]} rotation={[0, 0, quadril]} scale={[sx, sy, sx]}>
       {/* as pernas e o sapato */}
       {[-1, 1].map((k) => {
-        const passo = marcha ? Math.sin(est.t * marcha + (k > 0 ? 0 : Math.PI)) * (a === 'correr' ? 0.7 : 0.4) * ka : 0;
+        const perna = ps ? ps.perna[k > 0 ? 1 : 0] * ka : 0;
         return (
-          <group key={k} position={[k * 0.15, 0.76, 0]} rotation={[passo, 0, 0]}>
+          <group key={k} position={[k * 0.15, 0.76, 0]} rotation={[perna, 0, -quadril * 0.8]}>
             <Bloco s={[0.25, 0.72, 0.27]} p={[0, -0.36, 0]} c={calca} r={0.03} rough={0.85} />
             <Bloco s={[0.27, 0.1, 0.36]} p={[0, -0.71, 0.04]} c="#1a1a1f" r={0.03} />
           </group>
         );
       })}
-      <group position={[0, resp, 0]}>
-        {/* o tronco, com a faixa branca da camisa da referência */}
-        <Bloco s={[0.76, 0.66, 0.4]} p={[0, 1.1, 0]} c={p.roupa} r={0.05} rough={0.8} />
-        <Bloco s={[0.06, 0.5, 0.02]} p={[0.17, 1.12, 0.205]} c="#dcd8d0" r={0.008} sombra={false} />
-        <Bloco s={[0.22, 0.08, 0.22]} p={[0, 1.46, 0]} c={escurecer(p.pele, 0.88)} r={0.02} />
-      </group>
-      <BracoBloco lado={-1} g={est.gesto[0]} cor={p.roupa} pele={p.pele} t={est.t} acao={a} k={ka} />
-      <BracoBloco lado={1} g={est.gesto[1]} cor={p.roupa} pele={p.pele} t={est.t} acao={a} k={ka} />
-      <group position={[0, 1.8 + resp, 0]} rotation={[cp, cy, cr]}>
-        {p.cabeca !== 'facetada' ? (
-          <>
-            <Bloco s={[CAB, CAB, CAB]} c={p.pele} r={0.04} rough={0.6} />
-            <RostoPixel p={p} est={est} />
-            <Cabelo estilo={p.cabelo} cor={p.corCabelo} />
-          </>
-        ) : <CabecaFacetada p={p} est={est} />}
+      {/* do quadril para cima: o tronco, os braços e a cabeça giram juntos no quadril */}
+      <group position={[0, 0.76, 0]} rotation={[troncoX, troncoY, troncoZ]}>
+        <group position={[0, -0.76, 0]}>
+          <group position={[0, resp, 0]} scale={[1 + ar * 0.008, 1 + ar * 0.014, 1 + ar * 0.02]}>
+            {/* o tronco, com a faixa branca da camisa da referência */}
+            <Bloco s={[0.76, 0.66, 0.4]} p={[0, 1.1, 0]} c={p.roupa} r={0.05} rough={0.8} />
+            <Bloco s={[0.06, 0.5, 0.02]} p={[0.17, 1.12, 0.205]} c="#dcd8d0" r={0.008} sombra={false} />
+            <Bloco s={[0.22, 0.08, 0.22]} p={[0, 1.46, 0]} c={escurecer(p.pele, 0.88)} r={0.02} />
+          </group>
+          <BracoBloco lado={-1} g={est.gesto[0]} gc={(est.gestoAtras || est.gesto)[0]} cor={p.roupa} pele={p.pele} t={t} acao={a} k={ka} kc={est.forcaAtras ?? ka} ar={ar} sem={sem} />
+          <BracoBloco lado={1} g={est.gesto[1]} gc={(est.gestoAtras || est.gesto)[1]} cor={p.roupa} pele={p.pele} t={t} acao={a} k={ka} kc={est.forcaAtras ?? ka} ar={ar} sem={sem} />
+          <group position={[0, 1.8 + resp * 1.2, 0]} rotation={[cp - troncoX * 0.6, cy - troncoY * 0.6, cabecaZ]}>
+            {p.cabeca !== 'facetada' ? (
+              <>
+                <Bloco s={[CAB, CAB, CAB]} c={p.pele} r={0.04} rough={0.6} />
+                <RostoPixel p={p} est={est} />
+                <Cabelo estilo={p.cabelo} cor={p.corCabelo} />
+              </>
+            ) : <CabecaFacetada p={p} est={est} />}
+          </group>
+        </group>
       </group>
     </group>
   );
@@ -454,15 +489,20 @@ function PessoaBloco({ p, est }) {
 function Mascote({ p, est }) {
   const cor = p.cor || '#d9532b';
   const [abre] = est.boca;
-  const pulo = (est.acao === 'pular' || est.acao === 'comemorar') ? Math.abs(Math.sin(est.t * 6)) * 0.25 * (est.forcaAcao || 0) : 0;
-  const respira = Math.sin(est.t * 1.9 + 0.7) * 0.012;
-  const estica = 1 + abre * 0.07 + respira, achata = 1 - abre * 0.035;
+  const ka = Math.min(1, est.forcaAcao || 0);
+  // O pulo com peso: agacha, estica no impulso, cai acelerando e amassa no pouso (natural.salto).
+  const sl = (est.acao === 'pular' || est.acao === 'comemorar') ? salto(est.t, { periodo: 0.85, altura: 0.3 }) : { y: 0, sx: 1, sy: 1 };
+  const pulo = sl.y * ka;
+  const respira = (respiracao(est.t, (est.semente || 0) + 0.7) - 0.5) * 0.024;
+  const estica = (1 + abre * 0.07 + respira) * lerp(1, sl.sy, ka), achata = (1 - abre * 0.035) * lerp(1, sl.sx, ka);
   const pisca = clamp(est.pisca);
   const [cy, cp, cr] = est.cabeca;
   const W = 1.0, H = 0.92, D = 0.78, perna = 0.46;
   const pernas = [-0.38, -0.19, 0, 0.19, 0.38];
+  // O corpo balança de leve sobre as perninhas, atrasado da cabeça (sobreposição).
+  const ginga = ruido(est.t * 0.3, (est.semente || 0) + 21) * 0.025;
   return (
-    <group position={[0, pulo, 0]} rotation={[0, cy * 0.8, cr * 0.5]}>
+    <group position={[0, pulo, 0]} rotation={[0, cy * 0.8, cr * 0.5 + ginga]}>
       {pernas.map((x, i) => (
         <group key={i}>
           <Bloco s={[0.13, perna, 0.13]} p={[x, perna / 2 + Math.max(0, Math.sin(est.t * 9 + i)) * (est.falando ? 0.015 : 0), D / 2 - 0.12]} c={escurecer(cor, 0.9)} r={0.015} rough={0.6} />
@@ -804,33 +844,58 @@ export function VoxelCena({ 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;
   };
-  // A ação da fala vale da voz até 0,6 s depois, entrando e saindo suave.
+  // A ação da fala vale da voz até 0,6 s depois: entra em mola (passa do ponto e
+  // assenta) e sai devagar. O cotovelo pega a mesma ação ~0,1 s depois (sobreposição).
   const acaoDe = (i) => {
     for (const f of falas) {
       if (f.quem !== i || !f.acao || f.acao === 'falar') continue;
-      if (t >= f.de - 0.3 && t <= f.ate + 0.6) return [f.acao, Math.min(suave((t - f.de + 0.3) / 0.4), 1 - suave((t - f.ate - 0.1) / 0.5))];
+      if (t >= f.de - 0.3 && t <= f.ate + 0.6) {
+        const opc = { entra: 2.2, sai: 0.5, amort: 0.55 };
+        return [f.acao, envelope(t, f.de - 0.3, f.ate + 0.1, opc), envelope(t, f.de - 0.3, f.ate + 0.1, { ...opc, atraso: 0.09 })];
+      }
     }
-    return [null, 0];
+    return [null, 0, 0];
   };
-  const quemFala = () => { const f = falas.find((x) => t >= x.de && t <= x.ate); return f ? f.quem : -1; };
+  // O quanto cada um está falando (0 a 1, sem degrau): o aceno de cabeça de quem
+  // fala e o de quem ouve trocam com mola, não num corte seco.
+  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, figurante = false) => {
+    const sem = i * 13 + (figurante ? 101 : 1);
     const fala = !figurante && falandoAgora(i);
-    const qf = quemFala();
-    const outro = qf >= 0 && qf !== i;
+    const wFala = figurante ? 0 : pesoDaFala(i);
     const enfase = figurante ? [0, 0] : gesto(falas, i, t);
-    const nod = Math.sin(t * (fala ? 5.2 : 1.4) + i) * (fala ? 0.04 : 0.015) + (outro ? Math.max(0, Math.sin(t * 2.1 + i)) * 0.04 : 0);
+    const enfaseAtras = figurante ? [0, 0] : gesto(falas, i, t - 0.09);
+    // Quem ouve vira para quem fala com ~0,2 s de reação e mola, e volta devagar.
+    let paraQuemFala = 0, wOuve = 0, dx = 0;
+    if (!figurante) {
+      for (const f of falas) {
+        if (f.quem === i) continue;
+        const w = Math.min(1, envelope(t, f.de + 0.2, f.ate + 0.3, { entra: 1.6, sai: 0.7, amort: 0.62 }));
+        if (w > wOuve) { wOuve = w; dx = lugarDe(elenco, f.quem)[0] - lugarDe(elenco, i)[0]; }
+      }
+      paraQuemFala = clamp(dx * 0.35, -0.35, 0.35) * wOuve;
+    }
+    const nodFala = Math.sin(t * 5.2 + i) * 0.03 + ruido(t * 2.4, sem + 2) * 0.02;
+    const nodQuieto = ruido(t * 0.5, sem + 3) * 0.018;
+    const nod = lerp(nodQuieto, nodFala, wFala) + wOuve * Math.max(0, Math.sin(t * 2.1 + i)) * 0.04;
     const emo = figurante ? 'feliz' : emocaoDe(i);
-    const e = EMO[emo] || EMO.neutro;
-    const micro = (hash(Math.floor(t * 1.5) + i * 7) - 0.5) * 0.6;
-    // Quem ouve vira um pouco para quem fala; quem fala olha para a câmera de vez em quando.
-    const dx = outro && !figurante ? lugarDe(elenco, qf)[0] - lugarDe(elenco, i)[0] : 0;
-    const paraQuemFala = clamp(dx * 0.35, -0.35, 0.35);
-    const [acao, forcaAcao] = figurante ? [null, 0] : acaoDe(i);
+    // A inclinação da emoção chega e vai embora com peso, não troca no quadro.
+    let inclina = 0;
+    if (!figurante) {
+      for (const f of falas) {
+        if (f.quem !== i || f.de > t + 0.2) continue;
+        const ef = EMO[f.emocao] || EMO.neutro;
+        inclina = (ef.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 }));
+      }
+    } else inclina = (EMO.feliz.inclina || 0);
+    const micro = (hash(Math.floor(t * 1.5 + hash(i) * 0.9) + i * 7) - 0.5) * 0.6;
+    const [acao, forcaAcao, forcaAtras] = figurante ? [null, 0, 0] : acaoDe(i);
     return {
-      t, falando: fala, emocao: emo, boca: figurante ? [0, 0.55] : boca(falas, i, t), pisca: piscada(i + (figurante ? 5 : 0), t),
-      gesto: enfase, enfase: Math.max(enfase[0], enfase[1]), acao, forcaAcao,
-      olhar: [micro + (outro ? Math.sign(dx) * 0.8 : 0), 0.1],
-      cabeca: [Math.sin(t * 0.7 + i * 2) * 0.07 + paraQuemFala, nod, (e.inclina || 0) * (i % 2 ? -1 : 1) + Math.sin(t * 0.5 + i) * 0.02],
+      t, semente: sem, falando: fala, emocao: emo, boca: figurante ? [0, 0.55] : boca(falas, i, t), pisca: piscada(i + (figurante ? 5 : 0), t),
+      gesto: enfase, gestoAtras: enfaseAtras, enfase: Math.max(enfase[0], enfase[1], 0), acao, forcaAcao, forcaAtras,
+      olhar: [micro + Math.sign(dx) * 0.8 * wOuve, 0.1],
+      // 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.08 + paraQuemFala, nod, inclina * (i % 2 ? -1 : 1) + ruido((t - 0.06) * 0.25, sem + 7) * 0.025],
     };
   };
   const desenhar = (p, est) => (p.tipo === 'robo' ? <Mascote p={p} est={est} />

package/lib/estudio/kit.js

@@ -67,7 +67,7 @@ const PECAS = {
     animacao: { precisa: ['src'] },
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'natural.js', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/sem-narracao.js

@@ -0,0 +1,140 @@
+/**
+ * sem-narracao.js — o vídeo inteiro sem voz: só o motion e os barulhinhos.
+ *
+ *   "Motions sem narração: só o motion e os efeitos sonoros, os barulhinhos."
+ *   — Joel (14/10/2026)
+ *
+ * Sem voz não há tempo MEDIDO: cada parte dura o `duracao` (s) que o roteiro
+ * deu ou, sem ele, o que o texto da tela pede para ser lido. As palavras ganham
+ * tempos repartidos na parte, para as cenas que entram palavra por palavra
+ * continuarem entrando. E o som sobe de papel: um efeito leve em cada corte e
+ * em cada entrada marcante (sons-leves.js), sem repetir o mesmo em sequência.
+ */
+
+'use strict';
+
+const r3 = (x) => Math.round(x * 1000) / 1000;
+
+/* O pedido que tira a voz: "sem narração", "sem voz", "sem locução", "só efeito sonoro". */
+const PEDIDO = /\bsem\s+(narra[cç][aã]o|narrador|voz|locu[cç][aã]o)\b|\bs[oó]\s+(o\s+motion\s+e\s+)?(os\s+)?(efeitos?\s+sonoros?|barulhinhos?|sfx)\b/i;
+
+/** O vídeo é sem voz? `roteiro.semNarracao` manda (false desliga); sem ele, o pedido. */
+function ativo(roteiro, pedido = '') {
+    const r = roteiro || {};
+    if (r.semNarracao === true || r.semNarracao === 'true') return true;
+    if (r.semNarracao === false || r.semNarracao === 'false') return false;
+    return PEDIDO.test(String(pedido || ''));
+}
+
+/** O que a TELA mostra da parte (é o que se lê; a fala só se não há mais nada). */
+function textoDaTela(pt) {
+    if (!pt || typeof pt !== 'object') return '';
+    const lista = (x) => (Array.isArray(x) ? x.map((i) => (typeof i === 'string' ? i : (i && (i.texto || i.titulo || i.nome || i.rotulo)) || '')) : []);
+    const txt = [pt.titulo, pt.sub, pt.texto, pt.nao, pt.sim, pt.valor, pt.rotulo, pt.autor, ...lista(pt.itens), ...lista(pt.linhas)]
+        .filter((x) => x != null && String(x).trim()).join(' ');
+    return txt.trim() || String(pt.fala || '').trim();
+}
+
+/** Quanto a parte fica na tela: `duracao` do roteiro; senão 1,8 s + 0,25 s por palavra, entre 1,5 e 4 s. */
+function duracaoDe(pt) {
+    const d = Number(pt && pt.duracao);
+    if (d > 0) return Math.max(0.5, Math.min(30, d));
+    const n = textoDaTela(pt).split(/\s+/).filter(Boolean).length;
+    return Math.max(1.5, Math.min(4, 1.8 + 0.25 * n));
+}
+
+/**
+ * Os tempos de cada parte, no mesmo formato que a narração devolve
+ * ({de, ate, palavras:[{texto, de, ate}]}): partes coladas uma na outra e as
+ * palavras repartidas nos primeiros 70% da parte (o resto é o respiro).
+ * `falaDe` dá o texto cujas palavras a cena procura (o do compositor).
+ */
+function tempos(partes, { falaDe = textoDaTela } = {}) {
+    let t = 0;
+    return (partes || []).map((pt) => {
+        const dur = duracaoDe(pt);
+        const de = r3(t), ate = r3(t + dur);
+        const ws = String(falaDe(pt) || textoDaTela(pt) || '').split(/\s+/).filter(Boolean);
+        const ini = de + Math.min(0.2, dur * 0.1), janela = dur * 0.7 - (ini - de);
+        const passo = janela / Math.max(1, ws.length);
+        const palavras = ws.map((w, j) => ({ texto: w, de: r3(ini + j * passo), ate: r3(ini + j * passo + Math.max(0.08, passo * 0.8)) }));
+        t += dur;
+        return { de, ate, palavras };
+    });
+}
+
+/* Os momentos que pedem som: os CORTES (começo de parte, de batida, de cena)
+   e as ENTRADAS marcantes (o ícone, o item, a cena que a IA escreveu). */
+function momentos({ tempos: tps = [], plano = null, partitura = null } = {}) {
+    const cortes = [], entradas = [];
+    const perto = (lista, t, d = 0.3) => lista.some((x) => Math.abs(x - t) < d);
+    const corte = (t) => { if (t > 0.3 && !perto(cortes, t)) cortes.push(r3(t)); };
+    const entrada = (t) => { if (t != null && t >= 0 && !perto(entradas, t, 0.35) && !perto(cortes, t, 0.2)) entradas.push(r3(t)); };
+    for (const t of tps.slice(1)) corte(t.de);
+    const bs = (partitura && partitura.batidas) || [];
+    for (const b of bs) corte(b.de);
+    // Vídeo de várias cenas (os outros estilos): o começo de cada cena é um corte.
+    let acc = 0;
+    for (const c of (plano && plano.cenas) || []) { corte(acc); acc += Number(c.duracao) || 0; }
+    entrada(tps.length ? tps[0].de + 0.1 : 0.1);   // a abertura entra com som
+    for (const b of bs) {
+        if (b.icone3d && b.icone3d.t != null) entrada(b.icone3d.t);
+        for (const l of b.linhas || []) if ((l.papel === 'item' || l.papel === 'numero') && l.t != null) entrada(l.t);
+        if (b.comp === 'marca') entrada(b.de + 0.35);
+    }
+    for (const c of (plano && plano.cenas) || []) for (const el of c.elementos || []) if (el && el.tipo === 'componente' && el.de != null) entrada(el.de + 0.08);
+    return { cortes: cortes.sort((a, b) => a - b), entradas: entradas.sort((a, b) => a - b) };
+}
+
+// O corte passa com ar; a entrada chega com um toque pequeno. Ordem de rodízio.
+const DO_CORTE = ['whoosh', 'sopro', 'toque', 'riser'];
+const DA_ENTRADA = ['pop', 'bolha', 'clique', 'brilho'];
+// O whoosh e o sopro antecipam o corte (o ar chega antes da imagem); o riser sobe até ele.
+const ANTES = { whoosh: 0.18, sopro: 0.3, riser: 1.0, toque: 0 };
+const VOLUME = { whoosh: 0.5, sopro: 0.6, toque: 0.6, riser: 0.4, pop: 0.42, bolha: 0.45, clique: 0.4, brilho: 0.32 };
+
+/**
+ * Soma aos efeitos do plano um som leve em cada corte e em cada entrada.
+ * `sons` é o mapa nome → arquivo do sons-leves.preparar. Não encosta em som
+ * que já existe (0,12 s) e nunca repete o mesmo som duas vezes seguidas.
+ */
+function sonorizar(efeitos, { cortes = [], entradas = [], sons = {}, duracao = Infinity } = {}) {
+    const fora = (efeitos || []).slice();
+    const eventos = [...cortes.map((t) => ({ t, tipo: 'corte' })), ...entradas.map((t) => ({ t, tipo: 'entrada' }))].sort((a, b) => a.t - b.t);
+    const giro = { corte: 0, entrada: 0 };
+    let ultimo = null;
+    const novos = [];
+    for (const ev of eventos) {
+        const roda = ev.tipo === 'corte' ? DO_CORTE : DA_ENTRADA;
+        let nome = null;
+        for (let k = 0; k < roda.length; k++) {
+            const n = roda[(giro[ev.tipo] + k) % roda.length];
+            if (!sons[n] || n === ultimo) continue;
+            // O riser precisa de espaço antes do corte.
+            if (n === 'riser' && ev.t < 1.2) continue;
+            nome = n; giro[ev.tipo] = (giro[ev.tipo] + k + 1) % roda.length; break;
+        }
+        if (!nome) continue;
+        const t = r3(Math.max(0, ev.t - (ANTES[nome] || 0)));
+        if (t > duracao - 0.1) continue;
+        if ([...fora, ...novos].some((e) => Math.abs(e.t - t) < 0.12)) continue;
+        novos.push({ t, src: sons[nome], volume: VOLUME[nome] || 0.4, som: nome });
+        ultimo = nome;
+    }
+    return { efeitos: [...fora, ...novos.map(({ som, ...e }) => e)].sort((a, b) => a.t - b.t), novos };
+}
+
+/** O plano pronto ganha os barulhinhos (o plano é mudado no lugar). Devolve quantos entraram. */
+function sonorizarPlano(r, { tempos: tps = [], sons = {} } = {}) {
+    if (!r || !r.plano) return 0;
+    const plano = r.plano;
+    plano.audio = plano.audio || {};
+    const duracao = (plano.cenas || []).reduce((n, c) => n + (Number(c.duracao) || 0), 0) || Infinity;
+    const m = momentos({ tempos: tps, plano, partitura: r.partitura });
+    const s = sonorizar(plano.audio.efeitos || [], { ...m, sons, duracao });
+    plano.audio.efeitos = s.efeitos;
+    delete plano.audio.narracao;
+    return s.novos.length;
+}
+
+module.exports = { ativo, textoDaTela, duracaoDe, tempos, momentos, sonorizar, sonorizarPlano, PEDIDO };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.10.1",
+  "version": "10.11.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/planos-tela.test.js && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/gerativo-identidade.test.js && node test/gerativo-moldura.test.js && node test/gerativo-heroi.test.js && node test/gerativo-ambiente.test.js && node test/gerativo-variedade.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/estudio-acervo.test.js && node test/estudio-diretor.test.js && node test/estudio-marca.test.js && node test/estudio-novo-projeto.test.js && node test/estudio-plano.test.js && node test/estudio-slides.test.js && node test/estudio-video.test.js && node test/revisor.test.js && node test/conferencia.test.js && node test/cor.test.js && node test/assinatura.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/rolar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js && node test/personagem.test.js && node test/tela.test.js && node test/margem.test.js && node test/travado.test.js && node test/leitura.test.js && node test/producao-provedores.test.js && node test/broll-frase.test.js && node test/vazamento.test.js && node test/colecao.test.js && node test/mundo.test.js && node test/mcp-procurar.test.js && node test/selecao.test.js && node test/nome-curto.test.js && node test/agents-md.test.js && node test/outra-pasta.test.js && node test/estudio-sem-id.test.js && node test/estudio-objeto-do-site.test.js && node test/cenarios.test.js && node test/movimentos.test.js && node test/gerativo-so-fala.test.js && node test/estilos.test.js && node test/proporcao.test.js && node test/cena.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/planos-tela.test.js && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/gerativo-identidade.test.js && node test/gerativo-moldura.test.js && node test/gerativo-heroi.test.js && node test/gerativo-ambiente.test.js && node test/gerativo-variedade.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/estudio-acervo.test.js && node test/estudio-diretor.test.js && node test/estudio-marca.test.js && node test/estudio-novo-projeto.test.js && node test/estudio-plano.test.js && node test/estudio-slides.test.js && node test/estudio-video.test.js && node test/revisor.test.js && node test/conferencia.test.js && node test/cor.test.js && node test/assinatura.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/rolar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js && node test/personagem.test.js && node test/tela.test.js && node test/margem.test.js && node test/travado.test.js && node test/leitura.test.js && node test/producao-provedores.test.js && node test/broll-frase.test.js && node test/vazamento.test.js && node test/colecao.test.js && node test/mundo.test.js && node test/mcp-procurar.test.js && node test/selecao.test.js && node test/nome-curto.test.js && node test/agents-md.test.js && node test/outra-pasta.test.js && node test/estudio-sem-id.test.js && node test/estudio-objeto-do-site.test.js && node test/cenarios.test.js && node test/movimentos.test.js && node test/gerativo-so-fala.test.js && node test/estilos.test.js && node test/proporcao.test.js && node test/cena.test.js && node test/sem-narracao.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/skills/motion-de-primeira/SKILL.md

@@ -50,6 +50,7 @@ desenha é você, em React.
    `roteiro.estiloVisual` (humor, paleta, display, texto…). Um vídeo, uma
    identidade: 2 chãos, 1 acento, 2 fontes.
 3. `estudio_narrar` com o roteiro: os tempos MEDIDOS de cada fala.
+   Sem voz: pule; `semNarracao:true` e `duracao` por parte.
 4. Para cada parte, `write_file` com `path:"componentes/<nome>.jsx"`:
    `export default function Cena({ el, t, fps })`, `t` em segundos desde o
    começo da parte. Em `el.dados`: `titulo`, `fala`, `palavras` (cada uma com
@@ -61,6 +62,9 @@ desenha é você, em React.
    arquivo e mande o roteiro de novo.
 6. `estudio_render`. A voz, a trilha, os sons e o fundo são do Estúdio.
 
+**Variedade:** `estudio_midia acao:"efeitos"` antes das cenas; adapte e use
+como `componente`. Uma técnica nova por vídeo. Risco em 2+ linhas: traço por linha.
+
 Parte sem `componente` cai no gerativo (a tipografia anima sozinha): é a
 reserva, não o objetivo. Sem imagem é o padrão (foto só se pedirem).