primocode 9.9.0 → 10.0.0

package/lib/estudio/lancamento.js

@@ -0,0 +1,413 @@
+/**
+ * lancamento.js — os estilos "marca" (brand reveal) e "lancamento" (filme de
+ * lançamento de produto).
+ *
+ *   O repertório dos vídeos de referência que o Joel mandou (29/09/2026): o
+ *   brilho no escuro que vira a marca, as letras desenhadas em vetor com as
+ *   âncoras e o cursor, a marca chapada na cor, o padrão ladrilhado, a
+ *   mancha líquida, a marca cromada, os cartões de cor em 3D; o HUD de motion
+ *   designer; os cartões flutuando, o número gigante, o cartão do produto com
+ *   o marca-texto e as barras, o calendário e o mural que se afasta.
+ *
+ * Uma parte pode virar DUAS cenas (a logo: o vetor e depois a marca chapada;
+ * a chamada: o padrão e depois o fecho). O corte cai no beat; as cenas que
+ * pedem ("cta") entram pela mancha líquida. As peças são do kit
+ * (kit/marca.jsx); aqui só se decide o quê, onde e quando.
+ *
+ * Tipos de parte: abertura, logo, titulo, numero, lista, passos, contraste,
+ * citacao, imagem, grafico, cores, produto, cta. Qualquer parte pode pedir
+ * a peça que a conduz com "visual": orbe, vetor, estrela, esfera, grade,
+ * site, padrao, cromo, cartoes, painel, cores.
+ *
+ * Puro: roteiro, tempos da voz, glifos da fonte (glifos.js) e arquivos
+ * entram; o plano sai.
+ */
+
+'use strict';
+
+const { caber } = require('./composicao.js');
+const { misturarCor, ehCor } = require('./morfar.js');
+const { tempoDasPartes, gatilhos, volumesDaTrilha, r2 } = require('./ritmo.js');
+const { tese, termoDef } = require('./vox.js');
+
+const FPS = 30;
+const k = (t, v, e) => (e ? { t: r2(t), v, e } : { t: r2(t), v });
+const luz = (hex) => {
+    const h = String(hex || '').replace('#', '');
+    const n = h.length === 3 ? h.split('').map((c) => c + c).join('') : h.slice(0, 6);
+    const [r, g, b] = [0, 2, 4].map((i) => parseInt(n.slice(i, i + 2), 16) || 0);
+    return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+};
+const sobre = (c) => (luz(c) > 0.6 ? '#111114' : '#ffffff');
+const itensDe = (p) => (p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+const VISUAIS = ['orbe', 'vetor', 'estrela', 'esfera', 'grade', 'site', 'padrao', 'cromo', 'cartoes', 'painel', 'cores'];
+
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca: {nome, cores, fontes, logo}, partes: [...] }
+ * @param {string} op.variante  'marca' | 'lancamento'
+ * @param {object} op.glifos    { d, pontos, caixa } do nome da marca (glifos.js), para o vetor
+ * @param {object} op.imagens   { indiceDaParte: {src, tipo} }
+ */
+function montarLancamento({ roteiro, variante = 'lancamento', largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, imagens = {}, glifos = null }) {
+    const partes = (roteiro && roteiro.partes) || [];
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const ehMarca = variante === 'marca';
+    const W = largura, H = altura, deitado = W >= H;
+    const b = Math.min(W, H) / 1080;
+    const M = Math.round(Math.min(W, H) * 0.08);
+    const TOPO = Math.round(M * 1.45);        // abaixo do HUD: o rótulo dele mora na banda de cima
+
+    // ── a marca ────────────────────────────────────────────────────────
+    const marca = roteiro.marca || {};
+    const cores = marca.cores || {};
+    const ACENTO = ehCor(cores.destaque) ? cores.destaque : (ehMarca ? '#1f3cff' : '#ff5a1f');
+    const ESCURO = ehCor(cores.fundo) && luz(cores.fundo) < 0.2 ? cores.fundo : '#09090c';
+    const CLARO = '#f1f1ef';
+    const nome = marca.nome || (partes.find((p) => p.tipo === 'abertura' || p.tipo === 'logo') || {}).titulo || 'marca';
+    const F = {
+        display: (marca.fontes && marca.fontes.titulo) || (ehMarca ? 'Plus Jakarta Sans' : 'Inter Tight'),
+        texto: (marca.fontes && marca.fontes.texto) || 'Inter',
+        mono: 'JetBrains Mono',
+    };
+    const logo = marca.logo || null;
+    const base = { fonte: F.display, fonteMono: F.mono, corAcento: ACENTO };
+
+    // ── o tempo ────────────────────────────────────────────────────────
+    const leitura = (p) => 1.8 + 0.28 * String([p.titulo, p.sub, p.valor, p.rotulo, p.nao, p.sim, p.texto, ...itensDe(p)].filter(Boolean).join(' ')).split(/\s+/).length;
+    const { ini, dur, total, temVoz } = tempoDasPartes(partes, tempos, { semVoz: leitura, minimo: 1.4 });
+    const efeitos = [];
+    const som = (t, nome_, volume) => { if (sons[nome_]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome_], volume }); };
+
+    // ── ferramentas de cena ────────────────────────────────────────────
+    const fundoClaro = { tipo: 'gradiente', radial: true, centro: '50% 40%', cores: ['#fbfbfa', '#e6e6e3'] };
+    const fundoEscuro = { tipo: 'gradiente', radial: true, centro: '50% 30%', cores: [misturarCor(ESCURO, '#ffffff', 0.08), ESCURO] };
+    const fundoEstudio = { tipo: 'gradiente', angulo: 180, cores: [misturarCor(ESCURO, '#ffffff', 0.22), misturarCor(ESCURO, '#ffffff', 0.05), ESCURO] };
+    const fundoAcento = { tipo: 'gradiente', radial: true, centro: '50% 45%', cores: [misturarCor(ACENTO, '#ffffff', 0.12), ACENTO, misturarCor(ACENTO, '#000000', 0.12)] };
+    const push = (d, z = 1.06) => ({ zoom: [k(0, 1), k(Math.max(0.3, d - 0.25), z, 'camera'), k(d, z + 0.025, 'acelera')] });
+    const cena = (d, fundo, escuro, elementos, { zoom = 1.05, ...extra } = {}) => ({ duracao: r2(d), fundo, escuro, camera: push(d, zoom), elementos, ...extra });
+    const fit = (t, larg, linhas, max, min = 36) => caber(t, { largura: larg, linhas, max: max * b, min: min * b, fonte: F.display });
+    const alturaDe = (f) => f.linhas * f.tamanho * 1.0;
+    const palavrasT = (texto, tp, t0, d, op) => gatilhos(String(texto).split(/\s+/).filter(Boolean), tp, t0, d, op);
+    const partir = (d, k1) => [r2(d * k1), r2(d - d * k1)];
+    const brilhoSom = (t) => som(t, 'brilho', 0.28);
+
+    /* O cartão de enfeite: interface genérica, sem texto inventado. É a
+       "multidão" de posts do filme de lançamento, e não diz nada falso. */
+    const enfeites = (n, semente = 0) => Array.from({ length: n }).map((_, j) => ({ titulo: nome, rotulo: ['agora', '2 min', 'ontem', '1 h'][(j + semente) % 4] }));
+
+    // ── cada tipo de parte vira uma (ou duas) cenas ────────────────────
+    const CENAS = {
+        abertura(p, d, tp, t0) {
+            const titulo = p.titulo || nome;
+            const els = [
+                { tipo: 'kit', peca: 'orbe', x: W / 2, y: r2(H * 0.46), tamanho: r2(240 * b), cor: ehMarca ? '#5fd6c8' : ACENTO, corMarca: ehMarca ? '#dffcff' : ACENTO,
+                    t: 0.05, tMarca: r2(Math.min(1.1, d * 0.4)), logo, particulas: ehMarca ? 30 : 56 },
+            ];
+            const tt = Math.min(d - 0.9, Math.max(1.4, gatilhos([titulo], tp, t0, d)[0]));
+            els.push({ tipo: 'kit', peca: 'manchete', modo: 'digitar', texto: titulo, x: W / 2, y: r2(H * 0.46 + 190 * b), largura: W - 2 * M, alinhamento: 'center',
+                tamanho: r2(fit(titulo, W * 0.6, 1, 64).tamanho), peso: 700, cor: '#f4f4f6', t: tt, ...base, fonte: F.display });
+            if (p.sub) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.sub, x: W / 2, y: r2(H * 0.46 + 280 * b), largura: W - 2 * M, alinhamento: 'center',
+                tamanho: r2(30 * b), peso: 500, cor: '#9a9ca6', t: Math.min(d - 0.6, tt + 0.6), passo: 2, fonte: F.texto });
+            brilhoSom(t0 + Math.min(1.1, d * 0.4));
+            return [cena(d, ehMarca ? { tipo: 'gradiente', angulo: 100, cores: ['#1c5f64', '#06080c', '#06080c', '#233a8a'] } : fundoEscuro, true, els, { zoom: 1.08 })];
+        },
+
+        logo(p, d, tp, t0) {
+            const [d1, d2] = partir(d, 0.58);
+            const palavra = p.titulo || nome;
+            const altura = r2(Math.min(H * 0.6, (W * 1.5) / Math.max(3, palavra.length * 0.6)));
+            const a = cena(d1, '#050506', true, [
+                { tipo: 'kit', peca: 'vetor', glifos: glifos || undefined, texto: palavra, fonte: F.display, x: W / 2, y: r2(H * 0.52), altura, t: 0.05, durTraco: Math.min(1.3, d1 * 0.55),
+                    pan: { de: r2(W * 0.22), ate: r2(-W * 0.22), dur: d1 } },
+            ], { camera: { zoom: [k(0, 1.18), k(d1, 1.0, 'camera')] } });
+            const tam = fit(palavra, W * 0.4, 1, 120).tamanho;
+            const icone = r2(tam * 1.05);
+            const larg = palavra.length * tam * 0.56 + icone + 30 * b;
+            const b2 = cena(d2, ACENTO, luz(ACENTO) < 0.6, [
+                { tipo: 'kit', peca: 'cromo', modo: 'solido', tom: sobre(ACENTO), logo, reflexo: false, giro: 0, x: r2(W / 2 - larg / 2 + icone / 2), y: r2(H / 2), tamanho: icone, t: 0 },
+                { tipo: 'kit', peca: 'manchete', modo: 'digitar', texto: palavra.toLowerCase(), x: r2(W / 2 - larg / 2 + icone + 30 * b), y: r2(H / 2), ancora: 'meio', tamanho: tam, peso: 700,
+                    cor: sobre(ACENTO), t: 0.25, ...base, espacamento: '-0.03em' },
+            ], { zoom: 1.04 });
+            som(t0 + d1, 'toque', 0.35);
+            return [a, b2];
+        },
+
+        titulo(p, d, tp, t0) {
+            const titulo = p.titulo || '';
+            const curto = titulo.length <= 12;
+            const f = fit(curto ? titulo.toUpperCase() : titulo, W - 2 * M, curto ? 1 : 3, curto ? 300 : 150, 44);
+            const ts = palavrasT(titulo, tp, t0, d);
+            if (!ehMarca && !curto) {
+                // O campo de cartões flutuando, e a pergunta entrando palavra a palavra por cima.
+                return [cena(d, fundoAcento, true, [
+                    { tipo: 'kit', peca: 'cartoes', modo: 'voo', cartoes: enfeites(12, 1), x: 0, y: 0, largura: W, altura: H, larguraCartao: r2((deitado ? 330 : 420) * b), t: 0, ...base, corAcento: ACENTO },
+                    { tipo: 'forma', forma: 'circulo', x: r2(W / 2), y: r2(H / 2), largura: r2(W * 0.9), altura: r2(W * 0.5), ancora: 'centro', cor: ACENTO, opacidade: 0.55, anima: { desfoque: [k(0, 90)] } },
+                    { tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: titulo, destaque: '', x: W / 2, y: r2(H / 2 - alturaDe(f) / 2), largura: W - 2 * M, alinhamento: 'center',
+                        tamanho: f.tamanho, peso: 800, cor: '#ffffff', tempos: ts, ...base },
+                ], { perspectiva: 1400, zoom: 1.07 })];
+            }
+            const els = [{ tipo: 'kit', peca: 'manchete', modo: curto ? 'carimbo' : 'subir', texto: curto ? titulo.toUpperCase() : titulo, destaque: curto ? '' : tese(titulo, p.destaque),
+                x: W / 2, y: r2(H / 2 - alturaDe(f) / 2), largura: W - 2 * M, alinhamento: 'center', tamanho: f.tamanho, peso: 900, cor: '#111114', tempos: ts,
+                corAcento: '#ffffff', fonte: F.display, espacamento: curto ? '-0.02em' : '-0.035em',
+                saida: curto && d > 1.6 ? { t: r2(d - 0.55), modo: 'pontos' } : undefined }];
+            if (p.sub) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.sub, x: W / 2, y: r2(H / 2 + alturaDe(f) / 2 + 30 * b), largura: W - 2 * M, alinhamento: 'center',
+                tamanho: r2(34 * b), peso: 500, cor: '#111114', t: Math.min(d - 0.7, ts[ts.length - 1] + 0.3), passo: 2, fonte: F.texto });
+            som(t0 + ts[0], 'toque', 0.35);
+            return [cena(d, ehMarca ? ACENTO : fundoAcento, true, els, { zoom: 1.08 })];
+        },
+
+        numero(p, d, tp, t0) {
+            const v = String(p.valor || p.titulo || '');
+            const m = v.match(/^(\D*)([\d.,]+)(.*)$/);
+            const n = m ? Number(m[2].replace(/\./g, '').replace(',', '.')) : null;
+            const rot = p.rotulo || (p.valor ? p.titulo : '') || '';
+            const xL = deitado ? M * 1.4 : M;
+            const tamN = fit(v, deitado ? W * 0.36 : W - 2 * M, 1, 300).tamanho;
+            const tamR = fit(rot, deitado ? W * 0.42 : W - 2 * M, 2, 76).tamanho;
+            const yN = deitado ? H * 0.28 : H * 0.2;
+            const [tv, tr] = gatilhos([v, rot || v], tp, t0, d);
+            const els = [
+                { tipo: 'kit', peca: 'fonte', texto: (p.secao || p.tipo).toUpperCase(), x: r2(xL), y: r2(yN - 60 * b), t: 0.05, tamanho: r2(18 * b), fonteMono: F.mono, corAcento: ACENTO, cor: ACENTO },
+                { tipo: 'kit', peca: 'manchete', texto: v, ...(n != null ? { contar: { ate: n, antes: m[1], depois: m[3], casas: /,\d/.test(m[2]) ? 1 : 0, dur: 0.9 } } : { modo: 'carimbo' }),
+                    x: r2(xL), y: r2(yN), tamanho: tamN, peso: 900, cor: '#111114', t: tv, ...base },
+            ];
+            if (rot) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: rot, x: r2(xL), y: r2(yN + tamN * 0.98), largura: r2(deitado ? W * 0.44 : W - 2 * M), tamanho: tamR, peso: 800,
+                cor: '#111114', t: tr, passo: 4, ...base });
+            if (p.sub) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.sub, destaque: tese(p.sub), x: r2(xL), y: r2(yN + tamN * 0.98 + alturaDe({ linhas: Math.min(2, Math.ceil(rot.length * tamR * 0.56 / (W * 0.44))), tamanho: tamR }) + 26 * b),
+                largura: r2(W * 0.5), tamanho: r2(34 * b), peso: 600, cor: '#8a8c94', corAcento: ACENTO, t: Math.min(d - 0.6, tr + 0.5), passo: 3, fonte: F.texto });
+            // A pilha de cartões: ao lado do número no deitado, embaixo dele em pé.
+            const area = deitado ? { x: W * 0.52, y: H * 0.12, w: W * 0.44, h: H * 0.6 } : { x: M, y: H * 0.52, w: W - 2 * M, h: H * 0.36 };
+            els.push({ tipo: 'kit', peca: 'cartoes', modo: 'voo', x: r2(area.x), y: r2(area.y), largura: r2(area.w), altura: r2(area.h), larguraCartao: r2((deitado ? 380 : 520) * b), t: tv + 0.1,
+                cartoes: enfeites(Math.min(6, Math.max(3, Math.round(n || 4))), 2).map((c, j) => ({ ...c, x: r2(area.w / 2 + (j % 2 ? 60 : -40) * b), y: r2(j * 70 * b) })), ...base, fonte: F.texto });
+            som(t0 + tv, 'brilho', 0.25);
+            return [cena(d, fundoClaro, false, els)];
+        },
+
+        lista(p, d, tp, t0) {
+            if (!ehMarca) return CENAS.passos(p, d, tp, t0);
+            const itens = itensDe(p).slice(0, 6);
+            const titulo = p.titulo || '';
+            const ts = gatilhos(itens, tp, t0, d, { t0: 0.5 });
+            const w = r2((deitado ? 440 : 520) * b);
+            const lugares = deitado
+                ? [[0.2, 0.2], [0.8, 0.18], [0.16, 0.66], [0.84, 0.62], [0.5, 0.78], [0.62, 0.08]]
+                : [[0.5, 0.12], [0.3, 0.3], [0.7, 0.62], [0.32, 0.72], [0.66, 0.86], [0.5, 0.95]];
+            const cartoes = itens.map((it, j) => ({ titulo: nome, texto: it, rotulo: String(j + 1).padStart(2, '0'), x: r2(W * lugares[j][0]), y: r2(H * lugares[j][1] - 60 * b), t: ts[j], destaque: j === itens.length - 1 }));
+            const f = fit(titulo, W * 0.5, 2, 110);
+            return [cena(d, fundoEscuro, true, [
+                { tipo: 'kit', peca: 'cartoes', modo: 'voo', cartoes, x: 0, y: 0, largura: W, altura: H, larguraCartao: w, t: 0, ...base, fonte: F.texto },
+                { tipo: 'kit', peca: 'manchete', modo: 'subir', texto: titulo, destaque: tese(titulo, p.destaque), x: W / 2, y: r2(H / 2 - alturaDe(f) / 2), largura: W * 0.52, alinhamento: 'center',
+                    tamanho: f.tamanho, peso: 800, cor: '#ffffff', t: 0.1, passo: 3, ...base },
+            ], { perspectiva: 1400 })];
+        },
+
+        passos(p, d, tp, t0) {
+            const itens = itensDe(p).slice(0, deitado ? 5 : 3);
+            const titulo = p.titulo || '';
+            const ts = gatilhos(itens.map((x) => termoDef(x).def || x), tp, t0, d, { t0: 0.6 });
+            const colunas = itens.map((x, j) => {
+                const td = termoDef(x);
+                return { rotulo: td.def ? td.termo : 'passo', titulo: td.def || td.termo, numero: j + 1, itens: [], t: ts[j] };
+            });
+            const f = fit(titulo, W - 2 * M, 1, 96);
+            const yC = r2(TOPO + f.tamanho * 1.4 + 30 * b);
+            return [cena(d, fundoClaro, false, [
+                { tipo: 'kit', peca: 'fonte', texto: (p.secao || 'semana').toUpperCase(), x: M, y: r2(TOPO - 38 * b), t: 0.05, tamanho: r2(18 * b), fonteMono: F.mono, corAcento: ACENTO, cor: ACENTO },
+                { tipo: 'kit', peca: 'manchete', modo: 'subir', texto: titulo, destaque: tese(titulo, p.destaque), x: M, y: r2(TOPO), largura: W - 2 * M, tamanho: f.tamanho, peso: 800,
+                    cor: '#111114', t: 0.1, passo: 3, ...base },
+                { tipo: 'kit', peca: 'cartoes', modo: 'colunas', cartoes: colunas, x: M, y: yC, largura: W - 2 * M, altura: r2(Math.min(H - yC - M, (deitado ? 0.56 : 0.5) * H)), t: 0.35, ...base, fonte: F.texto },
+            ])];
+        },
+
+        contraste(p, d, tp, t0) {
+            const [d1, d2] = partir(d, 0.5);
+            const nao = p.nao || '—', sim = p.sim || p.titulo || '';
+            const campo = ehMarca ? '#d8f53a' : ACENTO;
+            const tinta = sobre(campo);
+            const a = cena(d1, campo, luz(campo) < 0.6, [
+                { tipo: 'kit', peca: 'textura', modo: 'contorno', texto: nao, largura: W, altura: H, tamanho: r2(fit(nao.toUpperCase(), W * 0.5, 1, 170).tamanho), cor: tinta, corDestaque: tinta,
+                    fonte: F.display, t: 0.02, velocidade: 90, separador: ' ' },
+            ], { zoom: 1.1 });
+            const f = fit(sim, W - 2 * M, 2, 190);
+            const b2 = cena(d2, ESCURO, true, [
+                { tipo: 'kit', peca: 'particulas', x: W / 2, y: H / 2, t: 0.05, n: 46, raio: r2(W * 0.4), cores: [ACENTO, '#ffffff', misturarCor(ACENTO, '#ffffff', 0.5)] },
+                { tipo: 'kit', peca: 'manchete', modo: 'carimbo', texto: sim, x: W / 2, y: r2(H / 2 - alturaDe(f) / 2), largura: W - 2 * M, alinhamento: 'center', tamanho: f.tamanho,
+                    peso: 900, cor: '#ffffff', t: 0.02, passo: 3, destaque: tese(sim, p.destaque), ...base },
+            ], { zoom: 1.1 });
+            som(t0 + d1, 'toque', 0.4);
+            return [a, b2];
+        },
+
+        citacao(p, d, tp, t0) {
+            const pw = r2(deitado ? W * 0.7 : W - 2 * M);
+            const texto = p.titulo || p.texto || '';
+            return [cena(d, fundoClaro, false, [
+                { tipo: 'kit', peca: 'painel', titulo: p.autor || nome, texto: '“' + texto + '”', destaque: p.destaque || tese(texto), abas: [], botao: 'Responder',
+                    x: r2((W - pw) / 2), y: r2(H * 0.5 - pw * (deitado ? 0.2 : 0.3)), largura: pw, t: 0, escala: deitado ? 1 : 1.35, tMarca: Math.max(0.7, gatilhos([p.destaque || tese(texto)], tp, t0, d)[0]), ...base, fonte: F.texto },
+            ], { perspectiva: 1600 })];
+        },
+
+        imagem(p, d, tp, t0, i) {
+            const m = imagens[i] || (p.src ? { src: p.src, tipo: 'imagem' } : null);
+            if (!m) return CENAS.titulo(p, d, tp, t0);
+            const iw = r2(deitado ? W * 0.62 : W - 2 * M), ih = r2(iw * 0.6);
+            const f = fit(p.titulo || '', deitado ? W * 0.3 : W - 2 * M, 3, 84);
+            const x = deitado ? W - M - iw : M, y = deitado ? (H - ih) / 2 : H * 0.14;
+            const els = [
+                { tipo: 'grupo', x: r2(x), y: r2(y), largura: iw, altura: ih, recorte: true, raio: r2(22 * b), sombra: '0 40px 90px -30px rgba(0,0,0,0.55)',
+                    anima: { rotacaoY: [k(0, -24), k(0.8, -6, 'editorial'), k(d, -3, 'camera')], x: [k(0, 220 * b), k(0.8, 0, 'editorial')], opacidade: [k(0, 0), k(0.15, 1)] },
+                    elementos: [{ tipo: m.tipo === 'video' ? 'video' : 'imagem', src: m.src, ...(m.tipo === 'video' ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                        anima: { escala: [k(0, 1.1), k(d, 1.0, 'camera')] } }] },
+            ];
+            if (p.titulo) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.titulo, destaque: tese(p.titulo, p.destaque), x: M, y: r2(deitado ? H / 2 - alturaDe(f) / 2 : y + ih + 60 * b),
+                largura: r2(deitado ? W * 0.3 : W - 2 * M), tamanho: f.tamanho, peso: 800, cor: '#111114', t: 0.4, ...base });
+            return [cena(d, fundoClaro, false, els, { perspectiva: 1600 })];
+        },
+
+        grafico(p, d, tp, t0) {
+            const barras = (p.barras || itensDe(p).map((x, j, l) => ({ rotulo: x, valor: 100 - j * (60 / Math.max(1, l.length)) }))).slice(0, 5);
+            const max = Math.max(1, ...barras.map((q) => Number(q.valor) || 0));
+            const pw = r2(deitado ? W * 0.7 : W - 2 * M);
+            return [cena(d, fundoClaro, false, [
+                { tipo: 'kit', peca: 'painel', titulo: nome, texto: p.titulo || '', destaque: tese(p.titulo || '', p.destaque), abas: [], barras: barras.map((q) => ({ rotulo: q.rotulo, valor: Math.round(100 * (Number(q.valor) || 0) / max) })),
+                    tituloBarras: p.sub || 'resultado', x: r2((W - pw) / 2), y: r2(deitado ? H * 0.5 - pw * 0.18 : H * 0.28), largura: pw, t: 0.15, tBarras: 0.6, empilhar: !deitado, escala: deitado ? 1 : 1.3, ...base, fonte: F.texto },
+            ], { perspectiva: 1600 })];
+        },
+
+        cores(p, d) {
+            const lista = (p.cores || [cores.fundo, cores.destaque, cores.tinta, cores.apoio].filter(ehCor).map((hex, j) => ({ nome: ['Fundo', 'Destaque', 'Tinta', 'Apoio'][j], hex })))
+                .slice(0, 5).map((c) => (typeof c === 'string' ? { nome: c, hex: c } : c));
+            const cs = lista.length >= 2 ? lista : [{ nome: 'Acento', hex: ACENTO }, { nome: 'Escuro', hex: ESCURO }, { nome: 'Claro', hex: '#f7f7f5' }];
+            return [cena(d, '#fafafa', false, [
+                ...(p.titulo ? [{ tipo: 'kit', peca: 'fonte', texto: p.titulo.toUpperCase(), x: M, y: TOPO, t: 0.1, tamanho: r2(20 * b), fonteMono: F.mono, corAcento: ACENTO, cor: '#555862' }] : []),
+                { tipo: 'kit', peca: 'cores', cores: cs, x: W / 2, y: r2(H / 2), largura: r2((deitado ? 290 : 300) * b), raioX: r2(deitado ? W * 0.3 : W * 0.3), raioY: r2(deitado ? H * 0.3 : H * 0.28),
+                    t: 0.1, fonte: F.texto, fonteMono: F.mono },
+                { tipo: 'kit', peca: 'cromo', logo, x: W / 2, y: r2(H / 2), tamanho: r2(250 * b), t: 0, reflexo: false },
+            ], { zoom: 1.04 })];
+        },
+
+        produto(p, d, tp, t0) {
+            const titulo = p.titulo || '';
+            const pw = r2(deitado ? W * 0.72 : W - 2 * M);
+            const f = fit(titulo, W - 2 * M, 1, 96);
+            const texto = p.texto || p.sub || titulo;
+            return [cena(d, fundoClaro, false, [
+                { tipo: 'kit', peca: 'fonte', texto: (p.secao || 'produto').toUpperCase(), x: M, y: r2(TOPO - 38 * b), t: 0.05, tamanho: r2(18 * b), fonteMono: F.mono, corAcento: ACENTO, cor: ACENTO },
+                { tipo: 'kit', peca: 'manchete', modo: 'subir', texto: titulo, destaque: tese(titulo, p.destaque), x: M, y: r2(TOPO), largura: W - 2 * M, tamanho: f.tamanho, peso: 800, cor: '#111114', t: 0.05, passo: 3, ...base },
+                { tipo: 'kit', peca: 'painel', titulo: nome, texto, destaque: p.destaque || tese(texto), selo: p.selo, barras: p.barras, x: r2((W - pw) / 2), y: r2(deitado ? TOPO + f.tamanho * 1.5 + 40 * b : H * 0.24), largura: pw,
+                    empilhar: !deitado, escala: deitado ? 1 : 1.3,
+                    t: 0.3, tMarca: Math.max(0.8, gatilhos([p.destaque || tese(texto)], tp, t0, d)[0] - 0.3), ...base, fonte: F.texto },
+            ], { perspectiva: 1600 })];
+        },
+
+        cta(p, d, tp, t0) {
+            const [d1, d2] = partir(d, ehMarca ? 0.4 : 0.46);
+            const titulo = p.titulo || '';
+            const a = ehMarca
+                ? cena(d1, ACENTO, true, [{ tipo: 'kit', peca: 'padrao', logo, largura: W, altura: H, celula: r2(170 * b), cor: sobre(ACENTO), corOnda: misturarCor(sobre(ACENTO), ACENTO, 0.35), t: 0 }], { zoom: 1.1 })
+                : cena(d1, { tipo: 'gradiente', radial: true, centro: '50% 50%', cores: ['#d9d9d6', '#9c9c99'] }, false, [
+                    { tipo: 'kit', peca: 'cartoes', modo: 'mural', cartoes: enfeites(10), x: 0, y: 0, largura: W, altura: H, colunas: deitado ? 7 : 4, linhas: deitado ? 5 : 8, dur: d1, ...base, fonte: F.texto },
+                ], { camera: { zoom: [k(0, 1)] } });
+            const f = fit(titulo, W - 2 * M, 2, 120);
+            const icone = r2(220 * b);
+            const els = [
+                { tipo: 'kit', peca: 'cromo', logo, x: W / 2, y: r2(H * 0.36), tamanho: icone, t: 0.05, ...(ehMarca ? {} : { modo: 'solido', tom: ACENTO, reflexo: false, giro: 6 }) },
+                { tipo: 'kit', peca: 'particulas', x: W / 2, y: r2(H * 0.36), t: 0.2, n: 40, raio: r2(420 * b), cores: ehMarca ? ['#ffffff', ACENTO, '#9fb0ff'] : [ACENTO, '#111114', misturarCor(ACENTO, '#ffffff', 0.5)] },
+                { tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: titulo, destaque: tese(titulo, p.destaque), x: W / 2, y: r2(H * 0.36 + icone * 0.75 + 30 * b), largura: W - 2 * M, alinhamento: 'center',
+                    tamanho: f.tamanho, peso: 800, cor: ehMarca ? '#ffffff' : '#111114', t: 0.45, passo: 3, ...base },
+            ];
+            if (p.link) els.push({ tipo: 'kit', peca: 'manchete', modo: 'digitar', texto: p.link, x: W / 2, y: r2(H * 0.36 + icone * 0.75 + 60 * b + alturaDe(f)), largura: W - 2 * M, alinhamento: 'center',
+                tamanho: r2(38 * b), peso: 500, cor: ehMarca ? '#b8bcc8' : '#555862', t: 1.0, fonte: F.mono });
+            const b2 = cena(d2, ehMarca ? fundoEstudio : '#fbfbfa', ehMarca, els, { transicao: { tipo: 'liquido', duracao: 0.6 }, zoom: 1.04 });
+            brilhoSom(t0 + d1 + 0.2);
+            return [a, b2];
+        },
+    };
+
+    // ── as peças que qualquer parte pode pedir pelo nome ("visual") ────
+    const VISUAL = {
+        esfera(p, d, tp, t0) {
+            const f = fit(p.titulo || '', W - 2 * M, 1, 64);
+            return [cena(d, ESCURO, true, [
+                { tipo: 'kit', peca: 'esfera', x: W / 2, y: r2(H * 0.46), raio: r2(Math.min(W, H) * 0.3), cor: '#f4f4f6', corAcento: ACENTO, t: 0 },
+                { tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.titulo || '', x: W / 2, y: r2(H * 0.84), largura: W - 2 * M, alinhamento: 'center', tamanho: f.tamanho, peso: 700, cor: '#f4f4f6',
+                    t: gatilhos([p.titulo || ''], tp, t0, d)[0], ...base },
+            ])];
+        },
+        estrela(p, d, tp, t0) {
+            return [cena(d, ESCURO, true, [
+                { tipo: 'kit', peca: 'estrela', x: W / 2, y: H / 2, tamanho: r2(170 * b), cor: ACENTO, t: 0.05, texto: (p.titulo || nome) + ' · ' + nome, fonteMono: F.mono },
+            ], { zoom: 1.1 })];
+        },
+        grade(p, d) {
+            return [cena(d, '#ffffff', false, [
+                { tipo: 'kit', peca: 'grade', largura: W, altura: H, horizonte: r2(H * 0.46), cor: alfaHex(ACENTO, 0.28) },
+                { tipo: 'kit', peca: 'cromo', logo, x: W / 2, y: r2(H * 0.42), tamanho: r2(220 * b), t: 0.05, modo: 'solido', tom: ACENTO, reflexo: false },
+                ...(p.titulo ? [{ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.titulo, x: W / 2, y: r2(H * 0.66), largura: W - 2 * M, alinhamento: 'center', tamanho: r2(fit(p.titulo, W * 0.7, 1, 72).tamanho),
+                    peso: 800, cor: '#111114', t: 0.6, ...base }] : []),
+            ])];
+        },
+        site(p, d) {
+            const sw = r2(deitado ? W * 0.8 : W - 2 * M), sh = r2(deitado ? sw * 0.56 : sw * 1.45);
+            return [cena(d, fundoClaro, false, [
+                { tipo: 'kit', peca: 'site', marca: nome, logo, titulo: p.titulo || '', sub: p.sub, destaque: tese(p.titulo || '', p.destaque), menu: p.menu, x: r2((W - sw) / 2), y: r2((H - sh) / 2),
+                    largura: sw, altura: sh, t: 0, ...base, fonte: F.display },
+            ])];
+        },
+        padrao(p, d) {
+            return [cena(d, ACENTO, true, [{ tipo: 'kit', peca: 'padrao', modo: p.modo === 'truchet' ? 'truchet' : 'icone', logo, largura: W, altura: H, celula: r2(170 * b),
+                cor: sobre(ACENTO), corOnda: misturarCor(sobre(ACENTO), ACENTO, 0.4), t: 0 }], { zoom: 1.08 })];
+        },
+        orbe: (p, d, tp, t0) => CENAS.abertura(p, d, tp, t0),
+        vetor: (p, d, tp, t0) => CENAS.logo(p, d, tp, t0),
+        cromo(p, d) {
+            const f = fit(p.titulo || '', W - 2 * M, 1, 72);
+            return [cena(d, fundoEstudio, true, [
+                { tipo: 'kit', peca: 'cromo', logo, x: W / 2, y: r2(H * 0.44), tamanho: r2(300 * b), t: 0.05 },
+                ...(p.titulo ? [{ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.titulo, x: W / 2, y: r2(H * 0.74), largura: W - 2 * M, alinhamento: 'center', tamanho: f.tamanho, peso: 700, cor: '#f4f4f6', t: 0.7, ...base }] : []),
+            ])];
+        },
+        cartoes: (p, d, tp, t0) => CENAS.passos(p, d, tp, t0),
+        painel: (p, d, tp, t0) => CENAS.produto(p, d, tp, t0),
+        cores: (p, d, tp, t0) => CENAS.cores(p, d, tp, t0),
+    };
+
+    // ── montar ─────────────────────────────────────────────────────────
+    const cenas = [];
+    partes.forEach((p, i) => {
+        const fazer = (p.visual && VISUAL[p.visual]) || CENAS[p.tipo] || CENAS.titulo;
+        const feitas = fazer(p, dur[i], tempos[i], ini[i], i);
+        feitas.forEach((c, j) => { c.secao = String(i + 1).padStart(2, '0') + ' · ' + String(p.visual || p.tipo || 'parte').toUpperCase() + (feitas.length > 1 ? ' ' + (j + 1) + '/' + feitas.length : ''); });
+        cenas.push(...feitas);
+    });
+    /* A transição cruza as cenas: a que entra começa antes de a anterior
+       acabar. Para a voz não adiantar, a anterior ganha esse tempo. */
+    cenas.forEach((c, i) => {
+        const tr = c.transicao && typeof c.transicao === 'object' ? c.transicao.duracao || 0 : 0;
+        if (i > 0 && tr) cenas[i - 1].duracao = r2(cenas[i - 1].duracao + tr);
+        if (!c.transicao) c.transicao = 'corte';
+    });
+
+    const plano = {
+        formato: { largura: W, altura: H, fps: FPS },
+        fundoGeral: ESCURO,
+        estilo: ehMarca ? 'marca' : 'lancamento',
+        hud: { marca: String(nome).toUpperCase(), rotulo: ehMarca ? 'revelação de marca' : 'filme de lançamento', direita: W + '×' + H, fonte: F.mono },
+        acabamento: { grao: 0.05, vinheta: 0.18 },
+        cenas,
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes: volumesDaTrilha(temVoz ? tempos : [], total), loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return { ok: true, plano, resumo: { cenas: cenas.length, segundos: total, partes: partes.length, fps: FPS, estilo: plano.estilo } };
+}
+
+function alfaHex(hex, a) {
+    const h = String(hex).replace('#', '');
+    return '#' + (h.length === 3 ? h.split('').map((c) => c + c).join('') : h.slice(0, 6)) + Math.round(a * 255).toString(16).padStart(2, '0');
+}
+
+module.exports = { montarLancamento, VISUAIS };

