primocode 10.1.0 → 10.3.0-beta.0

package/lib/estudio/print-site.js

@@ -0,0 +1,152 @@
+/**
+ * print-site.js — o print DE VERDADE de um site, para virar cena 3D.
+ *
+ *   "Se eu mandar um site e pedir, dependendo do modelo, ela pode tirar print
+ *    do site, transformar em 3D e pôr no Motion." (Joel, 09/10/2026)
+ *
+ * Até aqui, quando o vídeo era SOBRE um site, o estúdio desenhava uma janela
+ * de mentira (a peça `site` do kit: manchete, botão e um bloco de cor). Quem
+ * conhece o site olhava e não reconhecia — era um site genérico com o nome
+ * da marca. O navegador escondido já existia (browser.js, o revisor), mas
+ * só servia para conferir página; o `browser_screenshot` tirava print da
+ * aba visível da pessoa, do tamanho da janela dela, e só se o agente
+ * lembrasse de chamar.
+ *
+ * Aqui o print sai do navegador ESCONDIDO, com a tela de um computador
+ * (1440 de largura) ou de um celular (390, densidade 2), da página inteira
+ * (até um teto, para a imagem não virar 40 MB) ou só da primeira dobra. A
+ * imagem vai para midia/site/ do projeto e volta com a proporção medida,
+ * que é o que a peça `printsite` do kit precisa para rolar a página.
+ *
+ * Não decide se o vídeo usa o print. Isso é o modelo, pelo cardápio do
+ * estudio_midia: o pedido traz um site e o vídeo é sobre ele → vale; o vídeo
+ * só cita a marca → não precisa.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TELAS = {
+    computador: { width: 1440, height: 900, deviceScaleFactor: 1, mobile: false },
+    celular: { width: 390, height: 844, deviceScaleFactor: 2, mobile: true },
+};
+// Página mais longa que isto é cortada: um print de 1440×20000 passa de 10 MB
+// e o vídeo nunca mostra mais que umas três telas rolando.
+const ALTURA_MAX = 6000;
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** A URL que o navegador pode abrir — só http(s). null = não é site. */
+function normalizarUrl(url) {
+    let u = String(url || '').trim();
+    if (!u) return null;
+    if (!/^[a-z][a-z0-9+.-]*:/i.test(u)) u = 'https://' + u;
+    try {
+        const p = new URL(u);
+        return /^https?:$/.test(p.protocol) && p.hostname ? p.toString() : null;
+    } catch { return null; }
+}
+
+/* Antes do print, a página desce até o fim e volta: foto com loading="lazy"
+   só carrega quando chega perto da tela, e sem isto o print saía com metade
+   das imagens em branco. */
+const ROLAR_TUDO = `(async () => {
+  const passo = innerHeight * 0.8, fim = Math.min(document.documentElement.scrollHeight, ${ALTURA_MAX});
+  for (let y = 0; y < fim; y += passo) { scrollTo(0, y); await new Promise((r) => setTimeout(r, 120)); }
+  scrollTo(0, 0); await new Promise((r) => setTimeout(r, 300));
+  return true;
+})()`;
+const MEDIR = `JSON.stringify({ altura: Math.max(document.documentElement.scrollHeight, document.body ? document.body.scrollHeight : 0), titulo: document.title || '' })`;
+
+async function valor(sessao, expression, awaitPromise = false) {
+    const r = await sessao.send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise }, 30000).catch(() => null);
+    return r && r.result ? r.result.value : null;
+}
+
+/**
+ * Tira o print do site e grava na pasta do projeto.
+ *
+ * @param {string} url
+ * @param {object} op  { pasta, celular, inteira (padrão true), alturaMax, navegador, assentar }
+ * @returns {Promise<{ok, src, url, titulo, tela, largura, altura, proporcao, cortada, elemento} | {ok:false, error}>}
+ */
+async function capturarSite(url, op = {}) {
+    const alvo = normalizarUrl(url);
+    if (!alvo) return { ok: false, error: `"${url || ''}" não é o endereço de um site (http ou https).` };
+    if (!op.pasta) return { ok: false, error: 'o print vai para a pasta do projeto — diga o projeto (id).' };
+    const navegador = op.navegador || require('../browser.js');
+    const tela = op.celular ? 'celular' : 'computador';
+    const metrica = TELAS[tela];
+    // No celular a página é três vezes mais comprida: o teto é menor.
+    const teto = Math.max(metrica.height, Number(op.alturaMax) || (metrica.mobile ? 4000 : ALTURA_MAX));
+
+    let aba;
+    try {
+        /* A aba nasce em branco e só depois navega: a tela (largura, celular)
+           tem de valer ANTES do site carregar, senão o site responsivo já
+           escolheu o layout de computador e o "print do celular" sai largo. */
+        aba = await navegador.abaEscondida('about:blank', { assentar: 0 });
+        const s = aba.sessao;
+        await s.send('Emulation.setDeviceMetricsOverride', metrica);
+        if (metrica.mobile) await s.send('Emulation.setTouchEmulationEnabled', { enabled: true }).catch(() => {});
+        await s.send('Page.navigate', { url: alvo });
+        const prazo = Date.now() + (op.prazo || 20000);
+        while (Date.now() < prazo) {
+            if (await valor(s, 'document.readyState') === 'complete') break;
+            await sleep(200);
+        }
+        await sleep(op.assentar == null ? 1500 : op.assentar);
+        if (op.inteira !== false) await valor(s, ROLAR_TUDO, true);
+
+        let medida = {};
+        try { medida = JSON.parse(await valor(s, MEDIR) || '{}'); } catch { /* segue com a tela */ }
+        const alturaPagina = Math.max(metrica.height, Number(medida.altura) || metrica.height);
+        const altura = op.inteira === false ? metrica.height : Math.min(alturaPagina, teto);
+
+        const r = await s.send('Page.captureScreenshot', {
+            format: 'jpeg', quality: 88, captureBeyondViewport: true,
+            clip: { x: 0, y: 0, width: metrica.width, height: altura, scale: 1 },
+        }, 60000);
+        if (!r || !r.data) return { ok: false, error: 'o navegador devolveu um print vazio.' };
+
+        const host = new URL(alvo).hostname.replace(/^www\./, '').replace(/[^a-z0-9.-]/gi, '-');
+        const src = `midia/site/${host}-${tela}${op.inteira === false ? '-dobra' : ''}.jpg`;
+        const cheio = path.join(op.pasta, src);
+        fs.mkdirSync(path.dirname(cheio), { recursive: true });
+        fs.writeFileSync(cheio, Buffer.from(r.data, 'base64'));
+
+        const proporcao = Math.round((altura / metrica.width) * 1000) / 1000;
+        const feito = {
+            ok: true, src, url: alvo, titulo: medida.titulo || '', tela,
+            largura: metrica.width, altura, proporcao,
+            cortada: op.inteira !== false && alturaPagina > teto,
+        };
+        feito.elemento = elementoDoPrint(feito);
+        feito.nota = 'O elemento é uma sugestão: ajuste x, y, largura e o tempo ao seu plano. '
+            + 'rolar: true desce a página devagar; inclinacao muda o ângulo 3D.';
+        return feito;
+    } catch (e) {
+        return { ok: false, error: `não consegui tirar o print de ${alvo}: ${e.message}` };
+    } finally {
+        if (aba) { try { await aba.fechar(); } catch { /* a aba já fechou */ } }
+    }
+}
+
+/**
+ * O elemento de plano que mostra o print: a janela (ou o celular) em 3D.
+ * Num quadro 1920×1080 por padrão — o modelo ajusta ao formato dele.
+ */
+function elementoDoPrint(print, { quadroW = 1920, quadroH = 1080, t = 0 } = {}) {
+    const celular = print.tela === 'celular';
+    const largura = celular ? Math.round(quadroH * 0.42) : Math.round(quadroW * 0.66);
+    const altura = celular ? Math.round(largura * 2.05) : Math.round(largura * 0.64);
+    return {
+        tipo: 'kit', peca: 'printsite', src: print.src, proporcao: print.proporcao,
+        celular, url: print.url, t, rolar: print.proporcao > (altura / largura) * 1.2,
+        x: Math.round((quadroW - largura) / 2), y: Math.round((quadroH - altura) / 2), largura, altura,
+    };
+}
+
+module.exports = { capturarSite, elementoDoPrint, normalizarUrl, TELAS, ALTURA_MAX };

