primocode 9.10.0 → 10.0.0

package/lib/cursor.js

@@ -95,7 +95,16 @@ function subir() {
             };
             proc.on('exit', morreu);
             proc.on('error', morreu);
-            setTimeout(() => { if (!subiu) { semCursor = 'o cursor demorou demais para abrir'; resolve(false); } }, 20000);
+            // Demorou demais: desiste E mata — senão o Python ficava órfão, e o
+            // `pronto` guardado como false deixava o cursor fora a sessão toda.
+            const teto = setTimeout(() => {
+                if (subiu) return;
+                semCursor = 'o cursor demorou demais para abrir';
+                try { proc && proc.kill(); } catch { /* já morreu */ }
+                pronto = null;
+                resolve(false);
+            }, 20000);
+            if (teto.unref) teto.unref();
             // O cursor não pode segurar o PrimoCode aberto na saída.
             proc.unref();
             proc.stdout.unref && proc.stdout.unref();

package/lib/entrada.js

@@ -143,7 +143,8 @@ function montar(e) {
         if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
             conteudo += c.dim(e.fantasma);
         }
-        if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
+        if (i === 0 && vazio && e.ocupado) conteudo = c.dim('mande um recado — ele entra na tarefa depois do passo atual');
+        else if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
         // Sem `encher`: sem barra à direita não há nada para alinhar, e o
         // espaço sobrando só apagaria o que estivesse embaixo.
         out.push(' ' + marca + conteudo);
