primocode 10.0.9 → 10.2.0

package/lib/estudio/kit/gerativo.jsx

@@ -658,8 +658,8 @@ function Fundo({ P, b, prevB, t, cam, frame, origem }) {
         return <div key={'q' + i} style={{ position: 'absolute', left: x, top: y, width: q.r * 2 * sc, height: q.r * 2 * sc, borderRadius: '50%',
           background: i % 5 === 0 ? b.cores.acento : b.cores.texto, opacity: (0.1 + q.z * 0.25), filter: q.z < 0.3 ? 'blur(1.5px)' : undefined }} />;
       })}
-      <div style={{ position: 'absolute', inset: 0, ...textura, backgroundSize: passo + 'px ' + passo + 'px', backgroundPosition: px + 'px ' + py + 'px',
-        WebkitMaskImage: 'radial-gradient(ellipse at 50% 50%, #000 20%, transparent 78%)', maskImage: 'radial-gradient(ellipse at 50% 50%, #000 20%, transparent 78%)' }} />
+      {f.textura && <div style={{ position: 'absolute', inset: 0, ...textura, backgroundSize: passo + 'px ' + passo + 'px', backgroundPosition: px + 'px ' + py + 'px',
+        WebkitMaskImage: 'radial-gradient(ellipse at 50% 50%, #000 20%, transparent 78%)', maskImage: 'radial-gradient(ellipse at 50% 50%, #000 20%, transparent 78%)' }} />}
     </div>
   );
 }
@@ -688,7 +688,7 @@ function Heroi({ b, t, P, slot }) {
   const sem = h.semente;
   const cor = h.cor, cor2 = h.cor2;
   const { cx, cy, R, fraco } = slot;
-  const op = fraco ? 0.32 : 1;
+  const op = slot.op != null ? slot.op : fraco ? 0.32 : 1;
   const els = [];
   if (h.tipo === 'explosao') {
     // A explosão radial: nasce de um ponto, os raios saem em mola e giram devagar; anéis de régua em volta.
@@ -857,11 +857,21 @@ export function Gerativo({ el, t, fps }) {
       <Fundo P={P} b={b} prevB={bs[bi - 1]} t={t} cam={cam} frame={frame} origem={origem} />
       <div style={{ position: 'absolute', inset: 0, perspective: Math.round(Math.max(W, H) * 0.85) + 'px', perspectiveOrigin: '50% 48%' }}>
       <div style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, transformOrigin: '0 0', transform: mundo, transformStyle: 'preserve-3d' }}>
+        {/* O CAMPO (o padrão que cobre o quadro) mora ATRÁS de tudo — do produto 3D
+            e do texto — e calmo: desenhado por cima, brigava com os dois (05/10). */}
+        {noAr.filter((x) => x.heroi && x.heroi.modo === 'campo' && L[x.id]).map((x) => {
+          const bl = L[x.id].bloco, some = 1 - c01((t - x.ate) / 0.14);
+          return (
+            <div key={'campo' + x.id} style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, transform: 'translateZ(-200px)', opacity: some }}>
+              <Heroi b={x} t={t} P={P} slot={{ cx: (bl.x + bl.x1) / 2, cy: (bl.y + bl.y1) / 2, R: Math.min(W, H) * 0.32, op: 0.18 }} />
+            </div>
+          );
+        })}
         {produtos.map((q, i) => {
           const sai = c01((t - q.ate) / 0.3), entra = ed(c01((t - q.de) / 0.6));
           return (
             <div key={'p' + i} style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, opacity: 1 - sai, transform: 'scale(' + (0.94 + 0.06 * entra + 0.1 * sai) + ')', transformOrigin: (q.x + q.largura / 2) + 'px ' + (q.y + q.altura / 2) + 'px' }}>
-              <Produto3D el={{ x: q.x, y: q.y, largura: q.largura, altura: q.altura, modelo: q.modelo, cor: q.cor, corAcento: q.corAcento, t: q.de + 0.05, giro: 0.45, escala: q.escala || 1, semChao: true }} t={t} />
+              <Produto3D el={{ x: q.x, y: q.y, largura: q.largura, altura: q.altura, modelo: q.modelo, cor: q.cor, corAcento: q.corAcento, acabamento: q.acabamento, camera: q.camera, luz: q.luz, ritmo: q.ritmo, t: q.de + 0.05, giro: 0.45, escala: q.escala || 1, semChao: true }} t={t} />
             </div>
           );
         })}
