"use client"; // "Configuração do corte": modal em abas que edita o formato (vertical 9:16 ou horizontal 16:9) e a // duração, o layout (onde fica a câmera, a área do jogo), a legenda e o crédito. Abre de uma SESSÃO // ("Configurar corte") ou de um CANAL ("Padrão do canal"). Camadas: padrão ← canal ← sessão; salvar // manda só o que a camada fixa (layerFrom). O quadro e a prévia vêm do serviço (/api/files, com &v= // para furar cache). A prévia fica sempre ao lado e muda de proporção com o formato. // // Serviço antigo: não manda o grupo `format` (tratamos como vertical, via withFormat) e ignora o grupo // ao salvar; a prévia dele sai sempre 1080×1920. import { useCallback, useEffect, useRef, useState, type KeyboardEvent, type PointerEvent, type ReactNode } from "react"; import { MODE_LABEL, aspectOf, captureLabel, clipperCall, formatClock, gbPerHourLabel, layerFrom, mergeSettings, withFormat, type Aspect, type CamDetect, type ClipperChannel, type ClipperSession, type CutLayer, type CutSettings, type FrameResult, type LayoutMode, type PreviewResult, type Rect, type SettingsPayload, } from "./clipper-client"; import { AlertIcon, CheckIcon, ClockIcon, EyeIcon, InstagramIcon, RefreshIcon, SettingsIcon, SparkIcon, TikTokIcon, TrashIcon, UndoIcon, XIcon, YouTubeIcon, } from "./icons"; import { RECT_MIN_SIZE, clampRect, moveRect, nudgeRect, resizeRect } from "./rect-geometry"; import { Tabs, type TabItem } from "./tabs"; import { Badge, Button, ChoiceGroup, Feedback, Field, RangeField, Select, Spinner, Switch, cx, fileUrl } from "./ui"; import type { VoiceInfo } from "./voice-client"; // Gancho e fontes (editor de cortes): seletor com amostra e fontes empacotadas carregadas no navegador. import { HOOK_ANIM_LABEL, HOOK_STYLE_LABEL, SYSTEM_FONTS, hookOf, type HookAnim, type HookSettings, type HookStyle } from "./clipper-client"; import { FontPicker, fontStack, usePackagedFonts } from "./clip-editor-fonts"; import { askConfirm } from "./confirm-dialog"; export type CutScope = | { kind: "session"; session: ClipperSession; name: string } | { kind: "channel"; channel: ClipperChannel; /** Sessão mais recente do canal, para quadro e prévia. */ session: ClipperSession | null }; type Message = { ok: boolean; text: string } | null; type Target = "cam" | "game"; type TabId = "format" | "camera" | "caption" | "hook" | "credit"; /** Sessão ainda gravando (a qualidade nova só vale na próxima gravação ou retomada). */ const ACTIVE_CAPTURE: ClipperSession["status"][] = ["starting", "recording"]; /** Limites do serviço (os padrões vêm de `defaults`, não daqui). */ const DURATION_LIMITS = { minS: { min: 5, max: 120, step: 1 }, maxS: { min: 15, max: 180, step: 1 }, backtrackS: { min: 0, max: 120, step: 5 }, } as const; const ASPECTS: Record = { vertical: { label: "Vertical", ratio: "9:16", size: "1080×1920", use: "Shorts, Reels e TikTok", detail: "Câmera em cima e o jogo embaixo, ou o vídeo inteiro com fundo desfocado.", networks: <>, }, horizontal: { label: "Horizontal", ratio: "16:9", size: "1920×1080", use: "YouTube (vídeo normal)", detail: "O jogo em tela cheia, como na live. Bom para jogadas longas e tela grande.", networks: , }, }; /* ---------- Modal ---------- */ /** Modal nativo ( com showModal): foco preso, Esc fecha, fundo inerte. Monta o editor só aberto. */ export function CutSettingsDialog({ scope, onClose, onSaved }: { scope: CutScope | null; onClose: () => void; onSaved: () => void }) { const ref = useRef(null); const dirtyRef = useRef(false); useEffect(() => { const dialog = ref.current; if (!dialog) return; if (scope && !dialog.open) dialog.showModal(); if (!scope && dialog.open) dialog.close(); }, [scope]); const requestClose = useCallback(async () => { if (dirtyRef.current && !(await askConfirm({ title: "Fechar sem salvar?", message: "Os ajustes feitos aqui se perdem.", confirmLabel: "Fechar sem salvar", cancelLabel: "Continuar editando", tone: "danger" }))) return; dirtyRef.current = false; onClose(); }, [onClose]); // Altura fixa: trocar de aba não faz o modal pular de tamanho. return ( { e.preventDefault(); requestClose(); }} className="m-auto h-[min(94vh,68rem)] max-h-[94vh] w-[min(96vw,112rem)] overflow-hidden rounded-panel border border-line-strong bg-canvas p-0 text-fg shadow-pop backdrop:bg-black/75 backdrop:backdrop-blur-[2px]"> {scope && ( { dirtyRef.current = d; }} onClose={requestClose} onSaved={onSaved} /> )} ); } /* ---------- Editor ---------- */ /** O serviço antigo não manda `format`: completa como vertical, para o rascunho e a comparação "não salvo". */ function normalizePayload(p: SettingsPayload): SettingsPayload { return { ...p, effective: withFormat(p.effective), defaults: withFormat(p.defaults) }; } function CutSettingsEditor({ scope, onDirty, onClose, onSaved }: { scope: CutScope; onDirty: (dirty: boolean) => void; onClose: () => void; onSaved: () => void; }) { const session = scope.session; const base = scope.kind === "session" ? `sessions/${scope.session.id}` : `channels/${encodeURIComponent(scope.channel.id)}`; const channelId = scope.kind === "session" ? scope.session.channelId : scope.channel.id; const [payload, setPayload] = useState(null); const [draft, setDraft] = useState(null); const [loadError, setLoadError] = useState(null); const [pending, setPending] = useState(null); const [message, setMessage] = useState(null); const [target, setTarget] = useState("cam"); const [frame, setFrame] = useState(null); const [frameT, setFrameT] = useState(null); const [frameError, setFrameError] = useState(null); const [frameLoading, setFrameLoading] = useState(false); const [preview, setPreview] = useState(null); /** Formato pedido na última prévia (o serviço antigo não devolve `aspect`). */ const [previewAsked, setPreviewAsked] = useState("vertical"); const [previewError, setPreviewError] = useState(null); const load = useCallback(async (resetDraft: boolean) => { const r = await clipperCall(`${base}/settings`); if (!r.ok) { setLoadError(r.error); return null; } setLoadError(null); const data = normalizePayload(r.data); setPayload(data); if (resetDraft) setDraft(structuredClone(data.effective)); return data; }, [base]); useEffect(() => { void load(true); }, [load]); const loadFrame = useCallback(async (t: number | null) => { if (!session) return; setFrameLoading(true); const r = await clipperCall(`sessions/${session.id}/frame${t === null ? "" : `?t=${t.toFixed(1)}`}`); setFrameLoading(false); if (!r.ok) { setFrameError(r.error); return; } setFrameError(null); setFrame(r.data); setFrameT(r.data.t); }, [session]); useEffect(() => { void loadFrame(null); }, [loadFrame]); const dirty = Boolean(payload && draft && JSON.stringify(draft) !== JSON.stringify(payload.effective)); useEffect(() => { onDirty(dirty); }, [dirty, onDirty]); // Fontes empacotadas (assets/fonts): carregadas para as amostras aparecerem na própria fonte. usePackagedFonts(payload ? payload.fontFiles ?? {} : undefined); if (loadError && !payload) { return (
Não foi possível ler a configuração: {loadError}
); } if (!payload || !draft) { return (

Carregando a configuração…

); } // Base de baixo de cada camada: a sessão herda do canal; o canal herda do padrão. const sessionBase = mergeSettings(payload.defaults, payload.channel ?? null); const ownCount = countFields(payload.own); const aspect = aspectOf(draft.format); const horizontal = aspect === "horizontal"; const invalid = draft.duration.minS >= draft.duration.maxS; function update(group: G, values: Partial) { setDraft((d) => (d ? { ...d, [group]: { ...d[group], ...values } } : d)); } /** De onde vem o valor salvo de um campo: fixado nesta camada, herdado do canal ou padrão do Clipador. */ function originOf(group: keyof CutSettings, key: string): string { const has = (layer: CutLayer | null | undefined) => (layer?.[group] as Record | undefined)?.[key] !== undefined; if (has(payload!.own)) return scope.kind === "session" ? "fixado nesta sessão" : "fixado nesta fonte"; if (scope.kind === "session" && has(payload!.channel)) return "herdado da fonte"; return "padrão do Clipador"; } async function save(kind: "session" | "channel" | "clear-session" | "clear-channel") { if (!draft || !payload) return; setPending(kind); setMessage(null); let r: Awaited>>; if (kind === "session") { r = await clipperCall(`${base}/settings`, "PUT", layerFrom(draft, sessionBase, payload.own)); } else if (kind === "channel") { const channelOwn = scope.kind === "session" ? payload.channel : payload.own; r = await clipperCall(`channels/${encodeURIComponent(channelId!)}/settings`, "PUT", layerFrom(draft, payload.defaults, channelOwn)); } else { r = await clipperCall(`${base}/settings`, "PUT", {}); } setPending(null); if (!r.ok) { setMessage({ ok: false, text: r.error }); return; } // Salvar no canal a partir da sessão: relê a sessão (o efetivo dela muda). let fresh: SettingsPayload | null = normalizePayload(r.data); if (scope.kind === "session" && kind === "channel") fresh = await load(true); else { setPayload(fresh); setDraft(structuredClone(fresh.effective)); } const sessionStillOverrides = scope.kind === "session" && kind === "channel" && fresh && countFields(fresh.own) > 0; // Serviço antigo: aceita o PUT mas descarta o grupo `format`. Avisa em vez de fingir que salvou. const formatDropped = (kind === "session" || kind === "channel") && draft.format.aspect === "horizontal" && fresh !== null && r.data.effective.format === undefined; const captureChanged = (kind === "session" || kind === "channel") && draft.capture?.quality !== payload.effective.capture?.quality; setMessage({ ok: true, text: (kind === "session" ? "Salvo nesta sessão. Vale para os próximos renders." : kind === "channel" ? `Salvo como padrão da fonte.${sessionStillOverrides ? " Esta sessão tem ajustes próprios que continuam valendo; use “Limpar da sessão” para herdar tudo da fonte." : ""}` : kind === "clear-session" ? "Ajustes da sessão apagados: ela volta a herdar da fonte e do padrão." : "Padrão da fonte apagado: volta ao padrão do Clipador.") + (captureChanged ? " A qualidade de gravação nova vale na próxima gravação ou retomada." : "") + (formatDropped ? " Atenção: o Clipador em execução ainda não conhece o formato horizontal; o formato ficou vertical. Reinicie o serviço atualizado e salve de novo." : ""), }); onSaved(); } async function detectCam() { if (!session) return; setPending("detect"); setMessage(null); const r = await clipperCall(`sessions/${session.id}/detect-cam`, "POST"); setPending(null); if (!r.ok) { setMessage({ ok: false, text: r.error }); return; } // O serviço pode ter salvo (no canal, se ele não tinha câmera; senão na sessão): relê as camadas, // mas mantém o rascunho e só aplica a câmera achada. await load(false); if (r.data.hasWebcam && r.data.cam) { update("layout", { cam: r.data.cam }); setTarget("cam"); setMessage({ ok: true, text: `Câmera encontrada.${r.data.gameOnScreen === false ? " A IA não viu jogo na tela neste momento." : ""} Confira o retângulo e salve.` }); } else { setMessage({ ok: true, text: "A IA não achou webcam na tela. Sem câmera, o corte usa o vídeo inteiro com fundo desfocado." }); } onSaved(); } async function runPreview() { if (!session || !draft) return; setPending("preview"); setPreviewError(null); const asked = aspectOf(draft.format); const r = await clipperCall(`sessions/${session.id}/preview`, "POST", { ...(frameT !== null ? { t: frameT } : {}), settings: draft }); setPending(null); if (!r.ok) { setPreviewError(r.error); return; } setPreview(r.data); setPreviewAsked(asked); } const busy = pending !== null; const rect = draft.layout[target]; const groupCount = (...groups: (keyof CutSettings)[]) => { const n = groups.reduce((sum, g) => sum + Object.keys(payload.own[g] ?? {}).length, 0); return n > 0 ? n : undefined; }; const layerName = scope.kind === "session" ? "esta sessão" : "esta fonte"; // Fontes que o serviço aceita: as do Windows e as empacotadas (com arquivo em assets/fonts). const packagedFonts = Object.keys(payload.fontFiles ?? {}); const captureOptions = payload.captureQualities ?? []; const fontList = [...new Set([...(payload.fonts?.length ? payload.fonts : SYSTEM_FONTS), ...packagedFonts])]; const tabs: TabItem[] = [ { id: "format", label: "Formato e duração", icon: , count: groupCount("format", "duration", "capture") }, { id: "camera", label: "Câmera e layout", icon: , count: groupCount("layout") }, { id: "caption", label: "Legenda", icon: , count: groupCount("caption") }, { id: "hook", label: "Gancho", icon: , count: groupCount("hook") }, { id: "credit", label: "Crédito", icon: , count: groupCount("credit") }, ]; /* ----- Aba: formato e duração ----- */ const formatPanel = ( <>
} description="Escolha para qual tela o corte é feito. Câmera, legenda e crédito se ajustam ao formato.">
Formato do vídeo {(["vertical", "horizontal"] as const).map((a) => { const info = ASPECTS[a]; return ( ); })}
{horizontal && ( No horizontal o corte usa o quadro inteiro do jogo (ou a área do jogo marcada). A câmera em cima e o fundo desfocado ficam só para o vertical; “Câmera inteira” continua valendo. Detalhes na aba “Câmera e layout”. )}
update("duration", { minS })} format={durationLabel} hint={`Padrão: ${formatClock(payload.defaults.duration.minS)} · ${originOf("duration", "minS")}`} /> update("duration", { maxS })} format={durationLabel} hint={`Padrão: ${formatClock(payload.defaults.duration.maxS)} · ${originOf("duration", "maxS")}. ${horizontal ? "No YouTube horizontal não há limite curto; aqui vai até 3:00." : "Shorts aceita até 3:00."}`} /> update("duration", { backtrackS })} format={(v) => (v === 0 ? "não volta" : durationLabel(v))} hint={`Para dar contexto: pegar a ação que aconteceu antes do comentário ou da reação do chat. Padrão: ${formatClock(payload.defaults.duration.backtrackS)} · ${originOf("duration", "backtrackS")}`} />
{invalid ?

A duração mínima precisa ser menor que a máxima.

: }
{/* Qualidade de GRAVAÇÃO da live (serviço antigo não manda as opções: a seção some). */} {captureOptions.length > 0 && draft.capture && (
} description="Em que resolução a live é gravada. Mais resolução deixa a câmera recortada mais nítida no corte e ocupa mais disco. Vale na próxima gravação ou retomada; uma gravação em andamento continua como está.">
Qualidade da gravação {captureOptions.map((o) => ( ))}
{session?.capture && (

{scope.kind === "session" ? "Esta sessão" : `Última sessão (#${session.id})`}: {ACTIVE_CAPTURE.includes(session.status) ? "gravando" : "gravada"} em {captureLabel(session.capture)} {[session.capture.codec.toUpperCase(), session.capture.gbPerHour ? `≈ ${gbPerHourLabel(session.capture.gbPerHour)}` : ""].filter(Boolean).join(" · ")} {session.capture.mixed && trechos em outra resolução}

)}

Os blocos gravados ficam no disco até o Clipador apagá-los (CLIPPER_KEEP_HOURS, padrão 6 h, só sem corte pendente): 6 h de live em 1080p60 ocupam ~20 GB; em 720p, ~9 GB. 2K só é gravado quando a fonte transmite em 2K (na Twitch, pela transmissão aprimorada).

)} ); /* ----- Aba: câmera e layout ----- */ const effectiveHorizontal = draft.layout.mode === "cam_only" && draft.layout.cam ? "a câmera inteira (só o streamer)" : draft.layout.game ? "a área do jogo marcada, em tela cheia" : "o quadro inteiro do jogo"; const cameraPanel = ( <> {horizontal && ( Formato horizontal: o corte sai com {effectiveHorizontal}. “Câmera em cima”, “Desfoque” e a altura da câmera só valem no vertical; ficam guardados para quando você voltar a ele. Marque a área do jogo para cortar bordas, sobreposições ou o chat da live. )}

Onde ficam a câmera e o jogo

{(["cam", "game"] as const).map((t) => ( ))}
{session && ( )}
update("layout", { [which]: r } as Partial)} />

