"use client"; // Sessões do Clipador: gravar uma live ou baixar um VOD pelo link, acompanhar cada sessão (chat, // transcrição, varredura da IA, cortes), "Cortar agora" na live, parar, apagar e ver o gráfico do chat. // // O cartão da sessão se lê de cima para baixo: quem/estado/tempo + ações principais → saúde em uma frase → // o que está acontecendo (resumo da IA + jogo) → quatro blocos comparáveis do pipeline → ferramentas. // A página consulta o serviço a cada 5 s: todo bloco tem altura fixa (linhas truncadas, barra sempre // presente, espaço reservado) para nada pular nem mudar de altura quando um número muda. import { useEffect, useId, useLayoutEffect, useState, useSyncExternalStore, type FormEvent, type ReactNode } from "react"; import { ACTIVE_SESSION, CLIP_STATUS, CLIP_STATUS_ORDER, PLATFORM_LABEL, SESSION_STATUS, chatStatusInfo, clipperCall, formatClock, captureLabel, channelKeyOf, formatDuration, gameIdOf, gbPerHourLabel, useClipperAction, type Clip, type ClipStatus, type ClipperPlatform, type ClipperSession, type Game, type JudgeOptions, type Timeline, } from "./clipper-client"; import { ChannelEmotes, SessionGame } from "./clipper-games"; import { AlertIcon, BroadcastIcon, ChartIcon, ChatIcon, CheckIcon, ChevronDownIcon, EyeIcon, KickIcon, MicIcon, ScissorsIcon, SettingsIcon, SparkIcon, StopIcon, TrashIcon, TwitchIcon, YouTubeIcon, } from "./icons"; import { Badge, Button, EmptyState, Feedback, Input, ProgressBar, Spinner, cx, formatDate, formatInteger, type Tone } from "./ui"; import { askConfirm } from "./confirm-dialog"; /** Opções do "Cortar agora" (últimos N segundos). */ const CUT_OPTIONS = [30, 45, 60] as const; /** A varredura da IA assiste janelas de 3 min: padrão de `scanIntervalS` em `OPTION_DEFAULTS` (clipper/app/intel.py). * O valor em uso vem de `judge.options.scanIntervalS` em /status; este é o reserva (serviço antigo ou fora do ar). */ const SCAN_WINDOW_S = 180; /** Ao vivo, a IA fica até uma janela atrás por natureza; mais de duas janelas e pouco = atrasada. */ const SCAN_LATE_S = SCAN_WINDOW_S * 2 + 60; /** Trechos de 30 s esperando transcrição acima disso, ao vivo = transcrição atrasada. */ const TRANSCRIPT_LATE_SEGMENTS = 4; type Run = ReturnType["run"]; export function PlatformIcon({ platform, size = 16, className }: { platform: ClipperPlatform; size?: number; className?: string }) { const Icon = platform === "twitch" ? TwitchIcon : platform === "kick" ? KickIcon : YouTubeIcon; return ; } /* ---------- Gravar pelo link ---------- */ export function RecordForm({ onChanged, disabled }: { onChanged: () => void; disabled: boolean }) { const { pending, message, run } = useClipperAction(onChanged); const [url, setUrl] = useState(""); const titleId = useId(); const hintId = useId(); async function submit(e: FormEvent) { e.preventDefault(); const done = await run("record", () => clipperCall("sessions", "POST", { url: url.trim() }), (s) => s.kind === "vod" ? `VOD na fila: sessão #${s.id}. Baixando e processando.` : `Gravando: sessão #${s.id}.`); if (done) setUrl(""); } return (

Gravar pelo link

Live no ar: começa a gravar agora. Vídeo (VOD) da Twitch, do YouTube ou da Kick: baixa e processa inteiro.

