# Relógio Temporama — módulo autônomo (Rl)

O cronômetro, a claquete e o registro de tempo que o Temporama usa em set de filmagem,
extraídos do app e transformados em módulo que se incorpora em outro projeto.

**Aberto, sem token:** <https://usapi.temporama.com.br/relogio/>

| arquivo       | o que é                                        |
|---------------|------------------------------------------------|
| `relogio.js`  | o módulo inteiro — zero dependência            |
| `relogio.css` | o estilo, todo escopado em `.rl`               |
| `index.html`  | a amostra pública (esta demo)                  |
| `VERSAO.txt`  | versão e sha256 de cada arquivo                |

## Instalar

```html
<link rel="stylesheet" href="https://usapi.temporama.com.br/relogio/relogio.css">
<script src="https://usapi.temporama.com.br/relogio/relogio.js"></script>

<div id="onde"></div>
<script>
  const rl = new Relogio('#onde', { meta: 30, formato: '24', projeto: 'Meu Curta' });
</script>
```

Ou baixe os dois arquivos e hospede você mesmo. Não há build, não há bundler, não há
`npm install`. Funciona até num `file://`.

## Opções

| opção      | padrão      | o que faz                                            |
|------------|-------------|------------------------------------------------------|
| `meta`     | `0`         | duração prevista da volta, em segundos (0 = sem meta) |
| `formato`  | `'24'`      | base de tempo: `'24'`/`'25'`/`'30'` fps, `'cs'`, `'ms'` |
| `cena`     | `'1'`       | cena inicial                                          |
| `take`     | `1`         | take inicial                                          |
| `operador` | `''`        | vai em toda linha exportada                           |
| `projeto`  | `'Amostra'` | nomeia os arquivos exportados                         |
| `mudo`     | `false`     | desliga o som                                         |

## Métodos e eventos

```js
rl.iniciar(); rl.pausar(); rl.alternar();   // cronômetro
rl.volta();                                  // fecha o trecho e vira registro
rl.bater();                                  // claquete: numera o Take, carimba o TC
rl.rec();                                    // liga o REC; chamado de novo, é o CORTA
rl.zerar();
rl.favoritar(id);                            // marca a tomada como aproveitável

rl.registros;      // os dados crus
rl.csv();          // a planilha como string
rl.baixarCsv();    // .csv com BOM
rl.baixarPdf();    // o relatório do set
rl.destruir();     // solta os atalhos de teclado e limpa o elemento

rl.on('inicio' | 'pausa' | 'volta' | 'batida' | 'rec' | 'corta' | 'zerar' | 'favorito', fn)
```

Atalhos de teclado: `espaço` inicia/pausa · `V` volta · `C` claquete · `R` REC/CORTA · `Z` zera.
Ficam inativos enquanto o foco está num campo de texto.

## As três ideias que valem mais que o código

**1. REC não é o cronômetro.** Gravar e cronometrar são instrumentos diferentes: o material
corre com o cronômetro parado, e o cronômetro corre em ensaio que ninguém grava. Ligar o REC
abre um registro **sem duração** — aparece como `GRAVANDO` e só fecha no CORTA. Um registro
aberto não é dado faltando; é o estado real de uma tomada em curso.

**2. A batida da claquete é que carimba o timecode**, não o start do cronômetro. É esse
carimbo que faz a planilha bater com o material na ilha de edição.

**3. Cor é estado, nunca dado.** Verde, âmbar e vermelho dizem se a volta bateu a meta —
não identificam cena, take nem operador. Por isso todo estado vem com **palavra junto**:
quem não separa verde de vermelho lê a mesma informação.

## A meta e as quatro faixas

Limiares idênticos aos do app em produção:

| faixa      | quando                       |
|------------|------------------------------|
| no alvo    | dentro de ±1s da meta        |
| entrando   | de 1s a 3s abaixo            |
| passou     | mais de 1s acima             |
| —          | sem meta, ou muito abaixo    |

## Exportação

**CSV** com as mesmas colunas do Temporama, de propósito — planilha daqui abre no mesmo
lugar que a do set: `Cena, Take, Vai, REC, Horario, TC_Batida, Tempo, Favorito, Operador,
Anotacao, Tipo`. Sai com BOM, senão o Excel em português abre acento quebrado.

