primocode 10.19.0 → 11.1.0

package/kits/synthwave/receita.json

@@ -1,170 +0,0 @@
-{
-  "kit": "synthwave",
-  "fps": 30,
-  "batida_trilha_quadros": 16.36,
-  "duracao_video_s": [
-    6,
-    45
-  ],
-  "ordem_sugerida": [
-    "gancho",
-    "virada",
-    "data",
-    "oferta",
-    "cta",
-    "marca"
-  ],
-  "batidas": [
-    {
-      "nome": "gancho",
-      "obrigatoria": true,
-      "duracao": [
-        40,
-        75
-      ],
-      "elementos": [
-        "SolListrado",
-        "Montanhas"
-      ],
-      "entrada": [
-        "nenhuma"
-      ],
-      "sons": [
-        "subida",
-        "impacto"
-      ],
-      "nota": "o sol nasce atrás das montanhas e fica parado 0,5 s."
-    },
-    {
-      "nome": "virada",
-      "obrigatoria": true,
-      "duracao": [
-        45,
-        75
-      ],
-      "elementos": [
-        "TituloNeon",
-        "Palmeiras",
-        "Estrelas"
-      ],
-      "entrada": [
-        "cortar"
-      ],
-      "sons": [
-        "whoosh-entra",
-        "pop-palavra",
-        "impacto"
-      ],
-      "nota": "o nome do evento/produto em 2 linhas neon, palmeiras no apoio."
-    },
-    {
-      "nome": "data",
-      "obrigatoria": true,
-      "duracao": [
-        45,
-        75
-      ],
-      "elementos": [
-        "QuadroHUD"
-      ],
-      "entrada": [
-        "cortar"
-      ],
-      "sons": [
-        "pop-cartao",
-        "clique"
-      ],
-      "nota": "dados em painel HUD: data, local, preço."
-    },
-    {
-      "nome": "oferta",
-      "obrigatoria": false,
-      "duracao": [
-        36,
-        66
-      ],
-      "elementos": [
-        "TituloNeon",
-        "Estrelas"
-      ],
-      "entrada": [
-        "cortar"
-      ],
-      "sons": [
-        "whoosh-entra",
-        "impacto"
-      ],
-      "nota": "a chamada final em título neon com túnel de estrelas."
-    },
-    {
-      "nome": "cta",
-      "obrigatoria": false,
-      "duracao": [
-        30,
-        60
-      ],
-      "elementos": [
-        "TituloNeon",
-        "Palmeiras"
-      ],
-      "entrada": [
-        "cortar"
-      ],
-      "sons": [
-        "pop-palavra"
-      ],
-      "nota": "pergunta ou convite curto."
-    },
-    {
-      "nome": "marca",
-      "obrigatoria": true,
-      "duracao": [
-        48,
-        90
-      ],
-      "elementos": [
-        "AssinaturaMarca",
-        "Montanhas"
-      ],
-      "entrada": [
-        "cortar"
-      ],
-      "sons": [
-        "assinatura",
-        "clique"
-      ],
-      "nota": "sempre a última: ícone-sol, nome neon, tagline, endereço."
-    }
-  ],
-  "transicoes": [
-    {
-      "nome": "cortar",
-      "quadros": 10,
-      "como": "entra com zoom 1,14 → 1 e sobra; a anterior cresce 8% e some; o túnel de estrelas cobre o corte"
-    },
-    {
-      "nome": "zoom",
-      "quadros": 10,
-      "como": "entra de 1,9x para 1"
-    },
-    {
-      "nome": "direita",
-      "quadros": 10,
-      "como": "entra 348 px da direita"
-    },
-    {
-      "nome": "nenhuma",
-      "quadros": 0,
-      "como": "sem movimento de janela (gancho)"
-    }
-  ],
-  "camera": {
-    "deriva": "sempre",
-    "socos": "cada corte; o chão corre sempre"
-  },
-  "trilha": {
-    "arquivo": "assets/trilha/noite-110bpm.mp3",
-    "volume": 0.55,
-    "com_narracao": 0.25
-  }
-}

package/kits/synthwave/regras/area-segura.md

@@ -1,19 +0,0 @@
-# Área segura (9:16, 1080×1920)
-
-- Tudo que se lê fica entre **y = 168** e **y = 1330** e entre **x = 96** e **x = 984** (888 px úteis, margem de 8,9%).
-- Embaixo de 1330 px ficam a legenda e os botões do Reels/TikTok: ali só fundo e elementos que sangram.
-- Posições de referência (centro, em px):
-
-| uso | y |
-|---|---|
-| horizonte | 1180 |
-| sol (centro) | 880 |
-| título neon (centro do bloco) | 640 |
-| HUD (centro) | 700 |
-| montanhas (base) | 1180 |
-| palmeiras (base) | 1200 |
-| marca (nome) | 660 |
-| tagline / endereço | 860–1000 |
-
-- O céu, a grade e o sol podem sangrar; o texto fica a 96 px da borda e acima de y = 1330.
-- Respiro: 35–45% do quadro vazio, 1 herói + no máximo 1 apoio por plano, nada encostando na borda, e uma pausa de 15 a 24 quadros depois de cada golpe grande.

