primocode 10.10.1 → 10.11.1

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.10.1
+# PrimoCode v10.11.1
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.10.1
+ ▐▛███▜▌   Primo Code v10.11.1
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -17,6 +17,14 @@ está no limite de pedidos, o próximo atende. Você não vê o erro, e não pag
 Personalize o mascote (`primo`, `fox`, `cat`) e o nome com que ele te chama —
 veja `/mascot` e `/name`.
 
+## O que mudou na 10.11
+
+- **Barulhinhos:** cada palavra, item e ponto que entra no motion faz um som pequeno, numa escada de notas, com tique, clique de mouse, blip, swoosh e sub na revelação. A cena pode pedir o som no quadro certo (`sons: [{t, som}]`).
+- **Vídeo sem narração:** `semNarracao: true` (ou "sem voz" no pedido) gera só motion, trilha e efeitos, e a trilha não abaixa.
+- **Efeitos de fábrica:** peça do site em 3D com impacto, brilho que varre, cor que inunda, risco em várias linhas, entrada com física e raios de luz. Quando nenhuma cena é escrita, o plano devolve o cardápio de efeitos.
+- **3D com peso:** o boneco antecipa, respira, pula amassando e anda com o quadril.
+- **Risco:** texto riscado que quebra em várias linhas ganha um traço por linha.
+
 ## O que mudou na 10.4
 
 - **A tela do OpenCode.** O PrimoCode abre em tela cheia: a conversa rola em

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. Toda parte aceita sons:[{t, som}] (t na parte; pop, mouse, tique, digital, swoosh, sub, ponto1..ponto5) para o barulhinho cair no quadro em que a coisa acontece. '
                 + '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/cena.js

@@ -17,6 +17,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const EASING = ['linear', 'ease', 'quad', 'cubic', 'poly', 'sin', 'circle', 'exp', 'elastic', 'back', 'bounce', 'bezier', 'in', 'out', 'inOut', 'step0', 'step1'];
+const TROCA = { expo: 'exp', sine: 'sin', circ: 'circle', cubicBezier: 'bezier', easeIn: 'in', easeOut: 'out', easeInOut: 'inOut', quart: 'poly' };
 const PERMITIDOS = /^(react|remotion|three|@remotion\/[\w-]+|\.{1,2}\/.+)$/;
 
 let esbuild;
@@ -33,6 +35,10 @@ function conferirCena(arquivo, { compilar = compilador() } = {}) {
     if (!/export\s+default\b/.test(codigo)) return { ok: false, erro: 'falta o export default da função da cena ({el, t, fps}).' };
     const fora = [...codigo.matchAll(/\bfrom\s+['"]([^'"]+)['"]|\brequire\(\s*['"]([^'"]+)['"]\s*\)/g)].map((m) => m[1] || m[2]).filter((x) => !PERMITIDOS.test(x));
     if (fora.length) return { ok: false, erro: `import fora do permitido: ${[...new Set(fora)].join(', ')} (só react, remotion, @remotion/*, three).` };
+    /* Easing que não existe compila, mas mata o render inteiro (14/10, a
+       padaria: "Easing.expo" — easing is not a function, 3 renders perdidos). */
+    const easingErrado = [...new Set([...codigo.matchAll(/\bEasing\.(\w+)/g)].map((m) => m[1]))].filter((n) => !EASING.includes(n));
+    if (easingErrado.length) return { ok: false, erro: `Easing.${easingErrado[0]} não existe no Remotion${TROCA[easingErrado[0]] ? ` — use Easing.${TROCA[easingErrado[0]]}` : ''} (existem: ${EASING.join(', ')}).` };
     if (!compilar) return { ok: true, semCompilador: true };
     try {
         compilar.transformSync(codigo, { loader: /\.tsx$/i.test(arquivo) ? 'tsx' : 'jsx', jsx: 'automatic', logLevel: 'silent' });

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,17 @@ 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, cues: args.__semNarracao.cues, 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, entradas e micros`);
+        } else if (args.__barulhinhos && r.plano) {
+            // Com voz: os micros e os sons pedidos pela cena, baixinho por baixo da fala.
+            const n = semNarracao.sonorizarPlano(r, { tempos: args.__barulhinhos.tempos, cues: args.__barulhinhos.cues, sons: sonsLeves.preparar(p.pasta), comVoz: true });
+            if (n) projeto.anotar(p.id, 'plano', `barulhinhos: ${n} micros por baixo da fala`);
+        }
         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 });
@@ -431,9 +443,18 @@ async function ferramentaPlano(args) {
             projeto.salvar(args.id, { estrutura: usada.estrutura || '-' });
         }
         const quebradas = args.__cenasQuebradas || [];
+        /* NENHUMA CENA ESCRITA (14/10, a padaria da 10.11.0 saiu toda no
+           gerativo): a regra morava só na skill, e regra escrita não é regra
+           obedecida. O plano volta com o cardápio na mão — a IA ainda decide. */
+        const pts = Array.isArray(original) ? original : (original && original.partes) || [];
+        const nenhuma = pts.length > 1 && !pts.some((pt) => pt && pt.componente) && !quebradas.length;
         return {
             ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
             ...(quebradas.length ? { cenasQuebradas: quebradas } : {}),
+            ...(nenhuma ? { nenhumaCenaEscrita: {
+                aviso: 'Todas as partes caíram no gerativo automático. Para motion de verdade, escreva ao menos uma cena (componente), partindo de um destes efeitos (estudio_midia usar-efeito) se servir, e mande o roteiro de novo. Cada parte pode pedir som: sons:[{t, som}] (pop, mouse, tique, digital, swoosh, sub, ponto1..ponto5). Se o automático é o que você quer, siga para o render.',
+                efeitos: efeitos.cardapio().slice(0, 6),
+            } } : {}),
             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.',
@@ -536,7 +557,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 +1343,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 +1404,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 +1800,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, cues: semNarracao.cuesDe(partes, 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 });
@@ -1845,6 +1883,7 @@ async function prepararRoteiro(p, args) {
             }
         }
         tempos = v.partes;
+        args.__barulhinhos = { tempos, cues: semNarracao.cuesDe(partes, tempos) };
         narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
         // O motion usa os efeitos leves; os estilos de corte, os cheios.
@@ -1852,6 +1891,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]}>