primocode 9.8.0 → 9.10.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.23
+# PrimoCode v9.10.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.23
+ ▐▛███▜▌   Primo Code v9.10.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/estudio/cinema.js

@@ -31,8 +31,10 @@ const { caber } = require('./composicao.js');
 const r2 = (n) => Math.round(n * 100) / 100;
 const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
 
-/** Quanto tempo um texto precisa ficar na tela para ser lido. */
-const leitura = (t) => 0.55 + 0.22 * String(t || '').split(/\s+/).filter(Boolean).length;
+/** Quanto tempo um texto precisa ficar na tela para ser lido. Nunca menos que
+    0,3 s por palavra: a regra de legibilidade do /brag (Arthur, 28/09). */
+const nPalavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
+const leitura = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
 
 /** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
 /* A voz lê EXATAMENTE o que está na tela, na ordem da tela ("a narração tem
@@ -229,7 +231,7 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
            com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
            a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
         // Texto curto (um número, "3 DIAS.") se lê de relance: não espera a leitura cheia e não atrasa a voz.
-        const minimo = (x) => Math.min(leitura(x), String(x).split(/\s+/).length <= 3 ? 0.75 : 1.6);
+        const minimo = (x) => Math.max(0.3 * nPalavras(x), Math.min(leitura(x), nPalavras(x) <= 3 ? 0.75 : 1.6));
         for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + minimo(textosDaParte[k - 1])));
         if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
         const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);

package/lib/estudio/edicao.js

@@ -145,13 +145,36 @@ function forteDe(g) {
     return forte;
 }
 
+/* O B-ROLL EM QUATRO ROTAS (Arthur, do b-roll-finder, 28/09): a frase diz qual
+   imagem pede, na ordem abaixo. A primeira que casa decide.
+     marca     a frase diz o nome da marca    → a logo / o site da marca
+     numero    a frase tem número             → sem foto: o número já é a imagem
+     concreto  uma palavra tem foto no acervo → a foto de estoque dela
+     pessoa    ideia abstrata                 → fica no rosto de quem fala
+   `palavra` é onde o corte se ancora: ele entra 0,2 s DEPOIS dela. */
+const DEPOIS_DA_PALAVRA = 0.2;
+
+function rotaDeApoio(g, { marca = null } = {}) {
+    const ws = g || [];
+    const nomes = (Array.isArray(marca) ? marca : [marca]).filter(Boolean).map((m) => String(m).split(/\s+/).map(limpa));
+    for (const nome of nomes) {
+        const k = ws.findIndex((_, i) => nome.every((n, j) => ws[i + j] && limpa(ws[i + j].texto) === n));
+        if (k >= 0) return { rota: 'marca', termo: null, palavra: ws[k] };
+    }
+    const num = ws.find((p) => /\d/.test(p.texto));
+    if (num) return { rota: 'numero', termo: null, palavra: num };
+    let conc = null;
+    for (const p of ws) if (termoDeApoio(p.texto) && (!conc || peso(p.texto) > peso(conc.texto))) conc = p;
+    if (conc) return { rota: 'concreto', termo: termoDeApoio(conc.texto), palavra: conc };
+    return { rota: 'pessoa', termo: null, palavra: null };
+}
+
 /** Os termos das imagens de apoio que o plano vai pedir — para baixar antes. */
