primocode 9.8.0-beta.10 → 9.8.0-beta.11

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.10
+# PrimoCode v9.8.0-beta.11
 
 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 v9.8.0-beta.10
+ ▐▛███▜▌   Primo Code v9.8.0-beta.11
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/catalogo.js

@@ -104,7 +104,10 @@ 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: importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+              args: 'id. acao: editar | 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". '

package/lib/estudio/edicao.js

@@ -0,0 +1,331 @@
+/**
+ * edicao.js — a gravação da pessoa vira um vídeo editado, SEM o modelo
+ * escrever cena por cena.
+ *
+ *   "Deixe iguais aqueles vídeos que as videomakers editam: aquelas legendas
+ *    maravilhosas que fazem parte do vídeo, alguns ícones aparecendo, cortes
+ *    naturais, mais animações… Quero que até uma batata faça vídeos assim."
+ *   (25/09/2026)
+ *
+ * Com o Claude o vídeo saiu ótimo porque o modelo escreveu, à mão, cada
+ * legenda, cada palavra em destaque e cada zoom. Um modelo grátis não faz
+ * isso. Então a edição mora AQUI, em código: com as palavras e o tempo de
+ * cada uma, `montarEdicao` devolve o plano inteiro —
+ *
+ *   - uma cena por frase, com o corte seco entre elas e o zoom alternando
+ *     (o "punch-in" que dá ritmo a quem fala para a câmera);
+ *   - a legenda palavra por palavra, com a palavra dita em destaque e a
+ *     palavra forte da frase na cor dela;
+ *   - o ícone (emoji colorido) que salta na hora em que a palavra é dita;
+ *   - o letreiro grande da ideia, nas frases sem ícone;
+ *   - o pop e o whoosh nos momentos certos, e a barra de progresso.
+ *
+ * É uma função pura: entra palavra, sai plano. O modelo só escolhe o estilo,
+ * e pode ajustar qualquer cena depois com estudio_plano.
+ */
+
+'use strict';
+
+// ── as palavras que não carregam ideia ───────────────────────────────────
+const VAZIAS = new Set((
+    'a o as os um uma uns umas de do da dos das no na nos nas em por para pra pro com sem que se e '
+    + 'ou mas como mais menos muito muita muitos muitas isso isto esse essa este esta aquele aquela ele ela '
+    + 'eles elas eu voce voces nos meu minha seu sua nosso nossa tem ter ser foi era sao esta estao vai vou '
+    + 'ja ai aqui la entao tambem so quando onde porque pois ate sobre depois antes cada todo toda todos '
+    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje'
+).split(' '));
+
+/* A palavra (sem acento, minúscula, começo dela) → o emoji colorido. Casa
+   pelo começo para "aprender", "aprende" e "aprendizado" caírem no mesmo. Os
+   nomes foram conferidos na coleção fluent-emoji-flat do Iconify (25/09). */
+const ICONES = [
+    [['inteligencia', 'ia', 'robo', 'maquina', 'automac'], 'robot'],
+    [['cerebro', 'pens', 'raciocin', 'aprend', 'mente'], 'brain'],
+    [['ideia', 'criativ', 'inova'], 'light-bulb'],
+    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco'], 'money-bag'],
+    [['tempo', 'minuto', 'segundo', 'rapid', 'hora'], 'stopwatch'],
+    [['cresc', 'result', 'aument', 'melhor'], 'chart-increasing'],
+    [['cair', 'caiu', 'perd', 'queda', 'pior'], 'chart-decreasing'],
+    [['dados', 'numero', 'grafico', 'estatist', 'parametro'], 'bar-chart'],
+    [['foguete', 'lanc', 'decol', 'comec'], 'rocket'],
+    [['incrivel', 'fogo', 'bomba'], 'fire'],
+    [['certo', 'funcion', 'corret', 'pronto'], 'check-mark-button'],
+    [['errado', 'erro', 'falha', 'proibid'], 'cross-mark'],
+    [['celular', 'telefone', 'aplicativo', 'app'], 'mobile-phone'],
+    [['computador', 'codigo', 'program', 'software', 'site'], 'laptop'],
+    [['internet', 'mundo', 'global'], 'globe-showing-americas'],
+    [['olh', 'ver', 'imagem', 'imagens', 'visual', 'reconhec'], 'eyes'],
+    [['voz', 'som', 'sons', 'audio', 'ouv'], 'speaker-high-volume'],
+    [['texto', 'escrev', 'palavra', 'lista'], 'memo'],
+    [['musica', 'cancao'], 'musical-notes'],
+    [['cachorro', 'cao'], 'dog-face'],
+    [['gato'], 'cat-face'],
+    [['coracao', 'amor', 'ama', 'paixao'], 'red-heart'],
+    [['pessoa', 'cliente', 'usuario', 'equipe', 'publico'], 'busts-in-silhouette'],
+    [['casa', 'lar'], 'house'],
+    [['carro', 'dirig'], 'automobile'],
+    [['livro', 'estud', 'escola', 'ensin', 'aula', 'curso'], 'books'],
+    [['atencao', 'cuidado', 'perigo', 'risco'], 'warning'],
+    [['objeto', 'produto', 'pacote', 'entrega'], 'package'],
+    [['padr', 'peca', 'encaix'], 'puzzle-piece'],
+    [['decid', 'decis', 'escolh', 'duvida', 'pergunta'], 'thinking-face'],
+    [['exemplo', 'procur', 'busca', 'pesquis', 'analis'], 'magnifying-glass-tilted-left'],
+    [['assistente', 'convers', 'chat', 'mensag', 'responde'], 'speech-balloon'],
+    [['recomend', 'filme', 'serie', 'netflix', 'video'], 'clapper-board'],
+    [['tecnolog', 'algoritm', 'sistema', 'ferrament'], 'gear'],
+    [['cotidian', 'rotina', 'semana', 'calendario', 'agenda'], 'calendar'],
+    [['conhecimento', 'formad', 'diploma', 'sabe'], 'graduation-cap'],
+    [['sucesso', 'venc', 'ganhador', 'premio', 'campeao'], 'trophy'],
+    [['forca', 'forte', 'poder', 'energia'], 'flexed-biceps'],
+    [['acordo', 'parceri', 'junt', 'ajud'], 'handshake'],
+    [['compra', 'loja', 'carrinho'], 'shopping-cart'],
+    [['trabalh', 'empresa', 'negocio', 'emprego'], 'briefcase'],
+    [['seguranc', 'senha', 'proteg', 'privad'], 'locked'],
+    [['festa', 'comemor', 'parabens'], 'party-popper'],
+    [['surpre', 'chocad', 'absurd'], 'exploding-head'],
+];
+
+function limpa(palavra) {
+    return String(palavra || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+/** O emoji desta palavra, ou null. Palavra de 2 letras só casa inteira ("ia"). */
+function iconeDe(palavra) {
+    const w = limpa(palavra);
+    if (!w || VAZIAS.has(w)) return null;
+    for (const [raizes, nome] of ICONES) {
+        for (const r of raizes) {
+            if (r.length <= 3 ? w === r : w.startsWith(r)) return 'fluent-emoji-flat:' + nome;
+        }
+    }
+    return null;
+}
+
+/** Quanto a palavra carrega a ideia da frase. 0 = nada. */
+function peso(palavra) {
+    const w = limpa(palavra);
+    if (!w || VAZIAS.has(w)) return 0;
+    if (/^\d+$/.test(w)) return 20;
+    return w.length + (iconeDe(palavra) ? 6 : 0);
+}
+
+const fimDeFrase = (texto) => /[.!?…]$/.test(String(texto || '').trim());
+const r2 = (n) => Math.round(n * 100) / 100;
+
+/* As frases: corta no ponto final, na pausa longa ou quando a cena passa do
+   teto. Frase curta demais gruda na próxima — corte a cada meio segundo é
+   epilepsia, não ritmo. */
+function frases(palavras, { teto = 5.5, pausa = 0.5, minimo = 1.4 } = {}) {
+    const grupos = [];
+    let atual = [];
+    palavras.forEach((p, i) => {
+        atual.push(p);
+        const prox = palavras[i + 1];
+        const dur = p.ate - atual[0].de;
+        if (!prox || fimDeFrase(p.texto) || prox.de - p.ate >= pausa || dur >= teto) {
+            grupos.push(atual);
+            atual = [];
+        }
+    });
+    const juntos = [];
+    for (const g of grupos) {
+        const ult = juntos[juntos.length - 1];
+        const durG = g[g.length - 1].ate - g[0].de;
+        if (ult && (durG < minimo || ult[ult.length - 1].ate - ult[0].de < minimo)
+            && g[g.length - 1].ate - ult[0].de <= teto + 1.5) ult.push(...g);
+        else juntos.push([...g]);
+    }
+    return juntos;
+}
+
+/* Os pedaços da legenda: poucas palavras por vez (quem assiste no celular lê
+   em blocos curtos), quebrando na pontuação e na pausa. */
+function blocos(palavras, maximo) {
+    const out = [];
+    let atual = [];
+    palavras.forEach((p, i) => {
+        atual.push(p);
+        const prox = palavras[i + 1];
+        if (!prox || atual.length >= maximo || /[,.!?;:…]$/.test(p.texto) || prox.de - p.ate > 0.3) {
+            out.push(atual);
+            atual = [];
+        }
+    });
+    return out;
+}
+
+// O zoom de cada cena, em rodízio: parado, punch-in, empurrando devagar.
+function camera(i, dur) {
+    const tipo = i % 3;
+    if (tipo === 0) return { zoom: [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'linear' }] };
+    if (tipo === 1) return { zoom: [{ t: 0, v: 1.18 }, { t: dur, v: 1.21, e: 'linear' }] };
+    return { zoom: [{ t: 0, v: 1.07 }, { t: dur, v: 1.13, e: 'suave' }] };
+}
+
+const ESTILOS = {
+    viral: { icones: true, letreiro: true, sons: true, barra: true, destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, destaque: '#FFFFFF', forte: '#FFD400' },
+};
+
+/**
+ * O plano do vídeo editado.
+ *
+ * @param {object} op
+ * @param {string} op.src         o vídeo (já sem os silêncios), relativo à pasta do projeto
+ * @param {number} op.duracao     a duração dele, em segundos
+ * @param {Array}  op.palavras    [{de, ate, texto}] no tempo DESTE vídeo
+ * @param {number} op.largura     do vídeo de origem
+ * @param {number} op.altura
+ * @param {string} op.estilo      'viral' (padrão) | 'limpo'
+ * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
+ * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
+ */
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null }) {
+    const e = ESTILOS[estilo] || ESTILOS.viral;
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
+
+    const deitado = largura > altura;
+    const base = Math.min(largura, altura);
+    const grupos = frases(lista);
+    const total = duracao || lista[lista.length - 1].ate + 0.3;
+    const cenas = [];
+    const efeitos = [];
+    let lado = 0;
+
+    grupos.forEach((g, i) => {
+        const ini = i === 0 ? 0 : grupos[i - 1][grupos[i - 1].length - 1].ate
+            + (g[0].de - grupos[i - 1][grupos[i - 1].length - 1].ate) / 2;
+        const fim = i === grupos.length - 1 ? total : g[g.length - 1].ate + (grupos[i + 1][0].de - g[g.length - 1].ate) / 2;
+        const dur = r2(Math.max(0.4, fim - ini));
+        const local = (t) => r2(Math.max(0, t - ini));
+
+        // A palavra forte da frase: a que mais carrega a ideia.
+        let forte = null;
+        for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+
+        const elementos = [{
+            tipo: 'video', src, x: 0, y: 0, largura: '100%', altura: '100%',
+            deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
+        }];
+
+        // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
+        const icone = forte && e.icones ? iconeDe(forte.texto) : null;
+        const temIcone = icone && (!iconesOk || iconesOk.has(icone));
+        const x = lado++ % 2 === 0 ? '78%' : '22%';
+        if (temIcone) {
+            const de = local(forte.de - 0.05);
+            const vida = Math.min(1.8, dur - de);
+            if (vida > 0.5) {
+                elementos.push({
+                    tipo: 'icone', nome: icone, tamanho: Math.round(base * (deitado ? 0.2 : 0.24)),
+                    x, y: deitado ? '30%' : '26%', ancora: 'centro', de, ate: r2(de + vida),
+                    sombra: undefined,
+                    anima: {
+                        escala: [{ t: 0, v: 0 }, { t: 0.2, v: 1.18, e: 'saida' }, { t: 0.34, v: 1, e: 'suave' }],
+                        rotacao: [{ t: 0, v: -14 }, { t: 0.34, v: 0, e: 'saida' }, { t: vida, v: 4, e: 'suave' }],
+                        y: [{ t: 0.34, v: 0 }, { t: vida, v: -14, e: 'suave' }],
+                        opacidade: [{ t: vida - 0.2, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.45 });
+            }
+        } else if (forte && e.letreiro && i % 2 === 0 && peso(forte.texto) >= 7) {
+            const de = local(forte.de);
+            const vida = Math.min(1.6, dur - de);
+            if (vida > 0.5) {
+                elementos.push({
+                    tipo: 'texto', texto: limpaPontuacao(forte.texto).toUpperCase(), fonte: 'Anton',
+                    tamanho: Math.round(base * (deitado ? 0.11 : 0.1)), cor: e.forte, peso: 400,
+                    x, y: deitado ? '28%' : '24%', ancora: 'centro', de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 0.4 }, { t: 0.16, v: 1.12, e: 'saida' }, { t: 0.3, v: 1, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.18, v: 1 }, { t: vida, v: 0 }],
+                        rotacao: [{ t: 0, v: -6 }, { t: 0.3, v: -3, e: 'saida' }],
+                    },
+                });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.35 });
+            }
+        }
+
+        // A legenda palavra por palavra.
+        const fala = blocos(g, deitado ? 4 : 3).map((b, j, todos) => ({
+            de: local(b[0].de - 0.04),
+            ate: j < todos.length - 1 ? local(todos[j + 1][0].de - 0.04) : r2(dur),
+            texto: b.map((p) => p.texto).join(' '),
+            palavras: b.map((p) => ({
+                de: local(p.de), ate: local(p.ate), texto: limpaPontuacao(p.texto),
+                ...(p === forte ? { forte: true } : {}),
+            })),
+        }));
+        elementos.push({
+            tipo: 'legenda', x: '50%', y: deitado ? '80%' : '70%', ancora: 'centro', fala,
+            estilo: {
+                fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
+                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase',
+            },
+        });
+
+        if (e.barra) {
+            elementos.push({
+                tipo: 'forma', forma: 'retangulo', x: 0, y: 0, altura: Math.max(6, Math.round(base * 0.008)),
+                largura: '100%', cor: e.destaque,
+                anima: { escalaX: [{ t: 0, v: r2(ini / total) }, { t: dur, v: r2((ini + dur) / total), e: 'linear' }] },
+                origem: 'left',
+            });
+        }
+
+        // O whoosh entra no punch-in: é o corte que ele anuncia.
+        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.3 });
+
+        cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
+    });
+
+    return {
+        ok: true,
+        plano: {
+            formato: { largura, altura, fps: 30 },
+            fundoGeral: '#000',
+            cenas,
+            ...(efeitos.length ? { audio: { efeitos } } : {}),
+        },
+        resumo: {
+            cenas: cenas.length,
+            icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
+            letreiros: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'texto').length, 0),
+            efeitos: efeitos.length,
+        },
+    };
+}
+
+function limpaPontuacao(t) {
+    return String(t || '').replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}%]+$/gu, '');
+}
+
+/* Os dois sons, sintetizados pelo ffmpeg: nada baixado, nada com licença de
+   ninguém. O pop é um tom que cai rápido; o whoosh, um ruído que sobe e some. */
+const SONS = {
+    pop: ['-f', 'lavfi', '-i', "aevalsrc='0.9*sin(2*PI*(1500-7000*t)*t)*exp(-38*t)':s=44100:d=0.14"],
+    whoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.55:c=pink:a=0.6',
+        '-af', 'highpass=f=500,lowpass=f=5000,afade=t=in:st=0:d=0.3:curve=exp,afade=t=out:st=0.3:d=0.25,volume=0.9'],
+};
+
+async function prepararSons(pasta, video) {
+    const fs = require('fs');
+    const path = require('path');
+    const sons = {};
+    for (const [nome, args] of Object.entries(SONS)) {
+        const rel = `midia/sfx-${nome}.mp3`;
+        const cheio = path.join(pasta, rel);
+        if (!fs.existsSync(cheio)) {
+            fs.mkdirSync(path.dirname(cheio), { recursive: true });
+            const r = await video.rodar(video.ffmpeg(), ['-y', ...args, '-q:a', '4', cheio], { timeout: 30000 });
+            if (!r.ok) continue;
+        }
+        sons[nome] = rel;
+    }
+    return sons;
+}
+
+module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, ESTILOS, ICONES };