package/lib/estudio/referencias.js

@@ -18,14 +18,17 @@
 
 'use strict';
 
-let ATUAL = { modo: null, escopo: '' };
+let ATUAL = { modo: null, escopo: '', explicito: false };
 
-function definir(modo, escopo = '') {
-    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim() };
+function definir(modo, escopo = '', explicito = true) {
+    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim(), explicito: !!explicito };
     return ATUAL;
 }
 function atual() { return ATUAL; }
-function limpar() { ATUAL = { modo: null, escopo: '' }; }
+function limpar() { ATUAL = { modo: null, escopo: '', explicito: false }; }
+
+/** Sem foto nem vídeo de fora: o "sem" e também ninguém ter dito nada (o padrão, 07/10). */
+function semImagem({ modo } = ATUAL) { return modo !== 'aberto' && modo !== 'fechado'; }
 
 /** Os termos do escopo fechado: "site:anthropic.com, claude ai, sonnet" → lista. */
 function termos(escopo = ATUAL.escopo) {
@@ -41,33 +44,51 @@ function entender(resposta) {
     return null;
 }
 
-/* O MODO DEDUZIDO DO PEDIDO. Quem diz no pedido não é perguntado:
-     "só motion", "sem referência", "sem foto"          → sem
-     "só do site x.com", "usa apenas anthropic.com e …" → fechado (o escopo)
-     "web aberta", "escopo aberto", "pesquisa à vontade" → aberto
-   O resto volta com `explicito: false` e o terminal pergunta antes de
-   começar: "eu posso pedir um vídeo mas estar me referindo ao motion"
-   (Joel, 02/10) — chutar o aberto fazia vídeo com foto e b-roll quando a
-   pessoa queria só motion. */
+/* O MODO DEDUZIDO DO PEDIDO. O padrão é SEM IMAGEM: "por padrão, NÃO
+   usar imagens. Somente quando o usuário pedir explicitamente" (Joel, 07/10).
+   O menu 1/2/3 do terminal saiu; quem quer imagem diz no pedido:
+     "adicione imagens de apoio", "quero imagens durante o vídeo",
+     "use imagens reais", "web aberta"                    → aberto
+     "só do site x.com", "usa apenas anthropic.com e …"   → fechado (o escopo)
+     "só motion", "sem referência", "sem foto"            → sem (explícito)
+     o resto                                              → sem (o padrão)  */
+const PEDE_IMAGEM = /(adicion|coloc|use|usa|usar|quero|bota|pon|insir|inclu|com)\w*\s+(\w+\s+){0,3}(imagens?|fotos?|b-?roll|videos? de (apoio|banco)|cenas reais)\b|(imagens?|fotos?) (de apoio|reais|durante|para ilustrar|pra ilustrar|da (web|internet))|escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)/;
+const NEGA_IMAGEM = /so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima|(nao|nada de) (quero |use |usar |coloc\w* )?(imagens?|fotos?)/;
+
 function inferir(texto) {
-    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
-    if (/so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima/.test(t)) return { modo: 'sem', escopo: '', explicito: true };
+    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    if (NEGA_IMAGEM.test(t)) return { modo: 'sem', escopo: '', explicito: true };
     const dominios = String(texto || '').match(/\b[a-z0-9-]+(\.[a-z0-9-]+)+\.?[a-z]{2,}(\/[^\s,]*)?/gi) || [];
     if (/\b(so|apenas|somente|unicamente)\b[^.]{0,30}\b(site|sites|link|links|fonte|fontes|pagina|de|do|da|em)\b/.test(t) && dominios.length) {
         return { modo: 'fechado', escopo: dominios.join(', '), explicito: true };
     }
-    if (/escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)|com (imagens|fotos) da (web|internet)/.test(t)) {
-        return { modo: 'aberto', escopo: '', explicito: true };
-    }
-    return { modo: 'aberto', escopo: '', explicito: false };
+    if (PEDE_IMAGEM.test(t)) return { modo: 'aberto', escopo: '', explicito: true };
+    return { modo: 'sem', escopo: '', explicito: false };
+}
+
+/* O QUE A PESSOA DISSE dos vídeos (assinatura.js): as últimas notas da
+   assinatura do fluido vão junto da instrução, para o agente ler ANTES de
+   escrever o roteiro — o feedback de um vídeo vale para o próximo. */
+function notasDaAssinatura() {
+    try {
+        const notas = require('./assinatura.js').notasRecentes('fluido', 6);
+        return notas.length ? '\n[O QUE A PESSOA DISSE DOS ÚLTIMOS VÍDEOS — assinatura fluido] ' + notas.map((n) => `(${n.quando}) ${n.texto}`).join(' · ') : '';
+    } catch { return ''; }
 }
 
 /** A instrução para o agente, conforme o modo. */
