primocode 9.8.0-beta.9 → 9.8.0

package/lib/estudio/cinema.js

@@ -0,0 +1,399 @@
+/**
+ * cinema.js — o estilo cinematográfico, premium e humano.
+ *
+ *   "Os efeitos sonoros estão genéricos e sem impacto, a paleta da Paris não
+ *    é laranja, as cenas têm muito texto e não dá de ler antes de trocar, e
+ *    os textos não têm nada a ver com o roteiro." — e veio o roteiro dele:
+ *    "cinematográfico, premium, moderno e humano… poucas palavras por tela…
+ *    fotos nunca estáticas… NÃO usar excesso de efeitos… a abertura não
+ *    mostra o logo." (25/09/2026)
+ *
+ * O contrário do impacto: o texto entra com calma e FICA enquanto é falado
+ * (a voz lê o que está na tela), as fotos se movem sempre (zoom, pan,
+ * lateral), o preto é quase absoluto, o destaque é o gradiente da marca, a
+ * música cresce e silencia antes do clímax, e a marca só aparece no fim.
+ *
+ * Tipos de parte (todos com "fala" opcional; sem ela, a voz lê os textos):
+ *   frase      {linhas}                       preto, linha fina, texto
+ *   montagem   {linhas, ritmo}                fotos rápidas + texto por cima
+ *   numeros    {antes, itens:["3 EDIÇÕES"]}   os números contando
+ *   escada     {itens, final}                 "UMA SALA." "20 CADEIRAS." …
+ *   dia        {num, titulo, linhas}          01 PREPARAR + as três linhas
+ *   depoimento {clipes:[{src,de,ate,frase,nome}]}  o aluno falando
+ *   climax     {linhas}                       montagem acelerada, preto, silêncio
+ *   final      {linhas}                       a logo e a chamada
+ */
+
+'use strict';
+
+const { caber } = require('./composicao.js');
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+
+/** Quanto tempo um texto precisa ficar na tela para ser lido. */
+const leitura = (t) => 0.55 + 0.22 * String(t || '').split(/\s+/).filter(Boolean).length;
+
+/** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
+/* A voz lê EXATAMENTE o que está na tela, na ordem da tela ("a narração tem
+   que ser a mesma dos textos", 25/09). Caixa alta vira frase normal (senão a
+   voz soletra), "IA" fica "IA", o separador vira pausa e "/SC" sai da fala. */
+function paraFala(x) {
+    let t = String(x || '').replace(/\b0(\d)\b/g, '$1').replace(/[·→]/g, ',').replace(/\/(SC|SP|RJ|PR|RS|MG)\b/g, '').replace(/\s+,/g, ',').trim();
+    if (t && t === t.toUpperCase()) {
+        // Sigla de até 3 letras fica sigla ("AI" minúsculo a voz lê como "ai").
+        const SIGLAS = new Set(['IA', 'AI', 'TI', 'RH', 'CEO', 'KPI', 'BI', 'CRM', 'ERP', 'SC', 'SP', 'PR', 'RS', 'RJ', 'MG']);
+        t = t.split(/(\s+)/).map((w) => (SIGLAS.has(w.replace(/[:.,!?]$/, '')) ? w : w.toLowerCase())).join('')
+            .replace(/(^|[.!?:]\s+)(\p{L})/gu, (m, a, b) => a + b.toUpperCase());
+    }
+    t = t.replace(/[,;:\s]+$/, '');
+    if (!/[.!?]$/.test(t)) t += '.';
+    return t;
+}
+function falaDe(p) {
+    if (p.fala === '' || p.mudo) return '';   // parte MUDA: a tela fala sozinha
+    if (p.fala) return p.fala;
+    if (p.tipo === 'depoimento') return '';
+    const tela = p.tipo === 'dia' ? [`Dia ${p.num}`, p.titulo, ...(p.linhas || [])]
+        : p.tipo === 'escada' ? [...(p.itens || []), p.final]
+            : p.tipo === 'numeros' ? [p.antes, ...(p.itens || [])]
+                : (p.linhas || []);
+    /* A linha só emenda na seguinte quando não termina em pontuação E a
+       seguinte começa em minúscula ("E se 3 dias fossem suficientes" / "para
+       mudar…"); o resto é frase inteira. A frase repetida em seguida
+       ("CONSTRUIR" / "Construir.") a voz diz uma vez só. */
+    const linhas = tela.filter(Boolean).map((x) => String(x).trim());
+    const frases = [];
+    let atual = '';
+    linhas.forEach((bruto, k) => {
+        const prox = linhas[k + 1];
+        const emenda = !/[.!?…·→:]$/.test(bruto) && prox && /^[a-zà-ú]/.test(prox);
+        let pedaco = paraFala(bruto);
+        if (emenda) pedaco = pedaco.replace(/\.$/, '');
+        atual = atual ? `${atual} ${pedaco.charAt(0).toLowerCase()}${pedaco.slice(1)}` : pedaco;
+        if (!emenda) { frases.push(atual); atual = ''; }
+    });
+    if (atual) frases.push(atual);
+    const chave = (f) => f.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
+    return frases.filter((f, k) => k === 0 || chave(f) !== chave(frases[k - 1])).join(' ');
+}
+
+/* Quando cada texto começa, pelo tempo das palavras da voz: procura a
+   primeira palavra do texto a partir de onde parou. */
+function quando(textos, palavras, dur, t0 = 0.25) {
+    const ws = palavras.map((w) => ({ ...w, k: tokens(w.texto)[0] || '' }));
+    let cursor = 0;
+    return textos.map((txt, i) => {
+        const alvo = tokens(txt).find((w) => w.length >= 3) || tokens(txt)[0];
+        let achado = -1;
+        for (let j = cursor; j < ws.length; j++) if (ws[j].k === alvo || (alvo && ws[j].k.startsWith(alvo.slice(0, 5)))) { achado = j; break; }
+        if (achado >= 0) { cursor = achado + 1; return r2(ws[achado].de); }
+        return r2(t0 + (dur - t0) * (i / Math.max(1, textos.length)));
+    });
+}
+
+function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {} }) {
+    const partes = (roteiro && roteiro.partes) || [];
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const marca = roteiro.marca || {};
+    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : ['#2E81ED', '#9567DB'];
+    const PRETO = (marca.cores && marca.cores.fundo) || '#07070A';
+    const BRANCO = '#F5F5F7';
+    const DEST = grad[1];
+    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter' };
+    const W = largura, H = altura, deitado = W >= H;
+    const M = Math.round(Math.min(W, H) * 0.08), W0 = W - 2 * M;
+    const base = Math.min(W, H);
+    const cenas = [], trechos = [], efeitos = [], volumes = [];
+    let t = 0, fotoI = 0;
+    /* A foto certa para o texto: "projetos", "construir", "funcionando" pedem
+       a TELA (o dashboard); o resto pede GENTE. Foto de tela em "uma sala, 20
+       cadeiras" era o que "não tem nada a ver" (25/09). */
+    const pool = { pessoas: fotos.filter((f) => f.cat !== 'tela'), tela: fotos.filter((f) => f.cat === 'tela') };
+    const idx = { pessoas: 0, tela: 0 };
+    const foto = (cat = 'pessoas') => {
+        const l = pool[cat] && pool[cat].length ? pool[cat] : (pool.pessoas.length ? pool.pessoas : fotos);
+        const k = pool[cat] && pool[cat].length ? cat : 'pessoas';
+        return l.length ? l[idx[k]++ % l.length] : null;
+    };
+    const catDe = (texto) => (/projet|constru|funcion|dashboard|sistema|ferramenta/i.test(String(texto || '')) ? 'tela' : 'pessoas');
+    const som = (tt, nome, volume = 0.6) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, tt)), src: sons[nome], volume }); };
+    const vol = (tt, v) => volumes.push({ t: r2(tt), v });
+
+    // Os movimentos da foto, em rodízio: nunca parada.
+    const movs = [
+        (d) => ({ escala: [{ t: 0, v: 1.02 }, { t: d, v: 1.16, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.18 }, { t: d, v: 1.06, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.14 }, { t: d, v: 1.14 }], x: [{ t: 0, v: -W * 0.04 }, { t: d, v: W * 0.04, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.14 }, { t: d, v: 1.14 }], x: [{ t: 0, v: W * 0.04 }, { t: d, v: -W * 0.04, e: 'linear' }] }),
+    ];
+    let mov = 0;
+    /* O ENQUADRAMENTO pelas pessoas: com os rostos achados (studio/rostos.py),
+       o recorte centra neles; se eles não cabem no recorte (a foto deitada num
+       quadro em pé perde 2/3 da largura), a foto entra INTEIRA, com ela mesma
+       borrada de fundo. "Aparecem três homens ali, está cortada, não dá pra
+       ver ninguém" (25/09). */
+    const enquadrar = (f) => {
+        const ro = f.rosto;
+        if (!ro || !ro.largura) return { foco: 'center 30%', inteira: false };
+        const aF = W / H, aI = ro.largura / ro.altura;
+        if (aI > aF) {   // a foto é mais larga que o quadro: sobra largura
+            const vis = aF / aI;
+            if (ro.n && ro.x1 - ro.x0 > vis * 0.92) return { inteira: true };
+            const cx = ro.n ? ro.cx : 0.5;
+            const px = vis >= 1 ? 50 : Math.round(Math.max(0, Math.min(1, (cx - vis / 2) / (1 - vis))) * 100);
+            return { foco: `${px}% ${ro.n ? Math.round(Math.min(0.6, ro.cy) * 100) : 35}%`, inteira: false };
+        }
+        const vis = aI / aF;   // mais alta que o quadro: sobra altura
+        const cy = ro.n ? ro.cy : 0.35;
+        const py = vis >= 1 ? 50 : Math.round(Math.max(0, Math.min(1, (cy - vis / 2) / (1 - vis))) * 100);
+        return { foco: `50% ${py}%`, inteira: false };
+    };
+    const pFoto = (els, f, de, ate, { veu = 0.5, entrada = 'corte' } = {}) => {
+        if (!f) return;
+        const d = r2(ate - de), v = f.tipo === 'video';
+        const q = enquadrar(f);
+        const suave = entrada === 'suave' ? { opacidade: [{ t: 0, v: 0 }, { t: 0.4, v: 1 }] } : {};
+        if (q.inteira) {
+            els.push({ tipo: 'imagem', src: f.src, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', de: r2(de), ate: r2(ate),
+                anima: { desfoque: [{ t: 0, v: 36 }], brilho: [{ t: 0, v: 0.5 }], escala: [{ t: 0, v: 1.15 }, { t: d, v: 1.25, e: 'linear' }] } });
+            els.push({ tipo: 'imagem', src: f.src, x: 0, y: Math.round(H * 0.22), largura: '100%', altura: Math.round(H * 0.56), ajuste: 'contain', de: r2(de), ate: r2(ate),
+                anima: { escala: [{ t: 0, v: 1.0 }, { t: d, v: 1.07, e: 'linear' }], ...suave } });
+        } else {
+            els.push({ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: q.foco, de: r2(de), ate: r2(ate),
+                anima: { ...(deitado ? movs[mov++ % movs.length](d) : movs[(mov++ % 2)](d)), ...suave } });
+        }
+        if (veu > 0) els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: r2(de), ate: r2(ate),
+            fundo: { tipo: 'gradiente', cores: [`rgba(7,7,10,${veu * 0.7})`, `rgba(7,7,10,${veu})`, `rgba(7,7,10,${Math.min(0.95, veu + 0.25)})`], angulo: 180 } });
+    };
+    // O texto: entra palavra por palavra no tempo da voz e fica; as palavras marcadas no gradiente.
+    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
+        // Frase longa (a narração na tela) vai em letra normal: em caixa alta ela encolhe e cansa.
+        if (caixa && String(texto).split(/\s+/).length > 7) { caixa = false; peso = Math.min(peso, 700); }
+        // Frase longa ganha linhas (no vertical, até 5), para a letra não encolher.
+        if (String(texto).split(/\s+/).length > 7) linhas = Math.max(linhas, deitado ? 4 : 5);
+        const txt = caixa ? String(texto).toUpperCase() : String(texto);
+        const fit = caber(txt, { largura: larg * 0.86, linhas, max, fonte: F.titulo });
+        const h = fit.tamanho * 1.08 * fit.linhas;
+        const ws = txt.split(/\s+/);
+        /* Centralizado, a linha entra inteira: palavra por palavra, as que ainda
+           não foram ditas ocupam espaço invisível e o começo da frase aparece
+           torto, puxado para a esquerda. Alinhado à esquerda, palavra por palavra. */
+        const rev = ws.map((_, k) => (alinhar === 'center' ? 0 : r2(Math.max(0, (pal[k] != null ? pal[k] : de + 0.08 * k) - de))));
+        const idx = ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0);
+        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.08, espacamento: caixa ? 1 : 0,
+            x: Math.round(x), y: Math.round(y == null ? (H - h) / 2 : y), largura: Math.round(larg), alinhamento: alinhar, de: r2(de), ate: r2(ate),
+            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST } : {}),
+            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
+                // O texto que BATE no fundo: entra grande e assenta de uma vez.
+                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: 0.12, v: 0.97, e: 'saida' }, { t: 0.22, v: 1 }] } : {}) } });
+        return h;
+    };
+    const linhaFina = (els, y, de, larg = W * 0.18) => els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - larg) / 2), y: Math.round(y), largura: Math.round(larg), altura: 2,
+        fundo: { tipo: 'gradiente', cores: [grad[0], grad[1]], angulo: 90 }, origem: 'center', de: r2(de), anima: { escalaX: [{ t: 0, v: 0 }, { t: 0.8, v: 1, e: 'saida' }] } });
+    const pontos = (els, de) => { for (let k = 0; k < 3; k++) els.push({ tipo: 'forma', forma: 'circulo', largura: 6, altura: 6, cor: k === 1 ? DEST : 'rgba(255,255,255,0.4)', x: Math.round(W / 2 - 18 + k * 15), y: Math.round(H - M * 1.2), de: r2(de), anima: { opacidade: [{ t: 0.2 * k, v: 0 }, { t: 0.2 * k + 0.3, v: 1 }] } }); };
+
+    let narrI = 0;
+    partes.forEach((p, i) => {
+        const els = [];
+        const cena = { fundo: { tipo: 'cor', valor: PRETO }, elementos: els, transicao: { tipo: 'corte', duracao: 0 } };
+        // A parte de voz forte tem a voz dela (fortes[i]); a narração principal não a inclui.
+        const narrada = p.tipo !== 'depoimento' && falaDe(p) !== '' && !(p.falaForte && fortes[i]);
+        const tp = narrada ? (tempos[narrI++] || null) : null;
+        const off = 0.2;                                          // a voz entra um instante depois do corte
+        const falaDur = fortes[i] ? fortes[i].segundos + 0.3 : (tp ? (tempos[narrI] ? tempos[narrI].de : tp.ate + 0.8) - tp.de : 0);
+        const rel = (w) => r2(off + w - (tp ? tp.de : 0));        // tempo da voz → tempo da cena
+        const pals = tp ? tp.palavras || [] : [];
+        let dur;
+
+        /* O fim da fala: a transcrição marca o fim da última palavra um pouco
+           antes do fim de verdade, e cortar ali comia a última sílaba ("parece
+           que a narração não terminou", 25/09). O trecho vai até perto do
+           começo da próxima fala, com folga. */
+        const proxFala = tempos[narrI] ? tempos[narrI].de : null;
+        // Até o começo da próxima fala, sem teto: o áudio é contínuo, e cortar antes comia sílaba.
+        const forte = fortes[i];
+        const fimFala = tp ? r2(proxFala != null ? proxFala - 0.02 : tp.ate + 0.8) : 0;
+        if (tp && narracao && !forte && !p.mudo) trechos.push({ src: narracao, t: r2(t + off), de: r2(tp.de), ate: fimFala, volume: 1 });
+        if (forte) trechos.push({ src: forte.src, t: r2(t + (p.tipo === 'climax' ? 0 : off)), de: 0, ate: r2(forte.segundos + 0.3), volume: 1 });
+
+        const textosDaParte = p.tipo === 'escada' ? [...(p.itens || []), p.final].filter(Boolean)
+            : p.tipo === 'numeros' ? [p.antes, ...(p.itens || [])].filter(Boolean)
+                : p.tipo === 'dia' ? [p.num, p.titulo, ...(p.linhas || [])].filter(Boolean)
+                    : (p.linhas || []);
+        const somaLeitura = textosDaParte.reduce((n, x) => n + leitura(x), 0);
+        // A cena dura a fala (com um respiro) — e nunca menos que o tempo de ler.
+        dur = r2(Math.max(falaDur + off + 0.2, somaLeitura * 0.7, 1.8));
+        const inicios = quando(textosDaParte, pals.map((w) => ({ ...w, de: rel(w.de) })), dur, off);
+        /* Cada texto garante o SEU tempo de leitura e empurra o seguinte: sincronia
+           com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
+           a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
+        // Texto curto (um número, "3 DIAS.") se lê de relance: não espera a leitura cheia e não atrasa a voz.
+        const minimo = (x) => Math.min(leitura(x), String(x).split(/\s+/).length <= 3 ? 0.75 : 1.6);
+        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + minimo(textosDaParte[k - 1])));
+        if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
+        const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);
+        const palDo = (txt) => { const ws = String(txt).split(/\s+/); const a = pals.findIndex((w) => tokens(w.texto)[0] === tokens(ws[0])[0]); return a < 0 ? [] : ws.map((_, k) => (pals[a + k] ? rel(pals[a + k].de) : null)); };
+
+        if (p.tipo === 'frase') {
+            if (i === 0) { som(t + 0.1, 'teclado', 0.5); vol(t, 0.12); }
+            linhaFina(els, H * 0.5 - base * 0.12, 0.2);
+            textosDaParte.forEach((x, k) => pTexto(els, x, inicios[k], fimDe(k), { caixa: false, peso: 600, max: deitado ? H * 0.1 : W * 0.12, linhas: deitado ? 3 : 4, marcar: p.marcar || [], pal: palDo(x) }));
+        } else if (p.tipo === 'montagem' || p.tipo === 'climax') {
+            const rap = p.tipo === 'climax' ? 0.38 : (p.ritmo || 0.75);
+            let fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
+            const fz = p.tipo === 'climax' ? fortes[i] : null;
+            if (fz) {
+                /* A voz forte entra DEPOIS da montagem, junto com o texto que bate. */
+                fimFotos = 1.4;
+                const ini2 = quando(textosDaParte, (fz.palavras || []).map((w) => ({ ...w, de: w.de + fimFotos })), fz.segundos, fimFotos);
+                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + 1.2); });
+                dur = r2(Math.max(fimFotos + fz.segundos + 0.5, inicios[inicios.length - 1] + 1.6));
+                const tr = trechos[trechos.length - 1];
+                if (tr && tr.src === fz.src) tr.t = r2(t + fimFotos - 0.05);
+            }
+            for (let a = 0; a < fimFotos; a += rap) {
+                // A foto do momento acompanha o texto que está na tela.
+                let ativo = textosDaParte[0];
+                textosDaParte.forEach((x, k) => { if (a >= inicios[k] - 0.1) ativo = x; });
+                pFoto(els, foto(catDe(ativo)), a, Math.min(fimFotos, a + rap), { veu: p.tipo === 'climax' ? 0.15 : 0.5 });
+            }
+            if (p.tipo === 'climax') {
+                /* A virada: a música só ABAIXA (fica perceptível), e o texto bate
+                   no fundo com um impacto forte — "quero um som de impacto bem
+                   forte, do texto batendo no fundo" (25/09). */
+                vol(t, 0.5); vol(t + fimFotos - 0.3, 0.75); vol(t + fimFotos, 0.16); vol(t + dur - 0.2, 0.2);
+                som(t + fimFotos + 0.02, 'estalo', 0.8);
+                cena.tremor = [{ de: fimFotos, ate: fimFotos + 0.45, forca: 16 }];
+                cena.socos = [{ t: fimFotos, forca: 0.12 }];
+            } else { vol(t, 0.28); som(t, 'whoosh', 0.35); }
+            textosDaParte.forEach((x, k) => {
+                if (p.tipo === 'climax') { som(t + inicios[k], 'impacto', k === 0 ? 1.0 : 0.85); if (k > 0) cena.tremor = [...(cena.tremor || []), { de: inicios[k], ate: inicios[k] + 0.4, forca: 14 }]; }
+                pTexto(els, x, Math.max(inicios[k], p.tipo === 'climax' ? fimFotos : 0), fimDe(k), { peso: 800, marcar: p.marcar || [], pal: palDo(x), bater: p.tipo === 'climax',
+                    // A virada é o texto maior do vídeo.
+                    ...(p.tipo === 'climax' ? { max: deitado ? H * 0.13 : W * 0.17, linhas: deitado ? 3 : 5 } : {}) });
+            });
+        } else if (p.tipo === 'numeros') {
+            vol(t, 0.3);
+            for (let a = 0; a < dur; a += 1.2) pFoto(els, foto(), a, Math.min(dur, a + 1.2), { veu: 0.45 });
+            textosDaParte.forEach((x, k) => {
+                const m = String(x).match(/^(\d+)\s+(.*)$/);
+                if (k === 0 && p.antes) { pTexto(els, x, inicios[k], fimDe(k), { max: base * 0.08, peso: 700, pal: palDo(x) }); return; }
+                if (!m) { pTexto(els, x, inicios[k], fimDe(k), { pal: palDo(x) }); return; }
+                const tam = Math.round(deitado ? H * 0.24 : W * 0.3);
+                els.push({ tipo: 'texto', texto: m[1], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
+                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1]), dur: 0.45 }, gradienteTexto: undefined,
+                    anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.25, v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: 0.6, v: 1, e: 'saida' }] } });
+                pTexto(els, m[2], inicios[k] + 0.1, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
+            });
+        } else if (p.tipo === 'escada') {
+            vol(t, 0.22);
+            if (sons.sala) trechos.push({ src: sons.sala, t: r2(t), de: 0, ate: dur, volume: 0.25 });
+            // As fotos passam devagar numa janela, à direita (ou em cima, no vertical).
+            // No vertical a janela desce da zona do topo do Instagram e fica maior.
+            const jan = deitado ? { x: W * 0.56, y: M, l: W * 0.44 - M, a: H - 2 * M } : { x: M, y: H * 0.1, l: W0, a: H * 0.42 };
+            const itens = p.itens || [];
+            const hItem = Math.round(deitado ? H * 0.1 : W * 0.12);
+            const fimItens = p.final ? inicios[itens.length] : dur;
+            for (let a = 0; a < fimItens; a += 1.3) {
+                const f = foto();
+                if (f) els.push({ tipo: f.tipo === 'video' ? 'video' : 'imagem', src: f.src, ...(f.tipo === 'video' ? { volume: 0 } : {}), x: Math.round(jan.x), y: Math.round(jan.y), largura: Math.round(jan.l), altura: Math.round(jan.a), ajuste: 'cover', foco: 'center 30%', raio: 18, de: r2(a), ate: r2(Math.min(fimItens, a + 1.3)),
+                    anima: { ...movs[mov++ % movs.length](1.3), opacidade: [{ t: 0, v: 0 }, { t: 0.3, v: 1 }] } });
+            }
+            itens.forEach((x, k) => {
+                const yy = deitado ? H * 0.5 - (itens.length * hItem * 1.25) / 2 + k * hItem * 1.25 : H * 0.56 + k * hItem * 1.25;
+                pTexto(els, x, inicios[k], fimItens, { y: yy, max: hItem, linhas: 1, alinhar: 'left', larg: deitado ? W * 0.48 : W0, peso: 800, pal: palDo(x) });
+            });
+            if (p.final) pTexto(els, p.final, fimItens, dur, { marcar: p.marcar || [], pal: palDo(p.final) });
+        } else if (p.tipo === 'dia') {
+            vol(t, 0.32);
+            pFoto(els, foto(), 0, dur, { veu: 0.66, entrada: 'suave' });
+            som(t, 'whoosh', 0.3);
+            const tamN = Math.round(deitado ? H * 0.34 : W * 0.42);
+            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: 'rgba(149,103,219,0.12)', contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
+                x: M, y: Math.round(deitado ? H * 0.12 : H * 0.14), largura: W0, alinhamento: deitado ? 'left' : 'center',
+                anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.6, v: 1 }], x: [{ t: 0, v: -20 }, { t: dur, v: 20, e: 'linear' }] } });
+            const yT = deitado ? H * 0.5 : H * 0.42;
+            const hT = pTexto(els, p.titulo, inicios[1] || 0.4, dur, { y: yT, max: deitado ? H * 0.11 : W * 0.13, linhas: 1, alinhar: deitado ? 'left' : 'center', larg: W0, peso: 800, pal: palDo(p.titulo) });
+            // Frase longa (a narração) troca no mesmo lugar, em várias linhas; frase curta empilha.
+            const longas = (p.linhas || []).some((x) => String(x).split(/\s+/).length > 5);
+            if (longas) (p.linhas || []).forEach((x, k) => pTexto(els, x, inicios[2 + k] || 0.8 + k * 0.6, k < p.linhas.length - 1 ? (inicios[3 + k] || dur) : dur,
+                { y: yT + hT + H * 0.03, max: base * (deitado ? 0.06 : 0.075), linhas: 4, caixa: false, peso: 600, cor: 'rgba(245,245,247,0.92)', alinhar: deitado ? 'left' : 'center', larg: W0, pal: palDo(x) }));
+            else (p.linhas || []).forEach((x, k) => pTexto(els, x, inicios[2 + k] || 0.8 + k * 0.6, dur, { y: yT + hT + H * 0.03 + k * base * (deitado ? 0.085 : 0.1), max: base * (deitado ? 0.06 : 0.07), linhas: 1, caixa: false, peso: 500, cor: 'rgba(245,245,247,0.8)',
+                alinhar: deitado ? 'left' : 'center', larg: W0, pal: palDo(x) }));
+        } else if (p.tipo === 'depoimento') {
+            /* O aluno falando, com a voz dele; a música quase some. CADA depoimento
+               é uma cena: o vídeo conta o tempo do início da cena, e com os três
+               na mesma cena o segundo e o terceiro já tinham passado do fim (preto). */
+            vol(t, 0.035);
+            const clipes = p.clipes || [];
+            clipes.forEach((c, n) => {
+                const d = r2(c.ate - c.de + 0.3);
+                // Entre um depoimento e outro, esmaecer: o corte seco pegava o "é…" de quem começa.
+                const ce = { fundo: { tipo: 'cor', valor: PRETO }, elementos: [], transicao: { tipo: 'esmaecer', duracao: 0.4 }, duracao: d };
+                const el2 = ce.elementos;
+                if (deitado) {
+                    const wV = Math.round(H * 0.88 * 9 / 16), xV = Math.round(W * 0.08), xT = xV + wV + Math.round(W * 0.05);
+                    el2.push({ tipo: 'video', src: c.src, volume: 0, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { desfoque: [{ t: 0, v: 40 }], brilho: [{ t: 0, v: 0.4 }] } });
+                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: xV, y: Math.round(H * 0.06), largura: wV, altura: Math.round(H * 0.88), ajuste: 'cover', raio: 20, anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.2, v: 1 }] } });
+                    pTexto(el2, `“${c.frase}”`, 0.3, d, { x: xT, larg: W - xT - M, alinhar: 'left', caixa: false, peso: 600, max: H * 0.075, linhas: 5 });
+                    if (c.nome) el2.push({ tipo: 'texto', texto: c.nome.toUpperCase(), fonte: F.texto, peso: 700, tamanho: Math.round(H * 0.03), cor: DEST, espacamento: 3, x: xT, y: Math.round(H * 0.8), de: 0.5 });
+                } else {
+                    /* O vídeo do aluno vem com a legenda gravada embaixo (~73% da
+                       altura): aproximado pelo topo, ela sai do quadro e fica só a
+                       nossa frase — antes eram dois textos um sobre o outro. */
+                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center top',
+                        origem: 'center top', anima: { escala: [{ t: 0, v: 1.42 }, { t: d, v: 1.48, e: 'linear' }] } });
+                    el2.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(7,7,10,0)', 'rgba(7,7,10,0.35)', 'rgba(7,7,10,0.9)'], angulo: 180 } });
+                    // Tudo acima de 75% da altura: embaixo disso o Instagram põe a legenda e os botões.
+                    pTexto(el2, `“${c.frase}”`, 0.3, d, { y: H * 0.54, caixa: false, peso: 600, max: W * 0.08, linhas: 4 });
+                    if (c.nome) el2.push({ tipo: 'texto', texto: c.nome.toUpperCase(), fonte: F.texto, peso: 700, tamanho: Math.round(W * 0.035), cor: DEST, espacamento: 3, x: M, y: Math.round(H * 0.72), largura: W0, alinhamento: 'center', de: 0.5 });
+                }
+                if (n < clipes.length - 1) { cenas.push(ce); t += d; } else { Object.assign(cena, ce); dur = d; }
+            });
+            if (!clipes.length) dur = 1;
+        } else if (p.tipo === 'final') {
+            // A marca, enfim: a logo aparece devagar, as linhas em sequência, a logo some.
+            vol(t, 0.55); vol(t + dur - 1.8, 0.45); vol(t + dur, 0);
+            som(t + 0.05, 'impacto', 0.55);
+            const R = Math.round(Math.max(W, H) * 0.7);
+            els.push({ tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(W / 2 - R / 2), y: Math.round(H * 0.42 - R / 2), cor: grad[1], opacidade: 0.18, anima: { desfoque: [{ t: 0, v: Math.round(R * 0.25) }], escala: [{ t: 0, v: 0.8 }, { t: dur, v: 1.15, e: 'suave' }] } });
+            if (marca.logo) {
+                const lh = Math.round(base * (deitado ? 0.13 : 0.16));
+                els.push({ tipo: 'imagem', src: marca.logo, x: Math.round(W / 2 - lh * 1.75), y: Math.round(H * (deitado ? 0.2 : 0.3)), largura: Math.round(lh * 3.5), altura: lh, ajuste: 'contain',
+                    anima: { opacidade: [{ t: 0, v: 0 }, { t: 1.0, v: 1 }, { t: dur - 1.2, v: 1 }, { t: dur, v: 0 }], escala: [{ t: 0, v: 0.94 }, { t: dur, v: 1.02, e: 'linear' }] } });
+            }
+            const y0 = H * (deitado ? 0.44 : 0.42);
+            textosDaParte.forEach((x, k) => pTexto(els, x, inicios[k], k < textosDaParte.length - 1 ? fimDe(k) : dur, { y: y0 + (k % 2) * 0, max: k === textosDaParte.length - 1 ? base * (deitado ? 0.1 : 0.12) : base * (deitado ? 0.08 : 0.1), peso: k === textosDaParte.length - 1 ? 800 : 600,
+                marcar: p.marcar || [], cor: k === textosDaParte.length - 1 ? DEST : BRANCO, pal: palDo(x) }));
+            pontos(els, 0.3);
+            cena.transicao = { tipo: 'esmaecer', duracao: 0.6 };
+        }
+
+        // Entre as partes, um esmaecer curto: corte seco em tudo parecia fala interrompida.
+        if (i > 0 && cena.transicao.tipo === 'corte' && !['montagem', 'climax'].includes(p.tipo)) cena.transicao = { tipo: 'esmaecer', duracao: 0.35 };
+        cena.duracao = dur;
+        cenas.push(cena);
+        t += dur;
+    });
+
+    // Os cruzamentos são da cena que entra: a anterior fica no ar até ela entrar.
+    let acum = 0;
+    cenas.forEach((c, k) => {
+        const prox = cenas[k + 1];
+        c.duracao = r2(c.duracao + (prox && prox.transicao.tipo !== 'corte' ? prox.transicao.duracao : 0));
+        acum += c.duracao;
+    });
+    volumes.sort((a, b) => a.t - b.t);
+    return {
+        ok: true,
+        plano: {
+            formato: { largura: W, altura: H, fps: 30 }, fundoGeral: PRETO, cenas,
+            audio: { ...(trilha ? { trilha: { src: trilha, volumes: volumes.length ? volumes : [{ t: 0, v: 0.3 }], loop: true } } : {}), trechos, efeitos },
+            acabamento: { grao: 0.05, vinheta: 0.5, grade: 0.035, passoGrade: Math.round(base / 9) },
+        },
+        resumo: { cenas: cenas.length, estilo: 'cinema', segundos: r2(t) },
+    };
+}
+
+module.exports = { montarCinema, falaDe, paraFala, quando, leitura };