setUrl(e.target.value)} disabled={disabled} aria-label="Link da live ou do VOD" aria-describedby={hintId} placeholder="https://www.twitch.tv/nome ou link de um vídeo" className="min-w-0 flex-1" />
{message && {message.text}}
); } /* ---------- Cortar agora ---------- */ /** Botões "Cortar agora" (últimos 30/45/60 s). O corte manual nunca é descartado pela IA. */ export function CutNow({ sessionId, pending, run }: { sessionId: number; pending: string | null; run: Run }) { return ( {pending?.startsWith("cut-") ? : }Cortar agora {CUT_OPTIONS.map((s) => ( ))} ); } /* ---------- Lista de sessões ---------- */ export function SessionList({ sessions, clips, games, nameOf, onChanged, onShowClips, onConfigure, onGamesChanged }: { sessions: ClipperSession[]; clips: Clip[]; games: Game[]; nameOf: (s: ClipperSession) => string; onChanged: () => void; onShowClips: (sessionId: number) => void; /** Abre a "Configuração do corte" da sessão. */ onConfigure: (session: ClipperSession) => void; onGamesChanged: (games: Game[]) => void; }) { const scanIntervalS = useScanInterval(); if (sessions.length === 0) { return ( } title="Nenhuma sessão ainda"> Cole o link de uma live acima, ou ligue o monitor de uma fonte na aba Fontes para gravar sozinho quando ela entrar ao vivo. ); } return (
    {sessions.map((s) => (
  • c.sessionId === s.id)} games={games} onChanged={onChanged} onShowClips={onShowClips} onConfigure={onConfigure} onGamesChanged={onGamesChanged} scanIntervalS={scanIntervalS} />
  • ))}
); } /* ---------- Saúde da sessão ---------- */ type Level = "danger" | "warning" | "note"; type Issue = { level: Level; text: string }; type Health = { tone: Tone; text: string; full: string }; /** Uma frase que responde "está tudo bem com esta sessão?": o pior problema primeiro, observações depois. */ function sessionHealth(s: ClipperSession, mismatch: boolean): Health { const live = s.status === "recording" || s.status === "starting"; const issues: Issue[] = []; const seg = s.segments; if (s.status === "error") issues.push({ level: "danger", text: "Parou com erro (detalhe abaixo)" }); if (s.status === "interrupted") { issues.push({ level: "warning", text: "Interrompida: o serviço reiniciou no meio da gravação. Retome ou processe o que já foi gravado" }); } if (s.chatStatus.startsWith("error")) issues.push({ level: "danger", text: `Chat com erro: ${s.chatStatus.replace(/^error:\s*/, "")}` }); else if (live && s.chatStatus === "connecting") issues.push({ level: "note", text: "conectando ao chat" }); else if (live && (s.chatStatus === "off" || s.chatStatus === "")) { issues.push({ level: "warning", text: "Sem chat: os cortes dependem só do áudio e da IA" }); } const waiting = seg.total - seg.analyzed; if (live && waiting > TRANSCRIPT_LATE_SEGMENTS) issues.push({ level: "warning", text: `Transcrição atrasada: ${waiting} trechos na fila` }); if (live && s.scannedUntilS !== undefined && s.durationS - s.scannedUntilS > SCAN_LATE_S) { issues.push({ level: "warning", text: `IA ${formatDuration(s.durationS - s.scannedUntilS)} atrás da gravação` }); } if (mismatch) issues.push({ level: "warning", text: "Confirme o jogo: a tela não bate com a categoria" }); if (seg.transcriptErrors > 0) { // Um ou outro trecho sem fala é normal (silêncio, música); muitos indicam o serviço de voz com problema. const many = seg.transcriptErrors > Math.max(2, seg.total * 0.05); issues.push({ level: many ? "warning" : "note", text: `${seg.transcriptErrors} trecho${seg.transcriptErrors === 1 ? "" : "s"} sem transcrição` }); } if (live && s.camDetect === null) issues.push({ level: "note", text: "câmera ainda não identificada" }); const serious = issues.filter((i) => i.level !== "note"); const notes = issues.filter((i) => i.level === "note").map((i) => i.text); if (serious.length > 0) { const tone: Tone = serious.some((i) => i.level === "danger") ? "danger" : "warning"; const parts = [...serious.map((i) => i.text), ...notes]; return { tone, text: parts.join(" · "), full: parts.join("\n") }; } const base: { tone: Tone; text: string } = s.status === "starting" ? { tone: "info", text: "Iniciando a gravação" } : s.status === "recording" ? { tone: "success", text: "Tudo certo: gravando, com o chat e a IA em dia" } : s.status === "processing" ? s.kind === "live" ? { tone: "info", text: "A gravação parou e a IA está processando o que foi gravado. Se a live continua no ar, use “Retomar gravação”" } : { tone: "info", text: "Processando: transcrição, varredura da IA e juízes em andamento" } : s.status === "done" ? { tone: "success", text: "Concluída: tudo processado" } : { tone: "neutral", text: "Gravação parada" }; const parts = [base.text, ...notes]; return { tone: base.tone, text: parts.join(" · "), full: parts.join("\n") }; } const TONE_TEXT: Record = { neutral: "text-fg-muted", accent: "text-accent", info: "text-info", violet: "text-violet", success: "text-success", warning: "text-warning", danger: "text-danger", optionB: "text-option-b", optionC: "text-option-c", optionD: "text-option-d", }; const TONE_FILL: Record = { neutral: "bg-fg-subtle", accent: "bg-accent", info: "bg-info", violet: "bg-violet", success: "bg-success", warning: "bg-warning", danger: "bg-danger", optionB: "bg-option-b", optionC: "bg-option-c", optionD: "bg-option-d", }; /** Cor do ícone da plataforma e da borda do cartão, por estado da sessão. */ const STATUS_FRAME: Record = { starting: { icon: "border-info/35 bg-info-soft text-info", border: "border-info/30" }, recording: { icon: "border-danger/35 bg-danger-soft text-danger", border: "border-danger/30" }, processing: { icon: "border-info/35 bg-info-soft text-info", border: "border-info/25" }, done: { icon: "border-line-strong bg-raised text-fg-muted", border: "border-line" }, stopped: { icon: "border-line-strong bg-raised text-fg-muted", border: "border-line" }, error: { icon: "border-danger/35 bg-danger-soft text-danger", border: "border-danger/30" }, interrupted: { icon: "border-warning/35 bg-warning-soft text-warning", border: "border-warning/30" }, }; /* ---------- Cartão da sessão ---------- */ function SessionRow({ session: s, name, clips, games, onChanged, onShowClips, onConfigure, onGamesChanged, scanIntervalS }: { session: ClipperSession; name: string; clips: Clip[]; games: Game[]; onChanged: () => void; onShowClips: (id: number) => void; onConfigure: (session: ClipperSession) => void; onGamesChanged: (games: Game[]) => void; scanIntervalS: number; }) { const { pending, message, run } = useClipperAction(onChanged); const [chartOpen, setChartOpen] = useState(false); const chartId = useId(); const frame = STATUS_FRAME[s.status]; const live = s.status === "recording" || s.status === "starting"; const active = ACTIVE_SESSION.includes(s.status); const totalClips = CLIP_STATUS_ORDER.reduce((n, k) => n + (s.clips[k] ?? 0), 0); const lastMemory = s.memory?.length ? s.memory[s.memory.length - 1] : null; const confirmedGame = s.gameSource === "user"; const mismatch = Boolean(s.game && s.screenGame && !confirmedGame && gameIdOf(s.screenGame) !== gameIdOf(s.game)); const health = sessionHealth(s, mismatch); const showNow = Boolean(lastMemory?.summary) || s.game !== undefined; // Relógio da gravação: anda a cada segundo só enquanto grava; os números que dependem dele se inscrevem sozinhos. const clock = useRecordingClock(s.durationS, s.status === "recording"); return (
{/* 1. Quem, estado, tempo e ações principais */}

{name} {s.kind === "vod" ? "VOD" : "live"}

#{s.id}{PLATFORM_LABEL[s.platform]} início {formatDate(s.startedAt)} {s.url.replace(/^https?:\/\/(www\.)?/, "")}

{s.title &&

{s.title}

}
{/* Largura fixa: o relógio anda a cada segundo e o rótulo troca para o aviso sem empurrar nada. */}
{live && s.kind === "live" && } {active && ( )} {/* Interrompida = o serviço reiniciou no meio da gravação. Retomar continua NA MESMA sessão (a parte perdida durante o reinício não existe na gravação); processar encerra e deixa a IA analisar o que foi gravado. Live em "processando" (retomada automática falhou, live ainda no ar) também pode voltar a gravar: o serviço confere se o canal está no ar e devolve erro legível se não estiver. */} {s.kind === "live" && !live && ( )} {["interrupted", "stopped", "error"].includes(s.status) && ( )}
{/* 2. Saúde em uma frase (uma linha só: o texto muda, a altura não) */}

{health.tone === "success" ? : health.tone === "warning" || health.tone === "danger" ? : active ? : } {health.text}

{/* 3. O que está acontecendo: resumo da IA + jogo */} {showNow && (
{lastMemory?.summary && (
{/* Duas linhas reservadas: o resumo novo (a cada 3 min) não muda a altura do cartão. */}

{live ? "Agora na live" : "Último resumo da IA"} · {formatClock(lastMemory.fromS)}–{formatClock(lastMemory.toS)} : {lastMemory.summary}

)} {s.game !== undefined && (
)}
)} {/* 4. Saúde do pipeline: quatro blocos com a mesma estrutura (rótulo/estado, número, barra, detalhe) */}
{s.error &&

{s.error}

}
{/* 5. Ferramentas: tudo o que é secundário num lugar só. Os painéis abertos (gráfico, emotes) ocupam a linha toda abaixo. */}
{message && {message.text}}
); } function Dot() { return ; } /* ---------- Relógio da gravação ---------- */ // O `durationS` do serviço só sobe quando um bloco .ts fecha (a cada 30 s) e a página consulta a cada 5 s. Enquanto // grava, o relógio anda sozinho a partir do último valor real e da hora em que ele chegou, com um teto para não // inventar tempo: passou do teto sem bloco novo, ele para e o cartão mostra que está esperando. /** Quanto o relógio pode andar além do último `durationS` real (um bloco de 30 s + a consulta de 5 s + folga). */ const CLOCK_MAX_AHEAD_S = 45; /** Passo da conferência: curto para o segundo virar no momento certo; só avisa quem lê quando o número muda. */ const CLOCK_TICK_MS = 250; /** Ao voltar à aba, a página reconsulta o serviço: espera isso antes de acusar "aguardando" pelo tempo escondido. */ const CLOCK_VISIBLE_GRACE_MS = 6000; class RecordingClock { private realS: number; private running: boolean; private receivedAt = performance.now(); private visibleSince = performance.now(); private shown: number; private stalled = false; private mounted = false; private timer: ReturnType | null = null; private readonly listeners = new Set<() => void>(); constructor(realS: number, running: boolean) { this.realS = realS; this.running = running; this.shown = running ? Math.floor(realS) : realS; } readonly subscribe = (listener: () => void) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }; /** Segundos exibidos: nunca voltam enquanto grava. Parado, é o valor real. */ readonly getShown = () => this.shown; /** Chegou ao teto sem bloco novo: o relógio está parado esperando o serviço. */ readonly getStalled = () => this.stalled; /** Estimativa contínua da gravação agora (já com o teto). */ estimate(): number { return this.running ? this.realS + Math.min(CLOCK_MAX_AHEAD_S, (performance.now() - this.receivedAt) / 1000) : this.realS; } /** Valor novo da consulta. Menor que o exibido: o exibido segura até a estimativa alcançar; maior: pula. */ sync(realS: number, running: boolean) { if (realS !== this.realS || running !== this.running) { this.realS = realS; this.receivedAt = performance.now(); } this.running = running; this.schedule(); this.update(); } /** Liga o passo do relógio (só com o cartão na tela); devolve a limpeza. */ mount() { this.mounted = true; this.visibleSince = performance.now(); document.addEventListener("visibilitychange", this.onVisibility); this.schedule(); this.update(); return () => { this.mounted = false; document.removeEventListener("visibilitychange", this.onVisibility); this.schedule(); }; } private readonly onVisibility = () => { if (document.visibilityState === "visible") this.visibleSince = performance.now(); this.schedule(); this.update(); }; /** Um intervalo só, e só enquanto grava com a aba visível. */ private schedule() { const wanted = this.mounted && this.running && document.visibilityState === "visible"; if (wanted && this.timer === null) this.timer = setInterval(this.update, CLOCK_TICK_MS); else if (!wanted && this.timer !== null) { clearInterval(this.timer); this.timer = null; } } private readonly update = () => { let shown = this.realS; let stalled = false; if (this.running) { const now = performance.now(); const elapsed = (now - this.receivedAt) / 1000; shown = Math.max(Math.floor(this.shown), Math.floor(this.realS + Math.min(CLOCK_MAX_AHEAD_S, elapsed))); stalled = elapsed >= CLOCK_MAX_AHEAD_S && now - this.visibleSince >= CLOCK_VISIBLE_GRACE_MS; } if (shown === this.shown && stalled === this.stalled) return; this.shown = shown; this.stalled = stalled; for (const listener of this.listeners) listener(); }; } /** Um relógio por cartão. O cartão não re-renderiza a cada segundo: só os números inscritos nele. */ function useRecordingClock(durationS: number, running: boolean): RecordingClock { const [clock] = useState(() => new RecordingClock(durationS, running)); // Antes da pintura: o valor novo da consulta não aparece um quadro atrasado. useLayoutEffect(() => { clock.sync(durationS, running); }, [clock, durationS, running]); useEffect(() => clock.mount(), [clock]); return clock; } function useClockShown(clock: RecordingClock): number { return useSyncExternalStore(clock.subscribe, clock.getShown, clock.getShown); } function useClockStalled(clock: RecordingClock): boolean { return useSyncExternalStore(clock.subscribe, clock.getStalled, clock.getStalled); } function ClockText({ clock }: { clock: RecordingClock }) { return <>{formatClock(useClockShown(clock))}; } function ClockLabel({ clock, live }: { clock: RecordingClock; live: boolean }) { const stalled = useClockStalled(clock); if (stalled) { return ( aguardando o bloco ); } return {live ? "gravados" : "de duração"}; } /** Selo do estado. Gravando sem bloco novo além do teto: mesmo texto (a largura não muda), em alerta e sem pulsar. */ function StatusBadge({ status, clock }: { status: ClipperSession["status"]; clock: RecordingClock }) { const stalled = useClockStalled(clock) && status === "recording"; const info = SESSION_STATUS[status]; return ( {info.label} ); } /* ---------- Cadência do resumo ---------- */ /** Intervalo da varredura em uso no serviço (`judge.options.scanIntervalS` em /status), lido uma vez por montagem. */ function useScanInterval(): number { const [intervalS, setIntervalS] = useState(SCAN_WINDOW_S); useEffect(() => { let cancelled = false; void clipperCall<{ judge?: { options?: JudgeOptions } }>("status").then((r) => { const value = r.ok ? r.data.judge?.options?.scanIntervalS : undefined; if (!cancelled && typeof value === "number" && value > 0) setIntervalS(value); }); return () => { cancelled = true; }; }, []); return intervalS; } /** * Quando vem o próximo resumo. No serviço (intel.scan_due/scan_session), a janela seguinte é * [scannedUntilS, scannedUntilS + intervalo]; ela só é varrida quando a transcrição passa do fim dela, o laço da * varredura confere a cada 20 s (worker._scan_loop) e a IA leva o tempo da CLI. Só então o resumo e o * `scannedUntilS` são gravados. Por isso a previsão = fim da janela + a demora da IA medida nesta tela (a diferença * entre o relógio e o novo `scannedUntilS` quando ele avança); antes da 1ª medida, conta só até o fim da janela. */ function SummaryCadence({ clock, live, scannedUntilS, intervalS }: { clock: RecordingClock; live: boolean; scannedUntilS: number | null; intervalS: number; }) { const shown = useClockShown(clock); const [seen, setSeen] = useState({ scannedUntilS, delayS: 0 }); if (scannedUntilS !== seen.scannedUntilS) { // Estado derivado (padrão do React para "valor anterior"): mede a demora só quando a janela avança uma vez. const stepped = seen.scannedUntilS !== null && scannedUntilS !== null && scannedUntilS > seen.scannedUntilS; setSeen({ scannedUntilS, delayS: stepped ? Math.min(intervalS, Math.max(0, clock.estimate() - (scannedUntilS ?? 0))) : seen.delayS, }); } const cadence = `atualiza a cada ${formatDuration(intervalS)}`; let next: string; let tone = "text-fg-subtle"; if (!live || scannedUntilS === null) next = "último resumo"; else { const remaining = scannedUntilS + intervalS + seen.delayS - shown; if (remaining >= 1) next = `próximo em ${formatClock(remaining)}`; else { next = "gerando o próximo resumo…"; tone = "text-violet"; } } return ( // Largura e duas linhas fixas, dentro da altura das duas linhas do resumo: a contagem não empurra o texto.

