primocode 9.10.0 → 10.0.9

package/lib/estudio/lancamento.js

@@ -0,0 +1,441 @@
+/**
+ * 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") ────
+    /* Qual modelo 3D: o que a parte ou o roteiro disser, ou o que o texto
+       deixa claro. Sem pista, a caixa — um produto genérico que ainda gira. */
+    const modeloDe = (txt) => (/fone|headset|headphone|auricular/i.test(txt) ? 'fone'
+        : /celular|smartphone|iphone|phone|telefone/i.test(txt) ? 'celular'
+            : /lata|bebida|refri|cerveja|energ[eé]tico|garrafa/i.test(txt) ? 'lata' : 'caixa');
+    const VISUAL = {
+        /* O PRODUTO EM 3D (kit/tres.jsx): modelado e iluminado aqui, sem foto
+           de fora — girando devagar no centro, o nome embaixo. */
+        '3d'(p, d, tp, t0) {
+            const texto = `${p.titulo || ''} ${p.texto || ''} ${nome}`;
+            const modelo = p.modelo || roteiro.modelo3d || modeloDe(texto);
+            const f = fit(p.titulo || nome, W - 2 * M, 1, deitado ? 84 : 96);
+            const yT = deitado ? H * 0.8 : H * 0.76;
+            const els = [
+                { tipo: 'kit', peca: 'produto3d', modelo, cor: p.cor3d || roteiro.cor3d || '#1b1c20', corAcento: ACENTO, t: 0, giro: 0.4,
+                    x: 0, y: r2(deitado ? -H * 0.02 : -H * 0.08), largura: W, altura: H, escala: deitado ? 0.8 : 1.15 },   // deitado a 1,0 o arco saía cortado no topo
+                { tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.titulo || nome, x: W / 2, y: r2(yT), largura: W - 2 * M, alinhamento: 'center',
+                    tamanho: f.tamanho, peso: 800, cor: '#f4f4f6', t: Math.min(0.9, gatilhos([p.titulo || nome], tp, t0, d)[0] || 0.6), ...base },
+            ];
+            if (p.texto) els.push({ tipo: 'kit', peca: 'manchete', modo: 'desfoque', texto: p.texto, x: W / 2, y: r2(yT + f.tamanho * 1.25), largura: W - 2 * M, alinhamento: 'center',
+                tamanho: r2(fit(p.texto, W - 2 * M, 2, 40).tamanho), peso: 500, cor: '#b8bcc8', t: 1.1, ...base });
+            return [cena(d, ESCURO, true, els, { zoom: 1.06 })];
+        },
+        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 = [];
+    /* Com modelo 3D no roteiro (ou "3d" pedido), a parte de produto — ou a
+       abertura, se não houver produto — ganha o produto girando. */
+    if (roteiro.modelo3d) {
+        const alvo = partes.find((p) => p.tipo === 'produto' && !p.visual) || partes.find((p) => p.tipo === 'abertura' && !p.visual);
+        if (alvo) alvo.visual = '3d';
+    }
+    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/motion.js

@@ -32,6 +32,7 @@
 
 const { caber, falaDe } = require('./composicao.js');
 const { misturarCor, ehCor } = require('./morfar.js');
+const { volumesDaTrilha } = require('./ritmo.js');
 
 const k = (t, v, e) => (e ? { t, v, e } : { t, v });
 const r2 = (n) => Math.round(n * 100) / 100;
@@ -306,11 +307,7 @@ function montarMotion({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     cam.rotacaoX.push(k(DUR, 0, 'suave'));
 
     // ── o som: a música abaixa quando a voz fala ─────────────────────────
-    const volumes = [k(0, 0.05), k(0.4, 0.22)];
-    if (temVoz) {
-        for (const tp of tempos) volumes.push(k(r2(Math.max(0.41, tp.de - 0.15)), 0.22), k(r2(tp.de), 0.11), k(r2(tp.ate), 0.11), k(r2(tp.ate + 0.35), 0.22));
-    }
-    volumes.push(k(r2(DUR - 0.6), 0.2), k(DUR, 0));
+    const volumes = volumesDaTrilha(temVoz ? tempos : [], DUR);
     som(0.05, 'sopro', 0.3);
     som(DUR - 1.2, 'brilho', 0.35);
 

package/lib/estudio/plano.js

@@ -48,11 +48,13 @@
 const fs = require('fs');
 const path = require('path');
 const morfar = require('./morfar.js');
+const kit = require('./kit.js');
 
-const TIPOS = new Set(['texto', 'forma', 'imagem', 'video', 'icone', 'legenda', 'componente', 'grupo']);
+// "kit": uma peça pronta do kit de motion (kit.js), pelo nome — ver kit/*.jsx.
+const TIPOS = new Set(['texto', 'forma', 'imagem', 'video', 'icone', 'legenda', 'componente', 'grupo', 'kit']);
 const FORMAS = new Set(['retangulo', 'circulo', 'linha', 'poligono', 'traco']);
 const AJUSTES = new Set(['cover', 'contain', 'preencher']);
-const TRANSICOES = new Set(['corte', 'esmaecer', 'deslizar', 'zoom', 'giro', 'mascara', 'morph', 'chicote', 'soco', 'flash']);
+const TRANSICOES = new Set(['corte', 'esmaecer', 'deslizar', 'zoom', 'giro', 'mascara', 'morph', 'chicote', 'soco', 'flash', 'liquido']);
 
 /* As propriedades que a animação por quadro-chave alcança. Cada uma é um
    número no tempo; a curva entre dois quadros é a suavização declarada.
@@ -78,7 +80,9 @@ const TEXTUAIS = new Set(['cor', 'caminho']);
 // rotacaoX/rotacaoY/z: a câmera gira em volta do mundo e avança nele (precisa de `perspectiva` na cena).
 const ANIMAVEIS_CAMERA = new Set(['zoom', 'x', 'y', 'rotacao', 'rotacaoX', 'rotacaoY', 'z']);
 
-const SUAVIZACOES = new Set(['linear', 'suave', 'entrada', 'saida', 'elastico', 'salto']);
+/* editorial (ataque rápido, freio forte), camera (bezier longa), arrasto (a
+   mão que desenha) e acelera (a câmera antes do corte) vêm do guia VOX. */
+const SUAVIZACOES = new Set(['linear', 'suave', 'entrada', 'saida', 'elastico', 'salto', 'editorial', 'camera', 'arrasto', 'acelera']);
 
 const COR = /^(#[0-9a-f]{3,8}|rgba?\([^)]+\)|hsla?\([^)]+\)|transparent|currentColor)$/i;
 
@@ -240,6 +244,11 @@ function conferirElemento(caminho, el, pasta, problemas, duracao) {
             // A válvula de escape: um arquivo React escrito pela própria IA.
             conferirArquivo(`${caminho}.src`, el.src, pasta, problemas);
             break;
+        case 'kit':
+            for (const oque of kit.conferirPeca(el)) problemas.push(erro(`${caminho}.peca`, oque));
+            // A logo de uma peça é arquivo da pasta, como a imagem.
+            if (el.logo) conferirArquivo(`${caminho}.logo`, el.logo, pasta, problemas);
+            break;
     }
 }
 
@@ -298,6 +307,22 @@ function conferir(plano, { pasta = null } = {}) {
         conferirFundo(`${onde}.fundo`, cena.fundo, pasta, problemas);
         conferirAnima(`${onde}.camera`, cena.camera, problemas, ANIMAVEIS_CAMERA);
 
+        /* As CAMADAS de profundidade: [{p, desfoque, sujeito}]. "p" é a
+           profundidade (0,12 longe … 1,25 perto), e o elemento diz a dele por
+           índice. Índice fora da lista põe o elemento em lugar nenhum. */
+        const nCamadas = Array.isArray(cena.camadas) ? cena.camadas.length : 0;
+        if (cena.camadas != null) {
+            if (!nCamadas) problemas.push(erro(`${onde}.camadas`, 'camadas é uma lista de {p, desfoque, sujeito}'));
+            else cena.camadas.forEach((c, k) => {
+                if (!c || typeof c.p !== 'number' || !(c.p > 0)) problemas.push(erro(`${onde}.camadas[${k}].p`, 'p é a profundidade, um número maior que 0'));
+            });
+        }
+        for (const [k, el] of (Array.isArray(cena.elementos) ? cena.elementos : []).entries()) {
+            if (el && el.camada != null && !(Number.isInteger(el.camada) && el.camada >= 0 && el.camada < nCamadas)) {
+                problemas.push(erro(`${onde}.elementos[${k}].camada`, nCamadas ? `camada vai de 0 a ${nCamadas - 1}` : 'a cena não declara "camadas"'));
+            }
+        }
+
         if (cena.transicao) {
             const t = cena.transicao.tipo || cena.transicao;
             if (!TRANSICOES.has(t)) {

package/lib/estudio/referencias.js

@@ -0,0 +1,105 @@
+/**
+ * referencias.js — de onde o vídeo tira as referências, decidido pela
+ * PESSOA antes de começar.
+ *
+ *   "A IA deve pedir: pegar referências da web com escopo aberto, pegar
+ *    referências da web com escopo que você define (escopo fechado), ou sem
+ *    referências — só motion." (29/09)
+ *
+ * Três modos:
+ *   aberto   pesquisa, site da marca e b-roll de banco à vontade (o híbrido)
+ *   fechado  só o que a pessoa disse: os sites e termos do escopo, nada além
+ *   sem      nenhuma foto nem vídeo de fora: motion puro (o kit), sem b-roll
+ *
+ * A escolha vale para o pedido (o terminal pergunta a cada vídeo novo) e é
+ * lida em dois lugares: a instrução que vai para o agente e o Estúdio, que
+ * não baixa b-roll no "sem" e só busca o escopo no "fechado".
+ */
+
+'use strict';
+
+let ATUAL = { modo: null, escopo: '' };
+
+function definir(modo, escopo = '') {
+    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim() };
+    return ATUAL;
+}
+function atual() { return ATUAL; }
+function limpar() { ATUAL = { modo: null, escopo: '' }; }
+
+/** Os termos do escopo fechado: "site:anthropic.com, claude ai, sonnet" → lista. */
+function termos(escopo = ATUAL.escopo) {
+    return String(escopo || '').split(/[,;\n]+/).map((x) => x.trim()).filter(Boolean).slice(0, 8);
+}
+
+/** A resposta da pergunta ("1", "2", "aberto", "só motion"…) → modo. */
+function entender(resposta) {
+    const r = String(resposta || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').trim();
+    if (/^1\b|aberto|livre|qualquer/.test(r)) return 'aberto';
+    if (/^2\b|fechad|escopo|defino|so (d|n)(e|o)ss/.test(r)) return 'fechado';
+    if (/^3\b|sem ref|nenhum|so motion|motion|sem foto|sem imagem/.test(r)) return 'sem';
+    return null;
+}
+
+/* O MODO DEDUZIDO DO PEDIDO. Quem diz no pedido não é perguntado:
+     "só motion", "sem referência", "sem foto"          → sem
+     "só do site x.com", "usa apenas anthropic.com e …" → fechado (o escopo)
+     "web aberta", "escopo aberto", "pesquisa à vontade" → aberto
+   O resto volta com `explicito: false` e o terminal pergunta antes de
+   começar: "eu posso pedir um vídeo mas estar me referindo ao motion"
+   (Joel, 02/10) — chutar o aberto fazia vídeo com foto e b-roll quando a
+   pessoa queria só motion. */
+function inferir(texto) {
+    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+    if (/so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima/.test(t)) return { modo: 'sem', escopo: '', explicito: true };
+    const dominios = String(texto || '').match(/\b[a-z0-9-]+(\.[a-z0-9-]+)+\.?[a-z]{2,}(\/[^\s,]*)?/gi) || [];
+    if (/\b(so|apenas|somente|unicamente)\b[^.]{0,30}\b(site|sites|link|links|fonte|fontes|pagina|de|do|da|em)\b/.test(t) && dominios.length) {
+        return { modo: 'fechado', escopo: dominios.join(', '), explicito: true };
+    }
+    if (/escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)|com (imagens|fotos) da (web|internet)/.test(t)) {
+        return { modo: 'aberto', escopo: '', explicito: true };
+    }
+    return { modo: 'aberto', escopo: '', explicito: false };
+}
+
+/** A instrução para o agente, conforme o modo. */
+function instrucao({ modo, escopo } = ATUAL) {
+    if (modo === 'sem') {
+        return '[REFERÊNCIAS: NENHUMA] A pessoa quer SÓ MOTION: não pesquise (nada de pesquisar_referencia nem estudio_site), '
+            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz e deixe '
+            + 'o motion gerativo fazer o trabalho (roteiro.estilo "gerativo": a tipografia anima sozinha, sem template).';
+    }
+    if (modo === 'fechado') {
+        const t = termos(escopo);
+        return `[REFERÊNCIAS: ESCOPO FECHADO] Use SÓ estas fontes e termos: ${t.join(' · ') || escopo}. `
+            + 'Pesquise apenas dentro delas (em pesquisar_referencia, cite o site ou o termo no próprio texto da busca). '
+            + 'Nada de fato, foto ou vídeo de fora desse escopo; se faltar algo, diga no fim em uma linha. '
+            + `No roteiro, ponha roteiro.busca = ${JSON.stringify(t)} para o b-roll.`;
+    }
+    if (modo === 'aberto') {
+        return '[REFERÊNCIAS: ESCOPO ABERTO] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca) '
+            + 'e dê em cada parte do roteiro um "busca" em inglês com o que mostrar de fundo — gente, lugar, tela, objeto de verdade.';
+    }
+    return '';
+}
+
+/** Os domínios do escopo fechado: "só do site anthropic.com" → ['anthropic.com']. */
+function dominios(escopo = ATUAL.escopo) {
+    return termos(escopo).map((t) => t.replace(/^site:/, '').replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0].toLowerCase())
+        .filter((t) => /^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(t));
+}
+
+/** O resultado da pesquisa sem o que está fora do escopo fechado (subdomínios valem: www-cdn.anthropic.com). */
+function filtrar(r, { modo, escopo } = ATUAL) {
+    if (modo !== 'fechado' || !r || !Array.isArray(r.referencias)) return r;
+    const ds = dominios(escopo);
+    if (!ds.length) return r;
+    const dentro = (u) => { try { const h = new URL(u).hostname.toLowerCase(); return ds.some((d) => h === d || h.endsWith('.' + d)); } catch { return false; } };
+    const refs = r.referencias.filter((x) => dentro(x.url));
+    const fora = r.referencias.length - refs.length;
+    if (!refs.length) return { ok: false, consulta: r.consulta, error: `nada desta busca é de ${ds.join(', ')} (escopo fechado)`,
+        comoCorrigir: `Abra o site direto: browser_open https://${ds[0]} e browser_read. Não use fonte de fora.` };
+    return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
+}
+
+module.exports = { definir, atual, limpar, termos, entender, inferir, instrucao, dominios, filtrar };