primocode 10.11.1 → 10.13.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.11.1
+# PrimoCode v10.13.0
 
 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.11.1
+ ▐▛███▜▌   Primo Code v10.13.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -17,6 +17,19 @@ 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.13
+
+- **Motion pelas referências:** o título enche a tela (rótulo nunca abaixo de 2% da altura), a cena dura de 1 a 2 s, o texto entra com ataque rápido e freio forte, e a frase sai inteira. As saídas que espalhavam letras saíram. O círculo de caneta na palavra-chave ganha o ✓. Sem quadro morto entre as cenas. A conta está em `docs/planos/2026-10-15-motion-pelas-referencias.md`.
+- **Revisão do texto:** antes do render, o PrimoCode avisa texto pequeno demais para o celular e contraste abaixo de 3:1.
+- **Camadas sem legenda dobrada:** a cena escrita pela IA não repete a fala por cima da legenda.
+- **Voz do VoiceStudio:** com o app aberto no Mac, ele narra primeiro. Fechado, a narração segue para o Gemini (`PRIMOCODE_SEM_VOICESTUDIO=1` desliga).
+- **Edição de vídeo:** num vídeo sem pedido falado, a edição não para mais na legenda. O agente corta, dá zoom e cor.
+
+## O que mudou na 10.12
+
+- **Vídeo em camadas:** você grava só a fala e o PrimoCode monta o resto. O rosto vira cartão, bolinha no canto, some e volta, com mola, e o motion ocupa o espaço que sobra. A legenda vai palavra por palavra, com a palavra forte em serif itálico. O áudio nunca pula. Use `estudio_video acao:"camadas"`: sem batidas, ele propõe pela transcrição.
+- **Fábrica:** camadas 3D empilhadas e terminal com o prompt sendo digitado.
+
 ## 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}]`).

package/lib/catalogo.js

