primocode 9.10.0 → 10.0.9

package/lib/estudio/remotion.js

@@ -74,6 +74,10 @@ function pkgJson(nome) {
             remotion: VERSAO_REMOTION,
             react: '19.0.0',
             'react-dom': '19.0.0',
+            // O produto em 3D (kit/tres.jsx). Instalado uma vez na base compartilhada.
+            '@remotion/three': VERSAO_REMOTION,
+            three: '0.186.1',
+            '@react-three/fiber': '9.8.1',
         },
     }, null, 2) + '\n';
 }
@@ -98,6 +102,7 @@ import {
   useVideoConfig, interpolate, staticFile, continueRender, delayRender,
 } from 'remotion';
 import { morfar, ehCor, misturarCor } from './morfar';
+import { KIT, CURVAS_KIT, Filtros } from './kit';
 
 /* ── SUAVIZAÇÃO ──────────────────────────────────────────────────────────
  * Cada curva é uma função de 0..1 em 0..1. "suave" é o padrão porque
@@ -117,6 +122,8 @@ const CURVAS = {
     if (t < 2.5 / d) return n * (t -= 2.25 / d) * t + 0.9375;
     return n * (t -= 2.625 / d) * t + 0.984375;
   },
+  // editorial, camera, arrasto, acelera (kit/base.jsx): a curva certa do guia VOX.
+  ...CURVAS_KIT,
 };
 
 /* O valor de uma propriedade animada no segundo "t".
@@ -217,7 +224,12 @@ function Elemento({ el, t, dados }) {
 
   const tLocal = t - (el.de || 0);
   const a = animado(el.anima, tLocal);
-  const base = posicao(el);
+  /* A PEÇA DO KIT desenha nas coordenadas da cena (x, y dela são o lugar do
+     assunto, não o canto de uma caixa): a caixa dela é o quadro inteiro, e o
+     "anima" do elemento move o conjunto. */
+  const base = el.tipo === 'kit'
+    ? { position: 'absolute', left: 0, top: 0, width: '100%', height: '100%' }
+    : posicao(el);
   const move = transformDe(a, {});
   const estilo = {
     ...base,
@@ -355,6 +367,16 @@ function Elemento({ el, t, dados }) {
     /* O GRUPO: uma tela dentro da tela. Os filhos vivem no tempo e no espaço
        dele; com "recorte" o que passa da borda some (a tela do celular). O
        grupo anima como qualquer elemento: cresce, sai do celular, cobre tudo. */
+    case 'kit': {
+      const Peca = KIT[el.peca];
+      if (!Peca) return null;
+      return (
+        <div style={{ ...estilo, transformOrigin: el.origem || ((el.x || 0) + 'px ' + (el.y || 0) + 'px') }}>
+          <Peca el={el} t={tLocal} fps={dados.fps} />
+        </div>
+      );
+    }
+
     case 'grupo':
       return (
         <div style={{
@@ -516,11 +538,36 @@ export function Cena({ cena, dados, tFixo }) {
     cam.rotacaoY != null ? 'rotateY(' + cam.rotacaoY + 'deg)' : '',
   ].filter(Boolean).join(' ');
 
+  /* A CÂMERA EM CAMADAS (o parallax do guia VOX): "camadas" são planos de
+     profundidade, e o que está longe anda menos que o que está perto. O
+     parallax é CONSEQUÊNCIA da câmera, não um efeito à parte: o plano do
+     assunto ("sujeito") recebe a câmera exata, os outros na proporção da
+     profundidade deles — e cada um com o desfoque da lente naquela distância.
+     Cada elemento diz a camada dele ("camada": índice); sem, é a do sujeito. */
+  const camadas = Array.isArray(cena.camadas) && cena.camadas.length ? cena.camadas : null;
+  const iSujeito = camadas ? Math.max(0, camadas.findIndex((c) => c.sujeito)) : 0;
+  const mundo = (els, f, desfoque) => (
+    <AbsoluteFill style={{
+      transform: f == null ? (camTransform || undefined) : [
+        'translate(' + (-(cam.x || 0) * f + tx) + 'px,' + (-(cam.y || 0) * f + ty) + 'px)',
+        'scale(' + ((1 + ((cam.zoom ?? 1) - 1) * f) * soco) + ')',
+        'rotate(' + ((cam.rotacao || 0) * f + tr) + 'deg)',
+      ].join(' '),
+      transformOrigin: cena.cameraOrigem || 'center center',
+      // O mundo guarda o 3D dos filhos; a perspectiva vem do pai.
+      transformStyle: cena.perspectiva ? 'preserve-3d' : undefined,
+      filter: desfoque ? 'blur(' + desfoque + 'px)' : undefined,
+    }}>
+      {els.map((el, i) => <Elemento key={i} el={el} t={t} dados={dados} />)}
+    </AbsoluteFill>
+  );
+
   return (
     /* A perspectiva mora AQUI, um nível acima do mundo: se ficasse no mesmo
        elemento da câmera, girar a câmera sairia achatado. */
     <AbsoluteFill style={{ ...fundoCSS(cena.fundo), overflow: 'hidden',
       perspective: cena.perspectiva ? cena.perspectiva + 'px' : undefined }}>
+      <Filtros />
       {cena.fundo && cena.fundo.tipo === 'imagem' && (
         <Img src={staticFile(cena.fundo.src)} style={{
           position: 'absolute', inset: 0, width: '100%', height: '100%',
@@ -533,16 +580,13 @@ export function Cena({ cena, dados, tFixo }) {
           objectFit: cena.fundo.ajuste || 'cover',
         }} />
       )}
-      <AbsoluteFill style={{
-        transform: camTransform || undefined,
-        transformOrigin: cena.cameraOrigem || 'center center',
-        // O mundo guarda o 3D dos filhos; a perspectiva vem do pai.
-        transformStyle: cena.perspectiva ? 'preserve-3d' : undefined,
-      }}>
-        {(cena.elementos || []).map((el, i) => (
-          <Elemento key={i} el={el} t={t} dados={dados} />
-        ))}
-      </AbsoluteFill>
+      {camadas
+        ? camadas.map((c, ci) => (
+          <React.Fragment key={ci}>
+            {mundo((cena.elementos || []).filter((el) => (el.camada ?? iSujeito) === ci), (c.p || 1) / (camadas[iSujeito].p || 1), c.desfoque)}
+          </React.Fragment>
+        ))
+        : mundo(cena.elementos || [], null, 0)}
       {flash > 0.01 && <AbsoluteFill style={{ backgroundColor: cena.corFlash || '#fff', opacity: flash * 0.85 }} />}
     </AbsoluteFill>
   );
@@ -552,6 +596,7 @@ export function Cena({ cena, dados, tFixo }) {
 const RAIZ_JSX = String.raw`import React from 'react';
 import { AbsoluteFill, Audio, Sequence, staticFile, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
 import { Cena } from './Cena';
+import { Acabamento, Hud, bolhaCaminho } from './kit';
 import plano from './plano.json';
 import icones from './icones.json';
 
@@ -560,6 +605,7 @@ import icones from './icones.json';
  * o "piscar" de fundo que denuncia corte mal feito. */
 function Transicao({ tipo, progresso, children }) {
   const p = progresso;
+  const { width: W, height: H } = useVideoConfig();
   let estilo = {};
   if (tipo === 'esmaecer') estilo = { opacity: p };
   else if (tipo === 'deslizar') estilo = { transform: 'translateX(' + (1 - p) * 100 + '%)' };
@@ -572,6 +618,12 @@ function Transicao({ tipo, progresso, children }) {
   // O SOCO: a cena entra grande e bate no lugar.
   else if (tipo === 'soco') estilo = { transform: 'scale(' + (1.35 - 0.35 * p) + ')', opacity: Math.min(1, p * 3) };
   else if (tipo === 'flash') estilo = { opacity: Math.min(1, p * 2), filter: 'brightness(' + (1 + (1 - p) * 3) + ')' };
+  /* O LÍQUIDO: a cena nova entra como uma mancha que cresce de um canto e
+     engole a anterior, com a borda viva (os lóbulos respiram enquanto crescem). */
+  else if (tipo === 'liquido' && p < 1) {
+    const k = p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
+    estilo = { clipPath: "path('" + bolhaCaminho(W * 0.78, H * 0.62, Math.hypot(W, H) * 0.95 * k, p * 3, 2) + "')" };
+  }
   return <AbsoluteFill style={estilo}>{children}</AbsoluteFill>;
 }
 
@@ -591,7 +643,7 @@ export const Paginas = () => {
 };
 
 export const Video = () => {
-  const { fps } = useVideoConfig();
+  const { fps, width: largura, height: altura } = useVideoConfig();
   const frame = useCurrentFrame();
   const dados = { fps, icones };
 
@@ -632,31 +684,17 @@ export const Video = () => {
         );
       })}
 
-      {/* O ACABAMENTO: granulação de filme, vinheta e a luz da marca passando.
-          É o que tira a cara de apresentação e dá a cara de peça de 2026. */}
-      {plano.acabamento && plano.acabamento.luz && (
-        <AbsoluteFill style={{ pointerEvents: 'none', mixBlendMode: 'screen', opacity: plano.acabamento.luzForca ?? 0.22,
-          background: 'radial-gradient(circle at ' + (50 + 40 * Math.sin(frame / 38)) + '% ' + (30 + 25 * Math.cos(frame / 51)) + '%, '
-            + plano.acabamento.luz[0] + ' 0%, transparent 45%), radial-gradient(circle at ' + (50 - 40 * Math.sin(frame / 44)) + '% '
-            + (75 - 20 * Math.sin(frame / 33)) + '%, ' + (plano.acabamento.luz[1] || plano.acabamento.luz[0]) + ' 0%, transparent 40%)' }} />
-      )}
-      {plano.acabamento && plano.acabamento.grade && (
-        <AbsoluteFill style={{ pointerEvents: 'none', opacity: plano.acabamento.grade,
-          backgroundImage: 'linear-gradient(rgba(255,255,255,0.5) 1px, transparent 1px), linear-gradient(90deg, rgba(255,255,255,0.5) 1px, transparent 1px)',
-          backgroundSize: (plano.acabamento.passoGrade || 120) + 'px ' + (plano.acabamento.passoGrade || 120) + 'px',
-          backgroundPosition: (frame * 0.2) + 'px ' + (frame * 0.1) + 'px' }} />
-      )}
-      {plano.acabamento && plano.acabamento.vinheta && (
-        <AbsoluteFill style={{ pointerEvents: 'none', background: 'radial-gradient(ellipse at center, transparent 55%, rgba(0,0,0,' + plano.acabamento.vinheta + ') 100%)' }} />
-      )}
-      {plano.acabamento && plano.acabamento.grao && (
-        <AbsoluteFill style={{ pointerEvents: 'none', opacity: plano.acabamento.grao, mixBlendMode: 'overlay' }}>
-          <svg width="100%" height="100%">
-            <filter id="grao"><feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves="2" seed={frame % 60} /></filter>
-            <rect width="100%" height="100%" filter="url(#grao)" />
-          </svg>
-        </AbsoluteFill>
-      )}
+      {/* O ACABAMENTO: granulação de filme, vinheta e a luz da marca passando
+          (kit/base.jsx). É o que tira a cara de apresentação. */}
+      <Acabamento ac={plano.acabamento} frame={frame} />
+      {/* O HUD do motion designer: cantos, timecode, fps e a seção da cena. */}
+      {plano.hud && (() => {
+        const atual = pedacos.filter((q) => frame >= q.de).pop() || pedacos[0];
+        const total = pedacos.length ? pedacos[pedacos.length - 1].de + pedacos[pedacos.length - 1].dur : 1;
+        // A cena diz se é escura (o HUD claro) ou clara (o HUD escuro).
+        const escuro = !(atual && atual.cena.escuro === false);
+        return <Hud hud={plano.hud} frame={frame} fps={fps} total={total} W={largura} H={altura} secao={atual && atual.cena.secao} escuro={escuro} />;
+      })()}
 
       {plano.audio && plano.audio.narracao && (
         <Audio src={staticFile(plano.audio.narracao)} volume={plano.audio.volumeNarracao ?? 1} />
@@ -800,6 +838,8 @@ function montar({ pasta, titulo, plano, icones = {} }) {
     escrever(path.join(src, 'Video.jsx'), RAIZ_JSX);
     escrever(path.join(src, 'Cena.jsx'), CENA_JSX);
     escrever(path.join(src, 'morfar.js'), require('./morfar.js').fonteEsm());
+    // O kit de motion (kit.js): as peças que o elemento {"tipo":"kit"} monta.
+    for (const f of require('./kit.js').arquivos()) escrever(path.join(src, f.nome), f.conteudo);
     escrever(path.join(src, 'plano.json'), JSON.stringify(plano, null, 2));
     escrever(path.join(src, 'icones.json'), JSON.stringify(icones, null, 2));
     escrever(path.join(src, 'fontes.css'), fontesCSS(plano));
@@ -826,16 +866,30 @@ function montar({ pasta, titulo, plano, icones = {} }) {
    do usuário e roda com rede disponível no `npm install`; o Chromium do
    Remotion baixa a fonte no primeiro quadro e o Remotion espera por ela. */
 function fontesCSS(plano) {
+    /* Toda chave que começa com "fonte" (fonte, fonteMono, fonteDef…), em
+       qualquer profundidade: dentro de grupo, na legenda, nas peças do kit e
+       no HUD. Fonte que o plano usa e o CSS não declara sai em Times. */
     const usadas = new Set();
-    for (const cena of plano.cenas || []) {
-        for (const el of cena.elementos || []) {
-            if (el.fonte) usadas.add(el.fonte);
-            if (el.estilo && el.estilo.fonte) usadas.add(el.estilo.fonte);
+    const andar = (o) => {
+        if (!o || typeof o !== 'object') return;
+        if (Array.isArray(o)) return o.forEach(andar);
+        for (const [k, v] of Object.entries(o)) {
+            if (/^fonte/.test(k) && typeof v === 'string' && v.trim()) usadas.add(v.trim());
+            else if (v && typeof v === 'object') andar(v);
         }
-    }
+    };
+    for (const cena of plano.cenas || []) andar(cena.elementos || []);
+    andar(plano.hud);
     if (!usadas.size) return '/* nenhuma fonte externa neste vídeo */\n';
+    /* A FONTE VARIÁVEL: o motion gerativo anima os eixos (wght, wdth, GRAD…)
+       e precisa do arquivo variável inteiro, pedido pela faixa de cada eixo
+       ("Roboto+Flex:opsz,slnt,wdth,wght,GRAD@8..144,…"). As outras seguem
+       com os pesos fixos. */
+    const variaveis = plano.fontesVariaveis || {};
     const familias = [...usadas]
-        .map((f) => 'family=' + encodeURIComponent(f).replace(/%20/g, '+') + ':wght@300;400;500;600;700;800;900')
+        // O Google devolve o que a família tem e ignora o resto: pedir todos os pesos e o itálico não quebra.
+        .map((f) => 'family=' + encodeURIComponent(f).replace(/%20/g, '+')
+            + (variaveis[f] ? ':' + variaveis[f] : ':ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,600'))
         .join('&');
     return `@import url('https://fonts.googleapis.com/css2?${familias}&display=block');\n`;
 }
@@ -860,15 +914,47 @@ function citarWin(a) {
     return '"' + t.replace(/"/g, '""') + '"';
 }
 
+/* O REMOTION COMPARTILHADO. Cada projeto rodava o próprio `npm install`
+   (minutos, e ~300 MB por vídeo) — e um 404 passageiro do registro no meio
+   dele derrubava o vídeo inteiro (medido em 30/09: source-map-js 1.2.2).
+   Agora a instalação mora UMA vez em ~/.primocode/studio/remotion-base, com
+   as mesmas dependências, e o projeto aponta para ela. Dependência diferente
+   (versão nova do Remotion) reinstala a base. */
+const os = require('os');
+function baseCompartilhada(raiz) {
+    const base = path.join(os.homedir(), '.primocode', 'studio', 'remotion-base');
+    let deps = '';
+    try { const pj = JSON.parse(fs.readFileSync(path.join(raiz, 'package.json'), 'utf8')); deps = JSON.stringify({ d: pj.dependencies || {}, v: pj.devDependencies || {} }); } catch { return null; }
+    return { base, deps, pronta: (() => {
+        try { return fs.existsSync(path.join(base, 'node_modules', '.bin')) && fs.readFileSync(path.join(base, 'deps.json'), 'utf8') === deps; } catch { return false; }
+    })() };
+}
+
 function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     return new Promise((resolve) => {
-        const temNodeModules = fs.existsSync(path.join(raiz, 'node_modules'));
-        const passos = temNodeModules ? [] : [['npm', ['install', '--no-audit', '--no-fund']]];
-        passos.push(['npx', ['remotion', 'render', 'Video', saida, '--log=warn']]);
-
-        const correr = (i) => {
+        let temNodeModules = fs.existsSync(path.join(raiz, 'node_modules'));
+        const comp = temNodeModules || process.platform === 'win32' ? null : baseCompartilhada(raiz);
+        if (comp && comp.pronta) {
+            try { fs.symlinkSync(path.join(comp.base, 'node_modules'), path.join(raiz, 'node_modules'), 'dir'); temNodeModules = true; } catch { /* instala aqui mesmo */ }
+        }
+        const passos = [];
+        if (!temNodeModules && comp) {
+            // Instala na base (com uma segunda tentativa: o registro às vezes devolve 404 por instantes) e liga.
+            try { fs.mkdirSync(comp.base, { recursive: true }); fs.copyFileSync(path.join(raiz, 'package.json'), path.join(comp.base, 'package.json')); } catch { /* segue */ }
+            passos.push(['npm', ['install', '--no-audit', '--no-fund'], { cwd: comp.base, tentativas: 2, depois: () => {
+                fs.writeFileSync(path.join(comp.base, 'deps.json'), comp.deps);
+                try { fs.symlinkSync(path.join(comp.base, 'node_modules'), path.join(raiz, 'node_modules'), 'dir'); } catch { /* já existe */ }
+            } }]);
+        } else if (!temNodeModules) passos.push(['npm', ['install', '--no-audit', '--no-fund'], { tentativas: 2 }]);
+        // Vídeo de b-roll pesado (Pexels HD) levava mais de 30 s para o primeiro quadro.
+        /* VÁRIOS TRABALHADORES no render: o Remotion usa metade dos núcleos por
+           padrão; aqui vão quase todos (um fica para o terminal respirar). */
+        const nucleos = Math.max(2, (require('os').cpus() || []).length - 1);
+        passos.push(['npx', ['remotion', 'render', 'Video', saida, '--log=warn', '--timeout=120000', `--concurrency=${nucleos}`]]);
+
+        const correr = (i, tentativa = 1) => {
             if (i >= passos.length) return resolve({ ok: true, arquivo: saida });
-            const [cmd, args] = passos[i];
+            const [cmd, args, op = {}] = passos[i];
             aoFalar(i === 0 && !temNodeModules
                 ? 'instalando o Remotion nesta pasta (uma vez só, alguns minutos)'
                 : 'renderizando quadro a quadro');
@@ -882,7 +968,7 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
                CVE-2024-27980 o Node recusa spawnar npm.cmd/npx.cmd sem shell.
                Então as aspas entram na mão, só onde o shell existe. */
             const citados = process.platform === 'win32' ? args.map(citarWin) : args;
-            const p = spawn(cmd, citados, { cwd: raiz, shell: process.platform === 'win32' });
+            const p = spawn(cmd, citados, { cwd: op.cwd || raiz, shell: process.platform === 'win32' });
             let erro = '';
             p.stderr.on('data', (d) => { erro += d.toString().slice(0, 2000); });
             p.stdout.on('data', (d) => {
@@ -893,8 +979,10 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
             p.on('close', (code) => {
                 clearTimeout(relogio);
                 if (code !== 0) {
+                    if (tentativa < (op.tentativas || 1)) { aoFalar('o npm tropeçou — tentando de novo'); return setTimeout(() => correr(i, tentativa + 1), 3000); }
                     return resolve({ ok: false, error: `${cmd} saiu com ${code}: ${erro.slice(-600).trim()}` });
                 }
+                try { if (op.depois) op.depois(); } catch { /* segue */ }
                 correr(i + 1);
             });
             p.on('error', (e) => {
@@ -917,4 +1005,4 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     });
 }
 
-module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX };
+module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX, pkgJson, baseCompartilhada, TSCONFIG };

package/lib/estudio/ritmo.js

@@ -0,0 +1,77 @@
+/**
+ * ritmo.js — o tempo de um vídeo feito de partes: onde cada uma corta, quando
+ * cada coisa entra, e a música que abaixa quando a voz fala.
+ *
+ *   "O áudio comanda o quadro." — guia MOTION VOX STYLE
+ *
+ * Os estilos de cena por parte (vox.js, lancamento.js) dividem isto: o corte
+ * cai no beat (um pouco antes da primeira palavra da parte), cada elemento
+ * entra no instante em que a palavra dele é dita, e o volume da trilha segue
+ * a narração. Puro: tempos entram, números saem.
+ */
+
+'use strict';
+
+const { quando } = require('./cinema.js');
+
+const r2 = (n) => Math.round(n * 100) / 100;
+
+/**
+ * Onde cada parte começa e quanto dura.
+ *
+ * Com voz, a parte começa `antes` segundos antes da primeira palavra (o corte
+ * seco no beat) e vai até a próxima; a última ganha `cauda` de respiro. Sem
+ * voz, cada parte dura o que se leva para ler o que ela mostra.
+ *
+ * @returns {{ini:number[], dur:number[], total:number, temVoz:boolean}}
+ */
+function tempoDasPartes(partes, tempos = [], { semVoz = () => 2.0, antes = 0.08, cauda = 0.6, minimo = 0.9 } = {}) {
+    const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
+    const ini = [];
+    if (temVoz) partes.forEach((_, i) => ini.push(i === 0 ? 0 : r2(Math.max(ini[i - 1] + minimo, tempos[i].de - antes))));
+    else partes.forEach((p, i) => ini.push(i === 0 ? 0 : r2(ini[i - 1] + Math.max(minimo, semVoz(partes[i - 1])))));
+    const total = r2(temVoz ? Math.max(ini[ini.length - 1] + minimo, tempos[tempos.length - 1].ate + cauda) : ini[ini.length - 1] + Math.max(minimo, semVoz(partes[partes.length - 1])) + 0.4);
+    const dur = ini.map((t, i) => r2((i < ini.length - 1 ? ini[i + 1] : total) - t));
+    return { ini, dur, total, temVoz };
+}
+
+/**
+ * Quando cada texto entra, no tempo DA CENA: o instante em que a primeira
+ * palavra forte dele é dita. Sem voz (ou sem achar), espalha os textos pelo
+ * começo da cena, respeitando a ordem.
+ */
+function gatilhos(textos, tempo, inicio, dur, { t0 = 0.3, ate = 0.62 } = {}) {
+    const palavras = (tempo && tempo.palavras) || [];
+    const fim = Math.max(t0 + 0.2, dur * ate);
+    if (!palavras.length) return textos.map((_, i) => r2(t0 + (fim - t0) * (i / Math.max(1, textos.length))));
+    const abs = quando(textos, palavras, inicio + fim, inicio + t0);
+    // Nunca antes do corte, nunca tarde demais para ser lido, sempre em ordem.
+    let antes = 0;
+    return abs.map((t) => {
+        const rel = Math.min(Math.max(0.08, t - inicio), Math.max(0.1, dur - 0.9));
+        antes = Math.max(antes + 0.1, rel);
+        return r2(antes);
+    });
+}
+
+/** As palavras faladas numa parte, no tempo da cena: [{texto, t}]. */
+function palavrasNaCena(tempo, inicio) {
+    return ((tempo && tempo.palavras) || []).map((w) => ({ texto: w.texto, t: r2(Math.max(0.05, w.de - inicio)) }));
+}
+
+/** O volume da trilha no tempo: cheia no respiro, baixa quando a voz fala, some no fim. */
+function volumesDaTrilha(tempos, total, { alto = 0.4, baixo = 0.2 } = {}) {
+    const k = (t, v) => ({ t: r2(t), v });
+    const vs = [k(0, 0.05), k(0.4, alto)];
+    // Um quadro-chave de cada vez, sempre depois do anterior: fala colada na outra não volta no tempo.
+    const poe = (t, v) => vs.push(k(Math.max(vs[vs.length - 1].t + 0.01, t), v));
+    for (const tp of tempos || []) {
+        if (!tp || !(tp.ate > tp.de)) continue;
+        poe(tp.de - 0.15, alto); poe(tp.de, baixo); poe(tp.ate, baixo); poe(tp.ate + 0.35, alto);
+    }
+    poe(total - 0.6, alto * 0.9);
+    poe(total, 0);
+    return vs;
+}
+
+module.exports = { tempoDasPartes, gatilhos, palavrasNaCena, volumesDaTrilha, r2 };

package/lib/estudio/sons-leves.js

@@ -32,6 +32,14 @@ const EFEITOS = {
     subida: ['-f', 'lavfi', '-i', "aevalsrc='0.28*sin(2*PI*(180+260*t*t)*t)*(t/1.4)':s=44100:d=1.4", '-af', 'afade=t=out:st=1.2:d=0.2'],
     // Toque grave e macio: o que chega e assenta.
     toque: ['-f', 'lavfi', '-i', "aevalsrc='0.7*sin(2*PI*(110-50*t)*t)*exp(-7*t)':s=44100:d=0.6", '-af', 'lowpass=f=900'],
+    /* Os CHEIOS do motion gerativo ("motion é vida: efeito sonoro NA ação",
+       30/09): o whoosh da passagem, o impacto da tese, o riser antes da
+       revelação e o pop da letra que nasce. Ainda sintetizados, ainda limpos. */
+    whoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.75:c=pink:a=0.9', '-af',
+        'bandpass=f=1100:width_type=o:w=2.2,afade=t=in:st=0:d=0.42:curve=exp,afade=t=out:st=0.42:d=0.33:curve=qsin,volume=2.2'],
+    impacto: ['-f', 'lavfi', '-i', "aevalsrc='0.95*sin(2*PI*(62-26*t)*t)*exp(-4.5*t)+0.45*(random(0)*2-1)*exp(-38*t)':s=44100:d=1.1", '-af', 'lowpass=f=2600,volume=1.4'],
+    riser: ['-f', 'lavfi', '-i', "aevalsrc='(0.32*sin(2*PI*(170+620*t*t)*t)+0.22*(random(0)*2-1))*pow(t/1.1,2)':s=44100:d=1.1", '-af', 'highpass=f=260,afade=t=out:st=1.04:d=0.06,volume=1.3'],
+    pop: ['-f', 'lavfi', '-i', "aevalsrc='0.8*sin(2*PI*(980-640*t)*t)*exp(-28*t)*(1-exp(-700*t))':s=44100:d=0.18"],
 };
 
 /**
@@ -59,4 +67,33 @@ function preparar(pasta, { rodar = null } = {}) {
     return sons;
 }
 
-module.exports = { EFEITOS, preparar };
+/**
+ * A família de sons de UM vídeo (gerativo.js sonsDoVideo): cada receita vira
+ * midia/sfx-g<semente>-<nome>.mp3. O que já existe não é refeito.
+ */
+function prepararReceitas(pasta, { receitas = {}, semente = 0 } = {}, { rodar = null } = {}) {
+    const exec = rodar || ((args) => {
+        try { require('child_process').execFileSync('ffmpeg', args, { stdio: 'ignore', timeout: 30000 }); return true; }
+        catch { return false; }
+    });
+    const sons = {};
+    const sufixo = (semente >>> 0).toString(36);
+    for (const [nome, args] of Object.entries(receitas)) {
+        const rel = `midia/sfx-g${sufixo}-${nome}.mp3`;
+        const cheio = path.join(pasta, rel);
+        if (!fs.existsSync(cheio)) {
+            fs.mkdirSync(path.dirname(cheio), { recursive: true });
+            // O limitador no fim: o golpe sintetizado passava de 0 dB e estalava.
+            // "{pasta}" é a pasta do projeto: o som feito da própria trilha lê o arquivo dela.
+            const a = args.map((x) => String(x).split('{pasta}').join(pasta));
+            const fc = a.indexOf('-filter_complex'), i = a.indexOf('-af');
+            if (fc >= 0) a[fc + 1] += ',alimiter=limit=0.8:level=false';
+            else if (i >= 0) a[i + 1] += ',alimiter=limit=0.8:level=false'; else a.push('-af', 'alimiter=limit=0.8:level=false');
+            if (!exec(['-y', '-loglevel', 'error', ...a, '-q:a', '3', cheio])) continue;
+        }
+        sons[nome] = rel;
+    }
+    return sons;
+}
+
+module.exports = { EFEITOS, preparar, prepararReceitas };

package/lib/estudio/variedade.js

@@ -0,0 +1,105 @@
+/**
+ * variedade.js — a trilha e os efeitos dos vídeos de corte (híbrido, cinema,
+ * impacto) sem repetir de um vídeo para o outro.
+ *
+ *   "todos os vídeos é sempre as mesmas músicas, os mesmos efeitos sonoros,
+ *    sempre o mesmo padrão de vídeo" (Joel, 02/10)
+ *
+ * A causa era a mesma nos dois: um termo fixo na busca ("inspiring
+ * corporate", "cinematic whoosh") e o PRIMEIRO resultado baixado. A busca
+ * devolve a mesma lista na mesma ordem, então todo vídeo saía com a mesma
+ * faixa e o mesmo whoosh. Aqui:
+ *   1. o termo sai de um cardápio pelo clima do roteiro, em ordem sorteada;
+ *   2. dos resultados, sorteia — e pula o que os últimos vídeos já usaram;
+ *   3. o que foi usado entra na memória (~/.primocode/studio/<tipo>-usadas.json).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PASTA = path.join(os.homedir(), '.primocode', 'studio');
+const MEMORIA = { trilha: 16, sfx: 40 };
+
+function arquivo(tipo) { return path.join(PASTA, `${tipo}-usadas.json`); }
+
+function usadas(tipo) {
+    try { const l = JSON.parse(fs.readFileSync(arquivo(tipo), 'utf8')); return Array.isArray(l) ? l : []; } catch { return []; }
+}
+
+function marcar(tipo, id) {
+    if (!id) return;
+    try {
+        fs.mkdirSync(PASTA, { recursive: true });
+        const l = [id, ...usadas(tipo).filter((x) => x !== id)].slice(0, MEMORIA[tipo] || 20);
+        fs.writeFileSync(arquivo(tipo), JSON.stringify(l));
+    } catch { /* sem memória: só perde a garantia de não repetir */ }
+}
+
+function embaralhar(lista, aleatorio = Math.random) {
+    const a = [...lista];
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(aleatorio() * (i + 1));
+        [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+}
+
+/** Os itens da busca na ordem de tentar: os nunca usados primeiro (sorteados), os usados no fim. */
+function ordenar(itens, tipo, aleatorio = Math.random) {
+    const ja = new Set(usadas(tipo));
+    const validos = (itens || []).filter((x) => x && x.url);
+    return [...embaralhar(validos.filter((x) => !ja.has(x.url)), aleatorio), ...validos.filter((x) => ja.has(x.url))];
+}
+
+// ── a trilha: termos por clima ──────────────────────────────────────────
+const CLIMAS = {
+    tecnologia: ['electronic instrumental', 'synthwave instrumental', 'future bass instrumental', 'downtempo electronic', 'minimal techno instrumental', 'chillwave instrumental'],
+    energetico: ['funk instrumental', 'rock instrumental', 'drum and bass instrumental', 'breakbeat instrumental', 'upbeat indie instrumental', 'house instrumental'],
+    epico: ['epic orchestral', 'trailer instrumental', 'cinematic drums', 'epic hybrid instrumental', 'dramatic strings'],
+    calmo: ['lofi hip hop instrumental', 'ambient instrumental', 'acoustic guitar instrumental', 'piano instrumental', 'jazz instrumental'],
+    alegre: ['ukulele instrumental', 'indie pop instrumental', 'happy acoustic instrumental', 'latin instrumental', 'disco instrumental'],
+    emocional: ['piano emotional instrumental', 'post rock instrumental', 'cinematic strings', 'neo classical instrumental'],
+    misterio: ['dark ambient instrumental', 'trip hop instrumental', 'suspense instrumental', 'noir jazz instrumental'],
+    neutro: ['indie instrumental', 'soul instrumental', 'jazz hop instrumental', 'world instrumental', 'electronic instrumental', 'acoustic instrumental'],
+};
+const SINONIMOS = {
+    tecnologia: /tec|tech|ia\b|ai\b|software|app|digital|futur/, energetico: /energ|agit|rapid|forte|esport|academ/,
+    epico: /epic|epico|grandi|trailer|impact/, calmo: /calm|tranq|suave|relax|chill/, alegre: /aleg|feliz|divert|leve/,
+    emocional: /emoc|emoti|inspir|sentim|historia/, misterio: /mist|sombr|dark|suspen|tens/,
+};
+
+function climaDe(roteiro = {}, estilo = '') {
+    const t = String([roteiro.clima, roteiro.genero, roteiro.tom].filter(Boolean).join(' ')).toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '');
+    for (const [clima, re] of Object.entries(SINONIMOS)) if (re.test(t)) return clima;
+    return estilo === 'impacto' ? 'energetico' : 'neutro';
+}
+
+/**
+ * Os termos para buscar a trilha, em ordem de tentar. O pedido explícito
+ * (roteiro.musica) vem primeiro; depois o clima, sorteado; e por último um
+ * clima vizinho, para nunca sair sem música.
+ */
+function termosTrilha(roteiro = {}, estilo = '', aleatorio = Math.random) {
+    const clima = climaDe(roteiro, estilo);
+    const reserva = clima === 'neutro' ? 'calmo' : 'neutro';
+    return [...new Set([roteiro.musica, ...embaralhar(CLIMAS[clima], aleatorio).slice(0, 3),
+        ...embaralhar(CLIMAS[reserva], aleatorio).slice(0, 2)].filter(Boolean))];
+}
+
+// ── os efeitos: várias formas de pedir o mesmo som ───────────────────────
+const SFX = {
+    teclado: ['keyboard typing', 'typing keyboard', 'mechanical keyboard', 'laptop typing', 'typewriter keys'],
+    whoosh: ['cinematic whoosh', 'swoosh transition', 'air whoosh', 'fast swipe', 'woosh pass by', 'riser whoosh'],
+    impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit', 'bass drop hit', 'punch hit', 'sub boom'],
+    sala: ['crowd murmur indoor', 'office ambience', 'people talking background', 'cafe ambience', 'room tone people'],
+};
+
+function termosSfx(nome, aleatorio = Math.random) {
+    return embaralhar(SFX[nome] || [nome], aleatorio).slice(0, 3);
+}
+
+module.exports = { usadas, marcar, embaralhar, ordenar, climaDe, termosTrilha, termosSfx, CLIMAS, SFX };