package/kits/synthwave/regras/cor.md

@@ -1,16 +0,0 @@
-# Cor
-
-| token | hex | uso |
-|---|---|---|
-| `noite` | `#0D0221` | topo do céu e chão |
-| `roxo` | `#2B0B5E` | meio do céu, fundo das montanhas |
-| `magenta` | `#FF2A9D` | horizonte, linhas verticais da grade, aro das montanhas |
-| `ciano` | `#00E5FF` | linhas horizontais da grade, cantoneiras do HUD |
-| `sol` | `#FFD23F` | topo do sol e do título |
-| `rosa` | `#FF2A6D` | base do sol e do título |
-| `branco` | `#FFF4FF` | texto do HUD |
-
-- Céu: `#0D0221 0%`, `#2B0B5E 40%`, `#7A1E8C 55%`, `#FF2A9D 61%` (horizonte).
-- Sol: degradê vertical `#FFD23F → #FF2A6D`; letra: o mesmo degradê com contorno branco de 2 px.
-- Brilho (glow) só em sol (`0 0 120px rgba(255,42,109,0.6)`) e título (`0 0 16px #FF2A9D, 0 0 44px #FF2A9D`); nada mais brilha.
-- O cliente pode trocar `magenta` e `ciano`.

package/kits/synthwave/regras/movimento.md

@@ -1,16 +0,0 @@
-# Movimento
-
-- Tela 1080×1920, **30 fps**. Curva padrão `e5` ≈ cubic-bezier(.2,.8,.2,1); toda entrada com sobra `eb` (easeOutBack, passa ~10% e volta).
-- A câmera nunca para: zoom 1,02 ± 0,014 (período 120 quadros), deslize ±10 × ±8 px, giro ±0,29°; soco de +2,5% que cai em 8 quadros a cada corte; o chão corre 14 px por quadro o tempo todo.
-- Entrada de cena: 10 quadros; saída sobrepõe 8 quadros com a próxima. Corte ou troca a cada 0,6–1,5 s (18–45 quadros).
-
-| movimento | quadros | valores |
-|---|---|---|
-| sol nasce | 22 | sobe 700 px até y = 880 com `eb` (cortado pelo horizonte); listras descem 0,25 unid./quadro |
-| título entra | 16 | translateX −900 → 0 com `eb`, scale 1,3 → 1; pisca 3 vezes nos 6 primeiros quadros |
-| HUD liga | 24 | cantoneiras abrem do centro em 10 quadros; cada linha revela por varredura (clip) 10 quadros, 8 entre linhas |
-| montanhas sobem | 18 | translateY 300 → 0 com `eb`; deriva 0,15 px/quadro (paralaxe 2 camadas) |
-| palmeiras | 16 | sobem do chão com `eb` e balançam ±2° (período 60 quadros) |
-| túnel de estrelas | 20 | 36 riscos saem do ponto de fuga (540, 1180), raio ∝ t², cor branca/ciano/magenta |
-| chão de grade | contínuo | linhas correm 14 px por quadro em direção à câmera |
-| saída de cena | 8 | scale 1 → 1,08 e some, sobrepondo 8 quadros |

package/kits/synthwave/regras/ritmo.md

@@ -1,15 +0,0 @@
-# Ritmo
-
-- 110 bpm → 1 batida = **16.36 quadros** (0.545 s). Cortes caem nas batidas; o sol sobe em 2 batidas e fica parado por 0,5 s.
-- Tempo mínimo de leitura: **40** quadros por frase (≈ 0,45 s por palavra curta).
-
-| batida | duração (s) | quadros |
-|---|---|---|
-| gancho | 1.3–2.5 | 40–75 |
-| virada | 1.5–2.5 | 45–75 |
-| data | 1.5–2.5 | 45–75 |
-| oferta | 1.2–2.2 | 36–66 |
-| cta | 1.0–2.0 | 30–60 |
-| marca | 1.6–3.0 | 48–90 |
-
-- Vídeo de demo: 8 s = 240 quadros (14.7 batidas).

package/kits/synthwave/regras/som.md

@@ -1,21 +0,0 @@
-# Som
-
-- Trilha: `assets/trilha/noite-110bpm.mp3` (9 s, 110 bpm), volume **0.55**, fade de saída nos últimos **20 quadros**. Vídeo maior que 9 s: gere outra no MotionCraft (`music make`, preset dark-minimal, 110 bpm, tom A, progressão night-drive, lead pluck, bateria tight, comp eighths, brilho 1,1) — não faça loop.
-- Com narração: trilha a **0,25** e efeitos a 70% do volume da tabela.
-- Efeitos sintetizados (MotionCraft `sfx make`, pacote digital-soft: secos e digitais); trilha de 9 s, 110 bpm, noturna e batida.
-
-| som | volume | quando |
-|---|---|---|
-| `subida` | 0.7 | sol que nasce (1,3 s antes de chegar) |
-| `impacto` | 0.9 | sol no topo e palavra do título |
-| `whoosh-entra` | 0.9 | entrada de cena e túnel de estrelas |
-| `pop-palavra` | 1 | linha do título |
-| `clique` | 0.8 | linha do HUD que liga |
-| `swoosh` | 1 | montanhas e palmeiras |
-| `pop-cartao` | 0.9 | cantoneiras do HUD |
-| `assinatura` | 0.9 | revelação da marca |
-| `whoosh-sai` | 0.8 | saída grande |
-
-- Um som por movimento que importa; no máximo **3 sons por segundo**; nunca o mesmo arquivo duas vezes seguidas.
-- Som entra **1 a 2 quadros antes** do visual.
-- O render nivela o mix em **−14 LUFS**, pico −1,5 dBTP.