@@ -315,7 +316,8 @@ class Entrada extends EventEmitter {
     suspender() { this.suspenso = true; this._apagar(); }
     retomar() { this.suspenso = false; if (this.ativo && !this.fechado) this._desenhar(); }
 
-    /** O agente está trabalhando: a caixa esmaece e o Enter não manda nada. */
+    /** O agente está trabalhando: a caixa esmaece, e o Enter manda um RECADO
+     *  que entra na tarefa em curso (a caixa de entrada de lib/act.js). */
     trabalhando(sim) {
         if (this.ocupado === !!sim) return;
         this.ocupado = !!sim;

package/lib/estudio/diretor.js

@@ -62,6 +62,14 @@ function precisaDeProducao(texto) {
     return { producao: false };
 }
 
+/* Editar a GRAVAÇÃO da pessoa não é produzir vídeo do zero: aí o caminho é o
+   editor por linha do tempo (`primocode video`, lib/video/), não o roteiro. */
+const PEDE_EDICAO = /\b(edit[ae]r?|edi[cç][aã]o|cort[ae]r?|legend[ae]r?|tir[ae]r?\s+(o|os)\s+sil[eê]ncios?)\b[\s\S]{0,80}\b(grava[cç][aã]o|meu\s+v[ií]deo|esse\s+v[ií]deo|este\s+v[ií]deo|[\w-]+\.(mp4|mov|mkv|webm|m4v))\b|\b[\w-]+\.(mp4|mov|mkv|webm|m4v)\b[\s\S]{0,80}\b(edit|cort|legend|sil[eê]nci)/i;
+
+function precisaDeEdicao(texto) {
+    return PEDE_EDICAO.test(String(texto || ''));
+}
+
 // ── 2. as decisões que não são do modelo ─────────────────────────────────
 
 /**
@@ -293,7 +301,7 @@ function pauta(plano) {
 }
 
 module.exports = {
-    precisaDeProducao, vozPara, ritmoPara,
+    precisaDeProducao, precisaDeEdicao, vozPara, ritmoPara,
     normalizarPlano, extrairJSON, planejar, pauta,
     DIRETOR, REVISAO,
 };

package/lib/estudio/estilo.js

@@ -0,0 +1,51 @@
+/**
+ * estilo.js — qual estilo de vídeo um roteiro vira.
+ *
+ *   motion      o padrão: um plano contínuo em 3D, o protagonista que se deforma (motion.js)
+ *   vox         explainer editorial: tinta sobre papel, os oito dispositivos VOX (vox.js)
+ *   marca       brand reveal: o brilho, o vetor, a marca cromada, o padrão (lancamento.js)
+ *   lancamento  filme de lançamento de produto: cartões, painel, calendário, mural (lancamento.js)
+ *   impacto     anúncio: corte a cada batida (impacto.js)
+ *   cinema      filme de marca premium com fotos reais (cinema.js)
+ *   composicao  a composição antiga, uma cena por parte (composicao.js)
+ *
+ * Quem manda, em ordem: o estilo que o AGENTE pediu; o do roteiro (a menos
+ * que o pedido diga motion); o que o pedido descreve; e o motion.
+ */
+
+'use strict';
+
+const ESTILOS = ['motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao'];
+// Nomes que o modelo usa para os mesmos estilos.
+const APELIDOS = { limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
+
+const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
+const PEDE_VOX = /\bvox\b|explica|explainer|document[aá]rio|editorial|hist[oó]ria d[aoe]s?\b/i;
+const PEDE_MARCA = /\bbrand|identidade visual|revela[çc][ãa]o d[ae] marca|\blogo(tipo|marca)?\b|vinheta de marca/i;
+const PEDE_LANCAMENTO = /lan[çc]amento|\blaunch|\bsaas\b|produto novo|apresenta(ndo|r|ção d[oe]) (o |a )?(app|produto|plataforma|ferramenta)/i;
+const PEDE_IMPACTO = /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i;
+
+const normal = (e) => {
+    const x = String(e || '').trim().toLowerCase();
+    if (!x) return null;
+    const n = APELIDOS[x] || x;
+    return ESTILOS.includes(n) ? n : null;
+};
+
+function escolherEstilo({ pedido = '', agente = null, roteiro = null } = {}) {
+    const pedidoAgente = normal(agente);
+    if (pedidoAgente) return pedidoAgente;
+    const doRoteiro = normal(roteiro);
+    if (doRoteiro && !(doRoteiro !== 'motion' && PEDE_MOTION.test(pedido) && !PEDE_VOX.test(pedido))) return doRoteiro;
+    if (PEDE_VOX.test(pedido)) return 'vox';
+    if (PEDE_MARCA.test(pedido)) return 'marca';
+    if (PEDE_LANCAMENTO.test(pedido)) return 'lancamento';
+    if (PEDE_MOTION.test(pedido)) return 'motion';
+    if (PEDE_IMPACTO.test(pedido)) return 'impacto';
+    return 'motion';
+}
+
+/** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
+const LEVES = new Set(['motion', 'vox', 'marca', 'lancamento']);
+
+module.exports = { escolherEstilo, ESTILOS, LEVES, PEDE_MOTION };

package/lib/estudio/glifos.js

@@ -0,0 +1,215 @@
+/**
+ * glifos.js — as letras de uma palavra como VETOR de verdade: o contorno, as
+ * âncoras e as alças, lidos da própria fonte TrueType.
+ *
+ * A cena do brand reveal que mais vende "feito por designer" é a palavra
+ * enorme em contorno, com os quadradinhos das âncoras, as alças de bezier e o
+ * cursor passeando. Isso só convence com os pontos REAIS da letra — pontos
+ * inventados em cima de um <text> denunciam na hora. Então o PrimoCode lê a
+ * fonte: a tabela glyf de um .ttf guarda cada contorno como pontos na curva
+ * (âncoras) e fora dela (controles de quadrática, as alças).
+ *
+ * Zero dependência: um leitor de TrueType de ~150 linhas (cmap formatos 4 e
+ * 12, loca, glyf simples e composto, hmtx). A fonte vem do Google Fonts
+ * (a API antiga devolve .ttf) e fica em cache; sem rede, `palavra()` devolve
+ * null e a peça "vetor" desenha o contorno do próprio texto, sem alças.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// ── o leitor ─────────────────────────────────────────────────────────────
+function tabelas(buf) {
+    const n = buf.readUInt16BE(4);
+    const t = {};
+    for (let i = 0; i < n; i++) {
+        const o = 12 + i * 16;
+        t[buf.toString('latin1', o, o + 4)] = { off: buf.readUInt32BE(o + 8), len: buf.readUInt32BE(o + 12) };
+    }
+    return t;
+}
+
+/** Caractere → índice do glifo (cmap 3/10 formato 12, ou 3/1 e 0/x formato 4). */
+function mapaDeCaracteres(buf, cmap) {
+    const n = buf.readUInt16BE(cmap.off + 2);
+    const subs = [];
+    for (let i = 0; i < n; i++) {
+        const o = cmap.off + 4 + i * 8;
+        subs.push({ plat: buf.readUInt16BE(o), enc: buf.readUInt16BE(o + 2), off: cmap.off + buf.readUInt32BE(o + 4) });
+    }
+    subs.sort((a, b) => buf.readUInt16BE(b.off) - buf.readUInt16BE(a.off));   // o formato 12 primeiro
+    for (const s of subs) {
+        const fmt = buf.readUInt16BE(s.off);
+        if (fmt === 12) {
+            const grupos = buf.readUInt32BE(s.off + 12);
+            return (cp) => {
+                for (let g = 0; g < grupos; g++) {
+                    const o = s.off + 16 + g * 12;
+                    const ini = buf.readUInt32BE(o), fim = buf.readUInt32BE(o + 4);
+                    if (cp >= ini && cp <= fim) return buf.readUInt32BE(o + 8) + (cp - ini);
+                }
+                return 0;
+            };
+        }
+        if (fmt === 4) {
+            const segs = buf.readUInt16BE(s.off + 6) / 2;
+            const fins = s.off + 14, inis = fins + segs * 2 + 2, deltas = inis + segs * 2, ranges = deltas + segs * 2;
+            return (cp) => {
+                for (let i = 0; i < segs; i++) {
+                    const fim = buf.readUInt16BE(fins + i * 2);
+                    if (cp > fim) continue;
+                    const ini = buf.readUInt16BE(inis + i * 2);
+                    if (cp < ini) return 0;
+                    const delta = buf.readInt16BE(deltas + i * 2), ro = buf.readUInt16BE(ranges + i * 2);
+                    if (!ro) return (cp + delta) & 0xffff;
+                    const g = buf.readUInt16BE(ranges + i * 2 + ro + (cp - ini) * 2);
+                    return g ? (g + delta) & 0xffff : 0;
+                }
+                return 0;
+            };
+        }
+    }
+    return () => 0;
+}
+
+/** Os contornos de um glifo: [[{x, y, on}]], já com os componentes do composto. */
+function contornos(f, gid, profundidade = 0) {
+    const a = f.loca(gid), b = f.loca(gid + 1);
+    if (b <= a || profundidade > 4) return [];
+    const buf = f.buf, o = f.glyf + a;
+    const nc = buf.readInt16BE(o);
+    if (nc < 0) {
+        // Composto: cada componente é outro glifo, deslocado (e às vezes escalado).
+        const saida = [];
+        let p = o + 10, flags;
+        do {
+            flags = buf.readUInt16BE(p); const g = buf.readUInt16BE(p + 2); p += 4;
+            let dx, dy;
+            if (flags & 1) { dx = buf.readInt16BE(p); dy = buf.readInt16BE(p + 2); p += 4; } else { dx = buf.readInt8(p); dy = buf.readInt8(p + 1); p += 2; }
+            let sx = 1, sy = 1;
+            if (flags & 8) { sx = sy = buf.readInt16BE(p) / 16384; p += 2; }
+            else if (flags & 0x40) { sx = buf.readInt16BE(p) / 16384; sy = buf.readInt16BE(p + 2) / 16384; p += 4; }
+            else if (flags & 0x80) { sx = buf.readInt16BE(p) / 16384; sy = buf.readInt16BE(p + 6) / 16384; p += 8; }
+            if (!(flags & 2)) { dx = 0; dy = 0; }   // pontos casados em vez de deslocamento: raro em fonte do Google
+            for (const c of contornos(f, g, profundidade + 1)) saida.push(c.map((q) => ({ x: q.x * sx + dx, y: q.y * sy + dy, on: q.on })));
+        } while (flags & 0x20);
+        return saida;
+    }
+    const fins = [];
+    for (let i = 0; i < nc; i++) fins.push(buf.readUInt16BE(o + 10 + i * 2));
+    const n = nc ? fins[nc - 1] + 1 : 0;
+    let p = o + 10 + nc * 2;
+    p += 2 + buf.readUInt16BE(p);                  // pula as instruções
+    const fl = [];
+    while (fl.length < n) {
+        const f0 = buf.readUInt8(p++); fl.push(f0);
+        if (f0 & 8) { let r = buf.readUInt8(p++); while (r-- > 0) fl.push(f0); }
+    }
+    const coord = (curto, igual) => {
+        const v = []; let atual = 0;
+        for (let i = 0; i < n; i++) {
+            const q = fl[i];
+            if (q & curto) { const d = buf.readUInt8(p++); atual += q & igual ? d : -d; }
+            else if (!(q & igual)) { atual += buf.readInt16BE(p); p += 2; }
+            v.push(atual);
+        }
+        return v;
+    };
+    const xs = coord(2, 16), ys = coord(4, 32);
+    const saida = [];
+    let ini = 0;
+    for (const fim of fins) {
+        const c = [];
+        for (let i = ini; i <= fim; i++) c.push({ x: xs[i], y: ys[i], on: Boolean(fl[i] & 1) });
+        saida.push(c);
+        ini = fim + 1;
+    }
+    return saida;
+}
+
+function abrirFonte(buf) {
+    const t = tabelas(buf);
+    if (!t.glyf || !t.loca || !t.head || !t.cmap || !t.hmtx || !t.hhea) throw new Error('não é uma fonte TrueType com contornos (glyf)');
+    const longo = buf.readInt16BE(t.head.off + 50) === 1;
+    const nMetr = buf.readUInt16BE(t.hhea.off + 34);
+    return {
+        buf, glyf: t.glyf.off,
+        porEm: buf.readUInt16BE(t.head.off + 18),
+        loca: (i) => (longo ? buf.readUInt32BE(t.loca.off + i * 4) : buf.readUInt16BE(t.loca.off + i * 2) * 2),
+        avanco: (g) => buf.readUInt16BE(t.hmtx.off + Math.min(g, nMetr - 1) * 4),
+        glifo: mapaDeCaracteres(buf, t.cmap),
+    };
+}
+
+const r1 = (n) => Math.round(n * 10) / 10;
+
+/**
+ * A palavra desenhada: {d, pontos: [[x, y, naCurva, contorno]], caixa: [x, y, w, h]}.
+ * Coordenadas em unidades da fonte, com y para baixo (como no SVG).
+ */
+function desenhar(buf, texto, { espacamento = 0 } = {}) {
+    const f = abrirFonte(buf);
+    let x = 0, nC = 0;
+    const d = [], pontos = [];
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const ch of String(texto)) {
+        const g = f.glifo(ch.codePointAt(0));
+        for (const c of contornos(f, g)) {
+            if (c.length < 2) continue;
+            const P = c.map((q) => ({ x: r1(q.x + x), y: r1(-q.y), on: q.on }));
+            for (const q of P) {
+                pontos.push([q.x, q.y, q.on ? 1 : 0, nC]);
+                if (q.x < minX) minX = q.x; if (q.x > maxX) maxX = q.x; if (q.y < minY) minY = q.y; if (q.y > maxY) maxY = q.y;
+            }
+            // Quadrática com pontos implícitos: entre dois controles seguidos mora uma âncora no meio.
+            let k0 = P.findIndex((q) => q.on);
+            let inicio = k0 >= 0 ? P[k0] : { x: r1((P[0].x + P[1].x) / 2), y: r1((P[0].y + P[1].y) / 2), on: true };
+            if (k0 < 0) k0 = 0;
+            const seg = [`M ${inicio.x} ${inicio.y}`];
+            let ctrl = null;
+            for (let j = 1; j <= P.length; j++) {
+                const q = P[(k0 + j) % P.length];
+                if (q.on) { seg.push(ctrl ? `Q ${ctrl.x} ${ctrl.y} ${q.x} ${q.y}` : `L ${q.x} ${q.y}`); ctrl = null; }
+                else if (ctrl) { const m = { x: r1((ctrl.x + q.x) / 2), y: r1((ctrl.y + q.y) / 2) }; seg.push(`Q ${ctrl.x} ${ctrl.y} ${m.x} ${m.y}`); ctrl = q; }
+                else ctrl = q;
+            }
+            if (ctrl) seg.push(`Q ${ctrl.x} ${ctrl.y} ${inicio.x} ${inicio.y}`);
+            d.push(seg.join(' ') + ' Z');
+            nC++;
+        }
+        x += f.avanco(g) + espacamento * f.porEm;
+    }
+    if (!pontos.length) return null;
+    return { d: d.join(' '), pontos, caixa: [r1(minX), r1(minY), r1(maxX - minX), r1(maxY - minY)], porEm: f.porEm };
+}
+
+// ── a fonte, do Google Fonts para o cache ────────────────────────────────
+const CACHE = path.join(os.homedir(), '.primocode', 'studio', 'cache-fontes');
+
+async function baixarFonte(familia, peso = 700) {
+    const nome = String(familia).replace(/[^a-z0-9]+/gi, '-').toLowerCase() + '-' + peso + '.ttf';
+    const arq = path.join(CACHE, nome);
+    if (fs.existsSync(arq)) return arq;
+    // A API antiga (css, não css2) devolve .ttf; a nova devolve woff2, que não tem a glyf crua.
+    const css = await (await fetch('https://fonts.googleapis.com/css?family=' + encodeURIComponent(familia) + ':' + peso, { signal: AbortSignal.timeout(10000) })).text();
+    const url = (css.match(/url\((https:[^)]+\.ttf)\)/) || [])[1];
+    if (!url) return null;
+    const bin = Buffer.from(await (await fetch(url, { signal: AbortSignal.timeout(15000) })).arrayBuffer());
+    fs.mkdirSync(CACHE, { recursive: true });
+    fs.writeFileSync(arq, bin);
+    return arq;
+}
+
+/** A palavra em vetor na fonte da marca, ou null (sem rede, fonte sem glyf, palavra vazia). */
+async function palavra(texto, { fonte = 'Plus Jakarta Sans', peso = 700 } = {}) {
+    if (!String(texto || '').trim()) return null;
+    try {
+        const arq = await baixarFonte(fonte, peso);
+        return arq ? desenhar(fs.readFileSync(arq), texto) : null;
+    } catch { return null; }
+}
+
+module.exports = { palavra, desenhar, abrirFonte, baixarFonte, CACHE };

package/lib/estudio/index.js

@@ -46,6 +46,10 @@ const acervoSite = require('./acervo-site.js');
 const impacto = require('./impacto.js');
 const cinema = require('./cinema.js');
 const motion = require('./motion.js');
+const vox = require('./vox.js');
+const lancamento = require('./lancamento.js');
+const glifos = require('./glifos.js');
+const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
 const ende = require('./ende.js');
 
@@ -222,7 +226,8 @@ function roteiroValido(r) {
     const partes = Array.isArray(x) ? x : x && x.partes;
     if (!Array.isArray(partes) || partes.length < 2) return null;
     const CINEMA = ['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'];
-    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo)))) return null;
+    const NOVOS = ['logo', 'cores', 'produto'];   // vox.js e lancamento.js
+    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo) || NOVOS.includes(pt.tipo)))) return null;
     const obj = Array.isArray(x) ? { partes } : x;
     return partes.some((pt) => CINEMA.includes(pt.tipo)) && !obj.estilo ? { ...obj, estilo: 'cinema' } : obj;
 }
