primocode 9.8.0-beta.9 → 9.9.0

package/lib/estudio/edicao.js

@@ -0,0 +1,475 @@
+/**
+ * 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 '
+    // Verbos de ligação e de fala: não são a ideia da frase.
+    + 'mostra mostrar ajuda ajudar deixa deixar usar usa usando sabe saber quer querer precisa precisar '
+    + 'acho olha vem fica ficar falar fala dizer diz ver vai ir estou estava sendo tendo existe chamado'
+).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', 'financ', 'custo', 'econom', 'receita'], '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', 'atend', 'suporte', 'whatsapp'], 'speech-balloon'],
+    [['recomend', 'filme', 'serie', 'netflix', 'video'], 'clapper-board'],
+    [['tecnolog', 'algoritm', 'sistema', 'ferrament', 'operac', 'process', 'automat'], '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'],
+];
+
+/* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
+   inglês de propósito: os acervos abertos respondem muito melhor assim. */
+const FOTO = {
+    robot: 'humanoid robot', brain: 'human brain', 'light-bulb': 'light bulb idea', 'money-bag': 'money cash',
+    stopwatch: 'clock time', 'chart-increasing': 'business growth', 'chart-decreasing': 'stock market fall',
+    'bar-chart': 'data analytics', rocket: 'rocket launch', fire: 'fire flames', 'mobile-phone': 'smartphone hand',
+    laptop: 'laptop programming', 'globe-showing-americas': 'earth from space', eyes: 'eye closeup',
+    'speaker-high-volume': 'sound waves', memo: 'writing notebook', 'musical-notes': 'music concert',
+    'dog-face': 'puppy', 'cat-face': 'cat', 'red-heart': 'heart love', 'busts-in-silhouette': 'people crowd',
+    house: 'modern house', automobile: 'car road', books: 'library books', warning: 'warning sign',
+    package: 'objects on table', 'puzzle-piece': 'puzzle pieces', 'thinking-face': 'person thinking',
+    'magnifying-glass-tilted-left': 'magnifying glass', 'speech-balloon': 'smart speaker', 'clapper-board': 'watching tv',
+    gear: 'circuit board', calendar: 'city street people', 'graduation-cap': 'students classroom', trophy: 'trophy',
+    'flexed-biceps': 'strength', handshake: 'handshake', 'shopping-cart': 'shopping', briefcase: 'office work',
+    locked: 'cyber security', 'party-popper': 'party celebration', 'exploding-head': 'surprised face',
+};
+
+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-3d:' + 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);
+}
+
+/** O termo de busca da imagem de apoio para esta palavra, ou null. */
+function termoDeApoio(palavra) {
+    const ic = iconeDe(palavra);
+    return ic ? FOTO[ic.split(':')[1]] || null : null;
+}
+
+// Em quais cenas entra a mídia de apoio: uma a cada duas, a partir da segunda.
+const temApoio = (i) => i % 2 === 1;
+
+function forteDe(g) {
+    let forte = null;
+    for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+    return forte;
+}
+
+/* O B-ROLL EM QUATRO ROTAS (Arthur, do b-roll-finder, 28/09): a frase diz qual
+   imagem pede, na ordem abaixo. A primeira que casa decide.
+     marca     a frase diz o nome da marca    → a logo / o site da marca
+     numero    a frase tem número             → sem foto: o número já é a imagem
+     concreto  uma palavra tem foto no acervo → a foto de estoque dela
+     pessoa    ideia abstrata                 → fica no rosto de quem fala
+   `palavra` é onde o corte se ancora: ele entra 0,2 s DEPOIS dela. */
+const DEPOIS_DA_PALAVRA = 0.2;
+
+function rotaDeApoio(g, { marca = null } = {}) {
+    const ws = g || [];
+    const nomes = (Array.isArray(marca) ? marca : [marca]).filter(Boolean).map((m) => String(m).split(/\s+/).map(limpa));
+    for (const nome of nomes) {
+        const k = ws.findIndex((_, i) => nome.every((n, j) => ws[i + j] && limpa(ws[i + j].texto) === n));
+        if (k >= 0) return { rota: 'marca', termo: null, palavra: ws[k] };
+    }
+    const num = ws.find((p) => /\d/.test(p.texto));
+    if (num) return { rota: 'numero', termo: null, palavra: num };
+    let conc = null;
+    for (const p of ws) if (termoDeApoio(p.texto) && (!conc || peso(p.texto) > peso(conc.texto))) conc = p;
+    if (conc) return { rota: 'concreto', termo: termoDeApoio(conc.texto), palavra: conc };
+    return { rota: 'pessoa', termo: null, palavra: null };
+}
+
+/** Os termos das imagens de apoio que o plano vai pedir — para baixar antes. */
+function termosDeApoio(palavras, opcoes) {
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    const termos = [];
+    frases(lista).forEach((g, i) => {
+        const t = temApoio(i) ? rotaDeApoio(g, opcoes).termo : null;
+        if (t && !termos.includes(t)) termos.push(t);
+    });
+    return termos;
+}
+
+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, apoio: true, recorte: true, fundoRecorte: ['#1B1F3B', '#3A1C71'], destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, recorte: false, fundoRecorte: ['#111111', '#333333'], 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)
+ */
+// Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
+const temRecorte = (i) => i % 4 === 2;
+
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {}, marca = 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 = [];
+    const infos = [];   // onde cada cena começa e a palavra forte dela — para o recorte
+    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.
+        const forte = forteDe(g);
+
+        const elementos = [{
+            tipo: 'video', src, x: 0, y: 0, largura: '100%', altura: '100%',
+            deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
+        }];
+
+        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null });
+
+        /* A PALAVRA ATRÁS DA PESSOA: o fundo do quarto some, entra a cor da
+           marca, a palavra forte aparece enorme e a pessoa, recortada, fica
+           na frente dela. É o efeito que mais denuncia edição de videomaker. */
+        const rec = e.recorte && temRecorte(i) ? recortes[i] : null;
+        if (rec && forte) {
+            const vida = r2(rec.ate - rec.de);
+            const some = [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.12, v: 1 }, { t: vida, v: 0 }];
+            elementos.push({
+                tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: rec.de, ate: rec.ate,
+                fundo: { tipo: 'gradiente', cores: [e.fundoRecorte[0], e.fundoRecorte[1]], angulo: 160 }, anima: { opacidade: some },
+            });
+            const palavra = limpaPontuacao(forte.texto).toUpperCase();
+            const fit = Math.round(Math.min(altura * 0.42, (largura * 0.92) / Math.max(3, palavra.length * 0.46)));
+            elementos.push({
+                tipo: 'texto', texto: palavra, fonte: 'Anton', peso: 400, tamanho: fit, cor: e.forte,
+                x: '50%', y: deitado ? '38%' : '34%', ancora: 'centro', de: rec.de, ate: rec.ate,
+                anima: { escala: [{ t: 0, v: 0.6 }, { t: 0.22, v: 1.06, e: 'saida' }, { t: 0.4, v: 1, e: 'suave' }, { t: vida, v: 1.05 }], opacidade: some },
+            });
+            elementos.push({
+                tipo: 'video', src: rec.src, volume: 0, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                de: rec.de, ate: rec.ate, anima: { opacidade: some },
+            });
+            if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + rec.de - 0.1)), src: sons.whoosh, volume: 0.55 });
+        }
+
+        /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
+           que está sendo dito, com um zoom lento, e a legenda continua por
+           cima. É o "b-roll" das edições de videomaker. */
+        const r = e.apoio && temApoio(i) && !rec ? rotaDeApoio(g, { marca }) : null;
+        const apoio = !r ? null : r.rota === 'concreto' ? imagens[r.termo] : r.rota === 'marca' ? imagens.marca : null;
+        if (apoio) {
+            // O corte entra DEPOIS da palavra, nunca antes: quem ouve "cachorro" vê o cachorro.
+            const de = local(r.palavra.de + DEPOIS_DA_PALAVRA);
+            const vida = Math.min(2.2, dur - de);
+            if (vida > 0.8) {
+                // O apoio é foto ou vídeo (o Pexels dá os dois; vídeo é melhor).
+                const ehVideo = typeof apoio === 'object' && apoio.tipo === 'video';
+                elementos.push({
+                    tipo: ehVideo ? 'video' : 'imagem', src: typeof apoio === 'object' ? apoio.src : apoio,
+                    ...(ehVideo ? { volume: 0 } : {}),
+                    x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                    de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.0, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.12, v: 1 }, { t: vida - 0.15, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + de - 0.1)), src: sons.whoosh, volume: 0.55 });
+            }
+        }
+
+        // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
+        const icone = forte && e.icones && !apoio && !rec ? 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.8 });
+            }
+        } else if (forte && e.letreiro && !rec && 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.7 });
+            }
+        }
+
+        // A legenda palavra por palavra.
+        const fala = blocos(g, 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 ? '76%' : '68%', 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', largura: '92%',
+            },
+        });
+
+        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.6 });
+
+        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 || trilha ? { audio: {
+                ...(efeitos.length ? { efeitos } : {}),
+                // A música fica BAIXA: quem fala para a câmera fala o vídeo
+                // inteiro, e a trilha é cama, não disputa.
+                ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
+            } } : {}),
+        },
+        infos,
+        resumo: {
+            cenas: cenas.length,
+            recortes: Object.keys(recortes).length,
+            icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
+            apoios: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem' || (x.tipo === 'video' && x.volume === 0)).length, 0),
+            musica: Boolean(trilha),
+            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'],
+    // O impacto: um grave que cai de 60 para 30 Hz, com o estalo do ataque.
+    impacto: ['-f', 'lavfi', '-i', "aevalsrc='0.95*sin(2*PI*(62-30*t)*t)*exp(-3.6*t)+0.3*(random(0)*2-1)*exp(-45*t)':s=44100:d=1.3",
+        '-af', 'lowpass=f=2500,volume=1.4'],
+    // O riser: sobe dois segundos e corta — anuncia o que vem.
+    riser: ['-f', 'lavfi', '-i', "aevalsrc='0.4*sin(2*PI*(160+700*t*t)*t)*(t/2)+0.3*(random(0)*2-1)*pow(t/2,2)':s=44100:d=2",
+        '-af', 'highpass=f=120,volume=1.2'],
+    // O estalo do texto batendo na tela.
+    estalo: ['-f', 'lavfi', '-i', "aevalsrc='(random(0)*2-1)*exp(-38*t)*0.9':s=44100:d=0.22",
+        '-af', 'highpass=f=900,lowpass=f=9000'],
+};
+
+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, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };

