primocode 10.11.0 → 10.12.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.10.1
+# PrimoCode v10.12.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.10.1
+ ▐▛███▜▌   Primo Code v10.12.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.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}]`).
+- **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,7 +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. '
+                + '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. '
@@ -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/camadas.js

@@ -0,0 +1,382 @@
+/**
+ * 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),
+                        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/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/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,57 @@
+// 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);
+  const linhas = (Array.isArray(d.linhas) && d.linhas.length ? d.linhas : [d.titulo || d.fala || 'faz o vídeo pra mim']).map(String).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')));
 

package/lib/estudio/index.js

@@ -77,6 +77,7 @@ const colecao = require('./colecao.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
 const semNarracao = require('./sem-narracao.js');
+const camadas = require('./camadas.js');
 const ende = require('./ende.js');
 const producao = require('./producao.js');
 
@@ -409,9 +410,13 @@ async function ferramentaPlano(args) {
         /* SEM NARRAÇÃO: o som sobe de papel — um efeito leve em cada corte e em
            cada entrada marcante, variando (sem-narracao.js, sons-leves.js). */
         if (args.__semNarracao) {
-            const n = semNarracao.sonorizarPlano(r, { tempos: args.__semNarracao.tempos, sons: sonsLeves.preparar(p.pasta) });
+            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 e entradas`);
+            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`);
@@ -439,9 +444,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.',
@@ -849,6 +863,80 @@ async function ferramentaVideo(args, ctx = {}) {
         };
     }
 
+    /* O VÍDEO EM CAMADAS (camadas.js, 14/10: "quero uma edição nesse nível"):
+       a pessoa só gravou a fala; a IA passa as batidas (forma do rosto, cena
+       de motion, destaque) e o Estúdio monta o bolo por cima. Sem batidas,
+       devolve uma proposta pela transcrição — a IA aceita ou muda. */
+    if (acao === 'camadas') {
+        const m = await video.medir(alvo);
+        if (!m.ok) return m;
+        // A transcrição fica guardada: a proposta e a montagem não pagam duas vezes.
+        const guardada = path.join(p.pasta, 'midia', `transcricao-${path.basename(alvo).replace(/\.[^.]+$/, '')}.json`);
+        let palavras = Array.isArray(args.palavras) && args.palavras.length ? args.palavras : null;
+        if (palavras) { try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ } }
+        if (!palavras && fs.existsSync(guardada)) { try { palavras = JSON.parse(fs.readFileSync(guardada, 'utf8')); } catch { palavras = null; } }
+        if (!palavras) {
+            const tr = await transcrever(p, alvo, ctx);
+            if (!tr.ok) return tr;
+            palavras = (tr.palavras && tr.palavras.length) ? tr.palavras : repartirTrechos(tr.trechos || []);
+            try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ }
+        }
+        const batidas = Array.isArray(args.batidas) && args.batidas.length ? args.batidas : null;
+        if (!batidas) {
+            return {
+                ok: true, proposta: camadas.propor(palavras, m.segundos), duracao: m.segundos,
+                comoUsar: 'é uma SUGESTÃO pela transcrição. Decida você: mude as formas, junte ou separe batidas, '
+                    + 'escreva a cena de motion de cada ideia (componentes/x.jsx, recebe {el, t, fps}; el.dados traz largura/altura do espaço livre, '
+                    + 'palavras com t, destaque, cores e fontes) ou use um efeito de fábrica pelo nome (estudio_midia acao:"efeitos"), '
+                    + 'e chame de novo com batidas:[{de, ate, rosto, cena?, destaque?, canto?, dados?}].',
+            };
+        }
+        // A cena: arquivo da pasta (conferido antes do render) ou efeito de fábrica pelo nome.
+        const problemas = [];
+        const prontas = batidas.map((b, i) => {
+            if (!b || !b.cena) return b;
+            const cena = String(b.cena).trim();
+            if (/[\\/]|\.(jsx|tsx|js)$/i.test(cena)) {
+                const cheio = dentro(cena);
+                if (!cheio || !fs.existsSync(cheio)) { problemas.push(`batidas[${i}]: a cena "${cena}" não está na pasta do projeto.`); return { ...b, cena: null }; }
+                const conf = conferirCena(cheio);
+                if (!conf.ok) { problemas.push(`batidas[${i}]: ${cena} — ${conf.erro}`); return { ...b, cena: null }; }
+                return { ...b, cena };
+            }
+            const r = efeitos.reusar({ pasta: p.pasta, nome: cena });
+            if (!r.ok) { problemas.push(`batidas[${i}]: ${r.error}`); return { ...b, cena: null }; }
+            return { ...b, cena: r.src };
+        });
+        if (problemas.length) return { ok: false, error: 'as cenas têm problema — conserte e mande de novo.', problemas };
+
+        /* A voz no volume de vídeo de internet (-15 LUFS), como na edição
+           automática; o vídeo em si não é recodificado. */
+        let fonte = alvo;
+        if (args.normalizar !== false) {
+            const normal = path.join(p.pasta, 'midia', `voz-normal-${path.basename(alvo).replace(/\.[^.]+$/, '')}.mp4`);
+            if (!fs.existsSync(normal)) {
+                await video.rodar(video.ffmpeg(), ['-y', '-i', alvo, '-c:v', 'copy',
+                    '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+            }
+            if (fs.existsSync(normal)) fonte = normal;
+        }
+        const deitado = m.largura > m.altura;
+        const montado = camadas.montar({
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'), duracao: m.segundos, palavras, batidas: prontas,
+            largura: deitado ? 1920 : 1080, altura: deitado ? 1080 : 1920, fps: 30,
+            origem: { largura: m.largura, altura: m.altura }, rosto: args.rosto || {}, acento: args.acento,
+            sons: sonsLeves.preparar(p.pasta),
+        });
+        if (!montado.ok) return montado;
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `vídeo em camadas (${montado.resumo.batidas} batidas)` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `camadas: ${montado.resumo.batidas} batidas, ${montado.resumo.cenas} cenas de motion, ${montado.resumo.trocasDeForma} trocas de forma`);
+        return {
+            ok: true, ...montado.resumo, batidas: montado.batidas, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Para mudar uma batida, chame camadas de novo com a lista inteira.',
+        };
+    }
+
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
         const r = await rodarPessoa([
@@ -1792,7 +1880,7 @@ async function prepararRoteiro(p, args) {
            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 };
+        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);
@@ -1870,6 +1958,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.

package/lib/estudio/kit/index.jsx

@@ -12,6 +12,7 @@ import { FLUIDO } from './fluido';
 import { PERSONAGEM } from './personagem';
 import { VOXEL } from './voxel';
 import { ANIMACAO } from './animacao';
+import { ROSTO } from './rosto';
 
-export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, ...VOXEL, ...ANIMACAO, papel: Papel };
+export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, ...VOXEL, ...ANIMACAO, ...ROSTO, papel: Papel };
 export { Filtros, Acabamento, Hud, CURVAS_KIT, bolhaCaminho } from './base';

package/lib/estudio/kit/rosto.jsx

@@ -0,0 +1,108 @@
+/* kit/rosto.jsx — o rosto de quem fala, que muda de forma (camadas.js).
+ *
+ *   "o vídeo da pessoa é contínuo, mas o ROSTO muda de forma: tela cheia,
+ *    cartão com borda que brilha, bolinha no canto, some" (Joel, 14/10)
+ *
+ * Duas peças:
+ *  - palco: o fundo escuro com brilho que respira e grão (o que aparece
+ *    quando o rosto não ocupa a tela);
+ *  - rosto: a gravação dentro de uma caixa que vai de `antes` para `agora`
+ *    com mola (kit/natural.js): recua um tico (antecipação), vai, passa do
+ *    ponto e assenta. A gravação começa em `deOrigem` e NÃO reinicia: cada
+ *    cena pega do ponto em que a anterior parou, e o áudio dela é a fala do
+ *    vídeo. Quando "some", o vídeo continua tocando, só invisível.
+ * A geometria (onde fica cada caixa) vem pronta do camadas.js; aqui só se
+ * interpola. Nada de sorteio: o mesmo quadro sai igual sempre. */
+import React from 'react';
+import { AbsoluteFill, Video, staticFile, useVideoConfig } from 'remotion';
+import { mola, ruido } from './natural';
+
+const lerp = (a, b, k) => a + (b - a) * k;
+const clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+const CAMPOS = ['x', 'y', 'w', 'h', 'raio', 'anel', 'zoom', 'fx', 'fy'];
+
+/** A caixa no instante t (s) da cena. */
+export function caixaNoTempo(el, t) {
+  const B = el.agora || el.antes || {};
+  const A = el.antes || B;
+  if (!el.mudou) return { ...B };
+  const s = t - 0.05;
+  // A mola com peso: um pouco de sobra, e assenta em ~0,6 s.
+  const k = mola(s, { freq: 1.55, amort: 0.62 });
+  const kc = clamp(k, 0, 1);
+  // A antecipação: antes de ir, a caixa encolhe um tico (o "respiro" do gesto).
+  const prep = s > 0 && s < 0.14 ? Math.sin(Math.PI * (s / 0.14)) * 0.035 : 0;
+  const o = {};
+  for (const c of CAMPOS) o[c] = lerp(A[c] ?? B[c] ?? 0, B[c] ?? A[c] ?? 0, k);
+  o.raio = Math.max(0, o.raio);
+  o.anel = Math.max(0, o.anel);
+  o.w = Math.max(1, o.w); o.h = Math.max(1, o.h);
+  o.opacidade = lerp(A.opacidade ?? 1, B.opacidade ?? 1, kc);
+  o.escala = Math.max(0, lerp(A.escala ?? 1, B.escala ?? 1, k)) * (1 - prep);
+  return o;
+}
+
+export function Rosto({ el, t, fps }) {
+  const c = caixaNoTempo(el, t);
+  const ac = el.acento || '#8B7CF6';
+  const origem = el.origem || {};
+  const sw = origem.largura || 1080, sh = origem.altura || 1920;
+  // A gravação cobre a caixa (cover) com o zoom, e o rosto (fx, fy) vai para o centro, acima do meio (o queixo longe da legenda).
+  const s = Math.max(c.w / sw, c.h / sh) * Math.max(1, c.zoom || 1);
+  const vw = sw * s, vh = sh * s;
+  const left = clamp(c.w * 0.5 - (c.fx ?? 0.5) * vw, c.w - vw, 0);
+  const top = clamp(c.h * 0.38 - (c.fy ?? 0.4) * vh, c.h - vh, 0);
+  // A bolinha e o cartão flutuam de leve: parado de todo parece colado.
+  const flutua = el.forma === 'bolinha' || el.forma === 'cartao' ? ruido(t * 0.35, 11) * 4 : 0;
+  const anel = c.anel;
+  const brilho = anel > 0
+    ? `0 0 ${Math.round(18 + anel * 5)}px ${ac}88, 0 0 ${Math.round(60 + anel * 10)}px ${ac}33, 0 26px 70px rgba(0,0,0,.6)`
+    : 'none';
+  return (
+    <div style={{
+      position: 'absolute', left: c.x, top: c.y + flutua, width: c.w, height: c.h,
+      transform: `scale(${c.escala})`, transformOrigin: '50% 50%', opacity: c.opacidade,
+      borderRadius: c.raio, padding: anel,
+      // A borda que brilha: um degradê do acento ao branco, por trás do vídeo.
+      background: anel > 0 ? `linear-gradient(150deg, #ffffffcc, ${ac} 38%, ${ac}aa 70%, #ffffff88)` : 'transparent',
+      boxShadow: brilho, boxSizing: 'border-box',
+    }}>
+      <div style={{ position: 'relative', width: '100%', height: '100%', overflow: 'hidden', borderRadius: Math.max(0, c.raio - anel), background: '#000' }}>
+        <Video
+          src={staticFile(el.src)}
+          startFrom={el.deOrigem ? Math.round(el.deOrigem * fps) : undefined}
+          volume={el.volume ?? 1}
+          style={{ position: 'absolute', left, top, width: vw, height: vh, maxWidth: 'none' }}
+        />
+      </div>
+    </div>
+  );
+}
+
+/** O palco: preto azulado, dois brilhos que derivam devagar, vinheta e grão. */
+export function Palco({ el, t }) {
+  const { width: W, height: H } = useVideoConfig();
+  const ac = el.acento || '#8B7CF6';
+  const dx = ruido(t * 0.12, 3 + (el.semente || 0)) * 7;
+  const dy = ruido(t * 0.1, 7 + (el.semente || 0)) * 5;
+  const quadro = Math.floor(t * 24);
+  const id = 'grao-' + (el.semente || 0);
+  return (
+    <AbsoluteFill style={{ background: '#07060c', overflow: 'hidden' }}>
+      <div style={{ position: 'absolute', inset: 0, background:
+        `radial-gradient(55% 38% at ${50 + dx}% ${58 + dy}%, ${ac}40, transparent 72%),`
+        + `radial-gradient(45% 30% at ${16 - dx}% ${16 - dy}%, #4f46e526, transparent 70%),`
+        + `radial-gradient(70% 45% at ${80 + dy}% ${96}%, #1d4ed838, transparent 72%)` }} />
+      <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(120% 80% at 50% 45%, transparent 55%, rgba(0,0,0,.55) 100%)' }} />
+      <svg width={W} height={H} style={{ position: 'absolute', inset: 0, opacity: el.grao ?? 0.13, mixBlendMode: 'screen' }}>
+        <filter id={id}>
+          <feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves="2" seed={quadro % 61} stitchTiles="stitch" />
+          <feColorMatrix type="matrix" values="0 0 0 0 1  0 0 0 0 1  0 0 0 0 1  0 0 0 1.1 -0.45" />
+        </filter>
+        <rect width="100%" height="100%" filter={`url(#${id})`} />
+      </svg>
+    </AbsoluteFill>
+  );
+}
+
+export const ROSTO = { rosto: Rosto, palco: Palco };