Arraste no quadro para desenhar o retângulo selecionado; arraste o retângulo para mover e os cantos para redimensionar. Pelo teclado: foque o retângulo e use as setas (Shift + setas muda o tamanho).

update("layout", { [target]: r } as Partial)} /> {rect && ( )}
{session ? (
formatClock(v)} disabled={frameLoading} />
{scope.kind === "channel" && Quadro da sessão #{session.id} desta fonte.}
{frameError && {frameError}}
) : (

Esta fonte ainda não tem sessão gravada: dá para ajustar tudo, mas o quadro de referência e a prévia aparecem depois da primeira gravação.

)}
name="cut-mode" legend="Modo" value={draft.layout.mode} onChange={(mode) => update("layout", { mode })} options={(["auto", "cam_top", "cam_only", "blur", "game_only"] as const).map((m) => ({ value: m, label: MODE_LABEL[m].label, hint: MODE_LABEL[m].hint }))} /> {!horizontal && (draft.layout.mode === "cam_top" || draft.layout.mode === "auto") && !draft.layout.cam && (

Sem câmera marcada, o corte sai com fundo desfocado.

)} {draft.layout.mode === "cam_only" && !draft.layout.cam && (

“Câmera inteira” precisa da câmera marcada; sem ela, o corte {horizontal ? "sai com o jogo em tela cheia" : "sai com fundo desfocado"}.

)} update("layout", { camHeight })} format={pct} disabled={horizontal || !draft.layout.cam || draft.layout.mode === "blur" || draft.layout.mode === "game_only"} hint={horizontal ? "Só no vertical, com a câmera em cima." : "Quanto da tela vertical a webcam ocupa no layout com câmera em cima."} />
); /* ----- Aba: legenda ----- */ const captionPanel = (
update("caption", { enabled })} />} description="As palavras faladas aparecem no vídeo, com a palavra do momento destacada.">
Estilo da legenda