@@ -142,14 +142,19 @@ const GRUPOS = [
                 + 'Use os tempos que voltam para a duração das cenas — estimar por número de palavras erra em segundos.' },
 
             { tool: 'estudio_video', escreve: true, faz: 'o que se faz com a gravação do usuário: importar, medir, cortar silêncio, transcrever, recortar a pessoa',
-              args: 'id. acao: editar | importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+              args: 'id. acao: editar | camadas | importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
                 + 'editar: FAZ A EDIÇÃO INTEIRA sozinho — corta o silêncio, transcreve palavra por palavra e monta o plano '
                 + '(legenda animada, ícone na hora da palavra, zoom de corte, pop e whoosh). estilo: viral (padrão) | limpo. '
                 + 'Com gravação do usuário, é o PRIMEIRO passo depois de importar; depois só estudio_render. '
                 + 'arquivo: caminho (em "importar", de fora; nas outras, o relativo dentro do projeto). '
                 + 'cortar-silencio: minimoParaCortar (padrão 0.6s), respiro (padrão 0.18s) — os dois existem para o corte não soar robótico. '
                 + 'legendas: devolve os trechos com tempo, para virarem elemento "legenda". '
-                + 'recortar-pessoa: devolve um vídeo com fundo TRANSPARENTE, para pôr sobre qualquer fundo.' },
+                + 'recortar-pessoa: devolve um vídeo com fundo TRANSPARENTE, para pôr sobre qualquer fundo. '
+                + 'camadas: a pessoa SÓ GRAVOU A FALA e o motion vem por cima — a gravação contínua é a narração, o ROSTO muda de forma com mola '
+                + '(cheia | cartao | bolinha | some) e a cena de motion ocupa o espaço que sobra; legenda palavra por palavra (1 a 3), destaque em serif itálica na cor de acento. '
+                + 'Sem batidas, devolve uma PROPOSTA pela transcrição; você decide e chama de novo com '
+                + 'batidas:[{de, ate, rosto, cena?: "componentes/x.jsx" ou nome de efeito de fábrica, destaque?: ["palavra"], canto?: esquerda|direita|centro (bolinha), dados?: {…} para a cena}]. '
+                + 'Alterne as formas, ponha cena onde o rosto encolhe e varie as cenas. rosto: {foco:{x,y} (0 a 1, onde o rosto está na gravação), zoom} quando a pessoa está longe. acento: "#RRGGBB".' },
 
             { tool: 'estudio_render', escreve: true, faz: 'vira arquivo pelo Remotion e abre para o usuário: .mp4 no vídeo, .pdf em slides e arte',
               args: 'id. paginas: true força páginas paradas em vez de vídeo (projeto de formato "slides" ou "arte" já faz isso sozinho). '

package/lib/estudio/assinaturas/gerativo.json

@@ -4,7 +4,7 @@
   "origem": "o vídeo que o Joel aprovou em 08/10/2026 (teste-e2e-sono, o gerativo do PR #113, 30,3 s), medido",
   "descricao": "Batida curta e seca, pouco texto por linha, numa identidade só (2 chãos, 1 acento, 2 fontes): o fundo troca na virada de seção, a primeira por corte seco. A palavra gigante entra em ~1 de cada 3 batidas. O som é desenhado da semente e fica mais raro que no fluido.",
   "faixas": {
-    "batida_mediana_s": { "min": 2, "max": 4.5, "medido": 3.18, "diz": "cada batida dura de 1,7 a 4,5 s, o normal é ~3 s" },
+    "batida_mediana_s": { "min": 1, "max": 3, "medido": 3.18, "revisto": "15/10/2026: as referências do Joel (\"motion devem sair assim\") cortam a cada 1 a 2 s; a faixa saiu de 2–4,5 para 1–3 s.", "diz": "cada batida dura de 1 a 3 s, o normal é ~2 s" },
     "palavras_por_frase_max": { "max": 5, "medido": 3, "diz": "no máximo 3 palavras por linha" },
     "palavras_por_frase_mediana": { "max": 3, "medido": 2, "diz": "o normal é 1 a 2 palavras por linha" },
     "cortes_secos": { "min": 1, "medido": 5, "diz": "o fundo troca por corte seco (5 das 9 trocas)" },

package/lib/estudio/camadas.js

@@ -0,0 +1,386 @@
+/**
+ * camadas.js — a pessoa só gravou a fala; o Estúdio monta o bolo por cima.
+ *
+ *   "Quero uma edição nesse nível" — Joel (14/10/2026), com um reel em que o
+ *    vídeo de quem fala é contínuo, mas o ROSTO muda de forma: tela cheia,
+ *    cartão com borda que brilha, bolinha no canto, some — e o motion toma o
+ *    espaço que sobra.
+ *
+ * ── QUEM DECIDE ──────────────────────────────────────────────────────────
+ * A IA. Ela lê a transcrição e passa as BATIDAS: de quando a quando, a forma
+ * do rosto, a cena de motion que ocupa o espaço livre e as palavras que
+ * ganham destaque na legenda. Este módulo não escolhe nada disso — ele mede
+ * (onde fica a caixa do rosto, onde sobra espaço, onde a legenda não cobre o
+ * rosto) e monta o plano. Sem batidas, `propor` devolve uma SUGESTÃO pela
+ * transcrição, que a IA aceita ou muda.
+ *
+ * ── O QUE SAI ────────────────────────────────────────────────────────────
+ * Uma cena por batida, coladas. Em cada uma, de trás para a frente:
+ *   1. o palco (kit/rosto.jsx): fundo escuro, brilho que respira e grão;
+ *   2. a cena de motion (componente), num grupo do tamanho do espaço livre;
+ *   3. o rosto (kit/rosto.jsx): a gravação, que vai da forma da batida
+ *      anterior para a desta com mola e antecipação. O vídeo nunca reinicia:
+ *      cada cena começa a gravação em `deOrigem` = o começo da batida, e o
+ *      áudio da pessoa é a narração do vídeo inteiro;
+ *   4. a legenda palavra por palavra (1 a 3), a palavra de destaque na serifa
+ *      em itálico e na cor de acento, numa altura que foge do rosto.
+ * E o som: swoosh quando o rosto muda de forma, um toque quando a cena entra
+ * e o micro baixinho nas palavras de destaque (sem-narracao.sonorizarPlano,
+ * com voz).
+ *
+ * Função pura: entra batida e palavra, sai plano. Quem mexe em arquivo é a
+ * ferramenta (estudio_video acao:"camadas", em index.js).
+ */
+
+'use strict';
+
+const edicao = require('./edicao.js');
+const sem = require('./sem-narracao.js');
+
+const FORMAS = ['cheia', 'cartao', 'bolinha', 'some'];
+// O nome que a IA usar por outro caminho ("cartão", "avatar") vale a mesma forma.
+const APELIDOS = {
+    cheia: 'cheia', 'tela-cheia': 'cheia', tela: 'cheia', full: 'cheia', inteira: 'cheia',
+    cartao: 'cartao', 'cartão': 'cartao', card: 'cartao', janela: 'cartao',
+    bolinha: 'bolinha', bola: 'bolinha', avatar: 'bolinha', circulo: 'bolinha', 'círculo': 'bolinha',
+    some: 'some', sem: 'some', oculto: 'some', nenhum: 'some', fora: 'some',
+};
+const ACENTO = '#8B7CF6';
+const r3 = (x) => Math.round(x * 1000) / 1000;
+
+/** A forma do rosto pelo nome que a IA deu, ou null. */
+function formaDe(nome) {
+    return APELIDOS[String(nome || '').trim().toLowerCase()] || null;
+}
+
+/** A palavra sem acento, sem pontuação e em minúsculas — para casar o destaque. */
+function limpa(texto) {
+    return String(texto || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+const corValida = (c) => (/^#[0-9a-f]{6}$/i.test(String(c || '')) ? String(c) : null);
+
+/* ── a geometria ──────────────────────────────────────────────────────────
+   Tudo em pixels do quadro. Cada caixa: x, y, w, h, raio, anel (px da borda
+   que brilha), opacidade e escala. O kit só interpola entre duas caixas. */
+
+/** Onde o rosto fica nesta forma. `canto`: esquerda | direita | centro (a bolinha). */
+function caixaDe(forma, { largura: W = 1080, altura: H = 1920, canto = 'esquerda' } = {}) {
+    const deitado = W > H;
+    const M = Math.round(Math.min(W, H) * 0.06);
+    if (forma === 'cartao') {
+        if (deitado) {
+            const w = Math.round(W * 0.34), h = Math.round(H * 0.7);
+            return { x: W - M - w, y: Math.round((H - h) / 2), w, h, raio: Math.round(H * 0.045), anel: 3, opacidade: 1, escala: 1 };
+        }
+        const w = Math.round(W * 0.66), h = Math.round(H * 0.40);
+        return { x: Math.round((W - w) / 2), y: Math.round(H * 0.50), w, h, raio: Math.round(W * 0.06), anel: 3, opacidade: 1, escala: 1 };
+    }
+    if (forma === 'bolinha' || forma === 'some') {
+        const d = Math.round(deitado ? H * 0.26 : W * 0.26);
+        const lado = canto === 'direita' || (deitado && canto !== 'esquerda' && canto !== 'centro') ? 'direita' : canto;
+        const x = lado === 'direita' ? W - M - d : lado === 'centro' ? Math.round((W - d) / 2) : M;
+        const y = Math.round(deitado ? M : H * 0.055);
+        return { x, y, w: d, h: d, raio: Math.round(d / 2), anel: 6, opacidade: forma === 'some' ? 0 : 1, escala: forma === 'some' ? 0.35 : 1 };
+    }
+    return { x: 0, y: 0, w: W, h: H, raio: 0, anel: 0, opacidade: 1, escala: 1 };
+}
+
+/** O espaço que sobra para o motion nesta forma: {x, y, w, h}. */
+function areaLivre(forma, { largura: W = 1080, altura: H = 1920, canto = 'esquerda' } = {}) {
+    const M = Math.round(Math.min(W, H) * 0.06);
+    if (W > H) {
+        const c = caixaDe('cartao', { largura: W, altura: H });
+        if (forma === 'cartao') return { x: M, y: M, w: c.x - 2 * M, h: Math.round(H * 0.68) };
+        if (forma === 'cheia') return { x: M, y: M, w: W - 2 * M, h: Math.round(H * 0.2) };
+        if (forma === 'some') return { x: M, y: M, w: W - 2 * M, h: Math.round(H * 0.68) };
+        // A bolinha no canto de cima: o motion fica ao lado dela.
+        const b = caixaDe('bolinha', { largura: W, altura: H, canto });
+        const x = b.x > W / 2 ? M : b.x + b.w + M;
+        return { x, y: M, w: (b.x > W / 2 ? b.x - M : W - M) - x, h: Math.round(H * 0.68) };
+    }
+    if (forma === 'cartao') return { x: M, y: Math.round(H * 0.06), w: W - 2 * M, h: Math.round(H * 0.42) };
+    // Tela cheia: só uma faixa no alto (o letreiro "parte 1"), acima da testa.
+    if (forma === 'cheia') return { x: M, y: Math.round(H * 0.04), w: W - 2 * M, h: Math.round(H * 0.12) };
+    if (forma === 'bolinha') {
+        const b = caixaDe('bolinha', { largura: W, altura: H, canto });
+        const y = b.y + b.h + Math.round(H * 0.025);
+        return { x: M, y, w: W - 2 * M, h: Math.round(H * 0.72) - y };
+    }
+    return { x: M, y: Math.round(H * 0.08), w: W - 2 * M, h: Math.round(H * 0.62) };
+}
+
+/** Onde mora o rosto dentro da caixa (a parte de cima dela: testa ao queixo). */
+function regiaoDoRosto(forma, op = {}) {
+    const H = op.altura || 1920;
+    if (forma === 'some') return null;
+    if (forma === 'cheia') return { y: Math.round(H * 0.12), h: Math.round(H * 0.52) };
+    const c = caixaDe(forma, op);
+    if (forma === 'bolinha') return { y: c.y, h: c.h };
+    return { y: c.y, h: Math.round(c.h * 0.7) };
+}
+
+/** A legenda: {x, y} do centro e a meia altura da faixa dela — fora do rosto. */
+function lugarDaLegenda(forma, { largura: W = 1080, altura: H = 1920, canto = 'esquerda' } = {}) {
+    const meia = Math.round(H * 0.04);
+    if (W > H) {
+        if (forma === 'cartao') {
+            const a = areaLivre('cartao', { largura: W, altura: H });
+            return { x: Math.round(a.x + a.w / 2), y: Math.round(H * 0.86), meia };
+        }
+        return { x: Math.round(W / 2), y: Math.round(H * 0.84), meia };
+    }
+    if (forma === 'cheia') return { x: Math.round(W / 2), y: Math.round(H * 0.78), meia };
+    // No cartão, por cima do peito (o rosto fica nos 70% de cima), como na referência.
+    if (forma === 'cartao') {
+        const c = caixaDe('cartao', { largura: W, altura: H });
+        return { x: Math.round(W / 2), y: Math.round(c.y + c.h * 0.86), meia };
+    }
+    return { x: Math.round(W / 2), y: Math.round(H * 0.8), meia };
+}
+
+/* ── a proposta (sem batidas) ─────────────────────────────────────────── */
+
+const RODIZIO = ['cartao', 'bolinha', 'some', 'cartao', 'cheia', 'bolinha', 'some', 'cheia'];
+
+/**
+ * Uma SUGESTÃO de batidas pela transcrição: uma por frase (juntando as
+ * curtas até ~2,2 s e cortando as longas em ~3,6 s, o ritmo da referência), a primeira com o rosto cheio (o gancho é a pessoa), as
+ * outras num rodízio que não repete a forma vizinha. A cena fica em branco:
+ * quem escreve o motion de cada ideia é a IA. O destaque sugerido é a palavra
+ * que mais carrega a frase (edicao.peso) — sugestão, não decisão.
+ */
+function propor(palavras, duracao, { minimo = 2.2, teto = 3.6 } = {}) {
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    if (!lista.length) return [];
+    const juntos = [];
+    for (const g of edicao.frases(lista, { teto })) {
+        const ult = juntos[juntos.length - 1];
+        if (ult && ult[ult.length - 1].ate - ult[0].de < minimo) ult.push(...g);
+        else juntos.push([...g]);
+    }
+    const total = Math.max(Number(duracao) || 0, lista[lista.length - 1].ate);
+    let r = 0;
+    return juntos.map((g, i) => {
+        const de = i === 0 ? 0 : (juntos[i - 1][juntos[i - 1].length - 1].ate + g[0].de) / 2;
+        const ate = i === juntos.length - 1 ? total : (g[g.length - 1].ate + juntos[i + 1][0].de) / 2;
+        const rosto = i === 0 ? 'cheia' : RODIZIO[r++ % RODIZIO.length];
+        const forte = g.reduce((m, p) => (edicao.peso(p.texto) > (m ? edicao.peso(m.texto) : 0) ? p : m), null);
+        return {
+            de: r3(de), ate: r3(ate), rosto,
+            texto: g.map((p) => p.texto).join(' '),
+            destaque: forte ? [String(forte.texto).replace(/[^\p{L}\p{N}-]/gu, '')] : [],
+            cena: null,
+        };
+    });
+}
+
+/* ── conferir e montar ────────────────────────────────────────────────── */
+
+/** O que está errado nas batidas (lista vazia = boas). */
+function conferir(batidas, duracao) {
+    const problemas = [];
+    if (!Array.isArray(batidas) || !batidas.length) return ['"batidas" é uma lista com pelo menos uma batida {de, ate, rosto}.'];
+    batidas.forEach((b, i) => {
+        const n = `batidas[${i}]`;
+        if (!b || typeof b !== 'object') { problemas.push(`${n} não é um objeto.`); return; }
+        if (!Number.isFinite(Number(b.de)) || !Number.isFinite(Number(b.ate))) problemas.push(`${n}: "de" e "ate" são segundos.`);
+        else if (Number(b.ate) <= Number(b.de)) problemas.push(`${n}: "ate" (${b.ate}) tem de vir depois de "de" (${b.de}).`);
+        if (!formaDe(b.rosto)) problemas.push(`${n}: rosto "${b.rosto}" não existe — use ${FORMAS.join(', ')}.`);
+        if (b.cena != null && typeof b.cena !== 'string') problemas.push(`${n}: "cena" é o caminho do componente (ex.: componentes/x.jsx) ou o nome de um efeito de fábrica.`);
+        if (b.destaque != null && !Array.isArray(b.destaque) && typeof b.destaque !== 'string') problemas.push(`${n}: "destaque" é uma lista de palavras.`);
+    });
+    const ordem = batidas.filter((b) => b && Number.isFinite(Number(b.de))).slice().sort((a, b) => a.de - b.de);
+    for (let i = 1; i < ordem.length; i++) {
+        if (Number(ordem[i].de) < Number(ordem[i - 1].ate) - 0.05) problemas.push(`as batidas ${ordem[i - 1].de}–${ordem[i - 1].ate} e ${ordem[i].de}–${ordem[i].ate} se sobrepõem.`);
+    }
+    if (duracao && ordem.length && Number(ordem[0].de) >= duracao) problemas.push(`a primeira batida começa depois do fim da gravação (${duracao}s).`);
+    return problemas;
+}
+
+/** As batidas no tempo do quadro: em ordem, coladas (o buraco vira da anterior), de 0 ao fim. */
+function normalizar(batidas, duracao, fps = 30) {
+    const q = (x) => Math.round(x * fps) / fps;
+    const lista = batidas.map((b) => ({ ...b, rosto: formaDe(b.rosto), de: Number(b.de), ate: Number(b.ate) }))
+        .sort((a, b) => a.de - b.de)
+        .filter((b) => !duracao || b.de < duracao);
+    const fim = q(duracao || lista[lista.length - 1].ate);
+    return lista.map((b, i) => ({
+        ...b,
+        de: i === 0 ? 0 : q(b.de),
+        ate: i === lista.length - 1 ? fim : q(lista[i + 1].de),
+    })).filter((b) => b.ate - b.de >= 1 / fps);
+}
+
+const listaDe = (x) => (Array.isArray(x) ? x : typeof x === 'string' ? [x] : [])
+    .flatMap((s) => String(s).split(/\s+/)).map(limpa).filter(Boolean);
+
+/**
+ * O plano do vídeo em camadas.
+ *
+ * @param {object} op
+ * @param {string} op.src        a gravação, relativa à pasta do projeto (o áudio dela é a narração)
+ * @param {number} op.duracao    segundos
+ * @param {Array}  op.palavras   [{de, ate, texto}] no tempo da gravação
+ * @param {Array}  op.batidas    [{de, ate, rosto, cena?, destaque?, canto?, dados?, foco?, zoom?}] — da IA
+ * @param {number} op.largura    do vídeo final (e da gravação, se `origem` não vier)
+ * @param {object} op.origem     {largura, altura} da gravação
+ * @param {object} op.rosto      {foco:{x,y} (0 a 1, onde está o rosto na gravação), zoom}
+ * @param {string} op.acento     a cor da borda, do brilho e da palavra de destaque
+ * @param {object} op.sons       nome → arquivo (sons-leves.preparar)
+ */
+function montar({ src, duracao, palavras = [], batidas, largura = 1080, altura = 1920, fps = 30, origem = null, rosto = {}, acento = ACENTO, sons = {} } = {}) {
+    if (!src) return { ok: false, error: 'falta a gravação (src).' };
+    const problemas = conferir(batidas, duracao);
+    if (problemas.length) return { ok: false, error: 'as batidas têm problema: ' + problemas.join(' '), problemas };
+    const AC = corValida(acento) || ACENTO;
+    const W = largura, H = altura;
+    const orig = { largura: (origem && origem.largura) || W, altura: (origem && origem.altura) || H };
+    const lista = normalizar(batidas, duracao, fps);
+    const falas = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    const focoDe = (b) => {
+        const f = (b && b.foco) || rosto.foco || {};
+        const n = (v, d) => (Number.isFinite(Number(v)) ? Math.max(0, Math.min(1, Number(v))) : d);
+        return { fx: n(f.x, 0.5), fy: n(f.y, 0.4) };
+    };
+    const zoomDe = (b) => Math.max(1, Math.min(4, Number((b && b.zoom) ?? rosto.zoom) || 1));
+
+    const cenas = [];
+    const cues = [];
+    const micros = [];
+    const contagem = { cheia: 0, cartao: 0, bolinha: 0, some: 0 };
+    let comCena = 0;
+    let girarEntrada = 0;
+    const ENTRADA = ['pop', 'mouse', 'digital'];
+
+    lista.forEach((b, i) => {
+        const dur = r3(b.ate - b.de);
+        const op = { largura: W, altura: H, canto: b.canto || 'esquerda' };
+        const ant = i > 0 ? lista[i - 1] : null;
+        const opAnt = ant ? { largura: W, altura: H, canto: ant.canto || 'esquerda' } : op;
+        contagem[b.rosto]++;
+
+        /* As duas caixas: de onde o rosto vem e para onde vai. "Some" encolhe
+           no lugar de onde saiu (e volta a crescer de onde vai aparecer). */
+        const caixa = (forma, o, bat) => ({ ...caixaDe(forma, o), ...focoDe(bat), zoom: zoomDe(bat) });
+        let agora = caixa(b.rosto, op, b);
+        let antes = ant ? caixa(ant.rosto, opAnt, ant) : agora;
+        const sumir = (c) => ({ ...c, opacidade: 0, escala: 0.35, raio: Math.round(Math.min(c.w, c.h) / 2) });
+        if (b.rosto === 'some' && ant) agora = sumir(antes);
+        if (ant && ant.rosto === 'some') antes = sumir(agora);
+        const mudou = !!ant && ant.rosto !== b.rosto;
+
+        const elementos = [{ tipo: 'kit', peca: 'palco', acento: AC, semente: i }];
+
+        /* A cena anterior SAI, não some no corte: enquanto o rosto cresce, ela
+           continua no tempo dela (o componente com "de" negativo segue de onde
+           parou), encolhe e esmaece. Sem isso, o quadro da troca fica vazio. */
+        const grupoAnt = ant && mudou && cenas[i - 1].elementos.find((e) => e.tipo === 'grupo' && !e.saindo);
+        if (grupoAnt) {
+            const andou = r3(cenas[i - 1].duracao - grupoAnt.de);
+            elementos.push({
+                ...grupoAnt, de: 0, ate: 0.4, saindo: true,
+                anima: { opacidade: [{ t: 0, v: 1 }, { t: 0.36, v: 0 }], escala: [{ t: 0, v: 1 }, { t: 0.4, v: 0.94, e: 'suave' }] },
+                origem: 'center center',
+                elementos: grupoAnt.elementos.map((e) => ({ ...e, de: -andou })),
+            });
+        }
+
+        // A cena de motion entra quando o rosto já está saindo do caminho.
+        if (b.cena) {
+            comCena++;
+            const area = areaLivre(b.rosto, op);
+            const entra = mudou ? 0.18 : 0;
+            const ws = falas.filter((p) => p.de >= b.de && p.de < b.ate);
+            elementos.push({
+                tipo: 'grupo', x: area.x, y: area.y, largura: area.w, altura: area.h, de: entra,
+                anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.22, v: 1 }] },
+                elementos: [{
+                    tipo: 'componente', src: b.cena,
+                    dados: {
+                        largura: area.w, altura: area.h, duracao: r3(dur - entra),
+                        /* 15/10: a cena escrevia a fala, e a legenda do PrimoCode vinha
+                           por cima ("provou / provou o bolo"). A fala é para SINCRONIA. */
+                        legendaNoQuadro: true,
+                        regra: 'a legenda da fala já está no quadro: não escreva a fala; use as palavras só para o tempo, e desenhe a ideia',
+                        fala: ws.map((p) => p.texto).join(' '),
+                        palavras: ws.map((p) => ({ texto: p.texto, t: r3(p.de - b.de - entra) })),
+                        destaque: (Array.isArray(b.destaque) ? b.destaque : b.destaque ? [b.destaque] : []),
+                        cores: { fundo: 'transparent', texto: '#ffffff', acento: AC, suave: '#ffffff99' },
+                        fontes: { display: 'Instrument Serif', texto: 'Inter', mono: 'JetBrains Mono' },
+                        // As chaves "fonte…" são as que o fontesCSS do remotion.js carrega.
+                        fonteTitulo: 'Instrument Serif', fonteTexto: 'Inter', fonteMono: 'JetBrains Mono',
+                        ...(b.dados && typeof b.dados === 'object' ? b.dados : {}),
+                    },
+                }],
+            });
+            cues.push({ t: r3(b.de + entra + 0.06), som: ENTRADA[girarEntrada++ % ENTRADA.length], volume: 0.3 });
+        }
+
+        elementos.push({
+            tipo: 'kit', peca: 'rosto', src, deOrigem: r3(b.de), volume: 1,
+            origem: orig, antes, agora, mudou, acento: AC, forma: b.rosto,
+        });
+
+        // A legenda: 1 a 3 palavras por vez, o destaque na serifa e na cor de acento.
+        const fortes = new Set(listaDe(b.destaque));
+        const ws = falas.filter((p) => p.de >= b.de && p.de < b.ate);
+        const local = (t) => r3(Math.max(0, Math.min(dur, t - b.de)));
+        const blocos = edicao.blocos(ws, 3);
+        const fala = blocos.map((bl, j) => {
+            const fim = bl[bl.length - 1].ate + 0.6;
+            const prox = blocos[j + 1] ? blocos[j + 1][0].de - 0.04 : Infinity;
+            return {
+                de: local(bl[0].de - 0.04), ate: local(Math.min(fim, prox)),
+                texto: bl.map((p) => p.texto).join(' '),
+                palavras: bl.map((p) => {
+                    const forte = fortes.has(limpa(p.texto));
+                    if (forte) micros.push(r3(p.de));
+                    return { de: local(p.de), ate: local(p.ate), texto: String(p.texto).replace(/[.,;:!?…]+$/, ''), ...(forte ? { forte: true } : {}) };
+                }),
+            };
+        }).filter((f) => f.ate > f.de);
+        if (fala.length) {
+            const lugar = lugarDaLegenda(b.rosto, op);
+            elementos.push({
+                // Largura explícita: ancorada no meio, sem ela a caixa só teria a metade direita do quadro e quebraria a linha.
+                tipo: 'legenda', x: lugar.x, y: lugar.y, ancora: 'centro', largura: Math.round((W > H ? 0.6 : 0.9) * W), fala,
+                estilo: {
+                    fonte: 'Inter', peso: 800, tamanho: Math.round(Math.min(W, H) * 0.064),
+                    cor: '#ffffff', destaque: '#ffffff', corForte: clarear(AC), fonteForte: 'Instrument Serif',
+                    largura: '100%', contorno: '0px transparent',
+                    sombra: '0 4px 26px rgba(0,0,0,.65), 0 1px 2px rgba(0,0,0,.5)',
+                },
+            });
+        }
+
+        // O swoosh chega um tico antes da forma nova (o ar vem antes da imagem).
+        if (mudou) cues.push({ t: r3(Math.max(0, b.de - 0.1)), som: 'swoosh', volume: 0.34 });
+
+        cenas.push({ duracao: dur, fundo: { tipo: 'cor', valor: '#07060c' }, elementos, transicao: { tipo: 'corte' } });
+    });
+
+    const r = { plano: { formato: { largura: W, altura: H, fps }, fundoGeral: '#07060c', cenas, audio: {} } };
+    const total = cenas.reduce((n, c) => n + c.duracao, 0);
+    const nSons = sem.sonorizarPlano(r, { comVoz: true, sons, cues, tempos: [{ de: 0, ate: total, palavras: micros.map((t) => ({ de: t })) }] });
+    if (!r.plano.audio.efeitos || !r.plano.audio.efeitos.length) delete r.plano.audio;
+    return {
+        ok: true,
+        plano: r.plano,
+        batidas: lista.map((b) => ({ de: b.de, ate: b.ate, rosto: b.rosto, cena: b.cena || null })),
+        resumo: {
+            batidas: lista.length, formas: contagem, cenas: comCena,
+            trocasDeForma: lista.filter((b, i) => i && lista[i - 1].rosto !== b.rosto).length,
+            palavras: falas.length, destaques: micros.length, sons: nSons, duracao: r3(total),
+        },
+    };
+}
+
+/** O acento mais claro, para a palavra de destaque ler sobre o fundo escuro. */
+function clarear(hex, k = 0.28) {
+    const c = corValida(hex) || ACENTO;
+    const n = (i) => Math.round(parseInt(c.slice(i, i + 2), 16) + (255 - parseInt(c.slice(i, i + 2), 16)) * k);
+    return '#' + [1, 3, 5].map((i) => n(i).toString(16).padStart(2, '0')).join('');
+}
+
+module.exports = { FORMAS, formaDe, caixaDe, areaLivre, regiaoDoRosto, lugarDaLegenda, propor, conferir, normalizar, montar, limpa, clarear, ACENTO };

package/lib/estudio/diretor.js

@@ -110,7 +110,8 @@ function vozPara({ tom = 'neutro', idioma = 'pt-BR', genero } = {}) {
 /** Quantas cenas cabem, e de que tamanho, num vídeo desta duração. */
 function ritmoPara(segundos) {
     const s = Math.max(5, Number(segundos) || 30);
-    const media = s <= 20 ? 2.6 : s <= 45 ? 3.4 : s <= 90 ? 4.2 : 5;
+    // (15/10) As referências cortam a cada 1 a 2 s; o PrimoCode pedia 2,6 a 5 s e saía lento.
+    const media = s <= 20 ? 1.8 : s <= 45 ? 2.2 : s <= 90 ? 2.6 : 3;
     return { cenas: Math.max(3, Math.round(s / media)), duracaoMedia: media,
         palavrasPorCena: Math.round(media * 2.6) };   // ~155 palavras/minuto de narração
 }

package/lib/estudio/efeitos-fabrica/camadas-empilhadas.jsx

@@ -0,0 +1,64 @@
+// Camadas 3D empilhadas: placas arredondadas caem uma a uma numa pilha isométrica, com mola, e flutuam.
+// el.dados (ou el): camadas [{cor, rotulo}] (ou números de 3 a 6), titulo, cores {fundo, texto, acento}, fontes {display, texto}, largura, altura, atraso (s).
+import React from 'react';
+import { useVideoConfig } from 'remotion';
+
+const PADRAO = ['#F5B82E', '#3B82F6', '#8B7CF6', '#C4B5FD', '#F4F4F5'];
+
+function mola(s) {
+  if (s <= 0) return 0;
+  const w = 2 * Math.PI * 1.9, z = 0.55, wd = w * Math.sqrt(1 - z * z);
+  return 1 - Math.exp(-z * w * s) * (Math.cos(wd * s) + (z * w / wd) * Math.sin(wd * s));
+}
+
+export default function CamadasEmpilhadas({ 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 f = d.fontes || {};
+  const u = t - (d.atraso || 0);
+  const lista = Array.isArray(d.camadas) && d.camadas.length
+    ? d.camadas.slice(0, 6).map((x, i) => (typeof x === 'object' ? x : { cor: PADRAO[i % PADRAO.length] }))
+    : PADRAO.slice(0, Number(d.camadas) || 4).map((cor) => ({ cor }));
+  const n = lista.length;
+  const titulo = d.titulo ? 1 : 0;
+  const lado = Math.min(W * 0.56, (H * (titulo ? 0.66 : 0.82)) / 1.25);
+  const passo = lado * 0.13;
+  const respira = Math.sin(u * 1.6) * 6;
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || 'transparent', overflow: 'visible' }}>
+      <div style={{ position: 'absolute', left: '50%', top: titulo ? '58%' : '52%', width: 0, height: 0, perspective: 1600 }}>
+        {/* a sombra da pilha, no chão */}
+        <div style={{ position: 'absolute', left: -lado * 0.6, top: lado * 0.38, width: lado * 1.2, height: lado * 0.3, borderRadius: '50%',
+          background: 'radial-gradient(closest-side, rgba(0,0,0,.55), transparent)', filter: 'blur(8px)', opacity: Math.min(1, u / 0.6) }} />
+        <div style={{ position: 'absolute', transformStyle: 'preserve-3d', transform: `rotateX(58deg) rotateZ(-40deg) translateZ(${respira}px)` }}>
+          {lista.map((cam, i) => {
+            const k = mola(u - 0.12 - i * 0.16);
+            const z = i * passo + (1 - k) * lado * 0.9;
+            const op = Math.min(1, Math.max(0, (u - 0.12 - i * 0.16) / 0.12));
+            const cor = cam.cor || PADRAO[i % PADRAO.length];
+            return (
+              <div key={i} style={{
+                position: 'absolute', left: -lado / 2, top: -lado / 2, width: lado, height: lado, borderRadius: lado * 0.12,
+                transform: `translateZ(${z}px)`, opacity: op,
+                background: `linear-gradient(135deg, ${cor}, ${cor}cc)`,
+                boxShadow: `0 0 0 2px #ffffff30 inset, 0 ${passo * 0.6}px ${passo * 1.4}px rgba(0,0,0,.35)`,
+              }}>
+                {cam.rotulo ? (
+                  <div style={{ position: 'absolute', right: lado * 0.08, bottom: lado * 0.06, color: '#0b0b12', fontFamily: `"${f.texto || 'Inter'}", sans-serif`,
+                    fontWeight: 800, fontSize: lado * 0.08, letterSpacing: '0.04em', textTransform: 'uppercase' }}>{cam.rotulo}</div>
+                ) : null}
+              </div>
+            );
+          })}
+        </div>
+      </div>
+      {titulo ? (
+        <div style={{ position: 'absolute', top: 0, zIndex: 2, width: '100%', textAlign: 'center', color: c.texto || '#fff',
+          fontFamily: `"${f.display || 'Instrument Serif'}", serif`, fontStyle: 'italic', fontSize: Math.min(W * 0.09, H * 0.12),
+          opacity: Math.min(1, Math.max(0, u / 0.3)), transform: `translateY(${(1 - Math.min(1, Math.max(0, u / 0.3))) * 16}px)` }}>{d.titulo}</div>
+      ) : null}
+    </div>
+  );
+}

package/lib/estudio/efeitos-fabrica/terminal-digitando.jsx

@@ -0,0 +1,58 @@
+// Terminal com o prompt sendo digitado: a janela entra com mola, cada linha é digitada letra a letra e o cursor pisca.
+// el.dados (ou el): linhas [texto] (ou titulo/fala), rotulo (barra da janela), velocidade (letras/s), cores {fundo, texto, acento}, fontes {mono}, largura, altura, atraso (s).
+import React from 'react';
+import { useVideoConfig } from 'remotion';
+
+function mola(s) {
+  if (s <= 0) return 0;
+  const w = 2 * Math.PI * 1.7, z = 0.6, wd = w * Math.sqrt(1 - z * z);
+  return 1 - Math.exp(-z * w * s) * (Math.cos(wd * s) + (z * w / wd) * Math.sin(wd * s));
+}
+
+export default function TerminalDigitando({ 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 f = d.fontes || {};
+  const u = t - (d.atraso || 0);
+  // O prompt "›" é da janela: a linha que já vem com "> " ou "$ " saía com ele dobrado ("› > faz um site", 15/10).
+  const linhas = (Array.isArray(d.linhas) && d.linhas.length ? d.linhas : [d.titulo || d.fala || 'faz o vídeo pra mim']).map((x) => String(x).replace(/^\s*[>›$#]\s+/, '')).slice(0, 6);
+  const vel = d.velocidade || 26;
+  const k = mola(u);
+  const largura = Math.min(W * 0.96, H * 1.5);
+  const tam = Math.max(14, Math.min(largura * 0.058, (H * 0.6) / (linhas.length * 1.8 + 2)));
+  // Cada linha começa quando a anterior terminou de ser digitada (com um respiro).
+  let relogio = 0.35;
+  const tempos = linhas.map((l) => { const ini = relogio; relogio += l.length / vel + 0.25; return ini; });
+  const ac = c.acento || '#8B7CF6';
+  return (
+    <div style={{ position: 'absolute', inset: 0, width: W, height: H, background: c.fundo || 'transparent', display: 'grid', placeItems: 'center' }}>
+      <div style={{
+        width: largura, borderRadius: tam * 0.8, overflow: 'hidden', background: 'rgba(13,12,22,.92)',
+        border: '1px solid rgba(255,255,255,.12)', boxShadow: `0 30px 80px rgba(0,0,0,.55), 0 0 60px ${ac}22`,
+        transform: `translateY(${(1 - k) * 40}px) scale(${0.92 + 0.08 * k})`, opacity: Math.min(1, Math.max(0, u / 0.2)),
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: tam * 0.4, padding: `${tam * 0.55}px ${tam * 0.8}px`, borderBottom: '1px solid rgba(255,255,255,.08)' }}>
+          {['#ff5f57', '#febc2e', '#28c840'].map((cor) => <div key={cor} style={{ width: tam * 0.55, height: tam * 0.55, borderRadius: '50%', background: cor }} />)}
+          <div style={{ marginLeft: tam * 0.5, color: '#ffffff88', fontFamily: `"${f.mono || 'JetBrains Mono'}", monospace`, fontSize: tam * 0.62 }}>{d.rotulo || 'claude code'}</div>
+        </div>
+        <div style={{ padding: `${tam * 0.8}px ${tam}px ${tam * 1.1}px`, fontFamily: `"${f.mono || 'JetBrains Mono'}", monospace`, fontSize: tam, lineHeight: 1.6, color: c.texto || '#fff' }}>
+          {linhas.map((l, i) => {
+            const n = Math.max(0, Math.min(l.length, Math.floor((u - tempos[i]) * vel)));
+            if (u < tempos[i]) return null;
+            const digitando = n < l.length || i === linhas.length - 1;
+            const pisca = Math.floor(u * 2.2) % 2 === 0;
+            return (
+              <div key={i} style={{ whiteSpace: 'pre-wrap' }}>
+                <span style={{ color: ac, marginRight: tam * 0.5 }}>›</span>
+                {l.slice(0, n)}
+                {digitando ? <span style={{ display: 'inline-block', width: tam * 0.55, height: tam * 1.1, verticalAlign: 'text-bottom', marginLeft: 2, background: ac, opacity: n < l.length || pisca ? 1 : 0 }} /> : null}
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}

package/lib/estudio/efeitos.js

@@ -45,6 +45,8 @@ const FABRICA = [
     { 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'] },
+    { nome: 'camadas-empilhadas', descricao: 'placas 3D arredondadas caem uma a uma numa pilha isométrica, com mola, e flutuam (dados.camadas: [{cor, rotulo}], titulo)', tags: ['3d', 'camadas', 'pilha'] },
+    { nome: 'terminal-digitando', descricao: 'janela de terminal entra com mola e o prompt é digitado letra a letra, com o cursor piscando (dados.linhas, rotulo)', tags: ['terminal', 'codigo', 'prompt'] },
 ];
 const deFabrica = (nome) => FABRICA.find((x) => x.nome === nome && fs.existsSync(path.join(fabricaPasta, x.nome + '.jsx')));