package/lib/estudio/morfar.js

@@ -0,0 +1,191 @@
+/**
+ * morfar.js — uma forma que vira outra, sem corte.
+ *
+ *   "Uma bolinha viaja, aparece um fogo atrás, ela vai se deformando e se
+ *    transforma no foguete." — Joel, sobre o que separa motion de slide
+ *    (28/09/2026)
+ *
+ * O "morph" antigo era uma transição entre cenas (esmaece e desfoca). Isto é
+ * a deformação DE VERDADE: a `forma: "traco"` tem um `caminho` (o `d` de um
+ * SVG), e o `caminho` anima por quadro-chave como qualquer número. Entre dois
+ * caminhos, cada contorno é reamostrado no mesmo número de pontos, alinhado
+ * (mesmo sentido, mesmo ponto de partida) e interpolado ponto a ponto.
+ *
+ * O alinhamento é o que faz a bolinha "esticar" em foguete em vez de girar e
+ * se embolar no meio: sem ele, o ponto 0 de uma forma vai para o outro lado da
+ * outra.
+ *
+ * Aceita M, L, H, V, C, S, Q, T e Z (maiúsculo e minúsculo). Arco (A) não:
+ * escreva a curva com C. Só o primeiro contorno do caminho conta.
+ *
+ * Puro e sem dependência. O MESMO código vai para o projeto Remotion
+ * (fonteEsm), então o teste do Node prova o que o render desenha.
+ */
+
+'use strict';
+
+// ── embutido: daqui até o fim do bloco vai para src/morfar.js do Remotion ──
+const PONTOS_PADRAO = 120;
+const PASSOS_CURVA = 24;
+const _memo = new Map();
+
+function lerComandos(d) {
+    const partes = String(d || '').match(/[a-df-z]|-?(?:\d+\.?\d*|\.\d+)(?:e-?\d+)?/gi) || [];
+    const cmds = [];
+    let atual = null;
+    for (const p of partes) {
+        if (/[a-z]/i.test(p) && !/^e/i.test(p)) {
+            if (/a/i.test(p)) throw new Error('arco (A) não é aceito no caminho: desenhe a curva com C');
+            atual = { c: p, n: [] };
+            cmds.push(atual);
+        } else if (atual) atual.n.push(Number(p));
+    }
+    return cmds;
+}
+
+/** O primeiro contorno do caminho, como uma linha de pontos. */
+function contorno(d) {
+    const cmds = lerComandos(d);
+    const pts = [];
+    let x = 0, y = 0, x0 = 0, y0 = 0, cx = null, cy = null, qx = null, qy = null;
+    const curvaC = (x1, y1, x2, y2, x3, y3) => {
+        for (let i = 1; i <= PASSOS_CURVA; i++) {
+            const t = i / PASSOS_CURVA, u = 1 - t;
+            pts.push([u * u * u * x + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3,
+                u * u * u * y + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3]);
+        }
+        cx = x2; cy = y2; x = x3; y = y3;
+    };
+    const curvaQ = (x1, y1, x2, y2) => {
+        for (let i = 1; i <= PASSOS_CURVA; i++) {
+            const t = i / PASSOS_CURVA, u = 1 - t;
+            pts.push([u * u * x + 2 * u * t * x1 + t * t * x2, u * u * y + 2 * u * t * y1 + t * t * y2]);
+        }
+        qx = x1; qy = y1; x = x2; y = y2;
+    };
+    let fechou = false;
+    for (const { c, n } of cmds) {
+        if (fechou) break;
+        const rel = c === c.toLowerCase();
+        const C = c.toUpperCase();
+        const ox = () => (rel ? x : 0), oy = () => (rel ? y : 0);
+        if (C !== 'C' && C !== 'S') { cx = null; cy = null; }
+        if (C !== 'Q' && C !== 'T') { qx = null; qy = null; }
+        if (C === 'Z') { fechou = pts.length > 0; x = x0; y = y0; continue; }
+        const passo = { M: 2, L: 2, H: 1, V: 1, C: 6, S: 4, Q: 4, T: 2 }[C];
+        if (!passo) continue;
+        for (let i = 0; i + passo <= n.length; i += passo) {
+            const a = n.slice(i, i + passo);
+            if (C === 'M') {
+                if (i === 0 && pts.length) { fechou = true; break; }
+                x = a[0] + ox(); y = a[1] + oy();
+                if (i === 0) { x0 = x; y0 = y; }
+                pts.push([x, y]);
+            } else if (C === 'L') { x = a[0] + ox(); y = a[1] + oy(); pts.push([x, y]); }
+            else if (C === 'H') { x = a[0] + (rel ? x : 0); pts.push([x, y]); }
+            else if (C === 'V') { y = a[0] + (rel ? y : 0); pts.push([x, y]); }
+            else if (C === 'C') { const [bx, by] = [ox(), oy()]; curvaC(a[0] + bx, a[1] + by, a[2] + bx, a[3] + by, a[4] + bx, a[5] + by); }
+            else if (C === 'S') {
+                const [bx, by] = [ox(), oy()];
+                const x1 = cx == null ? x : 2 * x - cx, y1 = cy == null ? y : 2 * y - cy;
+                curvaC(x1, y1, a[0] + bx, a[1] + by, a[2] + bx, a[3] + by);
+            } else if (C === 'Q') { const [bx, by] = [ox(), oy()]; curvaQ(a[0] + bx, a[1] + by, a[2] + bx, a[3] + by); }
+            else if (C === 'T') {
+                const x1 = qx == null ? x : 2 * x - qx, y1 = qy == null ? y : 2 * y - qy;
+                curvaQ(x1, y1, a[0] + ox(), a[1] + oy());
+            }
+        }
+    }
+    if (pts.length < 2) throw new Error('o caminho precisa de pelo menos dois pontos');
+    return pts;
+}
+
+/** `n` pontos igualmente espaçados ao longo do contorno fechado. */
+function reamostrar(pts, n) {
+    const fechado = [...pts, pts[0]];
+    const acum = [0];
+    for (let i = 1; i < fechado.length; i++) {
+        acum.push(acum[i - 1] + Math.hypot(fechado[i][0] - fechado[i - 1][0], fechado[i][1] - fechado[i - 1][1]));
+    }
+    const total = acum[acum.length - 1] || 1;
+    const saida = [];
+    let j = 0;
+    for (let k = 0; k < n; k++) {
+        const alvo = (k / n) * total;
+        while (j < acum.length - 2 && acum[j + 1] < alvo) j++;
+        const seg = acum[j + 1] - acum[j] || 1;
+        const t = (alvo - acum[j]) / seg;
+        saida.push([fechado[j][0] + (fechado[j + 1][0] - fechado[j][0]) * t, fechado[j][1] + (fechado[j + 1][1] - fechado[j][1]) * t]);
+    }
+    return saida;
+}
+
+function area(pts) {
+    let s = 0;
+    for (let i = 0; i < pts.length; i++) { const a = pts[i], b = pts[(i + 1) % pts.length]; s += a[0] * b[1] - b[0] * a[1]; }
+    return s / 2;
+}
+
+function pontos(d, n = PONTOS_PADRAO) {
+    const chave = n + '|' + d;
+    if (!_memo.has(chave)) _memo.set(chave, reamostrar(contorno(d), n));
+    return _memo.get(chave);
+}
+
+/** Os dois contornos no mesmo sentido e com o ponto de partida que menos anda. */
+function alinhados(dA, dB, n = PONTOS_PADRAO) {
+    const chave = 'al|' + n + '|' + dA + '|' + dB;
+    if (_memo.has(chave)) return _memo.get(chave);
+    const a = pontos(dA, n);
+    let b = pontos(dB, n);
+    if (Math.sign(area(a)) !== Math.sign(area(b))) b = [...b].reverse();
+    let melhor = 0, menor = Infinity;
+    for (let s = 0; s < n; s++) {
+        let soma = 0;
+        for (let i = 0; i < n && soma < menor; i++) {
+            const p = a[i], q = b[(i + s) % n];
+            soma += (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2;
+        }
+        if (soma < menor) { menor = soma; melhor = s; }
+    }
+    const r = { a, b: b.map((_, i) => b[(i + melhor) % n]) };
+    _memo.set(chave, r);
+    return r;
+}
+
+const f2 = (v) => String(Math.round(v * 100) / 100);
+function caminhoDe(pts) {
+    return 'M ' + pts.map(([x, y]) => f2(x) + ' ' + f2(y)).join(' L ') + ' Z';
+}
+
+/** O caminho no instante `k` (0 = dA, 1 = dB). */
+function morfar(dA, dB, k, n = PONTOS_PADRAO) {
+    const { a, b } = alinhados(dA, dB, n);
+    const t = Math.max(0, Math.min(1, k));
+    return caminhoDe(a.map((p, i) => [p[0] + (b[i][0] - p[0]) * t, p[1] + (b[i][1] - p[1]) * t]));
+}
+
+const ehCor = (v) => typeof v === 'string' && /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(v.trim());
+function rgb(h) {
+    let s = h.trim().slice(1);
+    if (s.length === 3) s = s.split('').map((c) => c + c).join('');
+    return [0, 2, 4].map((i) => parseInt(s.slice(i, i + 2), 16));
+}
+function misturarCor(a, b, k) {
+    const x = rgb(a), y = rgb(b);
+    // A curva elástica passa de 1: a cor não pode passar de 255.
+    return '#' + x.map((v, i) => Math.max(0, Math.min(255, Math.round(v + (y[i] - v) * k))).toString(16).padStart(2, '0')).join('');
+}
+// ── fim do embutido ──
+
+/** Este mesmo código como ES module, para o src/morfar.js do projeto Remotion. */
+function fonteEsm() {
+    const src = require('fs').readFileSync(__filename, 'utf-8');
+    const ini = src.indexOf('// ── embutido');
+    const fim = src.indexOf('// ── fim do embutido');
+    return '/* Gerado de lib/estudio/morfar.js do PrimoCode — não edite aqui. */\n'
+        + src.slice(ini, fim)
+        + 'export { pontos, alinhados, caminhoDe, morfar, ehCor, misturarCor };\n';
+}
+
+module.exports = { pontos, alinhados, caminhoDe, morfar, ehCor, misturarCor, fonteEsm, PONTOS_PADRAO };