Aparência

Fonte update("caption", { font })} columns={2} />
update("caption", { size })} format={(v) => `${v} px`} />
update("caption", { color })} /> update("caption", { highlight })} /> update("caption", { outline })} />
update("caption", { outlineWidth })} format={(v) => `${v} px`} />

Fala de outra pessoa

Colega no Discord ou outro jogador no chat de voz: a legenda dele sai logo abaixo da do streamer, nesta cor.

update("caption", { otherColor })} />
update("caption", { otherSize: auto ? null : Math.round(draft.caption.size * 0.85) })} hint="85% do tamanho da legenda do streamer." /> {Boolean(draft.caption.otherSize) && ( update("caption", { otherSize })} format={(v) => `${v} px`} /> )}

Ritmo e posição

update("caption", { maxWords })} /> update("caption", { uppercase })} /> update("dev", { translation })} hint="Só no vídeo de revisão (fonte em inglês): a fala traduzida aparece embaixo da legenda. O vídeo final, ao aprovar, sai sem ela." /> update("caption", { y: auto ? null : 0.74 })} hint={horizontal ? "O serviço escolhe a altura no quadro horizontal." : "Na emenda entre câmera e jogo, ou a cerca de 74% da altura."} /> {draft.caption.y !== null && ( update("caption", { y })} format={(v) => `${pct(v)} do topo`} /> )}
update("dev", values)} />
); /* ----- Aba: gancho ----- */ const hook = hookOf(draft); const setHook = (values: Partial) => update("hook", { ...hook, ...values }); const hookPanel = (
} description="O texto curto que a IA põe nos primeiros segundos de cada corte. Dá para trocar em cada corte, no editor."> {!payload.hookStyles && ( O Clipador em execução ainda não conhece o gancho em tarja: estes ajustes só são salvos depois de reiniciar o serviço atualizado. )}