package/kits/synthwave/regras/tipografia.md

@@ -1,16 +0,0 @@
-# Tipografia
-
-Orbitron 900 (larga, geométrica) inclinada −8° para título e dados; Rajdhani 600 em caixa alta espaçada para rótulos, tagline e endereço.
-
-| papel | tamanho (px) | máx. caracteres | peso · tracking · caixa |
-|---|---|---|---|
-| título neon (linha) | 200 (encolhe até 100) | 9 por linha | Orbitron 900 · 0,02 em · MAIÚSCULAS · skewX −8° |
-| valor do HUD | 96 | 14 | Orbitron 900 · branco · glow ciano |
-| rótulo do HUD | 40 | 20 | Rajdhani 600 · 0,3 em · MAIÚSCULAS · ciano |
-| tagline | 48 | 34 | Rajdhani 600 · 0,3 em · MAIÚSCULAS |
-| endereço | 52 | 20 | Rajdhani 600 · 0,2 em · MAIÚSCULAS |
-| nome na marca | 180 (encolhe) | 10 | Orbitron 900 · neon |
-
-- Texto que passa da largura útil (888 px) **encolhe sozinho** (`caber()` em `elementos/base.ts`). Nunca palavra cortada.
-- Título sempre inclinado −8° e em duas camadas (brilho atrás, degradê na frente).
-- Margem lateral de 96 px; nada de texto sobre as listras do sol.

package/kits/terminal/assets/ASSETS.md

@@ -1,20 +0,0 @@
-# Assets do kit terminal
-
-| arquivo | o que é | origem | licença |
-|---|---|---|---|
-| `fontes/jetbrains-mono-700.woff2` | JetBrains Mono 700 (placa do monitor), subset latino | Google Fonts (fonts.gstatic.com), baixado em 26/10/2026 | SIL OFL 1.1 — texto em `fontes/OFL-jetbrains-mono-700.txt` |
-| `fontes/vt323.woff2` | VT323 (texto), subset latino | Google Fonts (fonts.gstatic.com), baixado em 26/10/2026 | SIL OFL 1.1 — texto em `fontes/OFL-vt323.txt` |
-| `sons/whoosh-entra.mp3` | efeito whoosh-entra | sintetizado: MotionCraft `sfx make`, tipo `whoosh_in`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/whoosh-sai.mp3` | efeito whoosh-sai | sintetizado: MotionCraft `sfx make`, tipo `whoosh_out`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/swoosh.mp3` | efeito swoosh | sintetizado: MotionCraft `sfx make`, tipo `swoosh`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/pop-palavra.mp3` | efeito pop-palavra | sintetizado: MotionCraft `sfx make`, tipo `word_pop`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/pop-cartao.mp3` | efeito pop-cartao | sintetizado: MotionCraft `sfx make`, tipo `icon_pop`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/clique.mp3` | efeito clique | sintetizado: MotionCraft `sfx make`, tipo `button`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/impacto.mp3` | efeito impacto | sintetizado: MotionCraft `sfx make`, tipo `impact`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/subida.mp3` | efeito subida | sintetizado: MotionCraft `sfx make`, tipo `riser`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/assinatura.mp3` | efeito assinatura | sintetizado: MotionCraft `sfx make`, tipo `logo_sting`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/tick.mp3` | efeito tick | sintetizado: MotionCraft `sfx make`, tipo `letter_tick`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/digitar.mp3` | rajada de 16 teclas com cadência humana | sintetizado: MotionCraft `sfx make`, tipo `type` ×16, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `sons/liga-crt.mp3` | o tubo ligando (baque + chiado subindo) | sintetizado: MotionCraft `sfx make`, `impact` + `riser`, pacote `digital-soft` | sem samples; síntese própria (CC0) |
-| `trilha/trilha.mp3` | trilha de 8,7 s, 110 bpm | MotionCraft `music make --preset dark-minimal --bpm 110 --key A` | síntese própria (CC0); MotionCraft é MIT |
-

package/kits/terminal/elementos/ArteAscii.tsx