package/lib/estudio/ende.js

@@ -0,0 +1,107 @@
+/**
+ * ende.js — trilha da ende.app: CC BY 4.0, uso comercial, sem Content ID.
+ *
+ *   "Usar músicas CC BY 4.0 sem Content ID, da ende.app." — Arthur, do
+ *    /brag (28/09/2026)
+ *
+ * Por que esta fonte: música do Openverse com licença comercial às vezes está
+ * registrada no Content ID, e o vídeo do cliente leva reivindicação no
+ * YouTube. A página da ende.app diz: "Important: NO Content ID. [...]
+ * Everything is under CC BY 4.0. [...] Commercial use is allowed as well."
+ * O crédito é opcional ("Attribution is nice but no longer required"), mas
+ * gravamos mesmo assim: custa uma linha e protege o cliente.
+ *
+ * ── SEM API ──────────────────────────────────────────────────────────────
+ * A ende.app não tem API, e a busca por texto (?q=) não filtra: devolve
+ * sempre a mesma lista. Então lemos os cartões da listagem, que trazem
+ * `musicPlayer(id, 'mp3', duração)`, o título, a página e as tags. A escolha é
+ * pelas tags e pela duração. `robots.txt` só fecha /user-api/ e /challenge.
+ *
+ * Se a página mudar, `lerLista` devolve [] e o provedor devolve null, e a
+ * corrente do producao.js cai no próximo provedor (o Openverse). A rede e o
+ * disco são injetados: o teste roda com um recorte do HTML real.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LISTA = 'https://ende.app/en/search';   // 25 cartões; a /en mostra 11
+const CREDITO = 'Música: Sascha Ende (ende.app), CC BY 4.0';
+
+// O clima do roteiro (pt) → palavras que aparecem nas tags da ende.app (en).
+const CLIMAS = {
+    emocional: ['emotional', 'acoustic', 'atmospheric', 'piano', 'cinematic', 'ambient', 'calm', 'strings'],
+    cinema: ['cinematic', 'epic', 'orchestral', 'atmospheric', 'emotional', 'strings'],
+    energetico: ['energetic', 'upbeat', 'beat', 'drums', 'rock', 'arcade', 'breakcore', 'epic'],
+    viral: ['upbeat', 'beat', 'energetic', 'pop', 'electronic'],
+    impacto: ['epic', 'drums', 'trailer', 'energetic', 'beat'],
+    neutro: ['background', 'corporate', 'chilled', 'calm', 'ambient'],
+};
+
+const limpar = (s) => String(s || '').replace(/<[^>]*>/g, '').replace(/&amp;/g, '&').replace(/&#0?39;/g, "'").replace(/\s+/g, ' ').trim();
+
+/** Os cartões de música da listagem. Página diferente do esperado: []. */
+function lerLista(html) {
+    const texto = String(html || '');
+    const cortes = [...texto.matchAll(/musicPlayer\(\s*(\d+)\s*,\s*'([^']+\.mp3)'\s*,\s*([\d.]+)/g)];
+    return cortes.map((m, k) => {
+        const fim = k + 1 < cortes.length ? cortes[k + 1].index : texto.length;
+        const cartao = texto.slice(m.index, fim);
+        const link = cartao.match(/<a href="([^"]+)" class="ap-title-link">([\s\S]*?)<\/a>/);
+        const tags = [...cartao.matchAll(/class="ap-subline-tag">([^<]+)</g)].map((t) => limpar(t[1]).toLowerCase());
+        return {
+            id: Number(m[1]), mp3: m[2], segundos: Number(m[3]),
+            titulo: link ? limpar(link[2]) : null, pagina: link ? link[1] : null, tags,
+        };
+    }).filter((f) => f.titulo && f.segundos > 0);
+}
+
+/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null. */
+function escolher(faixas, { clima = 'neutro', segundos = 0 } = {}) {
+    const palavras = CLIMAS[clima] || CLIMAS.neutro;
+    const nota = (f) => f.tags.reduce((n, t) => n + palavras.filter((p) => t.includes(p)).length, 0);
+    const cabem = (faixas || []).filter((f) => f.segundos >= segundos);
+    if (!cabem.length) return null;
+    return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+}
+
+async function buscarPadrao(url) {
+    const r = await fetch(url, { headers: { 'User-Agent': 'PrimoCode-Estudio' } });
+    if (!r.ok) throw new Error(`ende.app respondeu ${r.status}`);
+    return r.text();
+}
+
+/** Baixa na pasta de mídia e grava o .json da licença ao lado, como o acervo faz. */
+function baixarEm(pasta) {
+    return async (url, nome, meta) => {
+        const r = await fetch(url);
+        if (!r.ok) throw new Error(`download da ende.app respondeu ${r.status}`);
+        const destino = path.join(pasta, nome);
+        fs.mkdirSync(pasta, { recursive: true });
+        fs.writeFileSync(destino, Buffer.from(await r.arrayBuffer()));
+        fs.writeFileSync(destino + '.json', JSON.stringify(meta, null, 2));
+        return destino;
+    };
+}
+
+/** O provedor de `musica` para o producao.js. */
+function provedor({ buscar = buscarPadrao, baixar, pasta = 'midia' } = {}) {
+    const salvar = baixar || baixarEm(pasta);
+    return {
+        nome: 'ende', tipo: 'musica',
+        async gerar({ clima, segundos = 0 } = {}) {
+            const faixa = escolher(lerLista(await buscar(LISTA)), { clima, segundos });
+            if (!faixa) return null;
+            const meta = {
+                fonte: faixa.pagina, titulo: faixa.titulo, autor: 'Sascha Ende',
+                licenca: 'CC BY 4.0', contentId: false, credito: CREDITO,
+            };
+            const src = await salvar(faixa.mp3, `ende-${faixa.id}.mp3`, meta);
+            return { src, segundos: faixa.segundos, ...meta };
+        },
+    };
+}
+
+module.exports = { lerLista, escolher, provedor, CLIMAS, CREDITO };