@@ -898,7 +908,7 @@ export function Gerativo({ el, t, fps }) {
               {x.heroi && (() => {
                 // O lugar do herói: o vazio do bloco (como o ícone); sem vazio, atrás do texto e mais fraco.
                 const bl = lay.bloco, M = P.margem;
-                if (x.heroi.modo === 'campo') return <Heroi b={x} t={t} P={P} slot={{ cx: (bl.x + bl.x1) / 2, cy: (bl.y + bl.y1) / 2, R: Math.min(W, H) * 0.32 }} />;
+                if (x.heroi.modo === 'campo') return null;   // desenhado atrás, antes do produto
                 const R = Math.min(W, H) * (W >= H ? 0.2 : 0.17);
                 let slot = null;
                 if (W - M - bl.x1 >= R * 2.3) slot = { cx: bl.x1 + (W - M - bl.x1) / 2, cy: (bl.y + bl.y1) / 2, R };

package/lib/estudio/kit/index.jsx

@@ -8,6 +8,7 @@ import { MARCA } from './marca';
 import { Papel } from './base';
 import { TRES } from './tres';
 import { GERATIVO } from './gerativo';
+import { FLUIDO } from './fluido';
 
-export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, papel: Papel };
+export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, papel: Papel };
 export { Filtros, Acabamento, Hud, CURVAS_KIT, bolhaCaminho } from './base';

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/referencias.js

@@ -18,14 +18,17 @@
 
 'use strict';
 
-let ATUAL = { modo: null, escopo: '' };
+let ATUAL = { modo: null, escopo: '', explicito: false };
 
-function definir(modo, escopo = '') {
-    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim() };
+function definir(modo, escopo = '', explicito = true) {
+    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim(), explicito: !!explicito };
     return ATUAL;
 }
 function atual() { return ATUAL; }
-function limpar() { ATUAL = { modo: null, escopo: '' }; }
+function limpar() { ATUAL = { modo: null, escopo: '', explicito: false }; }
+
+/** Sem foto nem vídeo de fora: o "sem" e também ninguém ter dito nada (o padrão, 07/10). */
+function semImagem({ modo } = ATUAL) { return modo !== 'aberto' && modo !== 'fechado'; }
 
 /** Os termos do escopo fechado: "site:anthropic.com, claude ai, sonnet" → lista. */
 function termos(escopo = ATUAL.escopo) {
@@ -41,33 +44,40 @@ function entender(resposta) {
     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. */
+/* O MODO DEDUZIDO DO PEDIDO. O padrão é SEM IMAGEM: "por padrão, NÃO
+   usar imagens. Somente quando o usuário pedir explicitamente" (Joel, 07/10).
+   O menu 1/2/3 do terminal saiu; quem quer imagem diz no pedido:
+     "adicione imagens de apoio", "quero imagens durante o vídeo",
+     "use imagens reais", "web aberta"                    → aberto
+     "só do site x.com", "usa apenas anthropic.com e …"   → fechado (o escopo)
+     "só motion", "sem referência", "sem foto"            → sem (explícito)
+     o resto                                              → sem (o padrão)  */
+const PEDE_IMAGEM = /(adicion|coloc|use|usa|usar|quero|bota|pon|insir|inclu|com)\w*\s+(\w+\s+){0,3}(imagens?|fotos?|b-?roll|videos? de (apoio|banco)|cenas reais)\b|(imagens?|fotos?) (de apoio|reais|durante|para ilustrar|pra ilustrar|da (web|internet))|escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)/;
+const NEGA_IMAGEM = /so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima|(nao|nada de) (quero |use |usar |coloc\w* )?(imagens?|fotos?)/;
+
 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 t = String(texto || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    if (NEGA_IMAGEM.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 };
+    if (PEDE_IMAGEM.test(t)) return { modo: 'aberto', escopo: '', explicito: true };
+    return { modo: 'sem', escopo: '', explicito: false };
 }
 
 /** A instrução para o agente, conforme o modo. */
-function instrucao({ modo, escopo } = ATUAL) {
-    if (modo === 'sem') {
+function instrucao({ modo, escopo, explicito } = ATUAL) {
+    // O vídeo sem imagem é motion: o agente escolhe o estilo de motion que serve ao roteiro, não um fixo.
+    const motion = 'O vídeo é MOTION: tipografia, formas, ícones, animação e som. Escolha em roteiro.estilo o motion que serve a este '
+        + 'roteiro (gerativo, fluido, impacto, vox, marca, lancamento) ou deixe vazio para o rodízio — não repita sempre o mesmo.';
+    if (modo === 'sem' && explicito) {
         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).';
+            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz. ' + motion;
+    }
+    if (modo === 'sem') {
+        return '[SEM IMAGEM — o padrão] A pessoa não pediu imagem: não busque foto nem vídeo, não use estudio_midia de banco '
+            + 'nem "busca" nas partes. Pesquisar FATOS em texto (pesquisar_referencia) pode, se o assunto pedir. ' + motion;
     }
     if (modo === 'fechado') {
         const t = termos(escopo);
@@ -77,8 +87,9 @@ function instrucao({ modo, escopo } = ATUAL) {
             + `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 '[REFERÊNCIAS: ESCOPO ABERTO — a pessoa pediu imagens] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca). '
+            + 'A imagem é um elemento da narrativa, não o vídeo inteiro: dê "busca" (em inglês: gente, lugar, tela, objeto de verdade) '
+            + 'SÓ nas partes em que uma imagem real mostra o que o texto não mostra. Não troque de imagem a cada frase; o resto é motion.';
     }
     return '';
 }
@@ -102,4 +113,4 @@ function filtrar(r, { modo, escopo } = ATUAL) {
     return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
 }
 
-module.exports = { definir, atual, limpar, termos, entender, inferir, instrucao, dominios, filtrar };
+module.exports = { definir, atual, limpar, semImagem, termos, entender, inferir, instrucao, dominios, filtrar };

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,
@@ -711,6 +719,8 @@ export const Video = () => {
                 return vs[vs.length - 1].v; }
             : (plano.audio.trilha.volume ?? 0.18)}
           loop={plano.audio.trilha.loop !== false}
+          /* O início da faixa que casa as batidas com os cortes (batida.js). */
+          startFrom={Math.round((plano.audio.trilha.inicio || 0) * fps)}
         />
       )}
       {/* Os TRECHOS: pedaços de áudio no tempo certo — a narração partida entre
@@ -1005,4 +1015,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 };