@@ -1,61 +0,0 @@
-// ArteAscii: o nome do produto em LETRAS DE BLOCO (fonte 5×7 desenhada no kit), revelado linha a linha
-// pela cabeça de escrita do tubo: cada linha de blocos acende quente e esfria pro fósforo em 6 quadros.
-// O herói do vídeo: largura até 760 px. Blocos desenhados, não glifos (nada depende da fonte).
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {BLOOM, COR, VIDRO, lerp, ruido, seg} from './base';
-
-// fonte 5×7: cada letra é 7 linhas de 5 bits
-const F: Record<string, string[]> = {
-  A: ['01110', '10001', '10001', '11111', '10001', '10001', '10001'], B: ['11110', '10001', '10001', '11110', '10001', '10001', '11110'],
-  C: ['01111', '10000', '10000', '10000', '10000', '10000', '01111'], D: ['11110', '10001', '10001', '10001', '10001', '10001', '11110'],
-  E: ['11111', '10000', '10000', '11110', '10000', '10000', '11111'], F: ['11111', '10000', '10000', '11110', '10000', '10000', '10000'],
-  G: ['01111', '10000', '10000', '10111', '10001', '10001', '01111'], H: ['10001', '10001', '10001', '11111', '10001', '10001', '10001'],
-  I: ['11111', '00100', '00100', '00100', '00100', '00100', '11111'], J: ['00111', '00010', '00010', '00010', '00010', '10010', '01100'],
-  K: ['10001', '10010', '10100', '11000', '10100', '10010', '10001'], L: ['10000', '10000', '10000', '10000', '10000', '10000', '11111'],
-  M: ['10001', '11011', '10101', '10101', '10001', '10001', '10001'], N: ['10001', '11001', '10101', '10011', '10001', '10001', '10001'],
-  O: ['01110', '10001', '10001', '10001', '10001', '10001', '01110'], P: ['11110', '10001', '10001', '11110', '10000', '10000', '10000'],
-  R: ['11110', '10001', '10001', '11110', '10100', '10010', '10001'], S: ['01111', '10000', '10000', '01110', '00001', '00001', '11110'],
-  T: ['11111', '00100', '00100', '00100', '00100', '00100', '00100'], U: ['10001', '10001', '10001', '10001', '10001', '10001', '01110'],
-  V: ['10001', '10001', '10001', '10001', '10001', '01010', '00100'], X: ['10001', '10001', '01010', '00100', '01010', '10001', '10001'],
-  Y: ['10001', '10001', '01010', '00100', '00100', '00100', '00100'], Z: ['11111', '00001', '00010', '00100', '01000', '10000', '11111'],
-  0: ['01110', '10011', '10101', '10101', '10101', '11001', '01110'], 1: ['00100', '01100', '00100', '00100', '00100', '00100', '01110'],
-  2: ['01110', '10001', '00001', '00110', '01000', '10000', '11111'], 3: ['11110', '00001', '00001', '01110', '00001', '00001', '11110'],
-  4: ['00010', '00110', '01010', '10010', '11111', '00010', '00010'], 5: ['11111', '10000', '11110', '00001', '00001', '10001', '01110'],
-  6: ['01110', '10000', '10000', '11110', '10001', '10001', '01110'], 7: ['11111', '00001', '00010', '00100', '01000', '01000', '01000'],
-  8: ['01110', '10001', '10001', '01110', '10001', '10001', '01110'], 9: ['01110', '10001', '10001', '01111', '00001', '00001', '01110'],
-  '.': ['00000', '00000', '00000', '00000', '00000', '01100', '01100'], ' ': ['00000', '00000', '00000', '00000', '00000', '00000', '00000'],
-};
-
-export type ArteAsciiProps = {
-  texto: string;
-  /** topo do bloco, px no vidro */
-  y?: number;
-  /** largura máxima, px */
-  largura?: number;
-  inicio?: number;
-  /** quadros por linha de blocos (7 linhas) */
-  porLinha?: number;
-};
-
-export const ArteAscii: React.FC<ArteAsciiProps> = ({texto, y = 300, largura = 760, inicio = 0, porLinha = 2}) => {
-  const f = useCurrentFrame() - inicio;
-  if (f < 0) return null;
-  const letras = texto.toUpperCase().split('').map((c) => F[c] ?? F[' ']);
-  const colunas = letras.length * 6 - 1;
-  const cel = Math.floor(largura / colunas), gap = Math.max(2, Math.round(cel * 0.12));
-  const L = colunas * cel, x0 = (VIDRO.l - L) / 2;
-  const blocos: React.ReactNode[] = [];
-  letras.forEach((g, li) => g.forEach((row, r) => row.split('').forEach((b, c) => {
-    if (b !== '1') return;
-    const em = r * porLinha + ruido(li * 31 + c) * 0.8;
-    if (f < em) return;
-    const calor = 1 - seg(f, em, em + 6);
-    const glitch = calor > 0.6 ? (ruido(f * 3 + r) - 0.5) * cel * 0.6 : 0;
-    blocos.push(<div key={`${li}-${r}-${c}`} style={{position: 'absolute', left: x0 + (li * 6 + c) * cel + glitch, top: y + r * cel, width: cel - gap, height: cel - gap,
-      background: calor > 0.02 ? COR.quente : COR.fosforo, opacity: lerp(1, 0.94, 1 - calor), boxShadow: BLOOM(COR.fosforo, 0.5 + calor)}} />);
-  })));
-  // a cabeça de escrita
-  const cabeca = f < 7 * porLinha + 2 ? <div style={{position: 'absolute', left: x0 - 30, width: L + 60, top: y + Math.min(7, f / porLinha) * cel - 2, height: 4, background: COR.quente, boxShadow: BLOOM(COR.fosforo, 1.4)}} /> : null;
-  return <>{blocos}{cabeca}</>;
-};