-function termosDeApoio(palavras) {
+function termosDeApoio(palavras, opcoes) {
     const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
     const termos = [];
     frases(lista).forEach((g, i) => {
-        const f = forteDe(g);
-        const t = f && temApoio(i) ? termoDeApoio(f.texto) : null;
+        const t = temApoio(i) ? rotaDeApoio(g, opcoes).termo : null;
         if (t && !termos.includes(t)) termos.push(t);
     });
     return termos;
@@ -231,7 +254,7 @@ const ESTILOS = {
 // Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
 const temRecorte = (i) => i % 4 === 2;
 
-function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {} }) {
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {}, marca = null }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
     const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
     if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
@@ -290,9 +313,11 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
            que está sendo dito, com um zoom lento, e a legenda continua por
            cima. É o "b-roll" das edições de videomaker. */
-        const apoio = forte && e.apoio && temApoio(i) && !rec ? imagens[termoDeApoio(forte.texto)] : null;
+        const r = e.apoio && temApoio(i) && !rec ? rotaDeApoio(g, { marca }) : null;
+        const apoio = !r ? null : r.rota === 'concreto' ? imagens[r.termo] : r.rota === 'marca' ? imagens.marca : null;
         if (apoio) {
-            const de = local(forte.de - 0.1);
+            // O corte entra DEPOIS da palavra, nunca antes: quem ouve "cachorro" vê o cachorro.
+            const de = local(r.palavra.de + DEPOIS_DA_PALAVRA);
             const vida = Math.min(2.2, dur - de);
             if (vida > 0.8) {
                 // O apoio é foto ou vídeo (o Pexels dá os dois; vídeo é melhor).
@@ -447,4 +472,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };
+module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };

package/lib/estudio/ende.js

@@ -0,0 +1,109 @@
+/**
+ * ende.js — trilha da ende.app: CC BY 4.0, uso comercial, sem Content ID.
+ *
+ *   "Usar músicas CC BY 4.0 sem Content ID, da ende.app." — Arthur, do
+ *    /brag (28/09/2026)
+ *
+ * Por que esta fonte: música do Openverse com licença comercial às vezes está
+ * registrada no Content ID, e o vídeo do cliente leva reivindicação no
+ * YouTube. A página da ende.app diz: "Important: NO Content ID. [...]
+ * Everything is under CC BY 4.0. [...] Commercial use is allowed as well."
+ * O crédito é opcional ("Attribution is nice but no longer required"), mas
+ * gravamos mesmo assim: custa uma linha e protege o cliente.
+ *
+ * ── SEM API ──────────────────────────────────────────────────────────────
+ * A ende.app não tem API, e a busca por texto (?q=) não filtra: devolve
+ * sempre a mesma lista. Então lemos os cartões da listagem, que trazem
+ * `musicPlayer(id, 'mp3', duração)`, o título, a página e as tags. A escolha é
+ * pelas tags e pela duração. `robots.txt` só fecha /user-api/ e /challenge.
+ *
+ * Se a página mudar, `lerLista` devolve [] e o provedor devolve null, e a
+ * corrente do producao.js cai no próximo provedor (o Openverse). A rede e o
+ * disco são injetados: o teste roda com um recorte do HTML real.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LISTA = 'https://ende.app/en/search';   // 25 cartões; a /en mostra 11
+const CREDITO = 'Música: Sascha Ende (ende.app), CC BY 4.0';
+
+// O clima do roteiro (pt) → palavras que aparecem nas tags da ende.app (en).
+const CLIMAS = {
+    emocional: ['emotional', 'acoustic', 'atmospheric', 'piano', 'cinematic', 'ambient', 'calm', 'strings'],
+    cinema: ['cinematic', 'epic', 'orchestral', 'atmospheric', 'emotional', 'strings'],
+    energetico: ['energetic', 'upbeat', 'beat', 'drums', 'rock', 'arcade', 'breakcore', 'epic'],
+    viral: ['upbeat', 'beat', 'energetic', 'pop', 'electronic'],
+    impacto: ['epic', 'drums', 'trailer', 'energetic', 'beat'],
+    neutro: ['background', 'corporate', 'chilled', 'calm', 'ambient'],
+    // Produto e tecnologia: pulso de sintetizador, limpo, com impulso.
+    tecnologia: ['arpeggiator', 'analog synths', 'clockwork', 'rhythm', 'commercial', 'clean mix', 'crisp'],
+};
+
+const limpar = (s) => String(s || '').replace(/<[^>]*>/g, '').replace(/&amp;/g, '&').replace(/&#0?39;/g, "'").replace(/\s+/g, ' ').trim();
+
+/** Os cartões de música da listagem. Página diferente do esperado: []. */
+function lerLista(html) {
+    const texto = String(html || '');
+    const cortes = [...texto.matchAll(/musicPlayer\(\s*(\d+)\s*,\s*'([^']+\.mp3)'\s*,\s*([\d.]+)/g)];
+    return cortes.map((m, k) => {
+        const fim = k + 1 < cortes.length ? cortes[k + 1].index : texto.length;
+        const cartao = texto.slice(m.index, fim);
+        const link = cartao.match(/<a href="([^"]+)" class="ap-title-link">([\s\S]*?)<\/a>/);
+        const tags = [...cartao.matchAll(/class="ap-subline-tag">([^<]+)</g)].map((t) => limpar(t[1]).toLowerCase());
+        return {
+            id: Number(m[1]), mp3: m[2], segundos: Number(m[3]),
+            titulo: link ? limpar(link[2]) : null, pagina: link ? link[1] : null, tags,
+        };
+    }).filter((f) => f.titulo && f.segundos > 0);
+}
+
+/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null. */
+function escolher(faixas, { clima = 'neutro', segundos = 0 } = {}) {
+    const palavras = CLIMAS[clima] || CLIMAS.neutro;
+    const nota = (f) => f.tags.reduce((n, t) => n + palavras.filter((p) => t.includes(p)).length, 0);
+    const cabem = (faixas || []).filter((f) => f.segundos >= segundos);
+    if (!cabem.length) return null;
+    return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+}
+
+async function buscarPadrao(url) {
+    const r = await fetch(url, { headers: { 'User-Agent': 'PrimoCode-Estudio' } });
+    if (!r.ok) throw new Error(`ende.app respondeu ${r.status}`);
+    return r.text();
+}
+
+/** Baixa na pasta de mídia e grava o .json da licença ao lado, como o acervo faz. */
+function baixarEm(pasta) {
+    return async (url, nome, meta) => {
+        const r = await fetch(url);
+        if (!r.ok) throw new Error(`download da ende.app respondeu ${r.status}`);
+        const destino = path.join(pasta, nome);
+        fs.mkdirSync(pasta, { recursive: true });
+        fs.writeFileSync(destino, Buffer.from(await r.arrayBuffer()));
+        fs.writeFileSync(destino + '.json', JSON.stringify(meta, null, 2));
+        return destino;
+    };
+}
+
+/** O provedor de `musica` para o producao.js. */
+function provedor({ buscar = buscarPadrao, baixar, pasta = 'midia' } = {}) {
+    const salvar = baixar || baixarEm(pasta);
+    return {
+        nome: 'ende', tipo: 'musica',
+        async gerar({ clima, segundos = 0 } = {}) {
+            const faixa = escolher(lerLista(await buscar(LISTA)), { clima, segundos });
+            if (!faixa) return null;
+            const meta = {
+                fonte: faixa.pagina, titulo: faixa.titulo, autor: 'Sascha Ende',
+                licenca: 'CC BY 4.0', contentId: false, credito: CREDITO,
+            };
+            const src = await salvar(faixa.mp3, `ende-${faixa.id}.mp3`, meta);
+            return { src, segundos: faixa.segundos, ...meta };
+        },
+    };
+}
+
+module.exports = { lerLista, escolher, provedor, CLIMAS, CREDITO };

package/lib/estudio/index.js

@@ -45,6 +45,9 @@ const composicao = require('./composicao.js');
 const acervoSite = require('./acervo-site.js');
 const impacto = require('./impacto.js');
 const cinema = require('./cinema.js');
+const motion = require('./motion.js');
+const sonsLeves = require('./sons-leves.js');
+const ende = require('./ende.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -242,6 +245,8 @@ 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();
     const api = require('../api');
@@ -254,7 +259,8 @@ async function roteiroDoServidor(p, args) {
         fotos: (acervo.fotos || []).length ? `${acervo.fotos.length} fotos reais` : '',
         site: acervo.site ? new URL(acervo.site).hostname.replace(/^www\./, '') : '',
         rascunho: typeof args.roteiro === 'string' ? args.roteiro : '',
-        estilo: args.estilo || (/an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedido) ? 'impacto' : undefined),
+        // 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),
     }, 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 } };