**PDF** com o resumo do set (cena, take, contagem de registros, quantos com REC, quantos
aproveitáveis, tempo somado) e a tabela completa, paginada, mais o histórico de eventos.
É montado à mão em cerca de sessenta linhas, **sem biblioteca nenhuma** — arrastar 300 KB
de dependência para dentro do projeto de quem recebe o módulo contradiria a ideia de
ferramenta que se leva embora. Usa Helvetica, fonte base-14 que todo leitor de PDF tem.

## Temas

Seis prontos, em `temas.css` — **arquivo opcional**: o `relogio.css` sozinho já traz o
Noite embutido, e quem quer uma paleta só não carrega o peso das outras cinco.

| tema | |
|---|---|
| `noite` | o padrão — fundo quase preto, verde de sistema |
| `papel` | claro, tinta sobre papel quente; o único de dia |
| `fosforo` | terminal de fósforo verde, o mais escuro |
| `ilha` | azul profundo de mar fundo, areia no alerta |
| `grafite` | cinza neutro, sem temperatura |
| `contraste` | preto e branco puros, o máximo que a tela dá |

```html
<link rel="stylesheet" href="relogio.css">
<link rel="stylesheet" href="temas.css">   <!-- opcional -->
<div id="onde" data-tema="papel"></div>
```

Ou em tempo de execução: `rl.el.dataset.tema = 'ilha'`.

**Nenhuma dessas cores foi escolhida por gosto.** Cada tema passou por
`validar-temas.py` (publicado junto) com dois pisos: contraste WCAG do texto sobre o painel
≥ 4,5:1, e separação entre as três cores de meta ≥ ΔE 8 em OKLab **com protanopia e
deuteranopia simuladas**. Três paletas foram reprovadas na primeira rodada, sempre no mesmo
par — verde e âmbar somem um no outro em protanopia. A correção foi puxar o verde para o
teal e o vermelho para o carmim, porque o canal azul é o que o daltonismo preserva: é por
isso que nenhum verde aqui é verde puro. Os números estão em `PROVA-TEMAS.md`.

Se trocar para as suas cores, **rode o validador antes** — a medida vale mais que a nossa
opinião sobre a sua paleta.

## Tema próprio

Cinco variáveis, e nada mais precisa ser tocado:

```css
.rl {
  --rl-fundo: #0b0b0d;  --rl-painel: rgba(28,28,30,.75);
  --rl-borda: rgba(255,255,255,.12);
  --rl-texto: #fff;     --rl-fraco: #ebebf599;
  --rl-boa: #30d158;    --rl-entrando: #ff9f0a;  --rl-longa: #ff453a;
}
```

Todo seletor é escopado em `.rl`. Nenhuma regra em `body` ou `:root`: o módulo não repinta
a página de quem o recebeu.

## O que ele NÃO faz

E é honesto listar, porque é a fronteira entre o que se democratiza e o que é da casa:

- não sincroniza entre aparelhos (o app faz, por socket);
- não tem teleprompter acoplado;
- não reconcilia REC quando dois aparelhos discordam de quem estava gravando.

## Sobreviver a uma recarga

Desligado por padrão — um módulo que escreve no navegador de quem o instalou sem ninguém
pedir é um módulo mal-educado.

```js
new Relogio('#onde', { persistir: true });        // chave padrão
new Relogio('#onde', { persistir: 'meu-curta' }); // chave sua
rl.esquecer();                                    // apaga o que foi guardado
rl.on('restaurado', d => console.log(d.registros, d.gravando));
```

**O que sobrevive:** os registros, a cena, o take, a meta, a base de tempo — e, o que mais
importa, **o registro aberto do REC**. Era o buraco real, herdado do app: uma recarga no
meio de uma gravação perdia o vínculo com o registro aberto e o `GRAVANDO` nunca fechava,
deixando um take sem duração para sempre. Depois da recarga, o CORTA fecha certo.

**O que NÃO sobrevive, e é decisão e não esquecimento:** o cronômetro em curso.
`performance.now()` zera na recarga, e reconstruir "quanto tinha corrido" pelo relógio de
parede daria um número plausível e errado. Um cronômetro que mente é pior que um que zera
— então ele zera, e o REC (que é medido em tempo de parede) continua de pé.

## Estado

**Este é o relógio da próxima versão.** O Temporama em produção está no marco **v1.44**,
cujo relógio vive acoplado ao set — importa store, teleprompter, departamentos e fila
offline. Este módulo é o mesmo relógio **desacoplado**, e o compromisso assumido em
09/08/2026 é que ele entra no app no **próximo lançamento, o v1.45**.

Até lá: é código que roda, não é código que já embarcou.