Posição e estilo

setHook({ y })} /> {(() => { const place = hookPlacement(hook, aspect, draft.layout, draft.caption); return (
name="cut-hook-place" legend="Onde o gancho aparece" value={hook.y === null ? "auto" : "chosen"} onChange={(v) => setHook({ y: v === "auto" ? null : place.y })} options={[ { value: "auto", label: "Automático", hint: place.camTop ? "logo abaixo da câmera" : "longe da legenda" }, { value: "chosen", label: "Escolhido por mim", hint: "arraste no quadro" }, ]} /> {hook.y !== null && ( setHook({ y })} format={hookPct} hint={`Automático daria ${hookPct(place.auto)}. 0 % é o topo do vídeo.`} /> )}

{hook.y === null ? <>Agora em {hookPct(place.y)} da altura{place.camTop ? ", logo abaixo da câmera" : ""}. Arraste o gancho no quadro para escolher outro lugar. : <>Centro do gancho em {hookPct(hook.y)} da altura (o mesmo número do editor do corte).} {" "}Enquanto o gancho aparece, a legenda que ficaria embaixo dele desce para logo abaixo da tarja.

); })()} name="cut-hook-style" legend="Estilo" value={hook.style} onChange={(style) => setHook({ style })} options={(["banner", "plain"] as const).map((v) => ({ value: v, label: HOOK_STYLE_LABEL[v].label, hint: HOOK_STYLE_LABEL[v].hint }))} />
{hook.style === "banner" && setHook({ bg })} />} setHook({ color })} />
name="cut-hook-anim" legend="Animação de entrada" value={hook.anim} onChange={(anim) => setHook({ anim })} options={(["slide", "pop", "fade", "none"] as const).map((v) => ({ value: v, label: HOOK_ANIM_LABEL[v] }))} /> setHook({ seconds })} format={(v) => `${v.toLocaleString("pt-BR")} s`} hint={`Padrão: ${hookOf(payload.defaults).seconds.toLocaleString("pt-BR")} s · ${originOf("hook", "seconds")}`} />