package/kits/terminal/elementos/BarraProgresso.tsx

@@ -1,42 +0,0 @@
-// BarraProgresso: a saída do comando que vira herói. Uma linha por tarefa: rótulo, a barra de 14 blocos
-// entre colchetes que enche aos SALTOS (como I/O de verdade), e a porcentagem; no fim, [OK] quente.
-// Blocos desenhados (não dependem de glifo): 38 × 58 px, vão de 6 px, bloom do fósforo.
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {BLOOM, COR, FONTE, GRADE, ruido, seg} from './base';
-
-export type BarraProgressoProps = {
-  itens: {rotulo: string; duracao: number}[];
-  y?: number;
-  inicio?: number;
-  /** quadros entre o início de uma barra e da próxima */
-  intervalo?: number;
-  celulas?: number;
-};
-
-export const BarraProgresso: React.FC<BarraProgressoProps> = ({itens, y = 200, inicio = 0, intervalo = 6, celulas = 14}) => {
-  const f = useCurrentFrame() - inicio;
-  const W = 38, G = 6;
-  return <>{itens.map((it, i) => {
-    const t0 = i * intervalo;
-    if (f < t0) return null;
-    const lin = seg(f, t0, t0 + it.duracao);
-    // saltos: avança em degraus irregulares
-    const deg = Math.floor(lin * 9);
-    const p = lin >= 1 ? 1 : Math.min(0.97, (deg + ruido(deg + i * 13) * 0.9) / 9);
-    const cheios = Math.round(p * celulas);
-    const top = y + i * 230;
-    return <div key={i} style={{position: 'absolute', left: GRADE.margem, top, width: 840 - GRADE.margem * 2}}>
-      <div style={{fontFamily: FONTE, fontSize: 62, color: COR.fosforo, textShadow: BLOOM(COR.fosforo, 0.8), whiteSpace: 'pre'}}>
-        {it.rotulo}<span style={{float: 'right', marginLeft: 40, color: lin >= 1 ? COR.quente : COR.fosforo}}>{lin >= 1 ? '[ OK ]' : `${String(Math.round(p * 100)).padStart(3, ' ')}%`}</span>
-      </div>
-      <div style={{display: 'flex', alignItems: 'center', marginTop: 10, fontFamily: FONTE, fontSize: 80, color: COR.apagado}}>
-        <span>[</span>
-        <div style={{display: 'flex', gap: G, margin: '0 8px'}}>
-          {Array.from({length: celulas}, (_, k) => <div key={k} style={{width: W, height: 58, background: k < cheios ? (lin >= 1 ? COR.quente : COR.fosforo) : 'rgba(255,178,63,.08)', boxShadow: k < cheios ? BLOOM(COR.fosforo, 0.5) : undefined}} />)}
-        </div>
-        <span>]</span>
-      </div>
-    </div>;
-  })}</>;
-};

package/kits/terminal/elementos/BarraStatus.tsx

@@ -1,18 +0,0 @@
-// BarraStatus: a linha de status em vídeo inverso no pé do vidro (como os programas de DOS/BBS):
-// segmentos separados por "|" e um relógio que conta o tempo do vídeo. Fica em todas as cenas.
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {BLOOM, COR, FONTE, VIDRO} from './base';
-
-export type BarraStatusProps = {segmentos: string[]; desde?: number};
-
-export const BarraStatus: React.FC<BarraStatusProps> = ({segmentos, desde = 10}) => {
-  const f = useCurrentFrame();
-  if (f < desde) return null;
-  const s = Math.floor(f / 30), q = f % 30;
-  const relogio = `00:0${s}:${String(q).padStart(2, '0')}`;
-  return <div style={{position: 'absolute', left: 30, right: 30, top: VIDRO.a - 104, height: 54, background: COR.fosforo, color: COR.vidro, display: 'flex', alignItems: 'center', justifyContent: 'space-between',
-    padding: '0 22px', fontFamily: FONTE, fontSize: 40, boxShadow: BLOOM(COR.fosforo, 0.5), whiteSpace: 'pre'}}>
-    <span>{segmentos.join(' | ')}</span><span>{relogio}</span>
-  </div>;
-};

package/kits/terminal/elementos/BootBios.tsx