-function instrucao({ modo, escopo } = ATUAL) {
-    if (modo === 'sem') {
+function instrucao(atual = ATUAL) { const i = instrucaoDoModo(atual); return i ? i + notasDaAssinatura() : ''; }
+function instrucaoDoModo({ modo, escopo, explicito } = ATUAL) {
+    // O vídeo sem imagem é motion: o agente escolhe o estilo de motion que serve ao roteiro, não um fixo.
+    const motion = 'O vídeo é MOTION: tipografia, formas, ícones, animação e som. Escolha em roteiro.estilo o motion que serve a este '
+        + 'roteiro (gerativo, fluido, impacto, vox, marca, lancamento) ou deixe vazio para o rodízio — não repita sempre o mesmo.';
+    if (modo === 'sem' && explicito) {
         return '[REFERÊNCIAS: NENHUMA] A pessoa quer SÓ MOTION: não pesquise (nada de pesquisar_referencia nem estudio_site), '
-            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz e deixe '
-            + 'o motion gerativo fazer o trabalho (roteiro.estilo "gerativo": a tipografia anima sozinha, sem template).';
+            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz. ' + motion;
+    }
+    if (modo === 'sem') {
+        return '[SEM IMAGEM — o padrão] A pessoa não pediu imagem: não busque foto nem vídeo, não use estudio_midia de banco '
+            + 'nem "busca" nas partes. Pesquisar FATOS em texto (pesquisar_referencia) pode, se o assunto pedir. ' + motion;
     }
     if (modo === 'fechado') {
         const t = termos(escopo);
@@ -77,8 +98,9 @@ function instrucao({ modo, escopo } = ATUAL) {
             + `No roteiro, ponha roteiro.busca = ${JSON.stringify(t)} para o b-roll.`;
     }
     if (modo === 'aberto') {
-        return '[REFERÊNCIAS: ESCOPO ABERTO] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca) '
-            + 'e dê em cada parte do roteiro um "busca" em inglês com o que mostrar de fundo — gente, lugar, tela, objeto de verdade.';
+        return '[REFERÊNCIAS: ESCOPO ABERTO — a pessoa pediu imagens] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca). '
+            + 'A imagem é um elemento da narrativa, não o vídeo inteiro: dê "busca" (em inglês: gente, lugar, tela, objeto de verdade) '
+            + 'SÓ nas partes em que uma imagem real mostra o que o texto não mostra. Não troque de imagem a cada frase; o resto é motion.';
     }
     return '';
 }
@@ -102,4 +124,4 @@ function filtrar(r, { modo, escopo } = ATUAL) {
     return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
 }
 
-module.exports = { definir, atual, limpar, termos, entender, inferir, instrucao, dominios, filtrar };
+module.exports = { definir, atual, limpar, semImagem, termos, entender, inferir, instrucao, dominios, filtrar };

package/lib/estudio/remotion.js

@@ -103,6 +103,7 @@ import {
 } from 'remotion';
 import { morfar, ehCor, misturarCor } from './morfar';
 import { KIT, CURVAS_KIT, Filtros } from './kit';
+import { COMPONENTES } from './componentes';
 
 /* ── SUAVIZAÇÃO ──────────────────────────────────────────────────────────
  * Cada curva é uma função de 0..1 em 0..1. "suave" é o padrão porque
@@ -227,7 +228,7 @@ function Elemento({ el, t, dados }) {
   /* A PEÇA DO KIT desenha nas coordenadas da cena (x, y dela são o lugar do
      assunto, não o canto de uma caixa): a caixa dela é o quadro inteiro, e o
      "anima" do elemento move o conjunto. */
-  const base = el.tipo === 'kit'
+  const base = el.tipo === 'kit' || el.tipo === 'componente'
     ? { position: 'absolute', left: 0, top: 0, width: '100%', height: '100%' }
     : posicao(el);
   const move = transformDe(a, {});
@@ -383,6 +384,20 @@ function Elemento({ el, t, dados }) {
       );
     }
 
+    /* O COMPONENTE que a IA escreveu (ou reusou do catálogo, efeitos.js).
+       Antes o plano o aceitava e o Cena não sabia desenhar: o efeito sumia
+       do vídeo sem erro. Agora montar() copia o arquivo para src/componentes/
+       e ele recebe {el, t, fps}, no quadro inteiro, como a peça do kit. */
+    case 'componente': {
+      const Comp = COMPONENTES[el.src];
+      if (!Comp) return null;
+      return (
+        <div style={{ ...estilo, transformOrigin: el.origem || ((el.x || 0) + 'px ' + (el.y || 0) + 'px') }}>
+          <Comp el={el} t={tLocal} fps={dados.fps} />
+        </div>
+      );
+    }
+
     case 'grupo':
       return (
         <div style={{
@@ -611,9 +626,41 @@ import icones from './icones.json';
 /* A transição vive em quem SAI e em quem ENTRA ao mesmo tempo: as duas cenas
  * ficam no ar durante o cruzamento. Fazer só a que entra aparecer por cima dá
  * o "piscar" de fundo que denuncia corte mal feito. */
-function Transicao({ tipo, progresso, children }) {
+/* AS TRANSIÇÕES EM 3D (09/10: "quero mais animações, mais efeitos, e efeitos
+ * mais 3D dependendo do vídeo"). As de antes giravam só a cena que entra, sem
+ * perspectiva: o "giro" era um achatamento, não um giro. Estas quatro mexem
+ * nas DUAS cenas (a que sai também recebe o progresso, em "saida") e ficam
+ * num palco com perspectiva:
+ *   virar        a cena vira como um cartão, e o verso é a próxima
+ *   cubo         as duas são faces de um cubo que gira
+ *   profundidade a que sai passa pela câmera; a nova vem do fundo, desfocada
+ *   inclinar     a nova levanta deitada, como uma folha que se ergue */
+const TRANS_3D = { virar: 1, cubo: 1, profundidade: 1, inclinar: 1 };
+function estilo3d(tipo, p, saindo) {
+  const k = p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
+  if (tipo === 'virar') return { transform: 'rotateY(' + (saindo ? 180 * k : -180 + 180 * k) + 'deg)', backfaceVisibility: 'hidden' };
+  if (tipo === 'cubo') return saindo
+    ? { transformOrigin: '100% 50%', transform: 'translateX(' + -100 * k + '%) rotateY(' + -90 * k + 'deg)' }
+    : { transformOrigin: '0% 50%', transform: 'translateX(' + 100 * (1 - k) + '%) rotateY(' + 90 * (1 - k) + 'deg)' };
+  if (tipo === 'profundidade') return saindo
+    ? { transform: 'translateZ(' + 900 * k + 'px)', opacity: 1 - k }
+    : { transform: 'translateZ(' + -1400 * (1 - k) + 'px)', filter: 'blur(' + (1 - k) * 16 + 'px)', opacity: Math.min(1, k * 2.5) };
+  if (tipo === 'inclinar') return saindo
+    ? { transform: 'translateY(' + -12 * k + '%) scale(' + (1 - 0.08 * k) + ')', filter: 'brightness(' + (1 - 0.5 * k) + ')' }
+    : { transformOrigin: '50% 100%', transform: 'rotateX(' + 72 * (1 - k) + 'deg)', opacity: Math.min(1, k * 3) };
+  return {};
+}
+
+function Transicao({ tipo, progresso, saida, children }) {
   const p = progresso;
   const { width: W, height: H } = useVideoConfig();
+  // A cena que sai, quando a próxima entra por uma transição 3D, mexe também.
+  if (saida && TRANS_3D[saida.tipo] && saida.p > 0 && !(TRANS_3D[tipo] && p < 1)) {
+    return <AbsoluteFill style={{ perspective: 1800 }}><AbsoluteFill style={estilo3d(saida.tipo, saida.p, true)}>{children}</AbsoluteFill></AbsoluteFill>;
+  }
+  if (TRANS_3D[tipo] && p < 1) {
+    return <AbsoluteFill style={{ perspective: 1800 }}><AbsoluteFill style={estilo3d(tipo, p, false)}>{children}</AbsoluteFill></AbsoluteFill>;
+  }
   let estilo = {};
   if (tipo === 'esmaecer') estilo = { opacity: p };
   else if (tipo === 'deslizar') estilo = { transform: 'translateX(' + (1 - p) * 100 + '%)' };
@@ -683,9 +730,12 @@ export const Video = () => {
         const progresso = cruz > 0 && local < cruz && i > 0
           ? interpolate(local, [0, cruz], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' })
           : 1;
+        // O progresso de quem ENTRA depois desta: as transições 3D mexem nas duas.
+        const prox = pedacos[i + 1];
+        const saida = prox && prox.cruz > 0 ? { tipo: prox.tipo, p: interpolate(frame - prox.de, [0, prox.cruz], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' }) } : null;
         return (
           <Sequence key={i} from={de} durationInFrames={dur} name={'cena ' + (i + 1)}>
-            <Transicao tipo={i === 0 ? 'corte' : tipo} progresso={progresso}>
+            <Transicao tipo={i === 0 ? 'corte' : tipo} progresso={progresso} saida={saida}>
               <Cena cena={cena} dados={dados} />
             </Transicao>
           </Sequence>
@@ -719,6 +769,8 @@ export const Video = () => {
                 return vs[vs.length - 1].v; }
             : (plano.audio.trilha.volume ?? 0.18)}
           loop={plano.audio.trilha.loop !== false}
+          /* O início da faixa que casa as batidas com os cortes (batida.js). */
+          startFrom={Math.round((plano.audio.trilha.inicio || 0) * fps)}
         />
       )}
       {/* Os TRECHOS: pedaços de áudio no tempo certo — a narração partida entre
@@ -812,6 +864,24 @@ para este projeto, não para o PrimoCode.
 `;
 }
 
+/* Os componentes do plano viram import de verdade: o webpack do Remotion não
+   carrega arquivo por nome em tempo de render, então cada `src` é copiado
+   para src/componentes/ e entra no mapa COMPONENTES pelo mesmo nome. */
+function escreverComponentes(pasta, src, plano) {
+    const srcs = new Set();
+    const ver = (els) => { for (const el of els || []) { if (el && el.tipo === 'componente' && el.src) srcs.add(el.src); if (el) ver(el.elementos); } };
+    for (const c of plano.cenas || []) ver(c.elementos);
+    const linhas = [], mapa = [];
+    [...srcs].forEach((s, i) => {
+        const de = path.resolve(pasta, s);
+        if (!de.startsWith(path.resolve(pasta) + path.sep) || !fs.existsSync(de)) return;
+        escrever(path.join(src, 'componentes', 'c' + i + path.extname(de)), fs.readFileSync(de, 'utf8'));
+        linhas.push(`import * as M${i} from './componentes/c${i}';`);
+        mapa.push(`  ${JSON.stringify(s)}: M${i}.default || Object.values(M${i}).find((v) => typeof v === 'function'),`);
+    });
+    escrever(path.join(src, 'componentes.js'), `${linhas.join('\n')}\nexport const COMPONENTES = {\n${mapa.join('\n')}\n};\n`);
+}
+
 /**
  * Escreve o projeto Remotion dentro da pasta do projeto do Studio.
  *
@@ -849,6 +919,7 @@ function montar({ pasta, titulo, plano, icones = {} }) {
     // O kit de motion (kit.js): as peças que o elemento {"tipo":"kit"} monta.
     for (const f of require('./kit.js').arquivos()) escrever(path.join(src, f.nome), f.conteudo);
     escrever(path.join(src, 'plano.json'), JSON.stringify(plano, null, 2));
+    escreverComponentes(pasta, src, plano);
     escrever(path.join(src, 'icones.json'), JSON.stringify(icones, null, 2));
     escrever(path.join(src, 'fontes.css'), fontesCSS(plano));
 

package/lib/estudio/revisor.js

@@ -0,0 +1,117 @@
+/**
+ * revisor.js — a revisão do plano antes do render: o olho de editor que
+ * procura receita, excesso e pressa, e conserta o que dá sem perguntar.
+ *
+ *   "Antes de finalizar, procure padrões repetitivos, escolhas previsíveis,
+ *    templates rígidos, excesso de efeitos, excesso de imagens, cortes
+ *    artificiais, problemas de ritmo." (Joel, 07/10)
+ *
+ * plano.js confere se o plano RODA; este confere se ele está BOM. O que tem
+ * conserto seguro é consertado aqui (e dito); o que pede decisão vira aviso,
+ * que vai para o agente e para as notas do projeto:
+ *   conserta  a mesma transição 3+ vezes seguidas      → a do meio vira corte seco
+ *   conserta  o MESMO efeito sonoro colado nele (< 0,3 s) → fica um (camadas de sons diferentes são desenho, ficam)
+ *   conserta  câmera mexendo em 4 cenas seguidas       → a mais fraca para (respiro)
+ *   avisa     texto que não dá tempo de ler (0,3 s/palavra, mínimo 0,8 s)
+ *   avisa     a mesma sequência de elementos em 4+ cenas seguidas (cara de template)
+ *   avisa     imagem sem a pessoa pedir, ou imagem em mais da metade das cenas
+ *   conserta  efeito sonoro demais (mais de 1 a cada 1,5 s) → ficam os mais altos
+ * Puro: o plano entra, o plano consertado e a lista saem.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+
+const tipoDaTransicao = (c) => (c && c.transicao ? (c.transicao.tipo || c.transicao) : 'corte');
+const mexe = (cam) => {
+    if (!cam) return false;
+    return Object.values(cam).some((ks) => Array.isArray(ks) && ks.length > 1 && ks.some((k) => Math.abs(Number(k.v) - Number(ks[0].v)) > 0.005));
+};
+const forcaDaCamera = (cam) => Math.max(0, ...Object.values(cam || {}).filter(Array.isArray)
+    .map((ks) => Math.max(...ks.map((k) => Number(k.v) || 0)) - Math.min(...ks.map((k) => Number(k.v) || 0))));
+const palavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
+// Imagem ou vídeo DE FORA: o vídeo da própria gravação (deOrigem) e o recorte da pessoa não contam.
+const imagemDeFora = (el) => el && (el.tipo === 'imagem' || (el.tipo === 'video' && el.deOrigem == null && !/pessoa-/.test(el.src || '')));
+
+function revisar(plano, { semImagem = false } = {}) {
+    const consertos = [], avisos = [];
+    const cenas = (plano && plano.cenas) || [];
+    if (!cenas.length) return { plano, consertos, avisos };
+
+    // 1. A mesma transição (que não seja corte seco) 3+ vezes seguidas: receita.
+    for (let i = 2; i < cenas.length; i++) {
+        const t = tipoDaTransicao(cenas[i]);
+        if (t !== 'corte' && t === tipoDaTransicao(cenas[i - 1]) && t === tipoDaTransicao(cenas[i - 2])) {
+            cenas[i - 1].transicao = { tipo: 'corte' };
+            consertos.push(`cena ${i}: "${t}" 3 vezes seguidas — a do meio virou corte seco`);
+        }
+    }
+
+    // 2. Câmera mexendo em 4 cenas seguidas: a de movimento mais fraco para.
+    for (let i = 3; i < cenas.length; i++) {
+        const janela = [i - 3, i - 2, i - 1, i];
+        if (janela.every((k) => mexe(cenas[k].camera))) {
+            const k = janela.filter((j) => j > 0 && !cenas[j].impacto)   // a abertura (o gancho) e o golpe não param
+               
+                // Empate: a mais à frente — parar a primeira da janela fazia a janela seguinte pedir outra, e paravam todas (08/10).
+                .sort((a, b) => forcaDaCamera(cenas[a].camera) - forcaDaCamera(cenas[b].camera) || b - a)[0];
+            if (k == null) continue;
+            const cam = cenas[k].camera;
+            for (const prop of Object.keys(cam)) if (Array.isArray(cam[prop]) && cam[prop].length) cam[prop] = [{ t: 0, v: cam[prop][0].v }, { t: 1, v: cam[prop][0].v }];
+            consertos.push(`cena ${k + 1}: 4 cenas seguidas com a câmera mexendo — esta respira`);
+        }
+    }
+
+    // 3. Efeitos sonoros: colados um no outro, fica o mais alto; e a densidade.
+    const efeitos = ((plano.audio && plano.audio.efeitos) || []).slice().sort((a, b) => (a.t || 0) - (b.t || 0));
+    if (efeitos.length) {
+        const fica = [];
+        for (const e of efeitos) {
+            const ult = fica[fica.length - 1];
+            if (ult && e.src === ult.src && (e.t || 0) - (ult.t || 0) < 0.3) {
+                if ((e.volume ?? 1) > (ult.volume ?? 1)) fica[fica.length - 1] = e;
+                consertos.push(`efeito em ${r2(e.t || 0)}s colado no de ${r2(ult.t || 0)}s — ficou um`);
+            } else fica.push(e);
+        }
+        const total = cenas.reduce((n, c) => n + (Number(c.duracao) || 0), 0);
+        /* Som demais vira ruído: acima de 1 a cada 1,5 s, ficam os mais altos
+           (o desenho de som marca o mais importante com volume), um a cada 0,7 s. */
+        let final = fica;
+        if (total > 0 && fica.length / total > 1 / 1.5) {
+            const teto = Math.max(1, Math.floor(total / 1.5));
+            const guardados = [];
+            for (const e of fica.slice().sort((a, b) => (b.volume ?? 1) - (a.volume ?? 1))) {
+                if (guardados.length >= teto) break;
+                if (guardados.every((g) => Math.abs((g.t || 0) - (e.t || 0)) >= 0.7)) guardados.push(e);
+            }
+            final = guardados.sort((a, b) => (a.t || 0) - (b.t || 0));
+            consertos.push(`${fica.length} efeitos sonoros em ${r2(total)}s eram ruído — ficaram os ${final.length} mais fortes`);
+        }
+        plano.audio.efeitos = final;
+    }
+
+    // 4. Texto que não dá tempo de ler.
+    cenas.forEach((c, i) => {
+        const n = (c.elementos || []).filter((e) => e && e.tipo === 'texto').reduce((s, e) => s + palavras(e.texto), 0);
+        const precisa = Math.max(0.8, 0.3 * n);
+        if (n && Number(c.duracao) < precisa) avisos.push(`cena ${i + 1}: ${n} palavras em ${c.duracao}s (precisa de ${r2(precisa)}s para ler)`);
+    });
+
+    // 5. A mesma sequência de elementos em 4+ cenas seguidas: cara de template.
+    const assinatura = (c) => (c.elementos || []).map((e) => e && (e.tipo + (e.peca ? ':' + e.peca : ''))).join(',');
+    for (let i = 0, j = 1; j <= cenas.length; j++) {
+        if (j < cenas.length && assinatura(cenas[j]) === assinatura(cenas[i])) continue;
+        if (j - i >= 4 && assinatura(cenas[i])) avisos.push(`cenas ${i + 1} a ${j}: a mesma montagem (${assinatura(cenas[i])}) ${j - i} vezes seguidas — varie a composição`);
+        i = j;
+    }
+
+    // 6. Imagem: sem pedido, nenhuma; com pedido, não em toda cena.
+    const comImagem = cenas.filter((c) => (c.elementos || []).some(imagemDeFora) || (c.fundo && (c.fundo.tipo === 'imagem' || c.fundo.tipo === 'video'))).length;
+    if (semImagem && comImagem) avisos.push(`${comImagem} cena(s) com imagem de fora, mas a pessoa não pediu imagem`);
+    else if (cenas.length >= 4 && comImagem / cenas.length > 0.5) avisos.push(`imagem em ${comImagem} de ${cenas.length} cenas — a imagem é um momento, não o vídeo inteiro`);
+
+    return { plano, consertos, avisos };
+}
+
+module.exports = { revisar };