Fonte do gancho

setHook({ font })} columns={2} />

Na tarja o texto sai em maiúsculas, em até 2 linhas; se não couber, a fonte diminui (nunca corta palavra).

); /* ----- Aba: crédito ----- */ const creditPanel = (
update("credit", { enabled })} />} description="O endereço do streamer, por cima do vídeo. Para cortes de terceiros, deixe ligado.">
Estilo do crédito name="cut-credit" legend="Posição" value={draft.credit.position} onChange={(position) => update("credit", { position })} options={[{ value: "top", label: "Em cima" }, { value: "bottom", label: "Embaixo" }]} /> update("credit", { size })} format={(v) => `${v} px`} hint={!horizontal && draft.layout.mode === "cam_top" ? "Com a câmera em cima, o crédito de cima desce para o pé da câmera." : undefined} />
); return ( {ASPECTS[aspect].label} {ASPECTS[aspect].ratio} {formatClock(draft.duration.minS)}–{formatClock(draft.duration.maxS)} {ownCount > 0 ? {layerName} fixa {ownCount} ajuste{ownCount === 1 ? "" : "s"} (contados nas abas) : {scope.kind === "session" ? "herdando da fonte e do padrão" : "usando o padrão do Clipador"}} {dirty && alterações não salvas} } footer={
{message && {message.text}}
{scope.kind === "session" ? ( <> {channelId && ( )} {ownCount > 0 && ( )} ) : ( <> {ownCount > 0 && ( )} )} {dirty && ( )} {invalid ? Para salvar, corrija a duração na aba “Formato e duração”: a mínima precisa ser menor que a máxima. : <>Vale para os próximos renders. Para refazer um corte já pronto, use “Re-renderizar” no cartão dele.}
}>
param={null} label="Seções da configuração do corte" items={tabs} className="min-w-0 content-start" panels={{ format: formatPanel, camera: cameraPanel, caption: captionPanel, hook: hookPanel, credit: creditPanel }} /> {/* Prévia: sempre ao lado, na proporção do formato escolhido. */}
); } /* ----- Dublagem em português (camada de teste; doc/clipador/DUBLAGEM.md) ----- */ // Padrões do Clipador (layout.DEFAULTS["dev"]); valem com o serviço antigo, que ainda não manda as chaves. const DUB_VOICE = "pt-br-antonio"; const DUB_VOICE_OTHER = "kokoro-pm-alex"; const DUB_DUCK = 0.25; function voiceLabel(v: VoiceInfo): string { const gender = v.gender === "male" ? "masculina" : v.gender === "female" ? "feminina" : null; return [v.name, gender, v.offline ? "offline" : "online"].filter(Boolean).join(" · "); } /** Fica fora da caixa da legenda: a dublagem não depende de a legenda estar ligada. */ function DubSettings({ dev, onChange }: { dev: CutSettings["dev"]; onChange: (values: Partial>) => void; }) { const on = dev?.dub ?? false; const [voices, setVoices] = useState(null); useEffect(() => { if (!on || voices) return; let alive = true; // Só vozes TTS prontas em português: voz clonada fica de fora (nunca imitar o streamer, que não consentiu). fetch("/api/voice/status", { cache: "no-store" }).then((r) => r.json()).then((s: { voices?: VoiceInfo[] }) => { if (alive) setVoices((s.voices ?? []).filter((v) => v.provider !== "clone" && (v.languages ?? []).some((l) => l.toLowerCase().startsWith("pt")))); }).catch(() => { if (alive) setVoices([]); }); return () => { alive = false; }; }, [on, voices]); const voice = dev?.dubVoice ?? DUB_VOICE; const other = dev?.dubVoiceOther ?? DUB_VOICE_OTHER; const duck = dev?.dubDuck ?? DUB_DUCK; const options = (current: string) => { const list = voices ?? []; // A voz salva aparece mesmo se o serviço estiver fora (ou se ela sair do catálogo). return list.some((v) => v.id === current) ? list : [{ id: current, name: current } as VoiceInfo, ...list]; }; return (
onChange({ dub })} hint={"Só no vídeo de revisão (fonte em inglês): cada frase traduzida é dublada por uma voz TTS pronta e o áudio original fica baixo por baixo — dá para ouvir o jogo. O 1º render demora mais (~1,6 s por frase; depois fica guardado). O vídeo final, ao aprovar, sai com o áudio original."} /> {on && (
{voices === null &&

Carregando as vozes…

} {voices !== null && voices.length === 0 && Serviço de voz fora do ar: a dublagem não sai até ele voltar.} onChange({ dubDuck })} format={pct} hint="Fora das falas dubladas o áudio fica normal." />
)}
); } function countFields(layer: CutLayer | null | undefined): number { return Object.values(layer ?? {}).reduce((n, g) => n + Object.keys(g ?? {}).length, 0); } function pct(v: number): string { return `${Math.round(v * 100)}%`; } /** "1:30 · 90 s" (abaixo de um minuto, só "45 s"). */ function durationLabel(seconds: number): string { return seconds >= 60 ? `${formatClock(seconds)} · ${seconds} s` : `${seconds} s`; } function EditorShell({ scope, onClose, meta, footer, children }: { scope: CutScope; onClose: () => void; meta?: ReactNode; footer?: ReactNode; children: ReactNode; }) { return (

Configuração do corte

{scope.kind === "session" ? <>Sessão #{scope.session.id} · {scope.name} : <>Padrão da fonte · {scope.channel.displayName || scope.channel.channel}}

{meta &&
{meta}
}
{children}
{footer}
); } /** Bloco de uma aba: título, descrição curta e um canto à direita (chave liga/desliga ou origem do valor). */ function Section({ title, description, aside, children }: { title: string; description?: ReactNode; aside?: ReactNode; children: ReactNode }) { return (

{title}

{description &&

{description}

}
{aside}
{children}
); } function Origin({ text }: { text: string }) { return {text}; } function Note({ tone, children }: { tone: "info" | "warning"; children: ReactNode }) { return (

{children}

); } /** Resumo em frase + régua de 0 a 3:00: faixa do corte (mínimo cheio, até o máximo mais claro) e quanto a IA pode voltar. */ function DurationSummary({ duration }: { duration: CutSettings["duration"] }) { const scale = 180; const at = (s: number) => `${Math.min(100, (s / scale) * 100)}%`; return (

Cada corte terá entre {formatClock(duration.minS)} e{" "} {formatClock(duration.maxS)}.{" "} {duration.backtrackS > 0 ? <>Para dar contexto, a IA pode começar até {formatClock(duration.backtrackS)} antes do momento que chamou atenção. : <>A IA não volta no tempo: o corte começa perto do momento que chamou atenção.}

); } /** * Esquema do quadro final (não é a prévia): câmera em laranja, jogo em ciano, legenda em branco e * crédito em cinza, na proporção do formato. Serve de miniatura no seletor e de guia nas abas. */ function FrameMock({ aspect, layout, caption, credit, className }: { aspect: Aspect; layout: CutSettings["layout"]; caption: CutSettings["caption"] | null; credit: CutSettings["credit"] | null; className?: string; }) { const vertical = aspect === "vertical"; const hasCam = Boolean(layout.cam); const camOnly = layout.mode === "cam_only" && hasCam; const camTop = vertical && hasCam && (layout.mode === "cam_top" || layout.mode === "auto"); const blur = vertical && !camOnly && (layout.mode === "blur" || ((layout.mode === "cam_top" || layout.mode === "auto" || layout.mode === "cam_only") && !hasCam)); const camH = camTop ? layout.camHeight : 0; const captionY = caption?.enabled ? (caption.y ?? (camTop ? camH : vertical ? 0.74 : 0.85)) : null; return (