@@ -1,41 +0,0 @@
-// BootBios: a partida da máquina. Cabeçalho do BIOS, o CONTADOR DE MEMÓRIA gigante (140 px, herói)
-// que sobe em saltos irregulares, e as checagens que imprimem uma a uma com pontos de guia e [OK]
-// em vídeo inverso. Tudo dentro do vidro (coordenadas do vidro: 840 × 1110).
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {BLOOM, COR, FONTE, GRADE, ruido, seg} from './base';
-
-export type BootBiosProps = {
-  cabecalho: string[];
-  memoria: {rotulo: string; ate: number; unidade: string};
-  checagens: string[];
-  inicio?: number;
-  /** quadros entre linhas impressas */
-  intervalo?: number;
-};
-
-export const BootBios: React.FC<BootBiosProps> = ({cabecalho, memoria, checagens, inicio = 0, intervalo = 5}) => {
-  const f = useCurrentFrame() - inicio;
-  const M = GRADE.margem, T = 44;
-  const tMem = seg(f, 6, 26);
-  // saltos irregulares (como o teste de RAM de verdade)
-  const passos = Math.floor(tMem * 12), v = tMem >= 1 ? memoria.ate : Math.round(memoria.ate * Math.min(1, (passos + ruido(passos) * 0.8) / 12));
-  const linha = (t: string, i: number, y: number, cor = COR.fosforo) => f >= i ? <div key={t + y} style={{position: 'absolute', left: M, top: y, fontFamily: FONTE, fontSize: T, color: cor, textShadow: BLOOM(cor, 0.8), whiteSpace: 'pre'}}>{t}</div> : null;
-  return <>
-    {cabecalho.map((c, i) => linha(c, i * 2, 70 + i * 52, i === 0 ? COR.quente : COR.fosforo))}
-    {f >= 5 && <div style={{position: 'absolute', left: M, top: 250, fontFamily: FONTE, fontSize: T, color: COR.apagado, textShadow: BLOOM(COR.apagado, 0.5)}}>{memoria.rotulo}</div>}
-    {f >= 6 && <div style={{position: 'absolute', left: M - 6, top: 290, fontFamily: FONTE, fontSize: 210, lineHeight: 1, color: COR.quente, textShadow: BLOOM(COR.fosforo, 1.6), whiteSpace: 'pre'}}>
-      {String(v).padStart(6, '0')}<span style={{fontSize: 96, color: COR.fosforo}}>{memoria.unidade}</span>
-      {tMem >= 1 && <span style={{fontSize: 70, background: COR.fosforo, color: COR.vidro, padding: '0 10px', marginLeft: 20, verticalAlign: 'middle', textShadow: 'none', boxShadow: BLOOM(COR.fosforo, 0.6)}}>OK</span>}
-    </div>}
-    {checagens.map((c, i) => {
-      const em = 30 + i * intervalo;
-      if (f < em) return null;
-      const pontos = Math.min(14, Math.floor((f - em) * 4));
-      const ok = f >= em + 4;
-      return <div key={i} style={{position: 'absolute', left: M, top: 560 + i * GRADE.linha, fontFamily: FONTE, fontSize: T, color: COR.fosforo, textShadow: BLOOM(COR.fosforo, 0.8), whiteSpace: 'pre'}}>
-        {c} {'.'.repeat(pontos)}{ok && <span style={{color: COR.quente}}> OK</span>}
-      </div>;
-    })}
-  </>;
-};

package/kits/terminal/elementos/Camera.tsx

@@ -1,23 +0,0 @@
-// Camera: o monitor é um objeto físico. A câmera deriva devagar em 3D (giro Y ±2,5°, X ±1,2°) e
-// empurra por chaves [[quadro, zoom, deslocY px]] (curva suave). Os empurrões fortes (1,0 → 1,18)
-// entram no herói: o vidro enche a tela.
-import React from 'react';
-import {AbsoluteFill, useCurrentFrame} from 'remotion';
-import {e3, lerp, seg} from './base';
-
-export type CameraProps = {chaves?: [number, number, number][]; children: React.ReactNode};
-
-const valor = (f: number, ks: [number, number, number][], i: 1 | 2) => {
-  if (f <= ks[0][0]) return ks[0][i];
-  for (let k = 1; k < ks.length; k++) if (f <= ks[k][0]) return lerp(ks[k - 1][i], ks[k][i], e3(seg(f, ks[k - 1][0], ks[k][0])));
-  return ks[ks.length - 1][i];
-};
-
-export const Camera: React.FC<CameraProps> = ({chaves = [[0, 1, 0]], children}) => {
-  const f = useCurrentFrame();
-  const z = valor(f, chaves, 1), dy = valor(f, chaves, 2);
-  const ry = Math.sin(f / 70) * 2.5, rx = Math.sin(f / 53) * 1.2;
-  return <AbsoluteFill style={{perspective: 2400}}>
-    <AbsoluteFill style={{transform: `translateY(${dy}px) scale(${z}) rotateY(${ry}deg) rotateX(${rx}deg)`, transformOrigin: '50% 40%'}}>{children}</AbsoluteFill>
-  </AbsoluteFill>;
-};

package/kits/terminal/elementos/Cena.tsx

