primocode 10.0.9 → 10.1.0

package/lib/estudio/kit/tres.jsx

@@ -4,8 +4,9 @@
  *   (30/09), com "sem referências": nada de foto, então o produto é modelado
  *   aqui, com as peças do three.js, e iluminado como em estúdio.
  *
- * {"tipo":"kit","peca":"produto3d","modelo":"fone"|"celular"|"lata"|"caixa",
+ * {"tipo":"kit","peca":"produto3d","modelo":"fone"|"celular"|"lata"|"caixa"|"notebook"|"garrafa"|"relogio",
  *  "cor":"#1b1c20","corAcento":"#ff5a1f","t":0,"giro":0.35,
+ *  "acabamento":"metal","camera":"alto","luz":"recorte","ritmo":"pendulo",   (variacao3d.js)
  *  "x":0,"y":0,"largura":1920,"altura":1080}
  *
  * O movimento: entra pequeno e girado e assenta com mola (0,9 s), depois gira
@@ -33,19 +34,34 @@ function Ambiente({ forca = 1 }) {
 
 const saida = (x) => 1 - Math.pow(1 - Math.max(0, Math.min(1, x)), 3);
 
-function Material({ cor, brilho = 0.35, metal = 0.25, verniz = 0.8, emissivo }) {
-  return <meshPhysicalMaterial color={cor} roughness={brilho} metalness={metal} clearcoat={verniz} clearcoatRoughness={0.25}
+function Material({ cor, brilho = 0.35, metal = 0.25, verniz = 0.8, iris = 0, emissivo }) {
+  return <meshPhysicalMaterial color={cor} roughness={brilho} metalness={metal} clearcoat={verniz} clearcoatRoughness={0.25} iridescence={iris}
     {...(emissivo ? { emissive: emissivo, emissiveIntensity: 1.2 } : {})} />;
 }
 
 // O fone: o arco, os deslizadores, as conchas com o anel de acento, as almofadas e o logo aceso.
-function Fone({ cor, acento }) {
+/* AS VARIAÇÕES (variacao3d.js sorteia os nomes): o acabamento do corpo, o
+   enquadramento, a luz e o ritmo. Sem nome, o de sempre. */
+const ACABAMENTOS = {
+  verniz: { brilho: 0.3, metal: 0.3, verniz: 0.8 }, metal: { brilho: 0.18, metal: 0.92, verniz: 0.3 },
+  fosco: { brilho: 0.78, metal: 0, verniz: 0 }, perola: { brilho: 0.25, metal: 0.1, verniz: 1, iris: 1 },
+  acetinado: { brilho: 0.5, metal: 0.45, verniz: 0.4 },
+};
+const CAMERAS = {
+  frente: {}, alto: { y: 1.5, inclina: 0.12 }, baixo: { y: -0.6, inclina: -0.1 },
+  perfil: { giro0: -1.7, roll: 0.07 }, perto: { fov: 25 },
+};
+// [chave, preenchimento, recorte na cor de acento, ambiente]
+const LUZES = { estudio: [3.2, 1.1, 3.2, 0.35], recorte: [1.6, 0.4, 5.5, 0.15], suave: [2.2, 2.0, 1.4, 0.7], lateral: [4.2, 0.2, 2.6, 0.2] };
+const RITMOS = { lento: 0.18, medio: 0.35, rapido: 0.6 };
+
+function Fone({ cor, acento, fin }) {
   const R = 1.05;
   const concha = (lado) => (
     <group position={[lado * R, -0.12, 0]}>
       <mesh rotation={[0, 0, Math.PI / 2]}>
         <cylinderGeometry args={[0.44, 0.46, 0.26, 64]} />
-        <Material cor={cor} brilho={0.3} metal={0.35} />
+        <Material cor={cor} brilho={0.3} metal={0.35} {...fin} />
       </mesh>
       <mesh position={[lado * 0.135, 0, 0]} rotation={[0, Math.PI / 2, 0]}>
         <torusGeometry args={[0.43, 0.035, 24, 96]} />
@@ -65,7 +81,7 @@ function Fone({ cor, acento }) {
     <group>
       <mesh>
         <torusGeometry args={[R, 0.075, 32, 160, Math.PI]} />
-        <Material cor={cor} brilho={0.28} metal={0.4} />
+        <Material cor={cor} brilho={0.28} metal={0.4} {...fin} />
       </mesh>
       <mesh position={[0, -0.06, 0]} scale={[1, 1, 1.6]}>
         <torusGeometry args={[R - 0.07, 0.05, 24, 140, Math.PI]} />
@@ -83,10 +99,10 @@ function Fone({ cor, acento }) {
   );
 }
 
-function Celular({ cor, acento }) {
+function Celular({ cor, acento, fin }) {
   return (
     <group rotation={[0, 0, 0.05]}>
-      <mesh><boxGeometry args={[1.0, 2.05, 0.1]} /><Material cor={cor} brilho={0.22} metal={0.7} /></mesh>
+      <mesh><boxGeometry args={[1.0, 2.05, 0.1]} /><Material cor={cor} brilho={0.22} metal={0.7} {...fin} /></mesh>
       <mesh position={[0, 0, 0.052]}><planeGeometry args={[0.92, 1.96]} /><Material cor="#0b0c10" brilho={0.1} metal={0} emissivo="#0d1830" /></mesh>
       <mesh position={[0, 0.3, 0.054]}><circleGeometry args={[0.22, 48]} /><Material cor={acento} emissivo={acento} /></mesh>
       <mesh position={[0.26, 0.78, -0.07]} rotation={[Math.PI / 2, 0, 0]}><cylinderGeometry args={[0.14, 0.14, 0.05, 48]} /><Material cor="#222" brilho={0.1} metal={0.9} /></mesh>
@@ -94,26 +110,72 @@ function Celular({ cor, acento }) {
   );
 }
 
-function Lata({ cor, acento }) {
+function Lata({ cor, acento, fin }) {
   return (
     <group>
-      <mesh><cylinderGeometry args={[0.55, 0.55, 1.9, 96]} /><Material cor={cor} brilho={0.2} metal={0.85} /></mesh>
+      <mesh><cylinderGeometry args={[0.55, 0.55, 1.9, 96]} /><Material cor={cor} brilho={0.2} metal={0.85} {...fin} /></mesh>
       <mesh position={[0, 0.2, 0]}><cylinderGeometry args={[0.556, 0.556, 0.5, 96, 1, true]} /><Material cor={acento} brilho={0.3} metal={0.3} /></mesh>
       <mesh position={[0, 0.97, 0]}><cylinderGeometry args={[0.5, 0.55, 0.06, 96]} /><Material cor="#c9ccd2" brilho={0.25} metal={1} /></mesh>
     </group>
   );
 }
 
-function Caixa({ cor, acento }) {
+function Caixa({ cor, acento, fin }) {
   return (
     <group>
-      <mesh><boxGeometry args={[1.5, 1.5, 1.5]} /><Material cor={cor} brilho={0.3} metal={0.3} /></mesh>
+      <mesh><boxGeometry args={[1.5, 1.5, 1.5]} /><Material cor={cor} brilho={0.3} metal={0.3} {...fin} /></mesh>
       <mesh position={[0, 0, 0.752]}><planeGeometry args={[1.0, 0.18]} /><Material cor={acento} emissivo={acento} /></mesh>
     </group>
   );
 }
 
-const MODELOS = { fone: Fone, headset: Fone, celular: Celular, phone: Celular, lata: Lata, garrafa: Lata, caixa: Caixa };
+// O notebook: a base, o teclado escuro, a tampa aberta a ~105° e a tela acesa.
+function Notebook({ cor, acento, fin }) {
+  return (
+    <group position={[0, -0.3, 0.1]} rotation={[0.1, 0, 0]} scale={[0.7, 0.7, 0.7]}>{/* a 1,0 a tela saía cortada no topo (05/10) */}
+      <mesh><boxGeometry args={[2.2, 0.08, 1.45]} /><Material cor={cor} brilho={0.25} metal={0.75} {...fin} /></mesh>
+      <mesh position={[0, 0.042, -0.12]}><boxGeometry args={[1.9, 0.01, 0.75]} /><Material cor="#141416" brilho={0.8} metal={0} verniz={0} /></mesh>
+      <mesh position={[0, 0.042, 0.45]}><boxGeometry args={[0.7, 0.01, 0.38]} /><Material cor="#26272c" brilho={0.4} metal={0.2} /></mesh>
+      <group position={[0, 0.04, -0.72]} rotation={[-0.26, 0, 0]}>
+        <mesh position={[0, 0.72, 0]}><boxGeometry args={[2.2, 1.44, 0.06]} /><Material cor={cor} brilho={0.25} metal={0.75} {...fin} /></mesh>
+        <mesh position={[0, 0.74, 0.032]}><planeGeometry args={[2.0, 1.25]} /><Material cor="#0b0c10" brilho={0.1} metal={0} emissivo="#0d1830" /></mesh>
+        <mesh position={[0, 0.74, 0.034]}><circleGeometry args={[0.2, 48]} /><Material cor={acento} emissivo={acento} /></mesh>
+      </group>
+    </group>
+  );
+}
+
+// A garrafa: o corpo, o ombro, o gargalo, a tampa e o rótulo na cor de acento.
+function Garrafa({ cor, acento, fin }) {
+  return (
+    <group position={[0, -0.15, 0]}>
+      <mesh><cylinderGeometry args={[0.5, 0.5, 1.5, 96]} /><Material cor={cor} brilho={0.15} metal={0.6} {...fin} /></mesh>
+      <mesh position={[0, 0.95, 0]}><cylinderGeometry args={[0.2, 0.5, 0.4, 96]} /><Material cor={cor} brilho={0.15} metal={0.6} {...fin} /></mesh>
+      <mesh position={[0, 1.3, 0]}><cylinderGeometry args={[0.2, 0.2, 0.3, 64]} /><Material cor={cor} brilho={0.15} metal={0.6} {...fin} /></mesh>
+      <mesh position={[0, 1.52, 0]}><cylinderGeometry args={[0.23, 0.23, 0.18, 64]} /><Material cor={acento} brilho={0.3} metal={0.8} /></mesh>
+      <mesh position={[0, 0.05, 0]}><cylinderGeometry args={[0.506, 0.506, 0.55, 96, 1, true]} /><Material cor={acento} brilho={0.5} metal={0.1} verniz={0.3} /></mesh>
+    </group>
+  );
+}
+
+// O relógio: a caixa redonda, o aro de acento, o mostrador aceso e a pulseira.
+function Relogio({ cor, acento, fin }) {
+  return (
+    <group>
+      <mesh rotation={[Math.PI / 2, 0, 0]}><cylinderGeometry args={[0.62, 0.62, 0.22, 96]} /><Material cor={cor} brilho={0.2} metal={0.85} {...fin} /></mesh>
+      <mesh position={[0, 0, 0.11]}><torusGeometry args={[0.6, 0.045, 24, 96]} /><Material cor={acento} brilho={0.15} metal={0.95} verniz={1} /></mesh>
+      <mesh position={[0, 0, 0.112]}><circleGeometry args={[0.55, 64]} /><Material cor="#0b0c10" brilho={0.1} metal={0} emissivo="#0d1830" /></mesh>
+      <mesh position={[0, 0.16, 0.116]}><boxGeometry args={[0.04, 0.32, 0.01]} /><Material cor={acento} emissivo={acento} /></mesh>
+      <mesh position={[0.1, 0, 0.118]} rotation={[0, 0, -Math.PI / 2]}><boxGeometry args={[0.05, 0.22, 0.01]} /><Material cor="#f4f4f6" emissivo="#9aa0aa" /></mesh>
+      <mesh position={[0.66, 0, 0]} rotation={[Math.PI / 2, 0, 0]}><cylinderGeometry args={[0.06, 0.06, 0.14, 24]} /><Material cor={cor} brilho={0.2} metal={0.85} {...fin} /></mesh>
+      {[-1, 1].map((l) => <mesh key={l} position={[0, l * 1.0, -0.02]}><boxGeometry args={[0.6, 0.85, 0.08]} /><Material cor="#1a1a1d" brilho={0.7} metal={0} verniz={0.2} /></mesh>)}
+    </group>
+  );
+}
+
+const MODELOS = { fone: Fone, headset: Fone, celular: Celular, phone: Celular, lata: Lata, garrafa: Garrafa, caixa: Caixa,
+  notebook: Notebook, laptop: Notebook, relogio: Relogio, watch: Relogio };
+export const MODELOS_3D = Object.keys(MODELOS);
 
 export function Produto3D({ el, t }) {
   const W = el.largura || 1920, H = el.altura || 1080;
@@ -123,21 +185,26 @@ export function Produto3D({ el, t }) {
   const Modelo = MODELOS[el.modelo] || Caixa;
   const cor = el.cor || '#1b1c20';
   const acento = el.corAcento || '#ff5a1f';
-  const giro = (el.giro0 ?? -0.9) + (1 - k) * 1.4 + tl * (el.giro ?? 0.35);
+  const cam = CAMERAS[el.camera] || {};
+  const luz = LUZES[el.luz] || LUZES.estudio;
+  const fin = ACABAMENTOS[el.acabamento];
+  // O ritmo: o giro contínuo em três velocidades, ou o pêndulo, que vai e volta mostrando a frente.
+  const anda = el.ritmo === 'pendulo' ? Math.sin(tl * 0.9) * 0.7 : tl * (RITMOS[el.ritmo] ?? el.giro ?? 0.35);
+  const giro = (el.giro0 ?? cam.giro0 ?? -0.9) + (1 - k) * 1.4 + anda;
   const escala = (el.escala || 1) * (0.72 + 0.28 * k);
   const flutua = Math.sin(tl * 1.3) * 0.05;
   return (
     <div style={{ position: 'absolute', left: el.x || 0, top: el.y || 0, width: W, height: H, opacity: t >= t0 ? Math.min(1, tl / 0.25) : 0 }}>
-      <ThreeCanvas width={W} height={H} camera={{ position: [0, 0.35, 4.4], fov: el.fov || 32 }} gl={{ antialias: true, preserveDrawingBuffer: true }}>
+      <ThreeCanvas width={W} height={H} camera={{ position: [0, cam.y ?? 0.35, 4.4], fov: el.fov || cam.fov || 32 }} gl={{ antialias: true, preserveDrawingBuffer: true }}>
         <Ambiente forca={0.8} />
         <hemisphereLight args={['#ffffff', '#202020', 0.5]} />
-        <ambientLight intensity={0.35} />
-        <directionalLight position={[3, 4, 5]} intensity={3.2} />
-        <directionalLight position={[-2, 3, 4]} intensity={1.1} />
-        <directionalLight position={[-4, 1.5, -3]} intensity={3.2} color={acento} />
+        <ambientLight intensity={luz[3]} />
+        <directionalLight position={el.luz === 'lateral' ? [5, 1.5, 1.5] : [3, 4, 5]} intensity={luz[0]} />
+        <directionalLight position={[-2, 3, 4]} intensity={luz[1]} />
+        <directionalLight position={[-4, 1.5, -3]} intensity={luz[2]} color={acento} />
         <pointLight position={[0, -2, 3]} intensity={0.8} />
-        <group position={[0, flutua - 0.05, 0]} rotation={[0.18 + (1 - k) * 0.3, giro, 0]} scale={[escala, escala, escala]}>
-          <Modelo cor={cor} acento={acento} />
+        <group position={[0, flutua - 0.05, 0]} rotation={[0.18 + (cam.inclina || 0) + (1 - k) * 0.3, giro, cam.roll || 0]} scale={[escala, escala, escala]}>
+          <Modelo cor={cor} acento={acento} fin={fin} />
         </group>
         {/* O chão. O gerativo dispensa (semChao): o disco virava uma faixa escura atrás do texto. */}
         {!el.semChao && (

package/lib/estudio/kit.js

@@ -55,9 +55,11 @@ const PECAS = {
     icone3d: { precisa: ['icone'] },
     // O motion gerativo (kit/gerativo.jsx): a partitura inteira, numa peça só (gerativo.js).
     gerativo: { precisa: ['partitura'] },
+    // O estilo fluido (kit/fluido.jsx): a forma que vira a próxima, numa peça só (fluido.js).
+    fluido: { precisa: ['partitura'] },
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/kokoro.js

@@ -0,0 +1,111 @@
+/* A VOZ LOCAL (Kokoro-82M): roda na CPU desta máquina, sem cota e sem
+   servidor. Entra quando o Gemini falha (cota, voz cortada) ou quando o
+   roteiro pede `voz: 'kokoro'` (ou PRIMOCODE_VOZ=kokoro). Sem `uv` ou sem
+   espeak-ng ela diz que não está disponível e a corrente segue — nunca
+   derruba a narração.
+
+   Provado nesta máquina em 05/10: 11 s de áudio em 3,5 s (+4,3 s de carga
+   do modelo), sem o corte no fim que o Gemini às vezes deixa. */
+const fs = require('fs');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+const SCRIPT = path.join(__dirname, '..', '..', 'studio', 'voz_kokoro.py');
+// Sem `transformers>=4.45` o uv escolhe a 4.12 e o tokenizers não compila (05/10).
+const DEPS = ['kokoro>=0.9.4', 'transformers>=4.45', 'soundfile', 'misaki[en]'];
+// As vozes do Studio viram as do Kokoro em português: pf_dora (feminina), pm_alex (masculina).
+const VOZES = { thalita: 'pf_dora', francisca: 'pf_dora', feminina: 'pf_dora', antonio: 'pm_alex', masculina: 'pm_alex' };
+
+/** O roteiro (ou quem usa) pediu a voz local? */
+function querKokoro(voz, env = process.env) {
+    return String(voz || '').toLowerCase() === 'kokoro' || String(env.PRIMOCODE_VOZ || '').toLowerCase() === 'kokoro';
+}
+
+/** "PrimoCode" sai "Primo Kodi" no Kokoro; escrito assim, sai certo. */
+function pronuncia(texto) {
+    return String(texto || '').replace(/primo\s*code/gi, 'Primo Côude');
+}
+
+function vozKokoro(voz) {
+    const v = String(voz || '').toLowerCase();
+    if (/^p[fm]_/.test(v)) return v;
+    return VOZES[v] || 'pm_alex';
+}
+
+/** Onde está o espeak-ng (o Kokoro precisa dele para o português). */
+function acharEspeak({ existe = fs.existsSync, brew = () => execFileSync('brew', ['--prefix', 'espeak-ng'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }).toString().trim() } = {}) {
+    const bases = [];
+    try { bases.push(brew()); } catch { /* sem brew */ }
+    bases.push('/opt/homebrew/opt/espeak-ng', '/usr/local/opt/espeak-ng', '/usr');
+    for (const b of bases) {
+        if (!b) continue;
+        const dados = path.join(b, 'share', 'espeak-ng-data');
+        const lib = ['lib/libespeak-ng.dylib', 'lib/libespeak-ng.so.1', 'lib/x86_64-linux-gnu/libespeak-ng.so.1', 'lib/aarch64-linux-gnu/libespeak-ng.so.1']
+            .map((l) => path.join(b, l)).find(existe);
+        if (existe(dados) && lib) return { dados, lib };
+    }
+    return null;
+}
+
+/** O comando inteiro (uv + deps fixadas + env do espeak), ou null se falta peça. */
+function comando({ uv, espeak, arquivo, saida, voz, env = process.env }) {
+    if (!uv || !espeak) return null;
+    const args = ['run', '--quiet', '--python', '3.11'];
+    for (const d of DEPS) args.push('--with', d);
+    args.push('python', SCRIPT, 'roteiro', '--arquivo', arquivo, '--saida', saida, '--voz', vozKokoro(voz));
+    return { cmd: uv, args, env: { ...env, ESPEAK_DATA_PATH: espeak.dados, PHONEMIZER_ESPEAK_LIBRARY: espeak.lib } };
+}
+
+function rodar({ cmd, args, env }, timeout) {
+    return new Promise((resolve) => {
+        const p = spawn(cmd, args, { env });
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', () => {
+            clearTimeout(relogio);
+            try { resolve(JSON.parse(saida.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: (erro || saida).slice(-400).trim() || 'o kokoro não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
+/** Narra a lista [{texto}] em mp3 com o Kokoro. Devolve o mesmo formato do narrar.py. */
+async function narrar(lista, mp3, { voz, uv, espeak = acharEspeak(), executar = rodar, timeout = 15 * 60000 } = {}) {
+    const arquivo = mp3.replace(/\.mp3$/, '') + '.kokoro.json';
+    const c = comando({ uv, espeak, arquivo, saida: mp3, voz });
+    if (!c) return { ok: false, indisponivel: true, error: !uv ? 'kokoro: falta o uv' : 'kokoro: falta o espeak-ng (brew install espeak-ng)' };
+    try {
+        fs.writeFileSync(arquivo, JSON.stringify(lista.map((x) => ({ ...x, texto: pronuncia(x.texto) }))));
+        return await executar(c, timeout);
+    } catch (e) {
+        return { ok: false, error: e.message };
+    } finally {
+        try { fs.unlinkSync(arquivo); } catch { /* fica */ }
+    }
+}
+
+/** A ordem das vozes: pedida → Kokoro e depois o Edge; senão Gemini → Kokoro → Edge.
+    `motorVoz: 'edge'` no roteiro pula as outras. */
+function ordem(voz, env = process.env, { soEdge = false } = {}) {
+    if (soEdge) return ['edge'];
+    return querKokoro(voz, env) ? ['kokoro', 'edge'] : ['gemini', 'kokoro', 'edge'];
+}
+
+/** Roda a corrente: a primeira voz que der certo ganha; a falha de uma nunca derruba. */
+async function corrente(passos, provedores) {
+    let ultimo = { ok: false, error: 'nenhuma voz disponível' };
+    for (const nome of passos) {
+        const f = provedores[nome];
+        if (!f) continue;
+        let r;
+        try { r = await f(); } catch (e) { r = { ok: false, error: e.message }; }
+        if (r && r.ok) return r;
+        if (r) ultimo = r;
+    }
+    return ultimo;
+}
+
+module.exports = { querKokoro, pronuncia, vozKokoro, acharEspeak, comando, narrar, ordem, corrente, DEPS, SCRIPT };

package/lib/estudio/lancamento.js

@@ -29,6 +29,7 @@ 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 { modeloDoPedido } = require('./variacao3d.js');
 
 const FPS = 30;
 const k = (t, v, e) => (e ? { t: r2(t), v, e } : { t: r2(t), v });
@@ -328,9 +329,7 @@ function montarLancamento({ roteiro, variante = 'lancamento', largura = 1920, al
     // ── 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 modeloDe = modeloDoPedido;
     const VISUAL = {
         /* O PRODUTO EM 3D (kit/tres.jsx): modelado e iluminado aqui, sem foto
            de fora — girando devagar no centro, o nome embaixo. */
@@ -340,7 +339,7 @@ function montarLancamento({ roteiro, variante = 'lancamento', largura = 1920, al
             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,
+                { tipo: 'kit', peca: 'produto3d', modelo, cor: p.cor3d || roteiro.cor3d || '#1b1c20', corAcento: ACENTO, t: 0, giro: 0.4, ...(roteiro.variacao3d || {}),
                     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 },

package/lib/estudio/legibilidade.js

@@ -0,0 +1,20 @@
+/**
+ * legibilidade.js — a lei da legibilidade do /brag, em número (comum/desmontados/
+ * latent-spaces-brag.md): rótulo curto fica PARADO ~0,8 s; frase, 0,3 s por
+ * palavra; "fast-in, then hold — never fast-in, then gone".
+ *
+ * "Parado" é o tempo entre o fim da entrada e o começo da saída. Quando a cena
+ * é curta, quem encolhe é a animação (entrada e saída), nunca a leitura.
+ */
+
+'use strict';
+
+const nPalavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
+
+/** Quanto tempo o texto precisa ficar parado na tela: max(0,8 s; 0,3 s por palavra). */
+const minimoLeitura = (t) => Math.max(0.8, 0.3 * nPalavras(t));
+
+/** O que sobra para a animação depois da leitura, entre um piso e o tempo cheio. */
+const sobra = (vida, leitura, piso, cheio) => Math.min(cheio, Math.max(piso, vida - leitura));
+
+module.exports = { minimoLeitura, nPalavras, sobra };

package/lib/estudio/remotion.js

@@ -279,14 +279,20 @@ function Elemento({ el, t, dados }) {
       if (Array.isArray(el.revelar) && typeof el.texto === 'string') {
         const palavras = el.texto.split(' ');
         conteudo = palavras.map((w, i) => {
-          const t0 = el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0;
-          const k = Math.min(1, Math.max(0, (tLocal - t0) / 0.28));
+          const marcada = !!(el.destaques && el.destaques.includes(i));
+          /* A PALAVRA DE DESTAQUE: com "fonteDestaque", o acento é a serifa em
+             itálico (na cor do texto), que chega um instante depois das outras.
+             Um acento só — nada de caixa de cor atrás (a "cara de IA", 05/10). */
+          const serifa = marcada && el.fonteDestaque;
+          const t0 = (el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0) + (serifa ? 0.12 : 0);
+          const k = Math.min(1, Math.max(0, (tLocal - t0) / (serifa ? 0.45 : 0.28)));
           const e = CURVAS.saida(k);
           // O espaço fica FORA do span: é ali que a linha pode quebrar.
           return (
             <React.Fragment key={i}>
               <span style={{ display: 'inline-block', opacity: e, transform: 'translateY(' + (1 - e) * 0.35 + 'em)',
-                color: el.destaques && el.destaques.includes(i) ? (el.corDestaque || el.cor) : undefined }}>{w}</span>
+                color: marcada && !serifa ? (el.corDestaque || el.cor) : undefined,
+                ...(serifa ? { fontFamily: '"' + el.fonteDestaque + '", Georgia, serif', fontStyle: 'italic', fontWeight: 400, fontSize: '1.1em', letterSpacing: 0 } : {}) }}>{w}</span>
               {i < palavras.length - 1 ? ' ' : null}
             </React.Fragment>
           );
@@ -465,12 +471,14 @@ function Elemento({ el, t, dados }) {
                   display: 'inline-block',
                   // A palavra forte é MAIOR na fonte, não na escala: escala não
                   // abre espaço, e ela cresceria por cima da vizinha.
-                  fontSize: p.forte ? '1.22em' : undefined,
+                  fontSize: p.forte ? (e.fonteForte ? '1.1em' : '1.22em') : undefined,
+                  // Com "fonteForte", a palavra forte é a serifa em itálico, não o letreiro maior.
+                  ...(p.forte && e.fonteForte ? { fontFamily: '"' + e.fonteForte + '", Georgia, serif', fontStyle: 'italic', fontWeight: 400, textTransform: 'none' } : {}),
                   transform: 'scale(' + salto + ') translateY(' + (1 - entra) * 18 + 'px)',
                   opacity: entra,
                   color: cor,
                   textShadow: e.sombra || '0 6px 22px rgba(0,0,0,.6), 0 2px 0 rgba(0,0,0,.35)',
-                  WebkitTextStroke: e.contorno || '2px rgba(0,0,0,.55)',
+                  WebkitTextStroke: p.forte && e.fonteForte ? undefined : (e.contorno || '2px rgba(0,0,0,.55)'),
                   paintOrder: 'stroke fill',
                   background: falando && e.fundoAtivo ? e.fundoAtivo : undefined,
                   borderRadius: '0.18em', padding: falando && e.fundoAtivo ? '0 0.12em' : undefined,
@@ -1005,4 +1013,41 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     });
 }
 
-module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX, pkgJson, baseCompartilhada, TSCONFIG };
+/* ── ABRIR PARA EDITAR ────────────────────────────────────────────────
+   "Quando eu falar pra editar, edita no editor de vídeo open source." O
+   projeto já é Remotion: editar é abrir o Remotion Studio na pasta dele. Ele
+   sobe solto (o PrimoCode não espera) e abre o navegador sozinho. */
+function comandoStudio(raiz) {
+    return { cmd: 'npx', args: ['remotion', 'studio'], cwd: raiz };
+}
+
+function abrirStudio({ raiz, spawnar = spawn } = {}) {
+    if (!raiz || !fs.existsSync(path.join(raiz, 'package.json'))) {
+        return { ok: false, error: 'não achei o projeto Remotion nesta pasta.' };
+    }
+    // O Studio precisa do Remotion instalado. A base compartilhada já vem do primeiro render.
+    if (!fs.existsSync(path.join(raiz, 'node_modules'))) {
+        const comp = 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'); } catch { /* segue */ }
+        }
+        if (!fs.existsSync(path.join(raiz, 'node_modules'))) {
+            return { ok: false, error: 'o Remotion ainda não está instalado para este projeto.',
+                comoResolver: 'renderize uma vez com estudio_render (instala o Remotion), depois abra o editor.' };
+        }
+    }
+    const c = comandoStudio(raiz);
+    const win = process.platform === 'win32';
+    try {
+        const p = spawnar(c.cmd, win ? c.args.map(citarWin) : c.args,
+            { cwd: c.cwd, detached: true, stdio: 'ignore', shell: win });
+        if (p && p.on) p.on('error', () => { /* sem npx: o caminho vai na resposta */ });
+        if (p && p.unref) p.unref();
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+    return { ok: true, raiz, comando: `cd "${raiz}" && npx remotion studio` };
+}
+
+module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX, pkgJson, baseCompartilhada, TSCONFIG,
+    comandoStudio, abrirStudio };

package/lib/estudio/variacao3d.js

@@ -0,0 +1,46 @@
+/**
+ * variacao3d.js — o produto em 3D (kit/tres.jsx) diferente a cada vídeo.
+ *
+ *   "várias opções de elementos 3D... vários estilos... que não sejam padrão
+ *    da IA" (Joel, 05/10)
+ *
+ * Antes, todo fone saía igual: o mesmo material, a mesma câmera, a mesma luz
+ * e o mesmo giro. Agora cada vídeo sorteia o acabamento, o enquadramento, a
+ * luz e o ritmo — sem repetir os últimos (memória '3d' do variedade.js). Os
+ * nomes daqui são as chaves que o tres.jsx desenha.
+ */
+
+'use strict';
+
+const variedade = require('./variedade.js');
+
+const VARIACOES = {
+    acabamento: ['verniz', 'metal', 'fosco', 'perola', 'acetinado'],
+    camera: ['frente', 'alto', 'baixo', 'perfil', 'perto'],
+    luz: ['estudio', 'recorte', 'suave', 'lateral'],
+    ritmo: ['lento', 'medio', 'rapido', 'pendulo'],
+};
+
+/** Um 3D por vídeo: cada faceta sorteada sem repetir as últimas. */
+function escolherVariacao3d(aleatorio = Math.random) {
+    const v = {};
+    for (const [faceta, opcoes] of Object.entries(VARIACOES)) v[faceta] = variedade.sortear(opcoes, '3d', { prefixo: faceta + ':', aleatorio });
+    return v;
+}
+
+/** Qual modelo o pedido descreve. Sem pista, a caixa — um produto genérico que ainda gira. */
+const MODELOS3D = [
+    ['fone', /fone|headset|headphone|auricular/i],
+    ['celular', /celular|smartphone|iphone|phone|telefone/i],
+    ['notebook', /notebook|laptop|computador|macbook/i],
+    ['relogio', /rel[oó]gio|smartwatch|\bwatch\b/i],
+    ['garrafa', /garrafa|squeeze|bottle|garrafinha|vinho|perfume/i],
+    ['lata', /lata|bebida|refri|cerveja|energ[eé]tico/i],
+];
+
+function modeloDoPedido(texto) {
+    const achado = MODELOS3D.find(([, re]) => re.test(String(texto || '')));
+    return achado ? achado[0] : 'caixa';
+}
+
+module.exports = { VARIACOES, MODELOS3D, escolherVariacao3d, modeloDoPedido };

package/lib/estudio/variedade.js

@@ -21,7 +21,7 @@ const os = require('os');
 const path = require('path');
 
 const PASTA = path.join(os.homedir(), '.primocode', 'studio');
-const MEMORIA = { trilha: 16, sfx: 40 };
+const MEMORIA = { trilha: 16, sfx: 40, broll: 80, icones: 4, estilo: 8, '3d': 24 };
 
 function arquivo(tipo) { return path.join(PASTA, `${tipo}-usadas.json`); }
 
@@ -54,6 +54,22 @@ function ordenar(itens, tipo, aleatorio = Math.random) {
     return [...embaralhar(validos.filter((x) => !ja.has(x.url)), aleatorio), ...validos.filter((x) => ja.has(x.url))];
 }
 
+/**
+ * Uma das opções, sem repetir as últimas: as nunca usadas primeiro (sorteadas),
+ * depois a usada há mais tempo. Marca a escolhida na memória do tipo. Com
+ * `prefixo`, várias listas dividem o mesmo arquivo ('acabamento:fosco').
+ */
+function sortear(opcoes, tipo, { prefixo = '', aleatorio = Math.random } = {}) {
+    if (!opcoes || !opcoes.length) return null;
+    const ja = usadas(tipo);
+    const idade = (o) => ja.indexOf(prefixo + o);   // 0 = a última usada
+    const novas = embaralhar(opcoes.filter((o) => idade(o) < 0), aleatorio);
+    const velhas = opcoes.filter((o) => idade(o) >= 0).sort((a, b) => idade(b) - idade(a));
+    const escolha = [...novas, ...velhas][0];
+    marcar(tipo, prefixo + escolha);
+    return escolha;
+}
+
 // ── a trilha: termos por clima ──────────────────────────────────────────
 const CLIMAS = {
     tecnologia: ['electronic instrumental', 'synthwave instrumental', 'future bass instrumental', 'downtempo electronic', 'minimal techno instrumental', 'chillwave instrumental'],
@@ -102,4 +118,66 @@ 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 };
+// ── o b-roll: o mesmo pedido, de jeitos diferentes ───────────────────────
+/* "não ficar só nas mesmas fontes, mesmos estilos" (Joel, 05/10): o mesmo
+   roteiro renderizado duas vezes trocou fonte, cor e música, mas o b-roll
+   veio IDÊNTICO — as mesmas mãos no teclado. O termo era o mesmo e o
+   primeiro resultado do Pexels também. Agora o termo ganha um jeito de
+   filmar sorteado, e o clipe já usado vai para o fim da fila. */
+const JEITOS = ['cinematic', 'slow motion', 'close up', 'natural light', 'detail shot', 'wide shot', 'handheld'];
+
+function termosBroll(termo, aleatorio = Math.random) {
+    const t = String(termo || '').replace(/\s+/g, ' ').trim();
+    if (!t) return [];
+    const jeitos = embaralhar(JEITOS.filter((j) => !t.toLowerCase().includes(j)), aleatorio).slice(0, 2);
+    return embaralhar([t, ...jeitos.map((j) => `${t} ${j}`)], aleatorio);
+}
+
+/**
+ * Busca com as variações do termo e devolve os itens na ordem de tentar:
+ * para no primeiro termo que trouxer algo nunca usado. `buscar(termo)`
+ * devolve a lista de itens ({url, …}) — é a busca de verdade, ou um stub.
+ */
+async function buscarSemRepetir(buscar, termo, tipo = 'broll', aleatorio = Math.random) {
+    const ja = new Set(usadas(tipo));
+    let reserva = [];
+    for (const t of termosBroll(termo, aleatorio)) {
+        let itens = [];
+        try { itens = ordenar(await buscar(t), tipo, aleatorio); } catch { continue; }
+        if (itens.length && !ja.has(itens[0].url)) return itens;
+        if (!reserva.length) reserva = itens;
+    }
+    return reserva;
+}
+
+// ── os ícones: a coleção muda de um vídeo para o outro ──────────────────
+/* O ícone automático (edicao.iconeDe) é sempre "fluent-3d:<emoji>". Estas
+   coleções do Iconify usam os mesmos nomes de emoji, então dá para trocar a
+   coleção inteira do vídeo; o que não existir na coleção nova fica no 3D. */
+const FAMILIAS_ICONE = ['fluent-3d', 'fluent-emoji-flat', 'fluent-emoji', 'noto', 'twemoji', 'openmoji'];
+
+function colecaoIcones(aleatorio = Math.random) {
+    return ordenar(FAMILIAS_ICONE.map((url) => ({ url })), 'icones', aleatorio)[0].url;
+}
+
+function cadaIcone(plano, fn) {
+    for (const cena of (plano && plano.cenas) || []) for (const el of cena.elementos || []) if (el && el.tipo === 'icone' && el.nome) fn(el);
+}
+
+/** Os ícones automáticos do plano — os que o roteiro pediu pelo nome ficam como estão. */
+function iconesTrocaveis(plano, explicitos = []) {
+    const fixos = new Set(explicitos);
+    const nomes = new Set();
+    cadaIcone(plano, (el) => { if (/^fluent-3d:/.test(el.nome) && !fixos.has(el.nome)) nomes.add(el.nome); });
+    return [...nomes];
+}
+
+/** Troca no plano cada nome que estiver em `troca` ({velho: novo}). Devolve quantos trocou. */
+function trocarIcones(plano, troca = {}) {
+    let n = 0;
+    cadaIcone(plano, (el) => { if (troca[el.nome]) { el.nome = troca[el.nome]; n++; } });
+    return n;
+}
+
+module.exports = { usadas, marcar, embaralhar, ordenar, sortear, climaDe, termosTrilha, termosSfx, termosBroll, buscarSemRepetir,
+    colecaoIcones, iconesTrocaveis, trocarIcones, CLIMAS, SFX, JEITOS, FAMILIAS_ICONE };