@@ -245,7 +250,6 @@ async function garantirAcervo(p) {
 /* O ROTEIRISTA do servidor: quando o modelo não manda um roteiro que preste
    (nenhum, ou texto corrido), o pedido e os fatos da marca viram o roteiro
    numa chamada só, com uma tarefa só. */
-const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 
 async function roteiroDoServidor(p, args) {
     const cfg = require('../config').loadConfig();
@@ -260,7 +264,7 @@ async function roteiroDoServidor(p, args) {
         site: acervo.site ? new URL(acervo.site).hostname.replace(/^www\./, '') : '',
         rascunho: typeof args.roteiro === 'string' ? args.roteiro : '',
         // Pedido de motion nunca vira impacto, nem sendo anúncio.
-        estilo: args.estilo || (!PEDE_MOTION.test(pedido) && /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedido) ? 'impacto' : undefined),
+        estilo: args.estilo || (escolherEstilo({ pedido }) === 'impacto' ? 'impacto' : undefined),
     }, cfg.token);
     if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
     return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
@@ -922,20 +926,15 @@ async function prepararRoteiro(p, args) {
         if (roteiro.marca.logo && !existe(roteiro.marca.logo)) roteiro.marca.logo = (p.marca && existe(p.marca.logo)) ? p.marca.logo : undefined;
     } else if (p.marca) roteiro.marca = p.marca;
     const partes = roteiro.partes || [];
