primocode 8.42.2 → 9.1.0

package/lib/remotion.js

@@ -1,663 +0,0 @@
-/**
- * remotion.js — a mesma peça, renderizada por Remotion.
- *
- *   "Também ele vai poder usar o Remotion. Aí ele decide qual usar, ou usa o
- *    que o usuário pedir."
- *
- * ── POR QUE ISTO NÃO É UMA DEPENDÊNCIA DO PRIMOCODE ──────────────────────
- * Remotion é React + um Chromium próprio + ffmpeg: perto de meio giga. Pôr
- * isso no `dependencies` do PrimoCode faria `npm i -g primocode` baixar meio
- * giga para todo mundo — inclusive para quem nunca vai fazer um vídeo.
- *
- * E não precisa: Remotion é um projeto, não uma biblioteca de linha de
- * comando. O jeito certo de usá-lo é ter um projeto Remotion, e é isso que
- * este módulo escreve — na pasta do USUÁRIO, com as dependências dele. O
- * PrimoCode continua com zero dependência, e quem quiser Remotion tem um
- * projeto de verdade, que abre no `remotion studio`, entra no git e pode ser
- * editado à mão depois.
- *
- * ── POR QUE ELE PARTE DO DOCUMENTO DO ESTÚDIO ────────────────────────────
- * A tentação era inventar um segundo vocabulário — "para o Remotion escreva
- * assim". Seriam duas gramáticas para o agente aprender, duas para manter, e
- * uma ficaria velha.
- *
- * O projeto gerado leva junto o `render.js` e o `render.css` do estúdio, que
- * é quem sabe desenhar uma cena. A composição React só decide QUAL cena está
- * no ar em cada quadro e aplica entrada e transição a partir de
- * `useCurrentFrame()`. O mesmo `doc` que toca no navegador renderiza aqui.
- *
- * ── QUANDO VALE A PENA ───────────────────────────────────────────────────
- * O estúdio exporta em segundos, sem instalar nada, e é o padrão. Remotion
- * pede `npm install` (uma vez, minutos) e devolve outra coisa:
- *
- *   · quadro a quadro determinístico — o mesmo arquivo em toda máquina, sem
- *     depender de a aba estar em foco nem da carga do computador;
- *   · vídeo longo sem risco de o navegador engasgar no meio;
- *   · fps e qualidade escolhidos, ProRes, canal alfa, renderização paralela;
- *   · e um projeto que a pessoa pode abrir e mexer em React.
- *
- * ── LICENÇA ──────────────────────────────────────────────────────────────
- * Remotion é grátis para pessoa física e para empresa pequena, mas EMPRESA
- * ACIMA DE TRÊS PESSOAS precisa de licença paga. Isso vale para o projeto que
- * nasce na pasta do usuário, não para o PrimoCode — e por isso o aviso vai no
- * README gerado e na resposta da tool. Descobrir isso depois de montar o
- * fluxo de trabalho em cima dele seria péssimo.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const ORIGEM_ESTUDIO = path.join(__dirname, '..', 'studio', 'web');
-const VERSAO_REMOTION = '4.0.522';
-
-// Arquivos do estúdio que o projeto Remotion precisa para desenhar uma cena.
-// São os mesmos que o navegador carrega — nada é reescrito.
-const DO_ESTUDIO = [
-    ['js/render.js', 'render.js'],
-    ['js/icones.js', 'icones.js'],
-    ['render.css', 'render.css'],
-    ['fontes.css', 'fontes.css'],
-];
-
-function escrever(destino, conteudo) {
-    fs.mkdirSync(path.dirname(destino), { recursive: true });
-    fs.writeFileSync(destino, conteudo, 'utf-8');
-}
-
-/* Quantos quadros dura cada cena, com a MESMA conta do player.
- *
- * Duplicar esta conta aqui foi tentador e seria errado: se ela divergisse do
- * player, o vídeo exportado por Remotion teria duração diferente do que a
- * pessoa aprovou na tela — e ninguém desconfiaria, porque os dois estariam
- * "funcionando". Então a regra é uma só e está escrita em um lugar; o
- * projeto gerado importa daqui. */
-function segundosDaCena(c) {
-    let d = Number(c && c.duracao);
-    let clipe = 0;
-    for (const e of (c && c.elementos) || []) {
-        if (!e || e.tipo !== 'clipe') continue;
-        const de = Number(e.de) || 0;
-        const ate = Number(e.ate);
-        if (isFinite(ate) && ate > de) clipe = Math.max(clipe, ate - de);
-    }
-    if (!(isFinite(d) && d > 0)) d = clipe > 0 ? Math.min(600, clipe) : 4;
-    else d = Math.min(clipe > 0 ? 600 : 60, d);
-
-    const n = Number(c && c.narracaoDur);
-    if (isFinite(n) && n > 0 && c && c.narracaoAudio) d = Math.max(d, Math.min(90, n + 0.4));
-    return d;
-}
-
-function totalSegundos(doc) {
-    return ((doc && doc.cenas) || []).reduce((s, c) => s + segundosDaCena(c), 0);
-}
-
-// ── os arquivos do projeto ───────────────────────────────────────────────
-
-function pkgJson(nome) {
-    return JSON.stringify({
-        name: nome || 'video-primocode',
-        version: '1.0.0',
-        private: true,
-        scripts: {
-            /* `studio` abre a pré-visualização com linha do tempo; `render`
-               escreve o mp4.
-
-               O ponto de entrada vai ESCRITO. O Remotion procura sozinho por
-               `src/index.ts` e alguns outros nomes fixos, e este projeto é
-               .jsx — sem TypeScript, para não arrastar um toolchain inteiro
-               para dentro da pasta de quem só quer um vídeo. Sem o caminho,
-               ele responde "No entry point specified" e não renderiza nada. */
-            studio: 'remotion studio src/index.jsx',
-            render: 'remotion render src/index.jsx Video saida/video.mp4',
-            build: 'remotion render src/index.jsx Video saida/video.mp4 --codec=h264 --crf=16',
-        },
-        dependencies: {
-            remotion: VERSAO_REMOTION,
-            '@remotion/cli': VERSAO_REMOTION,
-            react: '19.0.0',
-            'react-dom': '19.0.0',
-        },
-    }, null, 2) + '\n';
-}
-
-const INDEX_JSX = `import { registerRoot } from "remotion";
-import { Raiz } from "./Raiz.jsx";
-
-registerRoot(Raiz);
-`;
-
-function raizJsx(doc, fps) {
-    return `import { Composition } from "remotion";
-import { Filme } from "./Filme.jsx";
-import doc from "./doc.json";
-import { totalQuadros } from "./tempo.js";
-
-/* A composição. \`durationInFrames\` sai da MESMA conta de duração que o
-   player do estúdio usa (ver tempo.js) — se as duas divergissem, o arquivo
-   exportado teria outro tamanho que o vídeo aprovado na tela, e nada
-   denunciaria. */
-export const Raiz = () => (
-  <Composition
-    id="Video"
-    component={Filme}
-    durationInFrames={totalQuadros(doc, ${fps})}
-    fps={${fps}}
-    width={${doc.largura || 1920}}
-    height={${doc.altura || 1080}}
-    defaultProps={{ doc }}
-  />
-);
-`;
-}
-
-/* A conta de tempo, em módulo próprio, gerada a partir da função acima.
-   Assim o projeto do usuário não depende do PrimoCode estar instalado. */
-function tempoJs(fps) {
-    return `/* Quanto dura cada cena — a MESMA regra do player do estúdio.
- *
- * Copiada de propósito para dentro do projeto: ele tem de renderizar sozinho,
- * sem o PrimoCode instalado. Se você mudar a duração de uma cena, mude no
- * doc.json — não aqui.
- */
-export const FPS = ${fps};
-
-export function segundosDaCena(c) {
-  let d = Number(c && c.duracao);
-  let clipe = 0;
-  for (const e of (c && c.elementos) || []) {
-    if (!e || e.tipo !== "clipe") continue;
-    const de = Number(e.de) || 0;
-    const ate = Number(e.ate);
-    if (isFinite(ate) && ate > de) clipe = Math.max(clipe, ate - de);
-  }
-  if (!(isFinite(d) && d > 0)) d = clipe > 0 ? Math.min(600, clipe) : 4;
-  else d = Math.min(clipe > 0 ? 600 : 60, d);
-
-  const n = Number(c && c.narracaoDur);
-  if (isFinite(n) && n > 0 && c && c.narracaoAudio) d = Math.max(d, Math.min(90, n + 0.4));
-  return d;
-}
-
-/* Quadros, não segundos: dentro do Remotion o tempo é inteiro. Arredondar
- * para cima em cada cena evita a cena de 3,02s virar 3,0 e comer dois
- * quadros do fim — e evita o acúmulo desse erro ao longo do filme. */
-export function quadrosDaCena(c, fps = FPS) {
-  return Math.max(1, Math.round(segundosDaCena(c) * fps));
-}
-
-export function totalQuadros(doc, fps = FPS) {
-  const cenas = (doc && doc.cenas) || [];
-  const soma = cenas.reduce((s, c) => s + quadrosDaCena(c, fps), 0);
-  return Math.max(1, soma);
-}
-
-/* Qual cena está no ar no quadro \`q\`, e há quantos quadros ela começou.
- * Devolver o "dentro" junto evita o chamador refazer a soma — e refazer a
- * soma com outra regra de arredondamento é exatamente como as duas metades
- * de um render saem fora de sincronia. */
-export function cenaNoQuadro(doc, q, fps = FPS) {
-  const cenas = (doc && doc.cenas) || [];
-  let acc = 0;
-  for (let i = 0; i < cenas.length; i++) {
-    const dur = quadrosDaCena(cenas[i], fps);
-    if (q < acc + dur) return { i, dentro: q - acc, dur };
-    acc += dur;
-  }
-  const ult = cenas.length - 1;
-  const dur = ult >= 0 ? quadrosDaCena(cenas[ult], fps) : 1;
-  return { i: Math.max(0, ult), dentro: dur - 1, dur };
-}
-`;
-}
-
-const FILME_JSX = `import { useCurrentFrame, useVideoConfig, AbsoluteFill, Audio, Sequence, staticFile, delayRender, continueRender } from "remotion";
-import { useLayoutEffect, useRef } from "react";
-import { cenaNoQuadro, quadrosDaCena } from "./tempo.js";
-import "./render.css";
-import "./fontes.css";
-import { renderCena } from "./render.js";
-
-/* ── POR QUE ESTE ARQUIVO MUDOU ──────────────────────────────────────────
-   O primeiro vídeo que saiu daqui estava MUDO e PARADO: \`animar: false\`
-   congelava toda animação (o número não contava, a lista não revelava, o
-   vidro não brilhava), e o único áudio era \`trilha.src\` — sem narração, sem
-   trilha gerada, sem efeitos. Tecnicamente perfeito, visualmente morto.
-
-   Agora a cena é desenhada COM as animações ligadas (a mesma classe
-   \`animar\` do player) e, a cada quadro, TODAS elas são levadas ao instante
-   certo pela Web Animations API (\`getAnimations().currentTime\`). É o que
-   torna o render determinístico: o mesmo quadro em qualquer máquina, sem
-   depender de relógio. A contagem dos números e o instante dos clipes seguem
-   a mesma conta do player. A narração de cada cena, a trilha em arquivo, o
-   áudio dos clipes e os sons por arquivo entram como <Audio> do Remotion.
-
-   O que o Remotion NÃO faz sozinho: a trilha GERADA e os sons SINTETIZADOS
-   (são WebAudio ao vivo). Por isso o studio_exportar do PrimoCode renderiza
-   este projeto sem áudio e MISTURA o áudio do Studio — é a mescla dos dois.
-   Aqui dentro, \`doc.__semAudio\` é como o PrimoCode pede esse silêncio. */
-
-const src = (u) => (/^(https?:|data:|blob:)/.test(u) ? u : staticFile(String(u).replace(/^\\//, "")));
-
-function inicioDaCena(cenas, k, fps) {
-  let q = 0;
-  for (let i = 0; i < k; i++) q += quadrosDaCena(cenas[i], fps);
-  return q;
-}
-
-/* A contagem dos números, determinística: a MESMA curva do player
-   (1,1 s, easeOutCubic), só que em função do tempo da cena e não do relógio. */
-function contarEm(el, t) {
-  el.querySelectorAll("b[data-contar]").forEach((b) => {
-    const alvo = parseFloat(b.getAttribute("data-contar"));
-    const molde = b.getAttribute("data-molde") || String(alvo);
-    const casas = (String(alvo).split(".")[1] || "").length;
-    const trecho = molde.match(/-?[\\d.,]+/);
-    if (!trecho) return;
-    const p = Math.min(1, t / 1.1);
-    const suave = 1 - Math.pow(1 - p, 3);
-    const v = (alvo * suave).toFixed(casas);
-    b.textContent = p >= 1 ? molde : molde.replace(trecho[0], String(v).replace(".", casas ? "," : ""));
-  });
-}
-
-function Cena({ cena, doc, dentro, fps }) {
-  const caixa = useRef(null);
-  const no = useRef(null);
-
-  useLayoutEffect(() => {
-    if (!caixa.current) return;
-    caixa.current.innerHTML = "";
-    no.current = renderCena(cena, doc, { animar: true });
-    caixa.current.appendChild(no.current);
-  }, [cena, doc]);
-
-  useLayoutEffect(() => {
-    const el = no.current;
-    if (!el) return;
-    const t = dentro / fps;
-    // 1. Toda animação CSS — entrada, chaves, transição da cena, brilho do
-    //    vidro, cubo girando — no instante t. Pausada: quem avança é o quadro.
-    let anims = [];
-    try { anims = el.getAnimations({ subtree: true }); } catch (e) { anims = []; }
-    for (const a of anims) {
-      try { a.pause(); a.currentTime = t * 1000; } catch (e) { /* animação já encerrada */ }
-    }
-    // 2. Os números que contam.
-    contarEm(el, t);
-    // 3. Os clipes do usuário: o quadro certo do arquivo, esperado de verdade.
-    el.querySelectorAll("video").forEach((v) => {
-      const de = Number(v.dataset.de || 0);
-      const alvo = de + t;
-      v.pause();
-      const buscar = () => {
-        if (Math.abs(v.currentTime - alvo) < 1 / (fps * 2)) return;
-        const h = delayRender("clipe em " + alvo.toFixed(2) + "s");
-        const fim = () => { v.removeEventListener("seeked", fim); continueRender(h); };
-        v.addEventListener("seeked", fim);
-        v.currentTime = alvo;
-      };
-      if (v.readyState >= 1) buscar();
-      else {
-        const h = delayRender("carregando clipe");
-        v.addEventListener("loadedmetadata", () => { buscar(); continueRender(h); }, { once: true });
-      }
-    });
-  }, [dentro, fps, cena, doc]);
-
-  return <div ref={caixa} style={{ width: "100%", height: "100%" }} />;
-}
-
-/* O som da peça, fora o que é sintetizado. */
-function Sons({ doc, fps }) {
-  if (doc.__semAudio) return null;
-  const cenas = doc.cenas || [];
-  const pecas = [];
-  const trilha = doc.trilha || {};
-  if (trilha.src && trilha.tipo !== "gerada") {
-    pecas.push(<Audio key="trilha" src={src(trilha.src)} loop={trilha.repetir !== false}
-      volume={trilha.volume == null ? 0.7 : trilha.volume}
-      startFrom={Math.round((Number(trilha.inicio) || 0) * fps)} />);
-  }
-  cenas.forEach((c, k) => {
-    const de = inicioDaCena(cenas, k, fps);
-    const dur = quadrosDaCena(c, fps);
-    if (c.narracaoAudio) {
-      pecas.push(<Sequence key={"n" + k} from={de} durationInFrames={dur}>
-        <Audio src={src(c.narracaoAudio)} volume={doc.voz && doc.voz.volume != null ? doc.voz.volume : 1} />
-      </Sequence>);
-    }
-    (c.elementos || []).forEach((e, i) => {
-      if (!e) return;
-      if (e.tipo === "clipe" && e.src && !e.mudo) {
-        pecas.push(<Sequence key={"c" + k + "-" + i} from={de} durationInFrames={dur}>
-          <Audio src={src(e.src)} startFrom={Math.round((Number(e.de) || 0) * fps)}
-            volume={e.volume == null ? 1 : e.volume} />
-        </Sequence>);
-      }
-      if (e.som && typeof e.som === "object" && e.som.arquivo) {
-        const atraso = e.som.em != null ? Number(e.som.em)
-          : (e.anim && typeof e.anim === "object" && e.anim.atraso != null) ? Number(e.anim.atraso)
-          : (e.chaves && e.chaves.length > 1 ? 0 : i * 0.09 + 0.1);
-        pecas.push(<Sequence key={"s" + k + "-" + i} from={de + Math.round(atraso * fps)}>
-          <Audio src={src(e.som.arquivo)} volume={e.som.volume == null ? 0.7 : e.som.volume} />
-        </Sequence>);
-      }
-    });
-  });
-  return <>{pecas}</>;
-}
-
-export const Filme = ({ doc }) => {
-  const quadro = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const { i, dentro } = cenaNoQuadro(doc, quadro, fps);
-  const cenas = doc.cenas || [];
-  const cena = cenas[i] || {};
-
-  return (
-    <AbsoluteFill style={{ backgroundColor: "#000" }}>
-      <Cena cena={cena} doc={doc} dentro={dentro} fps={fps} />
-      <Sons doc={doc} fps={fps} />
-    </AbsoluteFill>
-  );
-};
-`;
-
-/* O render.js do estúdio é um script de navegador: define funções soltas, sem
- * export nenhum. O bundler do Remotion precisa de módulo.
- *
- * A saída é o arquivo ORIGINAL, sem uma linha alterada, com um `export` no
- * fim. Reescrever o conteúdo seria criar uma segunda versão do desenhista
- * para manter — e a que ficasse velha seria justamente a que renderiza o
- * arquivo final, onde ninguém olha até estar publicado. */
-function comoModulo(fonte, nomes) {
-    return fonte
-        + '\n\n/* ── acrescentado pelo PrimoCode ─────────────────────────────────────\n'
-        + '   O arquivo acima é o render do estúdio, byte por byte. Só o export é\n'
-        + '   novo: no navegador ele é um script solto, e aqui precisa ser módulo.\n'
-        + '   Não edite o que está em cima — atualize o PrimoCode e gere de novo. */\n'
-        + `export { ${nomes.join(', ')} };\n`;
-}
-
-/* `icones.js` é lido pelo render.js pelo nome global. Em módulo, o nome não
-   vaza para o escopo global sozinho — daí o empurrão explícito. */
-function iconesComoModulo(fonte) {
-    return fonte
-        + '\n\n/* ── acrescentado pelo PrimoCode ────────────────────────────────────\n'
-        + '   O render.js procura os ícones no escopo global, como no navegador. */\n'
-        + 'if (typeof globalThis !== "undefined") {\n'
-        + '  if (typeof ICONES !== "undefined") globalThis.ICONES = ICONES;\n'
-        + '  if (typeof svgIcone === "function") globalThis.svgIcone = svgIcone;\n'
-        + '}\n';
-}
-
-function readme(titulo, doc) {
-    const seg = totalSegundos(doc);
-    return `# ${titulo || 'Vídeo'} — projeto Remotion
-
-Gerado pelo PrimoCode a partir da peça do Studio. As cenas estão em
-\`src/doc.json\`; o desenho delas é o mesmo do Studio (\`src/render.js\`).
-
-## Rodar
-
-\`\`\`bash
-npm install          # uma vez, e demora — Remotion traz o próprio navegador
-npm run studio       # pré-visualização com linha do tempo
-npm run render       # escreve saida/video.mp4
-\`\`\`
-
-Duração: ${seg.toFixed(1)}s · ${doc.largura || 1920}×${doc.altura || 1080}
-· ${(doc.cenas || []).length} cena(s).
-
-## Quando usar isto em vez do Studio
-
-O Studio exporta o MP4 num clique, sem instalar nada, e é o caminho normal.
-Este projeto existe para o que ele não faz:
-
-- **quadro a quadro determinístico** — o mesmo arquivo em qualquer máquina,
-  sem depender de a aba estar em foco nem da carga do computador;
-- **vídeo longo** sem risco de o navegador engasgar no meio;
-- **fps, CRF, ProRes, canal alfa** e renderização paralela;
-- **mexer no código**: daqui para a frente é React, e é seu.
-
-## Editar
-
-- Conteúdo, cores e tempo: \`src/doc.json\`.
-- Como cada cena entra: \`entrada()\` em \`src/Filme.jsx\`.
-- Como um elemento é desenhado: \`src/render.js\` — mas ele é copiado do
-  Studio. Mexendo ali, um novo \`remotion_projeto\` sobrescreve. Se for
-  mudança para valer, mude no PrimoCode.
-
-## Licença do Remotion
-
-Remotion é **grátis para pessoa física e para empresa de até três pessoas**.
-Acima disso, a empresa precisa de licença paga — veja
-<https://remotion.dev/license>. Isso vale para ESTE projeto, que é seu; o
-PrimoCode não depende de Remotion e não muda de licença por causa disto.
-`;
-}
-
-const GITIGNORE = 'node_modules/\nsaida/\n.remotion/\n';
-
-// ── montar o projeto ─────────────────────────────────────────────────────
-
-/**
- * Escreve um projeto Remotion completo a partir de uma peça do Studio.
- *
- * @param {object} op
- * @param {string} op.destino  pasta onde o projeto nasce
- * @param {string} op.titulo
- * @param {object} op.doc      o documento da peça (cenas, tema, trilha…)
- * @param {number} [op.fps]
- */
-function montar({ destino, titulo, doc, fps, midiaDir, semAudio }) {
-    if (!destino) return { ok: false, error: 'diga em que pasta o projeto vai nascer' };
-    if (!doc || !Array.isArray(doc.cenas) || !doc.cenas.length) {
-        return { ok: false, error: 'esta peça não tem cenas — Remotion renderiza cenas, como o Studio' };
-    }
-    const taxa = Math.max(1, Math.min(120, Number(fps) || 30));
-
-    const src = path.join(destino, 'src');
-    fs.mkdirSync(src, { recursive: true });
-
-    // A MÍDIA vai junto: "/midia/x.mp3" no doc vira public/midia/x.mp3 no
-    // projeto, que o Remotion serve por staticFile(). Sem isto a narração, a
-    // trilha e os clipes apontavam para o servidor do Studio — que não existe
-    // na hora do render, e o projeto nascia mudo sem dizer por quê.
-    const midia = [];
-    if (midiaDir) {
-        const andar = (o) => {
-            if (!o) return;
-            if (typeof o === 'string') { if (o.startsWith('/midia/')) midia.push(o); return; }
-            if (Array.isArray(o)) return o.forEach(andar);
-            if (typeof o === 'object') Object.values(o).forEach(andar);
-        };
-        andar(doc);
-        for (const u of new Set(midia)) {
-            const origem = path.join(midiaDir, path.basename(u));
-            if (!fs.existsSync(origem)) continue;
-            const alvo = path.join(destino, 'public', 'midia', path.basename(u));
-            fs.mkdirSync(path.dirname(alvo), { recursive: true });
-            try { fs.copyFileSync(origem, alvo); } catch { /* fica sem essa */ }
-        }
-    }
-    const docFinal = semAudio ? Object.assign({}, doc, { __semAudio: true }) : doc;
-
-    // Os arquivos do estúdio, sem reescrever conteúdo.
-    for (const [de, para] of DO_ESTUDIO) {
-        const origem = path.join(ORIGEM_ESTUDIO, de);
-        if (!fs.existsSync(origem)) continue;
-        let conteudo = fs.readFileSync(origem, 'utf-8');
-        if (para === 'render.js') conteudo = comoModulo(conteudo, ['renderCena', 'renderElemento']);
-        else if (para === 'icones.js') conteudo = iconesComoModulo(conteudo);
-        escrever(path.join(src, para), conteudo);
-    }
-    // A ordem importa: render.js procura os ícones no global.
-    const alvoRender = path.join(src, 'render.js');
-    if (fs.existsSync(alvoRender)) {
-        escrever(alvoRender, 'import "./icones.js";\n' + fs.readFileSync(alvoRender, 'utf-8'));
-    }
-
-    escrever(path.join(destino, 'package.json'), pkgJson(titulo));
-    escrever(path.join(destino, 'README.md'), readme(titulo, doc));
-    escrever(path.join(destino, '.gitignore'), GITIGNORE);
-    escrever(path.join(src, 'index.jsx'), INDEX_JSX);
-    escrever(path.join(src, 'Raiz.jsx'), raizJsx(docFinal, taxa));
-    escrever(path.join(src, 'Filme.jsx'), FILME_JSX);
-    escrever(path.join(src, 'tempo.js'), tempoJs(taxa));
-    escrever(path.join(src, 'doc.json'), JSON.stringify(docFinal, null, 2) + '\n');
-
-    return {
-        ok: true,
-        pasta: destino,
-        midia: [...new Set(midia)].length,
-        fps: taxa,
-        segundos: +totalSegundos(doc).toFixed(2),
-        quadros: Math.round(totalSegundos(doc) * taxa),
-        cenas: doc.cenas.length,
-        comoRodar: `cd ${destino} && npm install && npm run render`,
-        licenca: 'Remotion é grátis para pessoa física e empresa de até 3 pessoas; '
-            + 'acima disso a empresa precisa de licença paga (remotion.dev/license). '
-            + 'Vale para este projeto, não para o PrimoCode.',
-    };
-}
-
-/**
- * Roda o render de um projeto já montado. Só faz sentido depois do
- * `npm install` — Remotion baixa o próprio navegador, e isso leva minutos na
- * primeira vez.
- */
-function renderizar({ pasta, saida, minutos = 20 }) {
-    return new Promise((resolve) => {
-        if (!fs.existsSync(path.join(pasta, 'node_modules'))) {
-            return resolve({
-                ok: false,
-                error: `Falta instalar. Rode: cd ${pasta} && npm install  (demora — o Remotion `
-                    + 'traz o próprio navegador). Depois peça o render de novo.',
-            });
-        }
-        const arquivo = saida || path.join('saida', 'video.mp4');
-        const proc = spawn(process.platform === 'win32' ? 'npx.cmd' : 'npx',
-            ['remotion', 'render', 'src/index.jsx', 'Video', arquivo, '--log=error'],
-            { cwd: pasta, stdio: ['ignore', 'pipe', 'pipe'] });
-
-        let fora = '';
-        proc.stdout.on('data', (d) => { fora += d; });
-        proc.stderr.on('data', (d) => { fora += d; });
-
-        const prazo = setTimeout(() => { try { proc.kill(); } catch {} }, minutos * 60000);
-        proc.on('close', (codigo) => {
-            clearTimeout(prazo);
-            const alvo = path.join(pasta, arquivo);
-            if (codigo === 0 && fs.existsSync(alvo)) {
-                return resolve({
-                    ok: true, arquivo: alvo,
-                    bytes: fs.statSync(alvo).size,
-                });
-            }
-            resolve({ ok: false, error: (fora || `remotion saiu com ${codigo}`).slice(-1200) });
-        });
-        proc.on('error', (e) => { clearTimeout(prazo); resolve({ ok: false, error: e.message }); });
-    });
-}
-
-/* ── A MESCLA: o Remotion como motor de render do studio_exportar ─────────
- *
- * O dono: "ele deve usar o Remotion e o Studio, deve mesclar os 2". O Studio
- * é o autor — a cena, o motion, a narração, a trilha gerada, os efeitos — e
- * grava o MP4 em tempo real, com o risco de quadro perdido quando a máquina
- * está ocupada. O Remotion desenha a MESMA cena quadro a quadro, sem relógio,
- * mas não tem WebAudio. Então: o vídeo vem do Remotion, o áudio vem do
- * Studio, e o ffmpeg junta os dois. Quem chama é o lib/studio.js.
- *
- * Uma instalação só, em ~/.primocode/remotion — 250 MB uma vez, para todos
- * os projetos —, e nunca dentro do PrimoCode (zero dependências continua
- * valendo). Os projetos renderizados nascem em projetos/<slug>/ e resolvem
- * `remotion` e `react` subindo a árvore até o node_modules compartilhado. */
-const os = require('os');
-const CASA_REMOTION = process.env.PRIMOCODE_REMOTION_CASA || path.join(os.homedir(), '.primocode', 'remotion');
-
-function instalado() {
-    return fs.existsSync(path.join(CASA_REMOTION, 'node_modules', '@remotion', 'cli', 'package.json'))
-        && fs.existsSync(path.join(CASA_REMOTION, 'node_modules', 'react'));
-}
-
-function cliRemotion() {
-    const pasta = path.join(CASA_REMOTION, 'node_modules', '@remotion', 'cli');
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(pasta, 'package.json'), 'utf-8'));
-        const bin = typeof pkg.bin === 'string' ? pkg.bin : (pkg.bin && (pkg.bin.remotion || Object.values(pkg.bin)[0]));
-        if (bin) return path.join(pasta, bin);
-    } catch { /* cai no nome conhecido */ }
-    return path.join(pasta, 'remotion-cli.js');
-}
-
-let instalando = null;
-/** Traz o Remotion uma vez. `avisar(texto)` recebe o que dizer na tela. */
-function garantirInstalado({ minutos = 15, avisar } = {}) {
-    if (instalado()) return Promise.resolve({ ok: true, jaEstava: true });
-    if (instalando) return instalando;
-    instalando = new Promise((resolve) => {
-        fs.mkdirSync(CASA_REMOTION, { recursive: true });
-        escrever(path.join(CASA_REMOTION, 'package.json'), pkgJson('primocode-remotion'));
-        if (avisar) avisar('instalando o Remotion (uma vez, ~250 MB — alguns minutos)…');
-        const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-        const proc = spawn(npm, ['install', '--no-audit', '--no-fund', '--loglevel=error'],
-            { cwd: CASA_REMOTION, stdio: ['ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
-        let fora = '';
-        proc.stdout.on('data', (d) => { fora += d; });
-        proc.stderr.on('data', (d) => { fora += d; });
-        const prazo = setTimeout(() => { try { proc.kill(); } catch {} }, minutos * 60000);
-        proc.on('close', (codigo) => {
-            clearTimeout(prazo);
-            instalando = null;
-            if (codigo === 0 && instalado()) return resolve({ ok: true });
-            resolve({ ok: false, error: (fora || `npm saiu com ${codigo}`).slice(-600) });
-        });
-        proc.on('error', (e) => { clearTimeout(prazo); instalando = null; resolve({ ok: false, error: e.message }); });
-    });
-    return instalando;
-}
-
-/**
- * Renderiza UMA peça do Studio pelo Remotion e devolve o mp4 (só vídeo quando
- * `semAudio`). Monta o projeto em CASA_REMOTION/projetos/<slug>, com a mídia.
- */
-async function renderizarPeca({ doc, titulo, fps, midiaDir, semAudio = true, minutos = 30, avisar }) {
-    const pronto = await garantirInstalado({ avisar });
-    if (!pronto.ok) return { ok: false, error: `Remotion não instalou: ${pronto.error}` };
-    const slug = String(titulo || 'video').normalize('NFD').replace(/[̀-ͯ]/g, '')
-        .replace(/[^\w-]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase().slice(0, 40) || 'video';
-    const destino = path.join(CASA_REMOTION, 'projetos', slug);
-    const m = montar({ destino, titulo, doc, fps, midiaDir, semAudio });
-    if (!m.ok) return m;
-    if (avisar) avisar(`renderizando ${m.quadros} quadros pelo Remotion…`);
-    const arquivo = path.join('saida', 'video.mp4');
-    fs.mkdirSync(path.join(destino, 'saida'), { recursive: true });
-    const args = [cliRemotion(), 'render', 'src/index.jsx', 'Video', arquivo,
-        '--codec=h264', '--crf=18', '--log=error', '--concurrency=50%'];
-    if (semAudio) args.push('--muted');
-    return new Promise((resolve) => {
-        const proc = spawn(process.execPath, args, { cwd: destino, stdio: ['ignore', 'pipe', 'pipe'] });
-        let fora = '';
-        proc.stdout.on('data', (d) => { fora += d; });
-        proc.stderr.on('data', (d) => { fora += d; });
-        const prazo = setTimeout(() => { try { proc.kill(); } catch {} }, minutos * 60000);
-        proc.on('close', (codigo) => {
-            clearTimeout(prazo);
-            const alvo = path.join(destino, arquivo);
-            if (codigo === 0 && fs.existsSync(alvo)) {
-                return resolve({ ok: true, arquivo: alvo, bytes: fs.statSync(alvo).size, quadros: m.quadros, segundos: m.segundos, pasta: destino });
-            }
-            resolve({ ok: false, error: (fora || `remotion saiu com ${codigo}`).slice(-1200) });
-        });
-        proc.on('error', (e) => { clearTimeout(prazo); resolve({ ok: false, error: e.message }); });
-    });
-}
-
-module.exports = { montar, renderizar, renderizarPeca, garantirInstalado, instalado, cliRemotion,
-    segundosDaCena, totalSegundos, VERSAO_REMOTION, CASA_REMOTION };