// Cliente do Clipador no navegador: tipos do contrato de /api/clipper/* (repassado a /v1/* do serviço // Python em 127.0.0.1:4520), rótulos, formatação e o gancho de ações com retorno. Não importa de // lib/clipper.ts, que roda só no servidor. import { useCallback, useState } from "react"; import { apiCall, type ApiResult } from "./api-client"; import type { Tone } from "./ui"; export type ClipperPlatform = "twitch" | "youtube" | "kick"; export type JudgeProvider = "codex" | "claude" | "gemini" | "off"; export type ClipperStatus = { version: string; tools: { streamlink: string | null; ffmpeg: string | null }; voice: { configured: boolean; online: boolean }; judge: { provider: JudgeProvider; model: string; available: boolean; path: string | null; minScore: number }; recording: number; settings: { quality: string; segmentS: number; pollS: number; keepHours: number; language: string }; }; export type JudgeModel = { id: string; label: string; description?: string }; /** `faceTrack` e `timelineJson` são opcionais: o serviço antigo não manda. `timelineJson` = a IA lê o vídeo como * linha do tempo JSON curta (novo); false = transcrição + chat + frames soltos (antigo, para comparar). */ export type JudgeOptions = { scanEnabled: boolean; scanIntervalS: number; vision: boolean; camDetect: boolean; faceTrack?: boolean; timelineJson?: boolean; }; /** Equipe de IA (doc/clipador/EQUIPE-IA.md): quatro papéis, cada um com a sua IA. */ export type AiRoleId = "scan" | "analyst" | "editor" | "judge"; export type AiRoleProvider = Exclude; export type AiEffort = "" | "low" | "medium" | "high"; export type AiImages = "mosaic" | "frames" | "none"; export type ContextCheckId = "setup" | "payoff" | "who_what" | "standalone" | "intelligible" | "faithful" | "strong_open"; export type AiRole = { enabled: boolean; provider: AiRoleProvider; /** "" = padrão do provedor. */ model: string; /** Raciocínio (só Codex); "" = padrão (baixo). */ effort: AiEffort; /** Instruções do administrador, somadas às padrão (podem ser em português). */ extra: string; /** Só varredura e analista. */ images?: AiImages; // Só o juiz: checagens críticas, se pode ajustar o trecho e pôr frase de contexto, e quanto cada checagem // não crítica tira da nota. critical?: ContextCheckId[]; allowFix?: boolean; allowContextLine?: boolean; penalty?: number; /** Só leitura (o serviço calcula): modelo efetivo e a ordem de tentativa (reserva) deste papel. */ resolvedModel?: string; chain?: AiRoleProvider[]; }; export type AiRoles = Record; export type JudgeConfig = { provider: JudgeProvider; /** Modelo do EDITOR (2º juiz). null com o juiz desligado. */ model: string | null; /** Modelo do ANALISTA (1º juiz, vê os frames); vem resolvido (igual ao editor quando não há um próprio). */ analystModel?: string | null; available: boolean | null; path: string | null; minScore: number; options?: JudgeOptions; lastScanError?: string | null; /** `gemini` é opcional: o serviço antigo (antes do Gemini) não manda. */ models: { codex: JudgeModel[]; claude: JudgeModel[]; gemini?: JudgeModel[]; defaults: { codex: string; claude: string; gemini?: string } }; /** Por que a IA escolhida não roda (desligada em Configurações → IA, sem CLI, sem chave); null = pronta. */ unavailableReason?: string | null; /** Modo de login da IA escolhida (Configurações → IA). */ authMode?: "oauth" | "apiKey" | null; /** IA reserva: ordem efetiva em que o juiz tenta (a escolhida primeiro). Serviço antigo não manda. */ fallback?: { enabled: boolean; cooldownMin: number; chain: Exclude[] }; /** IAs em pausa depois de falha de indisponibilidade (`until` em ISO, UTC). */ pauses?: JudgePause[]; /** Equipe de IA (serviço novo): cada papel com a sua IA. Ausente = serviço antigo (um provedor só). */ roles?: AiRoles; /** Instruções padrão de cada papel nos dois idiomas (só leitura). Só em GET/PUT /judge. */ roleDefaults?: Record; /** Checagens do juiz de contexto (id + nome em português). */ checks?: { id: ContextCheckId; label: string }[]; /** Situação de cada IA (Configurações → IA): ligada, pronta e por que não. */ providers?: Partial>; }; /** GET /judge/report: medição da Equipe de IA (F0) — chamadas e tokens por papel, decisões do juiz e concordância com você. */ export type AiReport = { window: { days: number; since: string | null; sessionId: number | null; liveHours: number }; calls: { role: string; purpose: string; provider: string; model: string; mode: string; calls: number; failures: number; avgChars: number; avgImages: number; imageKB: number; tokensIn: number | null; tokensOut: number | null; tokensCached: number | null; withUsage: number; avgMs: number; }[]; perHour: Record; clips: { total: number; byStatus: Partial>; approvalRate: number | null; labeled: number; noContext: number }; judge: { approve: number; adjust: number; discard: number; warn: number; error: number; contextLine: number }; agreement: Record<"judge" | "editor", AiAgreement>; }; export type AiAgreement = { pairs: number; agree: number; rate: number | null; kappa: number | null; matrix: Record<"keep" | "discard", Record>; }; /** Sua avaliação do corte (conjunto de avaliação do juiz). */ export type OwnerLabel = "good" | "bad" | "no_context"; export type JudgePause = { provider: Exclude; until: string; reason: string }; export type ClipperChannel = { id: string; platform: ClipperPlatform; channel: string; url: string; displayName: string; monitor: boolean; authorized: boolean; lastCheckAt: string | null; lastStatus: "ao vivo" | "offline" | ""; createdAt: string; /** Idioma falado na live (transcrição e textos da IA). Opcional: o serviço antigo não manda (= padrão do serviço). */ language?: string; /** Monitor pausado por você ter parado uma sessão à mão: não grava de novo até religar. Opcional (serviço antigo). */ monitorPausedAt?: string | null; /** Sessão que você parou e motivou a pausa. */ monitorPausedBySession?: number | null; }; export type SessionStatus = "starting" | "recording" | "processing" | "done" | "stopped" | "error" | "interrupted"; export type ClipStatus = "candidate" | "pending" | "rendering" | "ready" | "approved" | "rejected" | "discarded" | "published" | "error"; export type ClipperSession = { id: number; channelId: string | null; platform: ClipperPlatform; kind: "live" | "vod"; url: string; title: string; status: SessionStatus; /** "connected" | "connecting" | "unsupported" | "off" | "error: …" */ chatStatus: string; chatMessages: number; durationS: number; startedAt: string; endedAt: string | null; error: string | null; segments: { total: number; analyzed: number; transcriptErrors: number }; clips: Partial>; // Fase 2 (opcionais: o serviço antigo não manda). game?: string; gameSource?: GameSource; /** O que a IA viu na tela; pode divergir da categoria da plataforma. */ screenGame?: string; gameHistory?: { game: string; source: GameSource; atS: number; at: string }[]; gameProfileReady?: boolean; /** Até onde (s) a varredura da IA já assistiu. */ scannedUntilS?: number; memory?: MemoryEntry[]; camDetect?: CamDetect | null; roomId?: string | null; hasOwnSettings?: boolean; /** O que a captura gravou de fato (1º bloco de cada execução). null = sessão antiga ou ainda sem bloco; ausente = serviço antigo. */ capture?: CaptureInfo | null; /** Idioma falado na live (copiado da fonte ao criar a sessão). Opcional: o serviço antigo não manda. */ language?: string; }; export type GameSource = "platform" | "screen" | "user" | ""; /** `summaryPt`: fonte em inglês — o resumo em português para o painel (`summary` é o inglês que vai à IA). */ export type MemoryEntry = { fromS: number; toS: number; summary: string; summaryPt?: string }; export type CamDetect = { hasWebcam: boolean; cam: Rect | null; gameOnScreen?: boolean; frame?: string; at?: string; /** Quem achou: yunet = local (rosto no quadro, sem IA) · ai = IA olhando quadros · manual = você marcou. */ source?: "yunet" | "ai" | "manual"; confidence?: number; fullFrame?: boolean; }; /** Expressões do rosto (reaction.py, `EXPRESSION_LABELS`). Serviço antigo só manda as 7 primeiras. */ export type FaceExpression = "risada" | "grito" | "susto" | "choque" | "confuso" | "raiva" | "neutro" | "gargalhada" | "alegria" | "medo" | "espanto" | "nojo" | "tristeza" | "tenso" | "bocejo"; /** Movimento da cabeça/corpo (reaction.py, `body_moments`), mesmo sem expressão no rosto. */ export type BodyLabel = "balançando" | "acenando" | "agitado" | "chegou perto" | "saiu do quadro"; /** Reação no rosto do streamer (rastreio local, reaction.py): pico, início e intensidade (z relativo ao normal dele). */ export type FaceReaction = { peakS: number; onsetS: number; endS: number; intensity: number; strong: boolean; label: FaceExpression; }; /** Um segundo do mapa de expressões (`GET sessions/{id}/face`); só os campos que o painel usa. */ export type FaceMapSecond = { t: number; present: number; /** Expressão dominante; ausente = sem rosto legível (ou serviço antigo). */ expr?: FaceExpression; /** Movimento do corpo que cobre o segundo; ausente = nada. */ body?: BodyLabel; /** Fração dos quadros com a cabeça visível (inclui a caixa do detector com o rosto de perfil). */ head?: number; }; export type BodyMoment = { startS: number; endS: number; peakS: number; label: BodyLabel; value: number }; export type FaceView = { fromS: number; toS: number; seconds: FaceMapSecond[]; moments: FaceReaction[]; /** Ausente no serviço antigo. */ body?: BodyMoment[]; }; export type Situation = "lag_ou_bug" | "jogada" | "falha_engracada" | "morte" | "susto" | "treta" | "conversa_engracada" | "historia" | "informacao_do_jogo" | "reacao" | "outro"; /** O que o ANALISTA (1º juiz) viu: tela + fala + chat. */ export type ClipAnalysis = { situation: string; what_happened: string; screen: string; speech: string; chat_meaning: string; /** 0–1 */ confidence: number; action_start_s: number; reaction_end_s: number; hook: string; /** Fonte em inglês: os textos traduzidos para o painel (o vídeo usa os originais, em inglês). */ pt?: { what_happened: string; screen: string; speech: string; chat_meaning: string; hook: string }; }; /** Fonte em inglês: a fala do corte em frases (tempo da sessão) com a tradução em português. */ export type ClipTranslation = { language: string; startS: number; endS: number; model?: string; /** `speaker` = quem fala a frase ("streamer" ou "other1", "other2"…; ausente nas traduções antigas = streamer). */ lines: { s: number; e: number; text: string; pt: string; speaker?: string }[]; }; export type ClipJudge = null | { model: string; keep: boolean; score: number; reason: string; analysis?: ClipAnalysis | null; analystModel?: string; /** Fonte em inglês: título, legenda e motivo em português (só para ler; o post sai em inglês). */ pt?: { title?: string; caption?: string; reason?: string }; /** Juiz de contexto (EQUIPE-IA.md). Ausente = juiz desligado, editor descartou ou corte de antes. */ context?: ClipContext; /** "context" = quem descartou foi o juiz de contexto (dá para forçar o render). */ discardedBy?: "context"; } | { error: string }; export type ContextCheck = { ok: boolean; t: number | null; why: string }; export type ClipContext = | { error: string } | { model: string; /** O que um espectador que nunca viu a live entende (escrito antes das checagens). */ viewerSummary: string; checks: Partial>; fix: { start_s: number | null; end_s: number | null; context_line: string }; confidence: number; reason: string; /** Fonte em inglês: resumo, motivo, frase e o porquê de cada checagem em português. */ pt?: { viewer_summary?: string; reason?: string; context_line?: string; checks?: Partial> }; /** O que o código decidiu pelas respostas. */ decision: "approve" | "adjust" | "discard" | "warn"; failed: ContextCheckId[]; failedCritical: ContextCheckId[]; solvedByLine: ContextCheckId[]; /** Frase de contexto que vai na tela no começo do corte ("" = nenhuma). */ contextLine: string; scoreAfter: number | null; /** Motivo da decisão, em português (montado pelo código). */ reasonPt: string; /** Trecho novo quando o juiz ajustou. */ window?: [number, number]; /** 1ª rodada, quando houve ajuste (o juiz conferiu de novo). */ first?: { viewerSummary: string; checks: Partial>; failedCritical: ContextCheckId[]; reasonPt: string }; }; export type ClipTags = { risada?: number; susto?: number; hype?: number; clip?: number }; export type Clip = { id: number; sessionId: number; peakS: number; startS: number; endS: number; durationS: number; score: number; source: "chat" | "audio" | "manual" | "ai" | "face"; reasons: { peakRatio?: number; messages?: number; tags?: ClipTags; topMessages?: string[]; /** Emotes do chat no pico: nome → quantidade. */ emotes?: Record; // Cortes da varredura da IA (source "ai"). proposalTitle?: string; proposalScore?: number; proposalReason?: string; scanFromS?: number; scanToS?: number; /** Fonte em inglês: a proposta da varredura em português. */ proposalTitlePt?: string; proposalReasonPt?: string; /** Reação no rosto do streamer dentro do trecho (opcional: só com câmera e rastreio ligado). */ face?: FaceReaction; /** Corte de fonte "face": o apoio do áudio (sinal suavizado) e do chat (mensagens de reação) que deixou o rosto virar corte. */ support?: { audioZ: number; chatReactions: number }; }; judge: ClipJudge; title: string; caption: string; transcript: string; /** Fonte em inglês: fala traduzida por frase; null = sessão em português ou ainda não traduzida. */ translation?: ClipTranslation | null; status: ClipStatus; file: string | null; thumb: string | null; error: string | null; createdAt: string; updatedAt: string; channelId: string | null; platform: ClipperPlatform; sessionUrl: string; /** Editor de cortes: há projeto de edição (o render usa ele); capa gerada no export. Opcional: serviço antigo não manda. */ edit?: { updatedAt: string; exportedAt: string | null; cover: string | null; origin?: "ai" | "user" | null } | null; /** Formato do vídeo renderizado. Opcional: o serviço antigo não manda (ausente = vertical). */ aspect?: Aspect; /** Idioma da sessão de origem (resolvido pelo serviço). Opcional: o serviço antigo não manda (= padrão, pt-BR). */ language?: string; /** Vídeo de revisão (`file`): camadas de teste que entraram nele ([] = nenhuma; null = não se sabe). doc/clipador/REVISAO.md */ review?: { devLayers: string[] | null }; /** Vídeo final, gerado ao aprovar (sem as camadas de teste); null = ainda não aprovado. */ final?: ClipFinal | null; /** O único arquivo que vai para as redes: o final pronto. null = ainda não (a publicação espera). */ publishFile?: string | null; /** Sua avaliação (bom / ruim / sem contexto) para medir o juiz. Opcional: o serviço antigo não manda. */ ownerLabel?: OwnerLabel | null; ownerNote?: string | null; }; export type ClipFinal = { status: "pending" | "rendering" | "ready" | "error"; file: string | null; thumb: string | null; cover: string | null; error: string | null; at: string | null; /** O vídeo de revisão não tinha camada de teste: ele mesmo virou o final (sem render novo). */ reused: boolean; }; /** Nome das camadas de teste do vídeo de revisão (grupo `dev` da configuração do corte). */ export const DEV_LAYER_LABEL: Record = { translation: "tradução em português", dub: "dublagem em português" }; /** O vídeo de revisão (o da fila) tem camadas de teste? null = não se sabe (corte antigo). */ export function reviewHasDevLayers(clip: Pick): boolean | null { const layers = clip.review?.devLayers; return layers == null ? null : layers.length > 0; } /* ---------- Configuração do corte ---------- */ /** Retângulo normalizado (0–1) sobre o quadro original 16:9; x, y = canto superior esquerdo. */ export type Rect = { x: number; y: number; w: number; h: number }; export type LayoutMode = "auto" | "blur" | "cam_top" | "game_only" | "cam_only"; /** Formato do corte: vertical = 1080×1920 (Shorts/Reels/TikTok); horizontal = 1920×1080 (YouTube, jogo em tela cheia). */ export type Aspect = "vertical" | "horizontal"; export type CutSettings = { layout: { mode: LayoutMode; cam: Rect | null; game: Rect | null; camHeight: number }; caption: { enabled: boolean; font: string; size: number; color: string; highlight: string; outline: string; outlineWidth: number; y: number | null; uppercase: boolean; maxWords: number; /** Fala de outra pessoa (colega no Discord, voz do jogo): cor e tamanho (null = 85 % de `size`). Serviço antigo não manda. */ otherColor?: string; otherSize?: number | null; /** Legado: virou `dev.translation`. */ translation?: boolean; }; /** Camadas só de desenvolvimento (vídeo de revisão); o vídeo final, depois de aprovar, sai sem elas. */ dev?: { translation: boolean; dub: boolean; /** Dublagem (doc/clipador/DUBLAGEM.md): voz TTS pronta do serviço de voz — nunca clone do streamer. */ dubVoice?: string; /** Voz das falas marcadas como de outra pessoa (`speaker: "other"`). */ dubVoiceOther?: string; /** Volume do áudio original enquanto a dublagem toca (0–1). */ dubDuck?: number; }; credit: { enabled: boolean; position: "top" | "bottom"; size: number }; duration: { minS: number; maxS: number; backtrackS: number }; /** O serviço antigo não manda este grupo: use `withFormat` para preencher com vertical. */ format: { aspect: Aspect }; /** Estilo do gancho que o projeto da IA põe no começo. Opcional: o serviço antigo não manda (use `hookOf`). */ hook?: HookSettings; /** Qualidade de gravação da live (vale na próxima gravação ou retomada). Opcional: o serviço antigo não manda. */ capture?: { quality: CaptureQuality }; }; /** Camada parcial (canal ou sessão): só o que ela fixa. */ export type CutLayer = { [G in keyof CutSettings]?: Partial }; export type SettingsPayload = { own: CutLayer; effective: CutSettings; defaults: CutSettings; modes: LayoutMode[]; fonts: string[]; /** Só nas configurações da sessão: a camada do canal (null se a sessão não tem canal). */ channel?: CutLayer | null; // Opcionais (o serviço antigo não manda): formatos, fontes empacotadas e opções do gancho. aspects?: Aspect[]; /** {família: "assets/fonts/….ttf"} das fontes empacotadas, relativo à raiz do repositório. */ fontFiles?: Record; hookStyles?: HookStyle[]; hookAnims?: HookAnim[]; /** Tamanho do vídeo e quadro lógico dos textos (ASS) de cada formato. */ frames?: Record; /** Opções de qualidade de gravação, com o disco por hora medido (serviço antigo não manda). */ captureQualities?: CaptureOption[]; }; export type FrameResult = { t: number; file: string; version: string }; export type PreviewResult = { t: number; file: string; mode: LayoutMode; version: string; aspect?: Aspect }; /** Formato de um corte ou configuração; ausente (serviço antigo) = vertical. */ export function aspectOf(value: { aspect?: Aspect | null } | null | undefined): Aspect { return value?.aspect === "horizontal" ? "horizontal" : "vertical"; } /** Completa uma configuração vinda do serviço antigo (sem o grupo `format`) com o formato vertical. */ export function withFormat(settings: CutSettings): CutSettings { return { ...settings, format: { aspect: aspectOf(settings.format) } }; } /** Mescla campo a campo: base ← camadas (igual ao serviço). */ export function mergeSettings(base: CutSettings, ...layers: (CutLayer | null | undefined)[]): CutSettings { const out = structuredClone(base); for (const layer of layers) { if (!layer) continue; for (const group of new Set([...Object.keys(out), "format"]) as Set) { const values = layer[group]; // Grupo que a base não tem (ex.: `format` com o serviço antigo): cria em vez de quebrar. if (values) (out as Record)[group] = { ...(out[group] ?? {}), ...values }; } } return out; } /** * Camada mínima para salvar: campos que diferem da base de baixo, mais os que a camada já fixava * (para não "soltar" um valor que o usuário fixou de propósito, mesmo igual ao herdado). */ export function layerFrom(draft: CutSettings, base: CutSettings, own: CutLayer | null | undefined): CutLayer { const out: Record> = {}; for (const group of Object.keys(draft) as (keyof CutSettings)[]) { const values = (draft[group] ?? {}) as Record; const under = (base[group] ?? {}) as Record; const pinned = (own?.[group] ?? {}) as Record; for (const key of Object.keys(values)) { if (key in pinned || JSON.stringify(values[key]) !== JSON.stringify(under[key])) (out[group] ??= {})[key] = values[key]; } } return out as CutLayer; } /* ---------- Jogos e emotes ---------- */ /** Missão do jogo (só quando a lista já é pública): nome oficial, capítulo/ato, resumo e o que marca o fim dela. */ export type GameMission = { name: string; chapter: string; summary: string; completion_triggers: string[] }; export type GameProfile = { name: string; summary: string; genre: string; mechanics: string[]; clip_worthy: string[]; avoid: string[]; jargon: string[]; news: string[]; sources: string[]; /** Hashtags do jogo (a 1ª é a principal): entram em toda legenda de corte deste jogo, depois da do canal. */ hashtags?: string[]; // Opcionais: perfis antigos e o serviço antigo não mandam. /** Outros nomes do jogo ("GTA 6", "GTA VI"): categoria e tela caem no mesmo perfil. */ aliases?: string[]; /** [] = a lista de missões ainda não é pública. */ missions?: GameMission[]; /** Sinais gerais de fim de missão/objetivo (banner, tela de resultado, fala): a IA termina o corte logo depois. */ end_triggers?: string[]; }; export type Game = { id: string; name: string; status: "pending" | "ready" | "error"; error: string | null; model: string | null; researchedAt: string | null; /** Perfil em português: o que o painel mostra. */ profile: GameProfile | null; /** Perfil em inglês: o que vai para a IA. null/ausente = ainda não traduzido (a IA usa o `profile`). */ profileAi?: GameProfile | null; /** Idioma do `profileAi` ("en-US"). */ aiLanguage?: string; /** Quando uma versão foi gerada a partir da outra. */ translatedAt?: string | null; /** União dos aliases das duas versões. */ aliases?: string[]; /** Última edição à mão ou por pedido seu à IA (serviço antigo não manda). */ editedAt?: string | null; /** Pedidos que você fez à IA; voltam em toda pesquisa nova. */ notes?: { text: string; at: string; section?: string }[]; }; export type Emote = { name: string; source: string; uses: number; weight: number; lastSeen: string | null }; /** Id do jogo no serviço (mesma regra de intel.game_id). */ export function gameIdOf(name: string): string { return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "desconhecido"; } /** Chave do canal para os emotes: "-" (ex.: twitch-skipnho). */ export function channelKeyOf(session: Pick): string { if (session.channelId) return session.channelId; const login = channelFromUrl(session.url).replace(/^@/, "").toLowerCase(); return login ? `${session.platform}-${login}` : ""; } export type Timeline = { durationS: number; messagesPerS: number[]; ratio: number[]; loudnessDb: (number | null)[] }; /* ---------- Chamadas ---------- */ /** Chama /api/clipper/. O erro do serviço ({error}) vira a mensagem. */ export function clipperCall(path: string, method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE" = "GET", body?: unknown): Promise> { return apiCall(`/api/clipper/${path}`, method, body); } /** O painel responde "Clipador fora do ar…" (ou "não instalado") quando não alcança o serviço. */ export function isOfflineError(message: string): boolean { return /fora do ar|não instalado/i.test(message); } export type ActionMessage = { ok: boolean; text: string } | null; /** * Ações com retorno: guarda qual está rodando (para o spinner certo), mostra sucesso/erro e, * se deu certo, chama `onDone` (normalmente recarregar os dados). */ export function useClipperAction(onDone?: () => void) { const [pending, setPending] = useState(null); const [message, setMessage] = useState(null); const run = useCallback(async (key: string, call: () => Promise>, success: string | ((data: T) => string)) => { setPending(key); setMessage(null); const result = await call(); setPending(null); if (!result.ok) { setMessage({ ok: false, text: result.error }); return null; } setMessage({ ok: true, text: typeof success === "function" ? success(result.data) : success }); onDone?.(); return result.data; }, [onDone]); return { pending, message, setMessage, run }; } /* ---------- Idiomas ---------- */ /** Idiomas que o Clipador conhece (transcrição, textos da IA e público dos canais). O 1º é o padrão. */ export const LANGUAGES: { id: string; label: string; short: string }[] = [ { id: "pt-BR", label: "Português (Brasil)", short: "PT" }, { id: "en-US", label: "English (US)", short: "EN" }, { id: "es-419", label: "Español (Latinoamérica)", short: "ES" }, ]; /** Nome legível do idioma ("Português (Brasil)"); código desconhecido volta como está. */ export function languageLabel(code: string | null | undefined): string { return LANGUAGES.find((l) => l.id === code)?.label ?? (code || "—"); } /** Sigla curta do idioma ("PT", "EN"); código desconhecido vira a parte antes do hífen em maiúsculas. */ export function languageShort(code: string | null | undefined): string { return LANGUAGES.find((l) => l.id === code)?.short ?? (code ? code.split("-")[0].toUpperCase() : "—"); } /* ---------- Rótulos ---------- */ export const PLATFORM_LABEL: Record = { twitch: "Twitch", youtube: "YouTube", kick: "Kick" }; export const SESSION_STATUS: Record = { starting: { label: "iniciando", tone: "info", pulse: true }, recording: { label: "gravando", tone: "danger", pulse: true }, processing: { label: "processando", tone: "info", pulse: true }, done: { label: "concluída", tone: "success" }, stopped: { label: "parada", tone: "neutral" }, error: { label: "erro", tone: "danger" }, interrupted: { label: "interrompida", tone: "warning" }, }; export const CLIP_STATUS: Record = { candidate: { label: "esperando a IA", tone: "violet", pulse: true }, pending: { label: "na fila de render", tone: "info" }, rendering: { label: "renderizando", tone: "info", pulse: true }, ready: { label: "pronto para aprovar", tone: "accent" }, approved: { label: "aprovado", tone: "success" }, rejected: { label: "rejeitado", tone: "neutral" }, discarded: { label: "descartado pela IA", tone: "warning" }, published: { label: "publicado", tone: "success" }, error: { label: "erro", tone: "danger" }, }; export const CLIP_STATUS_ORDER: ClipStatus[] = ["candidate", "pending", "rendering", "ready", "approved", "published", "rejected", "discarded", "error"]; export const SOURCE_LABEL: Record = { chat: "pico do chat", audio: "pico do áudio", manual: "corte manual", ai: "IA viu na tela", face: "reação no rosto", }; export const FACE_LABEL: Record = { risada: "risada", grito: "grito", susto: "susto", choque: "choque", confuso: "confuso", raiva: "raiva", neutro: "neutro", gargalhada: "gargalhada", alegria: "alegria", medo: "medo", espanto: "espanto", nojo: "nojo", tristeza: "tristeza", tenso: "tensão", bocejo: "bocejo", }; export const BODY_LABEL: Record = { "balançando": "balançando a cabeça", acenando: "acenando com a cabeça", agitado: "agitado na cadeira", "chegou perto": "chegou perto da câmera", "saiu do quadro": "saiu do quadro", }; export const SITUATION_LABEL: Record = { lag_ou_bug: "lag ou bug", jogada: "jogada", falha_engracada: "falha engraçada", morte: "morte", susto: "susto", treta: "treta", conversa_engracada: "conversa engraçada", historia: "história", informacao_do_jogo: "informação do jogo", reacao: "reação", outro: "outro", }; export const GAME_SOURCE_LABEL: Record = { platform: "categoria da plataforma", screen: "a IA viu na tela", user: "confirmado por você", "": "", }; export const MODE_LABEL: Record = { auto: { label: "Automático", hint: "câmera em cima se houver" }, cam_top: { label: "Câmera em cima", hint: "webcam + jogo" }, blur: { label: "Desfoque", hint: "vídeo inteiro" }, game_only: { label: "Só o jogo", hint: "recorta o jogo" }, cam_only: { label: "Câmera inteira", hint: "só o streamer" }, }; export const TAG_LABEL: Record = { risada: "risada", susto: "susto", hype: "hype", clip: "“clip” no chat" }; export const PROVIDER_LABEL: Record = { codex: "Codex (GPT)", claude: "Claude", gemini: "Gemini", off: "Desligado" }; /** Equipe de IA: nome e o que cada papel faz (cartões da configuração). */ export const ROLE_INFO: Record = { scan: { label: "Varredura", does: "Assiste a live por janelas e propõe momentos mesmo sem pico de chat; descreve a tela para a linha do tempo." }, analyst: { label: "Analista", does: "Olha tela, fala e chat do trecho e diz o que aconteceu (lag, jogada, treta…). Não decide." }, editor: { label: "Editor", does: "Decide se vira corte, escolhe o trecho e escreve título, legenda e hashtags." }, judge: { label: "Juiz", does: "Só texto: vê o que vai no corte e confere se quem nunca viu a live entende — começo, desfecho, funciona sozinho." }, }; export const ROLE_ORDER: AiRoleId[] = ["scan", "analyst", "editor", "judge"]; export const CHECK_LABEL: Record = { setup: "começo (setup)", payoff: "desfecho", who_what: "quem/o quê", standalone: "funciona sozinho", intelligible: "fala clara", faithful: "título fiel", strong_open: "abertura forte", }; export const OWNER_LABEL: Record = { good: { label: "Bom", tone: "success" }, bad: { label: "Ruim", tone: "danger" }, no_context: { label: "Sem contexto", tone: "warning" }, }; export const CONTEXT_DECISION: Record<"approve" | "adjust" | "discard" | "warn", { label: string; tone: Tone }> = { approve: { label: "aprovou", tone: "success" }, adjust: { label: "ajustou o trecho", tone: "info" }, discard: { label: "descartou", tone: "danger" }, warn: { label: "avisou", tone: "warning" }, }; /** Sessões que ainda mudam sozinhas (vale consultar de novo). */ export const ACTIVE_SESSION: SessionStatus[] = ["starting", "recording", "processing"]; /** Cortes que ainda mudam sozinhos (IA ou render). */ export const ACTIVE_CLIP: ClipStatus[] = ["candidate", "pending", "rendering"]; export function chatStatusInfo(status: string): { label: string; tone: Tone } { if (status === "connected") return { label: "chat conectado", tone: "success" }; if (status === "connecting") return { label: "conectando ao chat", tone: "info" }; if (status === "unsupported") return { label: "sem chat (plataforma)", tone: "neutral" }; if (status === "off" || status === "") return { label: "chat desligado", tone: "neutral" }; return { label: "erro no chat", tone: "danger" }; } /* ---------- Formatação ---------- */ /** Relógio "m:ss" ou "h:mm:ss". */ export function formatClock(seconds: number): string { const total = Math.max(0, Math.round(seconds)); const h = Math.floor(total / 3600); const m = Math.floor((total % 3600) / 60); const s = String(total % 60).padStart(2, "0"); return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${m}:${s}`; } /** Duração curta: "42 s", "4 min 30 s", "1 h 05 min". */ export function formatDuration(seconds: number): string { const total = Math.max(0, Math.round(seconds)); if (total < 60) return `${total} s`; const h = Math.floor(total / 3600); const m = Math.floor((total % 3600) / 60); if (h > 0) return `${h} h ${String(m).padStart(2, "0")} min`; const s = total % 60; return s ? `${m} min ${s} s` : `${m} min`; } export function formatScore(score: number): string { return score.toLocaleString("pt-BR", { maximumFractionDigits: 1 }); } /** Nome do canal a partir do link da live/VOD (twitch.tv/, kick.com/, youtube.com/@canal). */ export function channelFromUrl(url: string): string { try { const u = new URL(url); const first = u.pathname.split("/").filter(Boolean)[0] ?? ""; if (u.hostname.includes("youtu")) return first.startsWith("@") ? first : u.hostname.replace(/^www\./, ""); return first === "videos" ? u.hostname.replace(/^www\./, "") : first || u.hostname; } catch { return url; } } /** Rótulo de quem é a live: o nome do canal cadastrado ou o que dá para tirar do link. */ export function sourceName(channelId: string | null, url: string, channels: ClipperChannel[]): string { const channel = channelId ? channels.find((c) => c.id === channelId) : undefined; return channel?.displayName || channel?.channel || channelFromUrl(url); } /* ---------- Gancho, fontes e formatos (editor de cortes e "Configuração do corte") ---------- */ /** `plain` = texto solto (com caixa opcional); `banner` = tarja na largura toda, texto em maiúsculas em até 2 linhas. */ export type HookStyle = "plain" | "banner"; /** `slide`: a tarja atravessa a tela e o texto entra deslizando, borrado, e assenta nítido. */ export type HookAnim = "pop" | "fade" | "none" | "slide"; /** `y` = centro do gancho em fração da altura (0,04–0,96); null = automático (logo abaixo da câmera). */ export type HookSettings = { style: HookStyle; bg: string; color: string; font: string; anim: HookAnim; seconds: number; y: number | null }; /** Tamanho do vídeo de saída e quadro lógico do ASS (no horizontal os textos são contados em 2560×1440). */ export type FrameSize = { width: number; height: number; canvasWidth: number; canvasHeight: number }; /** Espelho de `layout.DEFAULTS["hook"]` do serviço, só para quando ele não manda o grupo (serviço antigo). */ export const HOOK_FALLBACK: HookSettings = { style: "banner", bg: "#00FF00", color: "#FFFFFF", font: "Luckiest Guy", anim: "slide", seconds: 3, y: null }; /** Grupo `hook` efetivo (o serviço antigo não manda: usa o espelho do padrão). */ export function hookOf(settings: Pick | null | undefined): HookSettings { return { ...HOOK_FALLBACK, ...(settings?.hook ?? {}) }; } export const HOOK_STYLE_LABEL: Record = { banner: { label: "Tarja", hint: "faixa colorida na largura toda" }, plain: { label: "Simples", hint: "texto solto, com caixa opcional" }, }; export const HOOK_ANIM_LABEL: Record = { slide: "Deslizar com desfoque", pop: "Entrada pop", fade: "Aparecer suave", none: "Sem animação", }; /** Fontes do Windows que o serviço sempre aceita (as empacotadas vêm de `fontFiles`). */ export const SYSTEM_FONTS = ["Arial Black", "Arial", "Impact", "Verdana", "Segoe UI Black", "Trebuchet MS"]; /* ---------- Qualidade de gravação (grupo `capture`) ---------- */ /** `best` = a maior resolução que a live oferece; as outras são teto (a maior variante que não passa dele). */ export type CaptureQuality = "best" | "1440p" | "1080p" | "720p" | "480p"; /** Uma opção do seletor, como o serviço manda em `captureQualities`. */ export type CaptureOption = { id: CaptureQuality; label: string; maxHeight: number | null; gbPerHour: number; gbPerHourMax: number; hint: string; }; /** Resolução, fps, codec e taxa lidos do 1º bloco da gravação (ffprobe). `mixed` = blocos em mais de uma resolução. */ export type CaptureInfo = { quality: CaptureQuality; width: number; height: number; fps: number | null; codec: string; kbps: number | null; gbPerHour: number | null; fromIdx: number; at: string; mixed: boolean; runs?: { fromIdx: number; quality: CaptureQuality; width: number; height: number; fps: number | null; codec: string }[]; }; /** "2560×1440 · 60 fps". */ export function captureLabel(info: Pick): string { return `${info.width}×${info.height}${info.fps ? ` · ${info.fps} fps` : ""}`; } /** "3,2 GB/h" (ou "3,2–4,5 GB/h" quando a opção tem faixa). */ export function gbPerHourLabel(min: number, max?: number | null): string { const f = (v: number) => v.toLocaleString("pt-BR", { maximumFractionDigits: v < 1 ? 2 : 1 }); return max && max - min >= 0.2 ? `${f(min)}–${f(max)} GB/h` : `${f(min)} GB/h`; } /* ---------- Apagar cortes (DELETE clips/ · POST clips/delete) ---------- */ /** Por que um corte não foi apagado. `busy_*` = o motor está mexendo nele; `published` = falta confirmar. */ export type ClipDeleteCode = "not_found" | "busy_candidate" | "busy_rendering" | "published" | "changed"; /** Arquivo que ficou no disco (fora das pastas do Clipador, ou em uso). */ export type ClipLeftFile = { file: string; reason: string }; export type ClipDeleted = { id: number; sessionId: number; status: ClipStatus; removedFiles: number; left: ClipLeftFile[] }; export type ClipDeleteFailure = { id: number; code: ClipDeleteCode; reason: string }; /** Resposta do lote: `remaining` = quantos passaram do limite de uma chamada (500). */ export type ClipDeleteResult = { requested: number; remaining: number; deleted: ClipDeleted[]; failed: ClipDeleteFailure[] }; /** Máximo de cortes numa chamada de lote (`clip_delete.MAX_BATCH` do serviço). */ export const CLIP_DELETE_MAX = 500; /** Estados que o serviço recusa apagar (a IA ou o render está trabalhando no corte). */ export const UNDELETABLE_CLIP: ClipStatus[] = ["candidate", "rendering"]; /** "12 apagados, 1 não pôde: está renderizando" (motivos iguais agrupados). */ export function deleteSummary(result: Pick): string { const n = result.deleted.length; const parts = [n === 1 ? "1 corte apagado" : `${n} cortes apagados`]; if (result.failed.length) { const reasons = new Map(); for (const f of result.failed) reasons.set(f.reason, (reasons.get(f.reason) ?? 0) + 1); const why = [...reasons].map(([reason, k]) => (reasons.size > 1 ? `${k} ${reason}` : reason)).join("; "); parts.push(`${result.failed.length} não pôde${result.failed.length === 1 ? "" : "ram"}: ${why}`); } const left = result.deleted.reduce((sum, d) => sum + (d.left?.length ?? 0), 0); // resposta sem `left` = nada ficou if (left) parts.push(`${left} arquivo${left === 1 ? " ficou" : "s ficaram"} no disco`); return parts.join(", "); }