-    /* O ESTILO. O padrão é MOTION (motion.js): um plano contínuo em 3D, com
-       um protagonista que se deforma de parte em parte — "isso sim é motion"
-       (Joel, 28/09). "limpo" era o nome antigo do padrão e vira motion
-       também. Anúncio, reels e venda vão para o "impacto" (corte a cada
-       batida), a menos que o pedido diga motion ou animação. A composição
-       antiga, uma cena por parte, só com estilo: "composicao". */
+    /* O ESTILO (estilo.js). O padrão é MOTION (motion.js): um plano contínuo
+       em 3D — "isso sim é motion" (Joel, 28/09). Explicação vira VOX
+       (editorial, tinta sobre papel), marca vira MARCA (brand reveal),
+       lançamento de produto vira LANCAMENTO, anúncio e reels vão para o
+       IMPACTO. O que o agente pediu vale mais que tudo. */
     const pedidoTxt = `${p.pedido || ''} ${args.pedido || ''}`;
-    // O estilo que o AGENTE pediu vale; o que o roteirista pôs no roteiro não
-    // passa por cima de um pedido de motion.
-    const pedido0 = args.estilo || (PEDE_MOTION.test(pedidoTxt) ? null : roteiro.estilo);
-    const estilo = pedido0 === 'limpo' ? 'motion' : (pedido0
-        || (PEDE_MOTION.test(pedidoTxt) ? 'motion'
-            : /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedidoTxt) ? 'impacto' : 'motion'));
-    const ehMotion = estilo === 'motion';
+    const estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo });
+    // Os estilos de motion usam os efeitos leves e a trilha do ende.app; os de corte, os cheios.
+    const ehMotion = LEVES.has(estilo);
     const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
     const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
 