@@ -1,25 +0,0 @@
-// Cena: a janela de tempo de um plano. Dentro dela, useCurrentFrame() começa em 0.
-// Entradas: corte (troca seca) · varre (a tela nova é escrita de cima a baixo em 8 quadros, com a
-// cabeça de escrita quente na frente) · nenhuma.
-import React, {createContext, useContext} from 'react';
-import {AbsoluteFill, Sequence, useCurrentFrame} from 'remotion';
-import {BLOOM, COR, VIDRO, seg} from './base';
-
-export type Entrada = 'corte' | 'varre' | 'nenhuma';
-const CenaCtx = createContext({duracao: 60});
-export const useDuracaoCena = () => useContext(CenaCtx).duracao;
-
-const Janela: React.FC<{entrada: Entrada; children: React.ReactNode}> = ({entrada, children}) => {
-  const f = useCurrentFrame();
-  if (entrada !== 'varre' || f >= 8) return <AbsoluteFill>{children}</AbsoluteFill>;
-  const y = seg(f, 0, 8) * VIDRO.a;
-  return <AbsoluteFill>
-    <AbsoluteFill style={{clipPath: `inset(0 0 ${VIDRO.a - y}px 0)`}}>{children}</AbsoluteFill>
-    <div style={{position: 'absolute', left: 0, right: 0, top: y - 3, height: 6, background: COR.quente, boxShadow: BLOOM(COR.fosforo, 1.5)}} />
-  </AbsoluteFill>;
-};
-
-export const Cena: React.FC<{de: number; ate: number; entrada?: Entrada; children: React.ReactNode}> = ({de, ate, entrada = 'corte', children}) =>
-  <Sequence from={de} durationInFrames={ate - de} layout="none">
-    <CenaCtx.Provider value={{duracao: ate - de}}><Janela entrada={entrada}>{children}</Janela></CenaCtx.Provider>
-  </Sequence>;

package/kits/terminal/elementos/Fundo.tsx

@@ -1,22 +0,0 @@
-// Fundo: o quarto escuro onde o monitor está. Parede quase preta, o brilho âmbar do vidro vazando
-// na parede e na mesa (y 1600+), com a borda da mesa refletindo. O brilho pulsa com a tela (±4%).
-import React from 'react';
-import {AbsoluteFill, useCurrentFrame} from 'remotion';
-import {COR} from './base';
-
-export type FundoProps = {
-  /** força do vazamento de luz (0–1) */
-  brilho?: number;
-};
-
-export const Fundo: React.FC<FundoProps> = ({brilho = 1}) => {
-  const f = useCurrentFrame();
-  const k = brilho * (0.96 + 0.04 * Math.sin(f / 3.1) * Math.sin(f / 7.7));
-  return <AbsoluteFill style={{background: COR.parede}}>
-    <AbsoluteFill style={{background: `radial-gradient(70% 45% at 50% 40%, rgba(255,160,50,${0.16 * k}) 0%, rgba(255,140,40,${0.05 * k}) 50%, rgba(0,0,0,0) 100%)`}} />
-    {/* a mesa */}
-    <div style={{position: 'absolute', left: 0, right: 0, top: 1590, bottom: 0, background: 'linear-gradient(180deg, #17110B 0%, #0B0806 60%)'}} />
-    <div style={{position: 'absolute', left: 0, right: 0, top: 1588, height: 3, background: `rgba(255,178,63,${0.25 * k})`}} />
-    <AbsoluteFill style={{background: `radial-gradient(45% 10% at 50% 84%, rgba(255,170,60,${0.14 * k}) 0%, rgba(0,0,0,0) 100%)`}} />
-  </AbsoluteFill>;
-};

package/kits/terminal/elementos/LinhaComando.tsx

@@ -1,31 +0,0 @@
-// LinhaComando: o prompt e o comando digitados com CADÊNCIA HUMANA (1–3 quadros por tecla, pausa antes
-// das opções), cursor de bloco sólido enquanto digita e piscando (8 on / 8 off) parado.
-// `enter` = quadro (relativo) em que a linha é confirmada: o cursor some.
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {BLOOM, COR, FONTE, GRADE, cadencia, digitados} from './base';
-
-export type LinhaComandoProps = {
-  prompt?: string;
-  comando: string;
-  y?: number;
-  inicio?: number;
-  enter?: number;
-  tamanho?: number;
-  semente?: number;
-};
-
-export const LinhaComando: React.FC<LinhaComandoProps> = ({prompt = 'C:\\>', comando, y = 60, inicio = 0, enter, tamanho = 54, semente = 3}) => {
-  const f = useCurrentFrame() - inicio;
-  if (f < 0) return null;
-  const tempos = cadencia(comando, semente);
-  const n = digitados(f, tempos);
-  const fimDigitar = tempos[tempos.length - 1] ?? 0;
-  const confirmado = enter !== undefined && f >= enter;
-  const digitando = n < comando.length;
-  const cursor = !confirmado && (digitando || Math.floor((f - fimDigitar) / 8) % 2 === 0);
-  return <div style={{position: 'absolute', left: GRADE.margem, top: y, fontFamily: FONTE, fontSize: tamanho, color: COR.fosforo, textShadow: BLOOM(COR.fosforo, 0.9), whiteSpace: 'pre'}}>
-    <span style={{color: COR.apagado}}>{prompt}</span>{comando.slice(0, n)}
-    {cursor && <span style={{display: 'inline-block', width: tamanho * 0.5, height: tamanho * 0.82, background: COR.quente, verticalAlign: '-0.08em', marginLeft: 2, boxShadow: BLOOM(COR.fosforo, 0.8)}} />}
-  </div>;
-};