@@ -916,11 +922,20 @@ 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: "impacto" (anúncio, corte a cada batida) ou "limpo" (uma cena
-       por parte). Pedido de anúncio, reels, divulgação ou venda já vem em
-       impacto — é o que se espera de uma peça dessas em 2026. */
-    const estilo = args.estilo || roteiro.estilo
-        || (/an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(`${p.pedido || ''} ${args.pedido || ''}`) ? 'impacto' : 'limpo');
+    /* 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". */
+    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 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']);
 
@@ -1131,8 +1146,17 @@ async function prepararRoteiro(p, args) {
         tempos = v.partes;
         narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
-        sons = await edicao.prepararSons(p.pasta, video);
-        try {
+        // O motion usa os efeitos leves; os estilos de corte, os cheios.
+        sons = ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+        // A trilha do motion: ende.app (CC BY 4.0, sem Content ID), clima tecnologia.
+        if (ehMotion) {
+            try {
+                const segundos = tempos.length ? tempos[tempos.length - 1].ate + 2 : 20;
+                const m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'tecnologia', segundos });
+                if (m) { trilha = path.relative(p.pasta, m.src).replace(/\\/g, '/'); projeto.anotar(p.id, 'trilha', m.credito); }
+            } catch { /* cai na busca de sempre */ }
+        }
+        if (!trilha) try {
             const b = await assets.procurarMusica(roteiro.musica || args.trilha || (estilo === 'impacto' ? 'epic energetic' : 'inspiring corporate'), { quantas: 6, duracaoMin: 45 });
             for (const item of (b.ok ? b.sons : [])) {
                 const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
@@ -1156,6 +1180,11 @@ 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') {
+        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 });
 }
 
@@ -1435,5 +1464,5 @@ async function ferramentaSite(args) {
 module.exports = {
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
-    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro,
 };

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 };