package/lib/estudio/index.js

@@ -40,6 +40,7 @@ const assets = require('./assets.js');
 const video = require('./video.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
+const edicao = require('./edicao.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -399,6 +400,52 @@ async function ferramentaVideo(args, ctx = {}) {
         return transcrever(p, alvo, ctx);
     }
 
+    /* A EDIÇÃO INTEIRA, em código (lib/estudio/edicao.js): corta o silêncio,
+       transcreve palavra por palavra e monta o plano — legenda animada,
+       ícones na hora da palavra, zoom de corte, pop e whoosh. É o caminho
+       para qualquer modelo entregar vídeo de videomaker: ele só chama isto e
+       renderiza. "Até uma batata faz vídeos assim." (25/09/2026) */
+    if (acao === 'editar' || acao === 'edicao' || acao === 'auto') {
+        let fonte = alvo;
+        let cortes = 0;
+        if (args.cortarSilencio !== false) {
+            const saida = path.join(p.pasta, 'midia', `cortado-${Date.now().toString(36)}.mp4`);
+            const c = await video.cortarSilencio(alvo, saida, args);
+            if (c.ok && !c.semCorte) { fonte = saida; cortes = c.cortes || 0; }
+        }
+        const m = await video.medir(fonte);
+        if (!m.ok) return m;
+
+        const tr = await transcrever(p, fonte, ctx);
+        if (!tr.ok) return tr;
+        let palavras = tr.palavras || [];
+        // Servidor sem o tempo por palavra: reparte cada trecho pelas palavras
+        // dele. Sai menos preciso, mas a legenda continua animada.
+        if (!palavras.length) palavras = repartirTrechos(tr.trechos || []);
+
+        const candidatos = [...new Set(palavras.map((w) => edicao.iconeDe(w.texto)).filter(Boolean))];
+        const iconesOk = new Set();
+        for (const nome of candidatos) {
+            try { const r = await assets.icone(nome); if (r && (r.ok !== false)) iconesOk.add(nome); } catch { /* fica sem */ }
+        }
+        const sons = await edicao.prepararSons(p.pasta, video);
+
+        const montado = edicao.montarEdicao({
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
+            duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
+            estilo: args.estilo || 'viral', sons, iconesOk,
+        });
+        if (!montado.ok) return montado;
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `${montado.resumo.cenas} cenas, ${montado.resumo.icones} ícones, ${cortes} cortes de silêncio`);
+        return {
+            ok: true, ...montado.resumo, cortesDeSilencio: cortes, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Antes, se quiser, ajuste uma cena com estudio_plano cena:N '
+                + '(ex.: trocar um ícone, pôr uma imagem de apoio atrás).',
+        };
+    }
+
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
         const r = await rodarPython('pessoa.py', [
@@ -418,6 +465,23 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+/* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
+   proporcional ao tamanho de cada uma. */
+function repartirTrechos(trechos) {
+    const out = [];
+    for (const t of trechos) {
+        const ws = String(t.texto || '').split(/\s+/).filter(Boolean);
+        const letras = ws.reduce((n, w) => n + w.length, 0) || 1;
+        let cur = t.de;
+        for (const w of ws) {
+            const d = (t.ate - t.de) * (w.length / letras);
+            out.push({ de: cur, ate: cur + d, texto: w });
+            cur += d;
+        }
+    }
+    return out;
+}
+
 /**
  * A transcrição com tempo — é ela que dá legenda sincronizada.
  *
@@ -448,7 +512,7 @@ async function transcrever(p, alvo, ctx) {
         if (!r || r.ok === false) return { ok: false, error: (r && r.erro) || 'a transcrição falhou.' };
         projeto.anotar(p.id, 'transcricao', `${(r.trechos || []).length} trechos`);
         return {
-            ok: true, texto: r.texto, trechos: r.trechos,
+            ok: true, texto: r.texto, trechos: r.trechos, palavras: r.palavras || [],
             comoUsar: 'cada trecho vira uma fala da legenda: {"de":…, "ate":…, "texto":…}. '
                 + 'O estilo da legenda (fonte, cor, peso, posição, animação) é escolha sua — não há padrão.',
         };

package/lib/estudio/remotion.js

@@ -212,6 +212,7 @@ function Elemento({ el, t, dados }) {
     transform: [base.transform, move].filter(Boolean).join(' '),
     filter: filtroDe(a) || undefined,
     mixBlendMode: el.mistura || undefined,
+    transformOrigin: el.origem || undefined,
   };
 
   if (el.vidro) {
@@ -294,7 +295,7 @@ function Elemento({ el, t, dados }) {
       // O SVG foi baixado para a pasta do projeto (estudio/assets.js): render
       // que busca ícone na internet falha no meio, depois de tudo pronto.
       return (
-        <div style={{ ...estilo, width: medida(el.tamanho, '96px'), height: medida(el.tamanho, '96px'), color: el.cor || '#fff' }}
+        <div style={{ ...estilo, width: medida(el.tamanho, '96px'), height: medida(el.tamanho, '96px'), fontSize: medida(el.tamanho, '96px'), lineHeight: 0, color: el.cor || '#fff' }}
              dangerouslySetInnerHTML={{ __html: dados.icones[el.nome] || '' }} />
       );
 
@@ -302,6 +303,55 @@ function Elemento({ el, t, dados }) {
       const fala = (el.fala || []).find((f) => t >= f.de && t <= f.ate);
       if (!fala) return null;
       const e = el.estilo || {};
+      /* LEGENDA DE VIDEOMAKER: com o tempo de cada palavra, elas entram uma a
+         uma, no instante em que são ditas, com um salto curto. A que está
+         sendo dita ganha a cor de destaque; a palavra forte (a ideia da
+         frase) ganha a cor dela e fica maior. Sem "palavras", a frase entra
+         inteira, como antes. */
+      if (Array.isArray(fala.palavras) && fala.palavras.length) {
+        const destaque = e.destaque || '#FFD400';
+        const forte = e.corForte || '#00E0A4';
+        const soUma = e.modo === 'palavra';
+        const visiveis = soUma
+          ? fala.palavras.filter((p, i, l) => t >= p.de && (i === l.length - 1 || t < l[i + 1].de)).slice(-1)
+          : fala.palavras.filter((p) => t >= p.de - 0.02);
+        return (
+          <div style={{
+            ...estilo,
+            display: 'flex', flexWrap: 'wrap', justifyContent: 'center', alignItems: 'baseline',
+            gap: '0 0.34em', maxWidth: medida(e.largura, '86%'),
+            fontFamily: e.fonte ? '"' + e.fonte + '", system-ui, sans-serif' : 'system-ui, sans-serif',
+            fontSize: medida(e.tamanho, '64px'),
+            fontWeight: e.peso || 900,
+            textTransform: e.caixa || undefined,
+            lineHeight: 1.1,
+          }}>
+            {visiveis.map((p, i) => {
+              const idade = t - p.de;
+              const entra = Math.min(1, Math.max(0, idade / 0.14));
+              const salto = entra < 1 ? 0.7 + 0.42 * CURVAS.saida(entra) : 1.12 - 0.12 * Math.min(1, (idade - 0.14) / 0.12);
+              const falando = t >= p.de && t <= p.ate + 0.05;
+              const cor = p.forte ? forte : (falando ? destaque : (e.cor || '#fff'));
+              return (
+                <span key={i} style={{
+                  display: 'inline-block',
+                  // A palavra forte é MAIOR na fonte, não na escala: escala não
+                  // abre espaço, e ela cresceria por cima da vizinha.
+                  fontSize: p.forte ? '1.22em' : undefined,
+                  transform: 'scale(' + salto + ') translateY(' + (1 - entra) * 18 + 'px)',
+                  opacity: entra,
+                  color: cor,
+                  textShadow: e.sombra || '0 6px 22px rgba(0,0,0,.6), 0 2px 0 rgba(0,0,0,.35)',
+                  WebkitTextStroke: e.contorno || '2px rgba(0,0,0,.55)',
+                  paintOrder: 'stroke fill',
+                  background: falando && e.fundoAtivo ? e.fundoAtivo : undefined,
+                  borderRadius: '0.18em', padding: falando && e.fundoAtivo ? '0 0.12em' : undefined,
+                }}>{p.texto}{p.emoji ? ' ' + p.emoji : ''}</span>
+              );
+            })}
+          </div>
+        );
+      }
       return (
         <div style={{
           ...estilo,
@@ -366,7 +416,7 @@ export function Cena({ cena, dados }) {
     </AbsoluteFill>
   );
 }
-";`;
+`;
 
 const RAIZ_JSX = String.raw`import React from 'react';
 import { AbsoluteFill, Audio, Sequence, staticFile, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
@@ -438,7 +488,7 @@ export const Video = () => {
     </AbsoluteFill>
   );
 };
-";`;
+`;
 
 function rootJsx(plano) {
     const f = plano.formato || {};
@@ -513,12 +563,25 @@ para este projeto, não para o PrimoCode.
  * @param {object} op.plano
  * @param {object} op.icones   { "lucide:zap": "<svg…>" } já baixados
  */
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: 'ES2018', module: 'commonjs', jsx: 'react-jsx', strict: false, noEmit: true,
+        lib: ['es2015', 'dom'], esModuleInterop: true, skipLibCheck: true, forceConsistentCasingInFileNames: true,
+    },
+    exclude: ['remotion.config.ts'],
+}, null, 2) + '\n';
+
 function montar({ pasta, titulo, plano, icones = {} }) {
     const raiz = path.join(pasta, 'remotion');
     const src = path.join(raiz, 'src');
 
     escrever(path.join(raiz, 'package.json'), pkgJson(titulo || 'video'));
     escrever(path.join(raiz, 'remotion.config.ts'), REMOTION_CONFIG);
+    /* O remotion.config.ts é TypeScript, e o Remotion 4 recusa renderizar sem
+       um tsconfig.json na raiz ("Could not find a tsconfig.json"). Medido em
+       25/09: o vídeo que saiu bom só saiu porque o modelo criou este arquivo à
+       mão depois do erro — um modelo grátis travaria ali. */
+    escrever(path.join(raiz, 'tsconfig.json'), TSCONFIG);
     escrever(path.join(raiz, 'README.md'), readme(titulo || 'Vídeo', plano));
     escrever(path.join(src, 'index.js'), INDEX_JS);
     escrever(path.join(src, 'Root.jsx'), rootJsx(plano));