primocode 11.0.0 → 11.2.0

package/lib/plugin/editor-pro-maquina.js

@@ -0,0 +1,355 @@
+/* A máquina de vídeo do editor: entende cada frase, escolhe gancho e estilo pelo CONTEÚDO (e pela variante),
+   e confere o plano com uma régua numérica (criticar). Sem rede, sem Python: só texto e números.
+   Ver docs/rebuild/editor-maquina-arquitetura.md. */
+'use strict';
+
+const FRACAS = new Set('a o e é de da do das dos em no na nos nas um uma uns umas que para pra por com como eu você ele ela isso esse essa este esta hoje vou vai ou se mas'.split(' '));
+const NEGACAO = /\b(nunca|n[aã]o|ningu[eé]m|nada|jamais|zero|sem)\b/i;
+const NUMERO = /\d|\b(dobro|metade|triplo|mil|milh[aã]o|dez|cem|vinte|trinta)\b/i;
+const PROMESSA = /\b(como|jeito|segredo|passo|m[eé]todo|f[aá]cil|r[aá]pido|grátis|gr[aá]tis|consegui|descobri)\b/i;
+const URGENCIA = /\b(agora|hoje|[uú]ltim[ao]s?|acaba|corre|r[aá]pido|j[aá])\b/i;
+const EMOCAO_FORTE = /\b(erro|medo|perd[ei]|caro|problema|pior|absurdo|chocante|incr[ií]vel|louco|nunca|dobro|segredo)\b/i;
+
+const limpar = (l) => String(l || '').replace(/^[\d.]+-[\d.]+\s+/, '').trim();
+const tempos = (l) => { const m = /^([\d.]+)-([\d.]+)/.exec(String(l || '')); return m ? [Number(m[1]), Number(m[2])] : [null, null]; };
+
+/** O que cada frase quer: intenção, emoção, palavra-chave e energia (0 a 1). Tudo medido no texto. */
+function entenderFrases(fala) {
+    return (fala || []).map((linha, i) => {
+        const texto = limpar(linha);
+        const [t0, t1] = tempos(linha);
+        const palavras = texto.replace(/[.,!?;:]/g, '').split(/\s+/).filter(Boolean);
+        const fortes = palavras.filter((p) => !FRACAS.has(p.toLowerCase()) && (p.length > 2 || /\d/.test(p) || /^[A-ZÀ-Ú]{2}$/.test(p)));
+        const chave = fortes.slice().sort((a, b) => (NUMERO.test(b) - NUMERO.test(a)) || (b.length - a.length))[0] || null;
+        let intencao = 'afirma';
+        if (/\?\s*$/.test(texto)) intencao = 'pergunta';
+        else if (NUMERO.test(texto)) intencao = 'prova';
+        else if (NEGACAO.test(texto)) intencao = 'nega';
+        else if (PROMESSA.test(texto)) intencao = 'promete';
+        else if (URGENCIA.test(texto)) intencao = 'urge';
+        const energia = Math.min(1, 0.25 + (/!/.test(texto) ? 0.25 : 0) + (EMOCAO_FORTE.test(texto) ? 0.25 : 0) + (NUMERO.test(texto) ? 0.15 : 0) + (NEGACAO.test(texto) ? 0.1 : 0));
+        return { i, texto, t0, t1, palavras, fortes, chave, intencao, energia, emocao: energia >= 0.6 ? 'forte' : energia >= 0.4 ? 'media' : 'calma' };
+    }).filter((f) => f.texto);
+}
+
+const marcar = (ps, ult) => (ps.length ? ps.join(' ') + ' ' : '') + `*${ult}*`;
+
+/** Candidatos a gancho, de tipos DIFERENTES, tirados das primeiras frases (o gancho pode nascer de qualquer uma). */
+function ganchosCandidatos(fala) {
+    const frases = entenderFrases(fala);
+    const out = [];
+    const jaTem = new Set();
+    const por = (tipo, f, nota, fn) => {
+        if (!f || !f.fortes.length) return;
+        const texto = fn(f);
+        if (!texto || jaTem.has(texto.toLowerCase())) return;
+        jaTem.add(texto.toLowerCase());
+        out.push({ tipo, texto, de: f.i, nota });
+    };
+    for (const f of frases.slice(0, 6)) {
+        if (f.intencao === 'prova') por('numero', f, 3 + f.energia, (x) => { const c = x.fortes.find((p) => NUMERO.test(p)) || x.chave; const ix = x.fortes.indexOf(c); return marcar(x.fortes.slice(Math.max(0, ix - 2), ix), c); });
+        if (f.intencao === 'nega') por('negacao', f, 2.5 + f.energia, (x) => marcar(x.fortes.slice(-3, -1), x.fortes[x.fortes.length - 1]));
+        if (f.intencao === 'pergunta') por('pergunta', f, 2 + f.energia, (x) => marcar(x.fortes.slice(0, 3).slice(0, -1), x.fortes.slice(0, 3).slice(-1)[0]));
+        if (f.intencao === 'promete') por('promessa', f, 2 + f.energia, (x) => marcar(x.fortes.slice(0, 3), x.chave || x.fortes[x.fortes.length - 1]).replace(/\*\*/g, '*'));
+        if (f.intencao === 'urge') por('urgencia', f, 1.5 + f.energia, (x) => marcar(x.fortes.slice(-3, -1), x.fortes[x.fortes.length - 1]));
+    }
+    if (frases[0]) por('palavra-forte', frases[0], 1, (x) => { const fs = x.fortes.slice(-4); const u = fs.pop(); return marcar(fs, u); });
+    return out.sort((a, b) => b.nota - a.nota);
+}
+
+/** O gancho da variante `variante` (0 = o de maior nota; 1 = o próximo TIPO; e assim por diante, girando). */
+function escolherGancho(fala, variante = 0) {
+    const c = ganchosCandidatos(fala);
+    if (!c.length) return null;
+    return c[((variante % c.length) + c.length) % c.length].texto;
+}
+
+const hash = (s) => { let h = 2166136261; for (const ch of String(s)) { h ^= ch.charCodeAt(0); h = Math.imul(h, 16777619); } return h >>> 0; };
+
+/** O estilo vem da energia do que é dito, não de um padrão fixo: conteúdo forte pede escuro/laranja; calmo, limpo.
+    A variante gira entre os estilos que servem, e o mesmo roteiro sempre dá a mesma resposta (sem sorteio). */
+function escolherEstilo(fala, variante = 0) {
+    const fr = entenderFrases(fala);
+    const e = fr.length ? fr.reduce((s, f) => s + f.energia, 0) / fr.length : 0.3;
+    const ordem = e >= 0.55 ? ['laranja', 'noite', 'papelaria', 'limpo'] : e >= 0.38 ? ['noite', 'laranja', 'limpo', 'papelaria'] : ['limpo', 'papelaria', 'noite', 'laranja'];
+    const sal = hash(fr.map((f) => f.texto).join('|')) % 2;
+    return ordem[(variante + sal) % ordem.length];
+}
+
+// ── a régua (autocrítica) ────────────────────────────────────────────────
+
+const REGUA = {
+    parado_max_s: 3.0,            // nenhum trecho maior que isso sem mudança visual
+    tratamentos_min_por_min: 12,  // eventos visuais (peça, bloco, zoom) por minuto
+    tipos_distintos_min: 4,       // famílias de tratamento diferentes no vídeo
+    sfx_no_corte_s: 0.15,         // todo corte de bloco tem som a até 150 ms
+    sfx_min_por_min: 10,          // camadas de som por minuto
+    gancho_ate_s: 1.0,            // o gancho aparece no primeiro segundo
+    zooms_distintos_min: 3,       // escalas de enquadramento diferentes
+    legenda_sobre_rosto: 0,       // trechos com texto sobre o rosto
+};
+const POS_ROSTO = new Set(['centro', 'rosto', 'meio-rosto']);
+const num = (x) => (typeof x === 'number' && isFinite(x) ? x : null);
+
+/** Pontos do tempo em que a imagem muda: começo e fim de peça, bloco e zoom. */
+function mudancasVisuais(cfg, duracao) {
+    const pts = [0, duracao];
+    const tipos = new Set();
+    let eventos = 0;
+    for (const a of cfg.animacoes || []) {
+        const e = num(a.em) ?? num(a.depois_de); const s = num(a.sai);
+        if (e != null) { pts.push(e); eventos++; } if (s != null) pts.push(s);
+        tipos.add('anim:' + (a.tipo || '?'));
+    }
+    for (const b of cfg.blocos || []) {
+        const d = num(b.de); const t = num(b.ate);
+        if (d != null) { pts.push(d); eventos++; } if (t != null) pts.push(t);
+        tipos.add('bloco:' + (b.cena || '?'));
+        for (const z of b.zooms || []) { if (num(z.em) != null) { pts.push(z.em); eventos++; } if (num(z.ate) != null) pts.push(z.ate); tipos.add('punch'); }
+    }
+    return { pts: pts.filter((p) => p >= 0 && p <= duracao).sort((a, b) => a - b), tipos, eventos };
+}
+
+/** Dá nota (0 a 100) a um plano montado (o projeto.json) e devolve as falhas, cada uma com o número e o que fazer. */
+function criticar(cfg, { duracao } = {}, regua = REGUA) {
+    const dur = duracao || Math.max(0, ...(cfg.blocos || []).map((b) => num(b.ate) || 0), ...(cfg.animacoes || []).map((a) => num(a.sai) || 0));
+    const falhas = [];
+    const m = {};
+    if (!dur) return { nota: 0, falhas: [{ regra: 'duracao', valor: 0, limite: '>0', conserto: 'sem duração não há o que conferir' }], metricas: m };
+    const { pts, tipos, eventos } = mudancasVisuais(cfg, dur);
+    let parado = 0; let onde = 0;
+    for (let k = 1; k < pts.length; k++) if (pts[k] - pts[k - 1] > parado) { parado = pts[k] - pts[k - 1]; onde = pts[k - 1]; }
+    m.parado_max_s = Math.round(parado * 100) / 100;
+    if (parado > regua.parado_max_s) falhas.push({ regra: 'parado_max_s', valor: m.parado_max_s, limite: regua.parado_max_s, em: onde, conserto: `ponha peça, zoom ou b-roll a partir de ${onde.toFixed(1)} s` });
+    m.tratamentos_por_min = Math.round((eventos / dur) * 60 * 10) / 10;
+    if (m.tratamentos_por_min < regua.tratamentos_min_por_min) falhas.push({ regra: 'tratamentos_por_min', valor: m.tratamentos_por_min, limite: regua.tratamentos_min_por_min, conserto: 'mais mudanças de imagem ligadas ao que se diz' });
+    m.tipos_distintos = tipos.size;
+    if (tipos.size < regua.tipos_distintos_min) falhas.push({ regra: 'tipos_distintos', valor: tipos.size, limite: regua.tipos_distintos_min, conserto: 'misture famílias: lettering, moldura, contador, b-roll, punch' });
+    const sons = (cfg.sons || []).filter((s) => !s.camada && s.tipo !== 'ambiente').map((s) => num(s.em)).filter((x) => x != null);   // camadas e ambiência não contam como som novo
+    m.sfx_por_min = Math.round((sons.length / dur) * 60 * 10) / 10;
+    if (m.sfx_por_min < regua.sfx_min_por_min) falhas.push({ regra: 'sfx_por_min', valor: m.sfx_por_min, limite: regua.sfx_min_por_min, conserto: 'rode o plano_sfx com --variar e mais camadas' });
+    const cortes = (cfg.blocos || []).map((b) => num(b.de)).filter((x) => x != null && x > 0.05);
+    const semSom = cortes.filter((c) => !sons.some((s) => Math.abs(s - c) <= regua.sfx_no_corte_s));
+    m.cortes_sem_som = semSom.length;
+    if (semSom.length) falhas.push({ regra: 'sfx_no_corte', valor: semSom.length, limite: 0, em: semSom[0], conserto: `som nos cortes: ${semSom.slice(0, 4).join(', ')} s` });
+    const g = (cfg.animacoes || []).find((a) => a.id === 'gancho' || a.tipo === 'lettering');
+    m.gancho_em_s = g ? num(g.em) : null;
+    if (!g || (num(g.em) ?? 99) > regua.gancho_ate_s) falhas.push({ regra: 'gancho_ate_s', valor: m.gancho_em_s, limite: regua.gancho_ate_s, conserto: 'o gancho entra no primeiro segundo' });
+    const escalas = new Set();
+    for (const b of cfg.blocos || []) { if (num(b.zoom) != null) escalas.add(b.zoom); for (const z of b.zooms || []) if (num(z.escala) != null) escalas.add(z.escala); }
+    m.zooms_distintos = escalas.size;
+    if (escalas.size < regua.zooms_distintos_min) falhas.push({ regra: 'zooms_distintos', valor: escalas.size, limite: regua.zooms_distintos_min, conserto: 'varie o enquadramento (mais de duas escalas)' });
+    const sobreRosto = (cfg.animacoes || []).filter((a) => POS_ROSTO.has(a.posicao) || a.cobre_rosto === true);
+    m.texto_sobre_rosto = sobreRosto.length;
+    if (sobreRosto.length > regua.legenda_sobre_rosto) falhas.push({ regra: 'texto_sobre_rosto', valor: sobreRosto.length, limite: regua.legenda_sobre_rosto, conserto: 'mova o texto para baixo do rosto ou ponha o rosto em moldura' });
+    const nota = Math.max(0, Math.round(100 - falhas.length * (100 / 8)));
+    return { nota, passou: falhas.length === 0, falhas, metricas: m };
+}
+
+/** Duas variantes não podem abrir igual nem ter o mesmo jeito (gancho, estilo e ritmo). */
+function compararVariantes(cfgs) {
+    const falhas = [];
+    const sig = (c) => {
+        const g = (c.animacoes || []).find((a) => a.id === 'gancho');
+        const t = (c.blocos || []).length;
+        return { gancho: g ? JSON.stringify(g.principal || g.texto || g.titulo || '').toLowerCase() : '', estilo: c.estilo || '', ritmo: Math.round(t / 3) };
+    };
+    const s = cfgs.map(sig);
+    for (let a = 0; a < s.length; a++) for (let b = a + 1; b < s.length; b++) {
+        if (s[a].gancho && s[a].gancho === s[b].gancho) falhas.push({ regra: 'mesmo_gancho', entre: [a, b], valor: s[a].gancho });
+        if (s[a].estilo === s[b].estilo && s[a].ritmo === s[b].ritmo) falhas.push({ regra: 'mesmo_estilo_e_ritmo', entre: [a, b], valor: `${s[a].estilo}/${s[a].ritmo}` });
+    }
+    return { passou: falhas.length === 0, falhas };
+}
+
+// ── emoção por frase → humor da trilha ───────────────────────────────────
+
+const HUMOR_TRISTE = /\b(perd[ei]|perdeu|dor|sozinh[oa]|triste|difícil|dificil|saudade|chor|fal[ií]|quebr)/i;
+const HUMOR_TENSO = /\b(erro|medo|cuidado|perigo|alerta|segredo|ningu[eé]m|nunca|problema|pior|caro|golpe)\b/i;
+const HUMOR_EPICO = /\b(incr[ií]vel|absurdo|chocante|dobro|milh[aã]o|mil|revela|resultado|virada|conseguiu|consegui)\b/i;
+
+/** O humor (id de helpers/trilhas_humores.json) que a frase pede. Só texto, sem sorteio. */
+function humorDaFrase(f) {
+    const t = f.texto || '';
+    if (HUMOR_TRISTE.test(t)) return 'triste';
+    if (f.intencao === 'nega' || HUMOR_TENSO.test(t)) return 'tensa';
+    if (HUMOR_EPICO.test(t) && f.energia >= 0.4) return 'epica';
+    if (f.intencao === 'promete') return f.energia >= 0.4 ? 'animada' : 'inspiradora';
+    if (f.energia >= 0.55) return 'animada';
+    if (f.energia < 0.4) return 'calma';
+    return 'inspiradora';
+}
+
+/** A emoção do vídeo: o humor de cada frase (a curva) e o dominante, ponderado pela energia. `cortes` = onde a trilha deve
+    ter acento (início das frases fortes, com o peso = energia), para alinhar o drop. */
+function emocaoDaFala(fala) {
+    const frases = entenderFrases(fala);
+    const curva = frases.map((f) => ({ i: f.i, t0: f.t0, t1: f.t1, humor: humorDaFrase(f), energia: f.energia }));
+    const placar = {};
+    for (const c of curva) placar[c.humor] = (placar[c.humor] || 0) + 0.2 + c.energia;
+    const ordem = Object.entries(placar).sort((a, b) => b[1] - a[1]);
+    const energia = frases.length ? frases.reduce((s, f) => s + f.energia, 0) / frases.length : 0.3;
+    const cortes = curva.filter((c) => c.t0 != null && c.energia >= 0.4).map((c) => ({ t: c.t0, peso: Math.round(c.energia * 100) / 100 }));
+    return { humor: ordem.length ? ordem[0][0] : 'calma', energia: Math.round(energia * 100) / 100, curva, placar, cortes };
+}
+
+// ── som em camadas ───────────────────────────────────────────────────────
+
+const ARQ_CAMADA = { grave: 'assets/sfx/camada_grave.wav', ar: 'assets/sfx/camada_ar.wav', brilho: 'assets/sfx/camada_brilho.wav', ambiente: 'assets/sfx/ambiente.wav' };
+
+/** Quantas camadas (som do plano + extras) cada impacto leva: a energia da frase decide. 2 a 3. */
+function camadasDoImpacto(energia) { return energia >= 0.6 ? 3 : 2; }
+
+/** Os impactos do projeto: começo de bloco (corte), punch, peça de texto e contador. {t, tipo}. */
+function impactosDoProjeto(cfg, duracao) {
+    const out = [];
+    for (const b of cfg.blocos || []) {
+        if (num(b.de) != null && b.de > 0.05) out.push({ t: b.de, tipo: 'corte' });
+        for (const z of b.zooms || []) if (num(z.em) != null) out.push({ t: z.em, tipo: 'punch' });
+    }
+    for (const a of cfg.animacoes || []) {
+        const e = num(a.em) ?? num(a.depois_de);
+        if (e != null && ['lettering', 'contador', 'lista_check', 'passo_a_passo'].includes(a.tipo)) out.push({ t: e, tipo: a.tipo });
+    }
+    return out.filter((x) => x.t >= 0 && x.t <= duracao).sort((a, b) => a.t - b.t);
+}
+
+/** As camadas por cima dos sons do plano: grave (sub) em todo impacto, ar/brilho nos de frase forte, e a ambiência
+    sob o vídeo todo. Tudo vira entradas de `sons` com `camada: true` (a régua não as conta como som novo). Puro: não toca em disco. */
+function camadasDeSom(cfg, { duracao, frases = [] } = {}) {
+    const energiaEm = (t) => {
+        const f = frases.find((x) => x.t0 != null && x.t1 != null && t >= x.t0 - 0.05 && t <= x.t1 + 0.05)
+            || frases.filter((x) => x.t0 != null && x.t0 <= t).pop();
+        return f ? f.energia : 0.3;
+    };
+    const novos = [];
+    let ult = -9;
+    for (const im of impactosDoProjeto(cfg, duracao)) {
+        if (im.t - ult < 0.45) continue;                   // impactos colados dividem as camadas
+        ult = im.t;
+        const n = camadasDoImpacto(energiaEm(im.t));
+        const base = { em: Math.round(im.t * 1000) / 1000, camada: true, nota: `camada · ${im.tipo}` };
+        novos.push({ ...base, arquivo: ARQ_CAMADA.grave, tipo: 'grave', pico_no_arquivo: 0.01, inicio_no_arquivo: 0, dur: 0.6, volume: im.tipo === 'corte' ? 0.45 : 0.35, fade: 0.2 });
+        if (n >= 3) novos.push({ ...base, arquivo: im.tipo === 'corte' ? ARQ_CAMADA.ar : ARQ_CAMADA.brilho, tipo: im.tipo === 'corte' ? 'ar' : 'brilho', pico_no_arquivo: 0.02, inicio_no_arquivo: 0, dur: 0.5, volume: 0.22, fade: 0.2 });
+    }
+    if (duracao > 1) novos.unshift({ em: 0, camada: true, tipo: 'ambiente', arquivo: ARQ_CAMADA.ambiente, pico_no_arquivo: 0, inicio_no_arquivo: 0, dur: Math.round(duracao * 1000) / 1000, volume: 0.07, fade: 1.2, fade_entrada: 0.8, nota: 'ambiência sob o vídeo todo' });
+    return novos;
+}
+
+// ── rosto grande: a fala vertical de uma câmera que pega o rosto de perto ───────────────
+
+/** O rosto da câmera ocupa quase o quadro vertical (webcam de perto, 16:9 cortado em 9:16). O corte cobrindo a tela dá um
+    rosto de 70% da altura: o texto não tem onde ficar. Devolve null quando o corte normal serve, ou
+    {caixa:[x,y,w,h], fracao_rosto, rosto_h, rosto_l} para a pessoa em um quadro de largura total, com o rosto em ~52% da altura
+    (a faixa de cima fica livre para o texto, a de baixo é o fundo desfocado). `fl` = o face_layout.json. */
+function layoutRostoGrande(fl, { W = 1080, H = 1920, alvo = 0.52, limite = 0.62 } = {}) {
+    const segs = ((fl && fl.segments) || []).filter((s) => s && s.face && num(s.end) != null && num(s.start) != null);
+    const vw = fl && num(fl.width); const vh = fl && num(fl.height);
+    if (!segs.length || !vw || !vh) return null;
+    const pesos = segs.map((s) => Math.max(0.05, s.end - s.start));
+    const mediana = (f) => {   // mediana ponderada pela duração do trecho
+        const v = segs.map((s, i) => [f(s.face), pesos[i]]).sort((a, b) => a[0] - b[0]);
+        const meio = v.reduce((t, x) => t + x[1], 0) / 2;
+        let acc = 0; for (const [x, w] of v) { acc += w; if (acc >= meio) return x; }
+        return v[v.length - 1][0];
+    };
+    const k = Math.max(W / vw, H / vh);                  // o corte cobrindo a tela
+    const rostoH = mediana((f) => (f.y1 - f.y0)) * vh * k / H;
+    const rostoL = mediana((f) => (f.x1 - f.x0)) * vw * k / W;
+    if (rostoH <= limite && rostoL <= limite + 0.2) return null;
+    const fh = mediana((f) => (f.y1 - f.y0));
+    // altura da gravação inteira no quadro: o rosto com `alvo` da altura da tela; nunca mais estreita que a tela, nem sem faixa em cima
+    let h = Math.round((alvo * H) / Math.max(0.2, fh));
+    h = Math.max(Math.ceil(W * vh / vw), Math.min(h, Math.round(H * 0.83)));
+    const y = Math.min(150, Math.round((H - h) / 2));
+    return { caixa: [0, y, W, h], fracao_rosto: Math.round(fh * h / H * 100) / 100, rosto_h: Math.round(rostoH * 100) / 100, rosto_l: Math.round(rostoL * 100) / 100 };
+}
+
+// ── reedição única ───────────────────────────────────────────────────────
+
+/** Conserta o que a régua reprovou, uma vez. Devolve uma cópia do cfg e a lista do que mudou. `cfg.sons` é o do plano_sfx;
+    quem chama refaz os sons e as camadas depois. Nada aqui sorteia: o mesmo plano reprovado dá o mesmo conserto. */
+function consertarPlano(cfg0, critica, { duracao, fala = [] } = {}, regua = REGUA) {
+    const cfg = JSON.parse(JSON.stringify(cfg0));
+    const mudancas = [];
+    const falhou = (r) => (critica.falhas || []).some((f) => f.regra === r);
+    cfg.blocos = cfg.blocos || [];
+    cfg.animacoes = cfg.animacoes || [];
+    const ESCALAS = [1.3, 1.4, 1.25, 1.5, 1.35];
+    const ESCALAS_MOLDURA = [1.12, 1.22, 1.06, 1.17, 1.09];   // múltiplo do quadro da moldura (o rosto já vem grande)
+    const doBloco = (t) => cfg.blocos.find((b) => (b.cena === 'tela_cheia' || b.cena === 'prova' || b.cena === 'moldura') && num(b.de) != null && t >= b.de + 0.3 && t <= b.ate - 0.9);
+    const escalasUsadas = () => new Set(cfg.blocos.flatMap((b) => [b.zoom, ...(b.zooms || []).map((z) => z.escala)]).filter((x) => num(x) != null));
+    const punch = (t, motivo) => {
+        const b = doBloco(t);
+        if (!b) return false;
+        b.zooms = b.zooms || [];
+        if (b.zooms.some((z) => t < z.ate + 0.3 && t + 0.6 > z.em - 0.3)) return false;
+        const usadas = escalasUsadas();
+        const lista = b.cena === 'moldura' ? ESCALAS_MOLDURA : ESCALAS;
+        const escala = lista.find((e) => !usadas.has(e)) || lista[b.zooms.length % lista.length];
+        b.zooms.push({ em: Math.round(t * 100) / 100, ate: Math.round((t + 0.6) * 100) / 100, escala, reedicao: true });
+        b.zooms.sort((x, y) => x.em - y.em);
+        mudancas.push(`punch ${escala}x em ${t.toFixed(1)} s (${motivo})`);
+        return true;
+    };
+    // 1) gancho no primeiro segundo e texto fora do rosto
+    const g = cfg.animacoes.find((a) => a.id === 'gancho' || a.tipo === 'lettering');
+    if (falhou('gancho_ate_s') && g && (num(g.em) ?? 99) > regua.gancho_ate_s) { mudancas.push(`gancho entra em 0,2 s (era ${g.em})`); g.sai = Math.max(num(g.sai) ?? 0, 2.4); g.em = 0.2; }
+    if (falhou('texto_sobre_rosto')) for (const a of cfg.animacoes) if (POS_ROSTO.has(a.posicao) || a.cobre_rosto === true) { mudancas.push(`texto ${a.id || a.tipo} desce para a base (estava sobre o rosto)`); a.posicao = 'base'; delete a.cobre_rosto; }
+    // 2) enquadramentos distintos: o zoom base de cada tela cheia gira
+    if (falhou('zooms_distintos')) {
+        const base = [1.0, 1.08, 1.18, 1.12];
+        let k = 0;
+        for (const b of cfg.blocos) if (b.cena === 'tela_cheia' && !(b.zooms || []).length) { b.zoom = base[k++ % base.length]; }
+        for (const b of cfg.blocos) if (b.cena === 'moldura' && b.rosto_grande && !(b.zooms || []).length) { b.zoom = 1.0; k++; }   // o quadro grande já é o enquadramento base; a variedade vem dos punches
+        if (k) mudancas.push(`zoom base variado em ${k} blocos`);
+    }
+    const frases = entenderFrases(fala).filter((f) => f.t0 != null && f.chave);
+    const arred = (x) => Math.round(x * 100) / 100;
+    const reforco = (t, motivo) => {
+        const f = frases.find((x) => t >= x.t0 && t <= (x.t1 ?? x.t0 + 3)) || frases.filter((x) => x.t0 <= t).pop();
+        if (!f) return false;
+        const em = arred(Math.max(t, 2.6));
+        if (cfg.animacoes.some((a) => a.tipo === 'lettering' && num(a.em) != null && em < (num(a.sai) ?? a.em + 2) + 0.2 && em + 1.8 > a.em - 0.2)) return false;
+        cfg.animacoes.push({ id: 'reforco' + cfg.animacoes.length, tipo: 'lettering', principal: `*${String(f.chave).toUpperCase()}*`, em, sai: arred(Math.min(em + 1.8, duracao - 0.2)), posicao: 'base', estilo: 'cinetico' });
+        mudancas.push(`lettering de reforço em "${f.chave}" (${em} s, ${motivo})`);
+        return true;
+    };
+    // 3) variedade: sem 4 famílias, a maior tela cheia sem punch escolhido à mão vira moldura (outra família, outro ritmo de imagem)
+    if (falhou('tipos_distintos') || mudancasVisuais(cfg, duracao).tipos.size < regua.tipos_distintos_min) {
+        const vizinhoMoldura = (i) => [cfg.blocos[i - 1], cfg.blocos[i + 1]].some((n) => n && n.cena === 'moldura');
+        const cand = cfg.blocos.map((b, i) => ({ b, i })).filter(({ b, i }) => b.cena === 'tela_cheia' && (num(b.de) ?? 0) >= 1.5 && b.ate - b.de >= 2.5 && !(b.zooms || []).some((z) => !z.auto) && !vizinhoMoldura(i))
+            .sort((x, y) => (y.b.ate - y.b.de) - (x.b.ate - x.b.de));
+        if (cand.length) {
+            const b = cand[0].b;
+            const { de, ate } = b;
+            for (const k of Object.keys(b)) delete b[k];
+            Object.assign(b, { cena: 'moldura', de, ate, fundo: cfg.estilo === 'limpo' ? 'papel' : 'desfocado' });
+            mudancas.push(`bloco de ${de.toFixed(1)} a ${ate.toFixed(1)} s vira moldura (mais uma família de tratamento)`);
+        }
+    }
+    // 4) parado e ritmo: punch nos maiores intervalos; onde não cabe punch (moldura, prova), um lettering de reforço (máx. 14 mexidas)
+    for (let i = 0; i < 14; i++) {
+        const { pts, eventos } = mudancasVisuais(cfg, duracao);
+        let gap = 0; let onde = 0;
+        for (let k = 1; k < pts.length; k++) if (pts[k] - pts[k - 1] > gap) { gap = pts[k] - pts[k - 1]; onde = pts[k - 1]; }
+        const ritmo = (eventos / duracao) * 60 < regua.tratamentos_min_por_min;
+        if (gap <= regua.parado_max_s && !ritmo) break;
+        const motivo = gap > regua.parado_max_s ? `parado ${gap.toFixed(1)} s` : 'ritmo';
+        if (!punch(onde + gap / 2 - 0.3, motivo) && !punch(onde + 0.6, motivo) && !punch(onde + gap - 1.2, motivo) && !reforco(onde + gap / 2 - 0.9, motivo)) break;
+    }
+    return { cfg, mudancas, mexeu: mudancas.length > 0 };
+}
+
+/** Sons que faltam nos cortes (régua sfx_no_corte): copia o primeiro som do plano em cada corte sem som. */
+function sonsNosCortes(cfg, regua = REGUA) {
+    const sons = (cfg.sons || []).filter((s) => !s.camada && s.tipo !== 'ambiente');
+    const modelo = sons.find((s) => /whoosh/i.test(s.tipo || s.arquivo || '')) || sons[0];
+    if (!modelo) return [];
+    const cortes = (cfg.blocos || []).map((b) => num(b.de)).filter((x) => x != null && x > 0.05);
+    const novos = [];
+    for (const c of cortes) if (![...sons, ...novos].some((s) => Math.abs(num(s.em) - c) <= regua.sfx_no_corte_s)) novos.push({ ...modelo, em: c, plano: false, reedicao: true, nota: 'reedição: som no corte' });
+    return novos;
+}
+
+module.exports = { layoutRostoGrande, humorDaFrase, emocaoDaFala, camadasDeSom, camadasDoImpacto, impactosDoProjeto, consertarPlano, sonsNosCortes, ARQ_CAMADA, REGUA, entenderFrases, ganchosCandidatos, escolherGancho, escolherEstilo, criticar, compararVariantes, mudancasVisuais };