@@ -1180,12 +1179,36 @@ async function prepararRoteiro(p, args) {
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo impacto: ${r.resumo.cenas} batidas`);
         return r;
     }
-    if (ehMotion && modo === 'video') {
+    if (estilo === 'vox' && modo === 'video') {
+        const r = vox.montarVox({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo vox: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
+    if ((estilo === 'marca' || estilo === 'lancamento') && modo === 'video') {
+        /* As letras em vetor (a peça "vetor") pedem os pontos de verdade da
+           fonte: glifos.js lê o .ttf. Sem rede, o vetor desenha o contorno do
+           próprio texto, sem as alças. */
+        const m = roteiro.marca || {};
+        const nome = m.nome || (partes.find((pt) => pt.tipo === 'logo' || pt.tipo === 'abertura') || {}).titulo || '';
+        const precisa = partes.some((pt) => pt.tipo === 'logo' || pt.visual === 'vetor');
+        const g = precisa ? await glifos.palavra((partes.find((pt) => pt.tipo === 'logo') || {}).titulo || nome,
+            { fonte: (m.fontes && m.fontes.titulo) || (estilo === 'marca' ? 'Plus Jakarta Sans' : 'Inter Tight') }) : null;
+        const r = lancamento.montarLancamento({ roteiro, variante: estilo, largura, altura, tempos, narracao, sons, trilha, imagens, glifos: g });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${estilo}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s${precisa ? (g ? ', vetor com os pontos da fonte' : ', vetor sem os pontos (sem a fonte)') : ''}`);
+        return r;
+    }
+    if (estilo === 'motion' && modo === 'video') {
         const r = motion.montarMotion({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo motion: ${r.resumo.segundos}s contínuos, ${r.resumo.partes} partes, ${r.resumo.fps} fps`);
         return r;
     }
-    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
+    /* A composição (e os slides) só conhece os tipos antigos: as partes novas
+       viram a mais parecida delas, e o roteiro do vídeo serve à página. */
+    const PARECIDA = { logo: 'abertura', cores: 'lista', produto: 'titulo' };
+    const paraComposicao = { ...roteiro, partes: partes.map((pt) => (PARECIDA[pt.tipo]
+        ? { ...pt, tipo: PARECIDA[pt.tipo], itens: pt.itens || (pt.cores || []).map((c) => (typeof c === 'string' ? c : c.nome)) }
+        : pt)) };
+    return composicao.comporRoteiro({ roteiro: paraComposicao, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
 }
 
 /* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,