{live ? cadence : "fora de gravação"} {next}

); } /** Resolução gravada de fato (1º bloco). Ao vivo sem bloco ainda: aviso no mesmo lugar, para a linha não mudar de forma. */ function CaptureState({ session: s, live }: { session: ClipperSession; live: boolean }) { if (s.capture === undefined || (s.capture === null && !live)) return null; // serviço antigo ou sessão antiga if (s.capture === null) return <>resolução: aguardando o 1º bloco; const c = s.capture; const detail = [`pedido: ${CAPTURE_ASKED[c.quality] ?? c.quality}`, c.codec.toUpperCase(), c.gbPerHour ? `≈ ${gbPerHourLabel(c.gbPerHour)}` : "", c.mixed ? "há trechos gravados em outra resolução" : ""].filter(Boolean).join(" · "); return ( <> {live ? "gravando em" : "gravado em"} {captureLabel(c)} ); } const CAPTURE_ASKED: Record = { best: "melhor disponível", "1440p": "até 1440p", "1080p": "até 1080p", "720p": "até 720p", "480p": "até 480p", }; /** Câmera do streamer: achada pela IA, pelo rosto, marcada à mão, ausente ou ainda não procurada. */ function CameraState({ session: s, live }: { session: ClipperSession; live: boolean }) { if (s.camDetect === undefined) return null; // serviço antigo: não há detecção if (s.camDetect === null) { return {live ? "câmera ainda não identificada" : "câmera não marcada"}; } const c = s.camDetect; return ( {c.source === "manual" ? "câmera marcada por você" : !c.hasWebcam ? "sem webcam na tela" : c.source === "yunet" ? "câmera achada (rosto, sem IA)" : "câmera achada pela IA"} ); } /* ---------- Blocos do pipeline ---------- */ /** Bloco de altura fixa: cabeçalho (rótulo + estado), número grande, barra (ou espaço reservado) e uma linha de detalhe. */ function Tile({ icon, label, state, value, unit, meter, detail, detailTone }: { icon: ReactNode; label: string; state: { tone: Tone; text: string; pulse?: boolean }; value: ReactNode; unit?: ReactNode; meter?: ReactNode; detail: ReactNode; detailTone?: Tone; }) { return (
{icon}{label} {state.text}

{value} {unit && {unit}}

{meter}

{detail}

); } function ChatTile({ session: s, live }: { session: ClipperSession; live: boolean }) { const chat = chatStatusInfo(s.chatStatus); const error = s.chatStatus.startsWith("error") ? s.chatStatus.replace(/^error:\s*/, "") : null; // Rótulo curto no selo; o texto completo do estado vai para a linha de detalhe. const short = s.chatStatus === "connected" ? "conectado" : s.chatStatus === "connecting" ? "conectando" : s.chatStatus === "unsupported" ? "sem chat" : error ? "erro" : "desligado"; return ( } label="Chat" state={{ tone: chat.tone, text: short, pulse: live && s.chatStatus === "connected" }} value={formatInteger(s.chatMessages)} unit={`mensage${s.chatMessages === 1 ? "m" : "ns"}`} detail={error ?? (s.chatStatus === "unsupported" ? "a plataforma não tem chat para ler" : live && s.chatStatus === "connected" ? "lendo em tempo real" : chat.label)} detailTone={error ? "danger" : undefined} /> ); } function TranscriptTile({ session: s, live, active }: { session: ClipperSession; live: boolean; active: boolean }) { const seg = s.segments; const waiting = seg.total - seg.analyzed; const state: { tone: Tone; text: string; pulse?: boolean } = seg.total === 0 ? (active ? { tone: "info", text: "esperando", pulse: true } : { tone: "neutral", text: "vazia" }) : waiting <= 0 ? { tone: "success", text: "em dia" } : live && waiting > TRANSCRIPT_LATE_SEGMENTS ? { tone: "warning", text: "atrasada" } : active ? { tone: "info", text: `${waiting} na fila`, pulse: true } : { tone: "neutral", text: `${waiting} pendentes` }; return ( } label="Transcrição" state={state} value={formatInteger(seg.analyzed)} unit={`de ${formatInteger(seg.total)} trecho${seg.total === 1 ? "" : "s"} de 30 s`} meter={} detail={seg.transcriptErrors > 0 ? `${seg.transcriptErrors} trecho${seg.transcriptErrors === 1 ? "" : "s"} sem fala reconhecida` : "fala e volume de cada trecho"} detailTone={seg.transcriptErrors > 0 ? "warning" : undefined} /> ); } function ScanTile({ session: s, live, active, clock, intervalS }: { session: ClipperSession; live: boolean; active: boolean; clock: RecordingClock; intervalS: number; }) { const scanned = s.scannedUntilS ?? null; if (scanned === null) { return ( } label="IA assistiu" state={{ tone: "neutral", text: "desligada" }} value="—" detail="varredura da IA desligada nesta sessão" /> ); } const lag = Math.max(0, s.durationS - scanned); const state: { tone: Tone; text: string; pulse?: boolean } = live ? (lag > SCAN_LATE_S ? { tone: "warning", text: "atrasada" } : { tone: "success", text: "em dia" }) : lag < SCAN_WINDOW_S ? { tone: "success", text: "completa" } : active ? { tone: "info", text: "assistindo", pulse: true } : { tone: "neutral", text: "parcial" }; return ( } label="IA assistiu" state={state} // O quanto a IA assistiu é sempre o real; só o total ("de H:MM:SS") acompanha o relógio da gravação. value={formatClock(scanned)} unit={<>de } meter={ 0 ? scanned / s.durationS : 0} label={`Quanto da sessão ${s.id} a IA já assistiu`} />} detail={live ? `olha janelas de ${formatDuration(intervalS)} · ${lag < 1 ? "em dia" : `${formatDuration(lag)} atrás`}` : lag < SCAN_WINDOW_S ? "assistiu a sessão inteira" : `faltam ${formatDuration(lag)}`} detailTone={live && lag > SCAN_LATE_S ? "warning" : undefined} /> ); } /** Estados que entram no detalhe do bloco de cortes (o "pronto para aprovar" é o número grande). */ const CLIP_DETAIL_ORDER: ClipStatus[] = CLIP_STATUS_ORDER.filter((k) => k !== "ready"); const CLIP_IN_PROGRESS: ClipStatus[] = ["candidate", "pending", "rendering"]; function ClipsTile({ session: s, total, active }: { session: ClipperSession; total: number; active: boolean }) { const ready = s.clips.ready ?? 0; const working = CLIP_IN_PROGRESS.reduce((n, k) => n + (s.clips[k] ?? 0), 0); const parts = CLIP_DETAIL_ORDER.filter((k) => (s.clips[k] ?? 0) > 0).map((k) => `${s.clips[k]} ${CLIP_STATUS[k].label}`); const state: { tone: Tone; text: string; pulse?: boolean } = working > 0 ? { tone: "violet", text: `IA avaliando ${working}`, pulse: true } : total > 0 ? { tone: "neutral", text: `${total} no total` } : { tone: "neutral", text: active ? "nenhum ainda" : "nenhum" }; return ( } label="Cortes" state={state} value={ 0 ? "text-accent" : undefined}>{formatInteger(ready)}} unit="para aprovar" meter={total > 0 ? (
{CLIP_STATUS_ORDER.filter((k) => (s.clips[k] ?? 0) > 0).map((k) => ( ))}
) :
} detail={parts.length ? parts.join(" · ") : total > 0 ? "todos prontos para aprovar" : active ? "a IA ainda não achou um momento" : "nenhum corte nesta sessão"} /> ); } /* ---------- Gráfico de mensagens/s ---------- */ /** Pontos no máximo: sessões de horas são agrupadas (máximo de cada grupo) para o SVG ficar leve. */ const MAX_POINTS = 480; const CHART_H = 100; function SessionTimeline({ session, clips }: { session: ClipperSession; clips: Clip[] }) { const [data, setData] = useState(null); const [error, setError] = useState(null); const live = ACTIVE_SESSION.includes(session.status); // Ao vivo, o gráfico acompanha a duração (que muda a cada consulta da página). const refreshKey = live ? Math.floor(session.durationS / 30) : 0; useEffect(() => { let cancelled = false; void clipperCall(`sessions/${session.id}/timeline`).then((r) => { if (cancelled) return; if (r.ok) { setData(r.data); setError(null); } else setError(r.error); }); return () => { cancelled = true; }; }, [session.id, refreshKey]); if (error) return Não deu para ler o gráfico: {error}; if (!data) return

Carregando o gráfico…

; if (data.messagesPerS.length === 0 || data.durationS <= 0) { return

Sem mensagens de chat registradas nesta sessão.

; } const series = data.messagesPerS; const bucket = Math.max(1, Math.ceil(series.length / MAX_POINTS)); const points: number[] = []; for (let i = 0; i < series.length; i += bucket) points.push(Math.max(...series.slice(i, i + bucket))); const peak = Math.max(1, ...points); const width = points.length; const secondsPerPoint = data.durationS / width; const y = (v: number) => CHART_H - (v / peak) * (CHART_H - 6); const area = `M0 ${CHART_H} ${points.map((v, i) => `L${i} ${y(v).toFixed(1)} L${i + 1} ${y(v).toFixed(1)}`).join(" ")} L${width} ${CHART_H} Z`; const x = (s: number) => Math.min(width, Math.max(0, s / secondsPerPoint)); const ticks = [0, 0.25, 0.5, 0.75, 1]; return (
{clips.map((c) => ( {`Corte ${c.id} · ${CLIP_STATUS[c.status].label} · ${formatClock(c.startS)}–${formatClock(c.endS)}`} ))} {clips.map((c) => ( ))}
mensagens/s (pico {peak}) trecho do corte pico usado no corte {formatDuration(data.durationS)} no total
); }