package/kits/terminal/elementos/Monitor.tsx

@@ -1,42 +0,0 @@
-// Monitor: a MOLDURA que se repete em todo vídeo do kit. Um monitor CRT de plástico grafite em pé
-// (retrato), com cantos de 46 px, chanfro de luz em cima e sombra embaixo, o vidro abaulado, e o queixo
-// com a placa do modelo e o LED âmbar que pisca quando a tela escreve. O vidro recebe as camadas do CRT
-// (ver Tela.tsx). Liga no quadro `liga` e desliga no `desliga` (a linha e o ponto do tubo).
-import React from 'react';
-import {useCurrentFrame} from 'remotion';
-import {COR, FONTE_PLACA, MONITOR, VIDRO, e5, seg} from './base';
-
-export type MonitorProps = {
-  /** texto da placa no queixo (modelo fictício) */
-  placa?: string;
-  /** quadro (absoluto) em que o tubo liga / desliga; −1 = nunca */
-  liga?: number; desliga?: number;
-  children?: React.ReactNode;
-};
-
-export const Monitor: React.FC<MonitorProps> = ({placa = 'VG-9 · FÓSFORO P3', liga = 0, desliga = -1, children}) => {
-  const f = useCurrentFrame();
-  // ligar: linha horizontal que abre (0–8) · desligar: fecha numa linha (0–4) e num ponto (4–8)
-  const on = liga < 0 ? 1 : e5(seg(f, liga + 2, liga + 9));
-  const offA = desliga < 0 ? 0 : seg(f, desliga, desliga + 4), offB = desliga < 0 ? 0 : seg(f, desliga + 4, desliga + 8);
-  const sy = Math.max(0.004, on * (1 - offA * 0.996));
-  const sx = 1 - offB * 0.99;
-  const linha = (on > 0 && on < 1) || offA > 0;
-  const led = f % 22 < 18 ? 1 : 0.35;
-  return <div style={{position: 'absolute', left: MONITOR.x, top: MONITOR.y, width: MONITOR.l, height: MONITOR.a}}>
-    {/* plástico */}
-    <div style={{position: 'absolute', inset: 0, borderRadius: 46, background: `linear-gradient(180deg, ${COR.plasticoLuz} 0%, ${COR.plastico} 12%, ${COR.plastico} 80%, ${COR.plasticoSombra} 100%)`,
-      boxShadow: '0 40px 80px rgba(0,0,0,.7), inset 0 2px 0 rgba(255,255,255,.08), inset 0 -3px 0 rgba(0,0,0,.6)'}} />
-    {/* rebaixo do vidro */}
-    <div style={{position: 'absolute', left: VIDRO.x - MONITOR.x - 14, top: VIDRO.y - MONITOR.y - 14, width: VIDRO.l + 28, height: VIDRO.a + 28, borderRadius: 70, background: '#0B0908', boxShadow: 'inset 0 6px 14px rgba(0,0,0,.9), 0 1px 0 rgba(255,255,255,.06)'}} />
-    {/* o vidro */}
-    <div style={{position: 'absolute', left: VIDRO.x - MONITOR.x, top: VIDRO.y - MONITOR.y, width: VIDRO.l, height: VIDRO.a, borderRadius: '64px / 56px', overflow: 'hidden', background: '#050302'}}>
-      <div style={{position: 'absolute', inset: 0, transform: `scale(${sx}, ${sy})`, filter: linha ? 'brightness(2.2)' : undefined}}>{children}</div>
-      {linha && <div style={{position: 'absolute', left: '50%', top: '50%', width: VIDRO.l * sx, height: 4, transform: 'translate(-50%,-50%)', background: COR.quente, boxShadow: `0 0 24px ${COR.fosforo}`}} />}
-    </div>
-    {/* queixo: placa + LED */}
-    <div style={{position: 'absolute', left: 70, bottom: 54, fontFamily: FONTE_PLACA, fontWeight: 700, fontSize: 22, letterSpacing: '0.24em', color: '#5E564D', textTransform: 'uppercase'}}>{placa}</div>
-    <div style={{position: 'absolute', right: 74, bottom: 60, width: 14, height: 14, borderRadius: 7, background: COR.led, opacity: on > 0.5 && offB < 1 ? led : 0.15, boxShadow: `0 0 12px ${COR.led}`}} />
-    <div style={{position: 'absolute', right: 104, bottom: 56, width: 54, height: 22, borderRadius: 4, background: '#141210', boxShadow: 'inset 0 2px 3px rgba(0,0,0,.8)'}} />
-  </div>;
-};