package/lib/estudio/kit.js

@@ -65,9 +65,12 @@ const PECAS = {
     voxel: { precisa: ['partitura'] },
     // A animação pronta da biblioteca (kit/animacao.jsx, colecao.js): o Lottie tocado quadro a quadro.
     animacao: { precisa: ['src'] },
+    // O vídeo em camadas (kit/rosto.jsx, camadas.js): a gravação que muda de forma, e o palco escuro atrás dela.
+    rosto: { precisa: ['src'] },
+    palco: {},
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'natural.js', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'rosto.jsx', 'natural.js', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/revisor.js

@@ -67,7 +67,10 @@ function revisar(plano, { semImagem = false } = {}) {
     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) {
+        /* O micro (o tique, a escada de notas) não conta para o teto: é a
+           textura das referências, 2 a 3 por segundo, baixinho (14/10). */
+        const micros = efeitos.filter((e) => e.micro);
+        for (const e of efeitos.filter((x) => !x.micro)) {
             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;
@@ -88,7 +91,7 @@ function revisar(plano, { semImagem = false } = {}) {
             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;
+        plano.audio.efeitos = [...final, ...micros].sort((a, b) => (a.t || 0) - (b.t || 0));
     }
 
     // 4. Texto que não dá tempo de ler.

package/lib/estudio/sem-narracao.js

@@ -65,12 +65,14 @@ function tempos(partes, { falaDe = textoDaTela } = {}) {
 
 /* Os momentos que pedem som: os CORTES (começo de parte, de batida, de cena)
    e as ENTRADAS marcantes (o ícone, o item, a cena que a IA escreveu). */
-function momentos({ tempos: tps = [], plano = null, partitura = null } = {}) {
-    const cortes = [], entradas = [];
+function momentos({ tempos: tps = [], plano = null, partitura = null, cues = [] } = {}) {
+    const cortes = [], entradas = [], micros = [], revelas = [];
     const perto = (lista, t, d = 0.3) => lista.some((x) => Math.abs(x - t) < d);
     const corte = (t) => { if (t > 0.3 && !perto(cortes, t)) cortes.push(r3(t)); };
     const entrada = (t) => { if (t != null && t >= 0 && !perto(entradas, t, 0.35) && !perto(cortes, t, 0.2)) entradas.push(r3(t)); };
     for (const t of tps.slice(1)) corte(t.de);
+    // A cena escrita pela IA não tem batida: as palavras repartidas na parte são os micros dela.
+    for (const tp of tps) for (const pw of tp.palavras || []) if (pw && pw.de != null) micros.push(r3(pw.de));
     const bs = (partitura && partitura.batidas) || [];
     for (const b of bs) corte(b.de);
     // Vídeo de várias cenas (os outros estilos): o começo de cada cena é um corte.
@@ -80,25 +82,35 @@ function momentos({ tempos: tps = [], plano = null, partitura = null } = {}) {
     for (const b of bs) {
         if (b.icone3d && b.icone3d.t != null) entrada(b.icone3d.t);
         for (const l of b.linhas || []) if ((l.papel === 'item' || l.papel === 'numero') && l.t != null) entrada(l.t);
-        if (b.comp === 'marca') entrada(b.de + 0.35);
+        if (b.comp === 'marca') { entrada(b.de + 0.35); revelas.push(r3(b.de + 0.3)); }
+        /* O MICRO (14/10, as referências): cada linha e cada palavra que entra
+           faz um som pequeno — é isso que dá a sensação de "tudo tem som". */
+        for (const l of b.linhas || []) {
+            if (l.t != null) micros.push(r3(l.t));
+            for (const pw of l.palavras || []) if (pw && pw.t != null) micros.push(r3(pw.t));
+        }
     }
     for (const c of (plano && plano.cenas) || []) for (const el of c.elementos || []) if (el && el.tipo === 'componente' && el.de != null) entrada(el.de + 0.08);
-    return { cortes: cortes.sort((a, b) => a - b), entradas: entradas.sort((a, b) => a - b) };
+    const ocupado = [...cortes, ...entradas];
+    const mic = [...new Set(micros)].sort((a, b) => a - b).filter((t, i, l) => t > 0.05 && !ocupado.some((x) => Math.abs(x - t) < 0.1) && (i === 0 || t - l[i - 1] >= 0.09));
+    return { cortes: cortes.sort((a, b) => a - b), entradas: entradas.sort((a, b) => a - b), micros: mic, revelas, cues: (cues || []).filter((c) => c && c.t != null) };
 }
 
 // O corte passa com ar; a entrada chega com um toque pequeno. Ordem de rodízio.
-const DO_CORTE = ['whoosh', 'sopro', 'toque', 'riser'];
-const DA_ENTRADA = ['pop', 'bolha', 'clique', 'brilho'];
+const DO_CORTE = ['swoosh', 'whoosh', 'sopro', 'toque', 'riser'];
+const DA_ENTRADA = ['pop', 'mouse', 'bolha', 'digital', 'clique', 'brilho'];
+// O micro sobe numa escada (ponto1→ponto5) enquanto as coisas entram em sequência, e recomeça na pausa.
+const ESCADA = ['ponto1', 'ponto2', 'ponto3', 'ponto4', 'ponto5'];
 // O whoosh e o sopro antecipam o corte (o ar chega antes da imagem); o riser sobe até ele.
-const ANTES = { whoosh: 0.18, sopro: 0.3, riser: 1.0, toque: 0 };
-const VOLUME = { whoosh: 0.5, sopro: 0.6, toque: 0.6, riser: 0.4, pop: 0.42, bolha: 0.45, clique: 0.4, brilho: 0.32 };
+const ANTES = { whoosh: 0.18, swoosh: 0.12, sopro: 0.3, riser: 1.0, toque: 0 };
+const VOLUME = { swoosh: 0.45, mouse: 0.4, digital: 0.3, tique: 0.3, sub: 0.7, whoosh: 0.5, sopro: 0.6, toque: 0.6, riser: 0.4, pop: 0.42, bolha: 0.45, clique: 0.4, brilho: 0.32 };
 
 /**
  * Soma aos efeitos do plano um som leve em cada corte e em cada entrada.
  * `sons` é o mapa nome → arquivo do sons-leves.preparar. Não encosta em som
  * que já existe (0,12 s) e nunca repete o mesmo som duas vezes seguidas.
  */
-function sonorizar(efeitos, { cortes = [], entradas = [], sons = {}, duracao = Infinity } = {}) {
+function sonorizar(efeitos, { cortes = [], entradas = [], micros = [], revelas = [], cues = [], sons = {}, duracao = Infinity, volMicro = 0.24 } = {}) {
     const fora = (efeitos || []).slice();
     const eventos = [...cortes.map((t) => ({ t, tipo: 'corte' })), ...entradas.map((t) => ({ t, tipo: 'entrada' }))].sort((a, b) => a.t - b.t);
     const giro = { corte: 0, entrada: 0 };
@@ -121,20 +133,57 @@ function sonorizar(efeitos, { cortes = [], entradas = [], sons = {}, duracao = I
         novos.push({ t, src: sons[nome], volume: VOLUME[nome] || 0.4, som: nome });
         ultimo = nome;
     }
+    // A revelação (a marca no fim) ganha o sub por baixo do som da entrada.
+    for (const t of revelas) if (sons.sub && t < duracao - 0.1) novos.push({ t: r3(t), src: sons.sub, volume: VOLUME.sub, som: 'sub' });
+    // O som que a cena pediu (parte.sons: a IA sabe quando a bolinha chega).
+    for (const c of cues) {
+        const nome = sons[c.som] ? c.som : (sons.pop ? 'pop' : null);
+        if (nome && c.t < duracao - 0.05) novos.push({ t: r3(c.t), src: sons[nome], volume: Number(c.volume) || VOLUME[nome] || 0.35, som: nome, micro: true });
+    }
+    // Os micros: a escada sobe em sequência e recomeça depois de 0,6 s de pausa; um tique a cada tanto quebra a repetição.
+    let degrau = -1, antes = -9;
+    for (const t of micros) {
+        if (t > duracao - 0.05) continue;
+        degrau = t - antes > 0.6 ? 0 : Math.min(ESCADA.length - 1, degrau + 1);
+        antes = t;
+        const nome = degrau === ESCADA.length - 1 && sons.tique && micros.length > 8 && Math.round(t * 10) % 3 === 0 ? 'tique' : ESCADA[degrau];
+        if (!sons[nome] || novos.some((e) => Math.abs(e.t - t) < 0.08)) continue;
+        novos.push({ t, src: sons[nome], volume: volMicro, som: nome, micro: true });
+    }
     return { efeitos: [...fora, ...novos.map(({ som, ...e }) => e)].sort((a, b) => a.t - b.t), novos };
 }
 
 /** O plano pronto ganha os barulhinhos (o plano é mudado no lugar). Devolve quantos entraram. */
-function sonorizarPlano(r, { tempos: tps = [], sons = {} } = {}) {
+function sonorizarPlano(r, { tempos: tps = [], sons = {}, cues = [], comVoz = false } = {}) {
     if (!r || !r.plano) return 0;
     const plano = r.plano;
     plano.audio = plano.audio || {};
     const duracao = (plano.cenas || []).reduce((n, c) => n + (Number(c.duracao) || 0), 0) || Infinity;
-    const m = momentos({ tempos: tps, plano, partitura: r.partitura });
-    const s = sonorizar(plano.audio.efeitos || [], { ...m, sons, duracao });
+    const m = momentos({ tempos: tps, plano, partitura: r.partitura, cues });
+    /* Com voz, os cortes e entradas já têm som (gerativo.js): entram só os
+       micros e os pedidos pela cena, baixinho, para não brigar com a fala. */
+    const s = comVoz
+        ? sonorizar(plano.audio.efeitos || [], { micros: m.micros, cues: m.cues, sons, duracao, volMicro: 0.14 })
+        : sonorizar(plano.audio.efeitos || [], { ...m, sons, duracao });
     plano.audio.efeitos = s.efeitos;
+    if (comVoz) return s.novos.length;
     delete plano.audio.narracao;
+    /* Sem voz não há o que abrir espaço: a trilha não abaixa entre os cortes
+       (o ducking era para a fala, e deixava o vídeo em -17 LUFS). */
+    const tr = plano.audio.trilha;
+    if (tr && Array.isArray(tr.volumes)) tr.volumes = tr.volumes.map((v) => (v.t > 0.3 && v.v < 0.85 ? { ...v, v: 0.85 } : v));
     return s.novos.length;
 }
 
-module.exports = { ativo, textoDaTela, duracaoDe, tempos, momentos, sonorizar, sonorizarPlano, PEDIDO };
+/** parte.sons [{t, som, volume}] (t na parte) → no tempo do vídeo. */
+function cuesDe(partes = [], tps = []) {
+    const out = [];
+    (partes || []).forEach((pt, i) => {
+        const de = tps[i] && tps[i].de;
+        if (de == null || !pt || !Array.isArray(pt.sons)) return;
+        for (const c of pt.sons) if (c && Number.isFinite(Number(c.t))) out.push({ t: r3(de + Number(c.t)), som: String(c.som || 'pop'), volume: c.volume });
+    });
+    return out;
+}
+
+module.exports = { cuesDe, ativo, textoDaTela, duracaoDe, tempos, momentos, sonorizar, sonorizarPlano, PEDIDO };

package/lib/estudio/sons-leves.js

@@ -40,6 +40,21 @@ const EFEITOS = {
     impacto: ['-f', 'lavfi', '-i', "aevalsrc='0.95*sin(2*PI*(62-26*t)*t)*exp(-4.5*t)+0.45*(random(0)*2-1)*exp(-38*t)':s=44100:d=1.1", '-af', 'lowpass=f=2600,volume=1.4'],
     riser: ['-f', 'lavfi', '-i', "aevalsrc='(0.32*sin(2*PI*(170+620*t*t)*t)+0.22*(random(0)*2-1))*pow(t/1.1,2)':s=44100:d=1.1", '-af', 'highpass=f=260,afade=t=out:st=1.04:d=0.06,volume=1.3'],
     pop: ['-f', 'lavfi', '-i', "aevalsrc='0.8*sin(2*PI*(980-640*t)*t)*exp(-28*t)*(1-exp(-700*t))':s=44100:d=0.18"],
+    /* OS BARULHINHOS DAS REFERÊNCIAS (14/10, "eu quero meus barulhinhos", com o
+       motion1.mp4: 29 sons em 15 s, cada bolinha e cada ponto que aparece faz
+       um). Pequenos e secos: o tique da interface, o clique do mouse, o blip
+       digital, o swoosh que desce, o sub da revelação e a escada de notas. */
+    tique: ['-f', 'lavfi', '-i', "aevalsrc='0.45*sin(2*PI*3200*t)*exp(-140*t)+0.12*(random(0)*2-1)*exp(-220*t)':s=44100:d=0.05", '-af', 'highpass=f=900'],
+    mouse: ['-f', 'lavfi', '-i', "aevalsrc='0.6*(random(0)*2-1)*exp(-260*t)+0.45*(random(0)*2-1)*exp(-260*(t-0.07))*gte(t,0.07)':s=44100:d=0.14", '-af', 'bandpass=f=2600:width_type=o:w=1.6,volume=1.6'],
+    digital: ['-f', 'lavfi', '-i', "aevalsrc='0.28*sgn(sin(2*PI*(1500+900*gte(t,0.03))*t))*exp(-38*t)':s=44100:d=0.08", '-af', 'lowpass=f=5200'],
+    swoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.55:c=white:a=0.8', '-af',
+        'bandpass=f=2600:width_type=o:w=3,afade=t=in:st=0:d=0.12:curve=exp,afade=t=out:st=0.12:d=0.43:curve=exp,volume=1.6'],
+    sub: ['-f', 'lavfi', '-i', "aevalsrc='0.9*sin(2*PI*(55-20*t)*t)*exp(-3*t)*(1-exp(-300*t))':s=44100:d=1.2", '-af', 'lowpass=f=220,volume=1.5'],
+    ponto1: ['-f', 'lavfi', '-i', "aevalsrc='0.55*sin(2*PI*784.0*t)*exp(-34*t)*(1-exp(-900*t))+0.15*sin(2*PI*1568.0*t)*exp(-50*t)':s=44100:d=0.16"],
+    ponto2: ['-f', 'lavfi', '-i', "aevalsrc='0.55*sin(2*PI*880.0*t)*exp(-34*t)*(1-exp(-900*t))+0.15*sin(2*PI*1760.0*t)*exp(-50*t)':s=44100:d=0.16"],
+    ponto3: ['-f', 'lavfi', '-i', "aevalsrc='0.55*sin(2*PI*987.8*t)*exp(-34*t)*(1-exp(-900*t))+0.15*sin(2*PI*1975.6*t)*exp(-50*t)':s=44100:d=0.16"],
+    ponto4: ['-f', 'lavfi', '-i', "aevalsrc='0.55*sin(2*PI*1174.7*t)*exp(-34*t)*(1-exp(-900*t))+0.15*sin(2*PI*2349.4*t)*exp(-50*t)':s=44100:d=0.16"],
+    ponto5: ['-f', 'lavfi', '-i', "aevalsrc='0.55*sin(2*PI*1318.5*t)*exp(-34*t)*(1-exp(-900*t))+0.15*sin(2*PI*2637.0*t)*exp(-50*t)':s=44100:d=0.16"],
 };
 
 /**

package/package.json

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

package/skills/editar-meu-video/SKILL.md

@@ -45,6 +45,12 @@ por 1 a 3 segundos. Depois volta. É isso que dá ritmo a vídeo falado.
 Busque a imagem pelo que ela DISSE naquele instante (você tem os tempos da
 transcrição). Volte sempre antes de a frase acabar.
 
+## Vídeo em camadas
+
+Pediu "edição nesse nível", motion por cima da fala, rosto que vira cartão ou
+bolinha: `acao:"camadas"`. Você decide as batidas; a descrição da ferramenta
+diz o formato.
+
 ## Troca de fundo
 
 `acao:"recortar-pessoa"` devolve a pessoa com fundo transparente. Ponha uma