25 KiB
Impl: Acervo: o player e o link abrem no ponto certo da fala
Status: executado (gate humano 2026-09-16; Fase 0 com 5 evidências medidas; entrega no PR) Atualizado em: 2026-09-16 Issue: #1082 Intenção: docs/plans/acervo-video-no-ponto-certo-da-fala.md Appetite restante: herdado (~0,5–1 dia eng). Corte explícito: a âncora da API entra como limite superior (erra para "antes") e a medição verificada vira override — nada a inflar depois da Fase 0.
Leitura da intenção
- Outcome: abrir uma fala do Acervo (na tela ou pelo link "Abrir no YouTube"/compartilhamento) posiciona o vídeo no mesmo ponto que a referência do YouTube entrega; player e link não divergem e o desvio residual é pequeno e explicado por evidência — nunca um palpite.
- O que NÃO negociar:
- Sem schema, sem Consent, sem migration. O ajuste é comportamento de seek, não dado novo.
- Contratos de URL pública e de C162/C166/C167 intactos.
?t=do deep link segue sendo segundo de sessão (o player soma o offset); a URL/mensagem do share (C166) e a seleção/corte (C167, que usastartSeconds/endSecondsde sessão) não mudam de forma nem de semântica. - Sem evidência → não inventar
t=. Quando o offset for desconhecido, o comportamento é o de hoje (não fabricar um número). - Calibração baseada em evidência, não em chute. A fala 997 (~13 s) e a sessão da fala 641 (~37 s) da C163 são a amostra mínima (intenção, questão B).
- Um único offset corrigido, consumido por player e share (intenção, questão C).
- Sem UI (Impeccable A) — nenhum dispatch de designer.
- O que reavaliar (hipóteses da intenção):
- A recomendação literal da intenção — "usar o método da C163" com uma constante — é incompatível com a evidência: o lag varia por sessão (37 s vs 13 s); uma constante global corrigiria uma e abriria 24 s antes na outra. O método (descontar o atraso real de início da sessão) é válido; o valor global não.
- A hipótese de que a correção cabe no dono atual sem nova informação: parcialmente.
excerptOffsetSeconds(src/lib/speechVod.ts:219-228) só conheceeventStartAt(relógio do slot), que não é a âncora do vídeo. Falta uma âncora por vídeo; é isso que o plano resolve. - Se a YouTube Data API v3 expõe
liveStreamingDetails.actualStartTimepara estes vídeos — verificado na Fase 0 (2026-09-16): sim, mas o valor não é a origem exata do vídeo (ver "Resultado da Fase 0").
Abordagem recomendada
flowchart LR
A["linha Speech<br/>excerptTMs · eventStartAt · youtubeUrl"] --> B["parseYoutubeVideoId<br/>(puro, dono atual)"]
B --> C{"videoId?"}
C -- "sim" --> D["getYouTubeVideoStart<br/>videos.list?part=liveStreamingDetails<br/>unstable_cache + timeout + fail-closed"]
C -- "não" --> E["actualStartTime = null"]
D --> F["youtubeVideoStartAt (ISO|null)"]
E --> F
F --> G["toSpeechDetailViewModel<br/>ÚNICO ponto de nascimento"]
G --> H["sessionLagSeconds(actualStartAt, eventStartAt)"]
G -. "fallback se lag null" .-> I
H --> I["correctedExcerptOffsetSeconds(base, lag)<br/>lag null → base (comportamento de hoje)"]
I --> J["youtubeOffsetSeconds (um só campo)"]
J --> K["SpeechDetailPlayer<br/>embed start + seek do transcrito"]
J --> L["SpeechExcerptShare + Abrir no YouTube<br/>buildSpeechExcerptYoutubeUrl"]
M["excerptOffsetSeconds<br/>(INALTERADO)"] -. "C163 intocado (t=608s)" .-> N["cityReportSnapshot → relatório"]
Opções consideradas: A (constante global) | B (mapa medido por videoId) | C (âncora automática por vídeo via YouTube Data API v3) | D (não corrigir / sempre omitir t=).
Recomendação (aprovada no gate humano de 2026-09-16): C, com override medido. lag = actualStartTime − eventStartAt por vídeo, via liveStreamingDetails.actualStartTime (cliente YouTube do dono), e um override medido por videoId para os vídeos já verificados no browser. O override vence a âncora da API.
Por que a âncora da API serve mesmo errando (gate humano): o arquivo de uma transmissão não pode começar depois de o broadcast entrar no ar, então actualStartTime ≥ origem real do vídeo ⇒ lag_api ≥ lag_origem. Na amostra real (5 sessões) isso se confirmou em 4: a âncora erra para o lado de "alguns segundos antes". O 5º ponto (sessão de 17/06) mostrou lag_medido (89) > lag_api (67) — a âncora ficou 22 s depois: "sempre antes" é a tendência, não uma lei (o medido embute também o julgamento humano de onde a fala começa, que varia por fala). Ainda assim o erro máximo observado (52 s antes / 22 s depois) é muito menor que o defeito atual (o app abre 10–89 s depois, em todas as amostras). O override devolve o ponto exato onde existe medição.
Resultado da Fase 0 (2026-09-16, HTTP público, zero DB de prod):
| fala 997 | fala 641 | fala 981 (staging) | fala 973 (staging) | sessão 17/06 (staging) | |
|---|---|---|---|---|---|
vídeo / eventStartAt |
DC_i9Kp1LVk / 2026-08-11 15:32:00 |
2cX_gKkJH7Q / 2018-03-13 14:00:00 |
hAUJ3fXgsIQ / 2026-06-16 13:59:00 |
hZ9Yl4MFHQs / 2026-05-27 15:00:00 |
nHHqPaJEERI / 2026-06-17 14:04:00 |
| offset de sessão (app) | 11962 | 645 | 25156 | 392 | 11622 |
| ponto correto (evidência) | 11949 | 608 | 25125 | ~382 | ~11533 |
| lag medido | 13 s | 37 s | 31 s | ~10 s | ~89 s |
actualStartTime da API |
15:32:57 BRT → lag 57 s | 14:00:46 BRT → lag 46 s | 13:59:37 BRT → lag 37 s | 15:01:02 BRT → lag 62 s | 14:05:07 BRT → lag 67 s |
| erro da âncora da API | +44 s | +9 s | +6 s | +52 s | +22 s (depois) |
Em cinco sessões a API não reproduz o lag medido (erros de +44 s, +9 s, +6 s, +52 s e −22 s) e não há preditor comum: os lags medidos (13/31/37/10/89) não correlacionam com nenhuma quantidade derivável (actualStartTime − eventStartAt = 57/37/46/62/67; actualStartTime − scheduledStartTime; janela do evento vs duração do vídeo; offset do primeiro trecho da sessão = 28/9/1/24/25). Em 4 das 5 o erro é para "antes"; na sessão de 17/06 o lag medido (89) superou o da API (67) — ou seja, a âncora pode ficar levemente depois, e "sempre antes" é tendência, não garantia. O que resta, depois de descontar a origem do vídeo, é em boa medida julgamento humano de onde a fala começa (o trecho curado da Câmara pode incluir a concessão da palavra), que varia por fala — por isso o override medido é exato na fala medida e a âncora fica como limite superior para as demais. Corroboração de que o arquivo começa antes do actualStartTime: com a origem da API (15:32:57), a primeira fala da própria sessão (Benedita, 15:32:28) cairia 29 s antes do início do vídeo.
Rejeitadas:
- A — constante global (37 s "método C163" literal): a evidência contradiz (13 s vs 37 s); 37 s numa sessão de 13 s abriria 24 s antes. É o Rabbit hole nº 1 da intenção.
- D — não corrigir / sempre omitir
t=: falha o outcome ("o desvio deixa de ser sistemático" e "o link cai no mesmo ponto que o player"). Omitir sempre também regride o C162 em ambientes sem chave. - C "puro" (só API, sem override): não fixa o caso relatado no ponto exato (997 abriria 44 s antes); o override custa ~10 linhas e devolve exatidão onde há medição. Rejeitada a ausência do override, não a API.
- B como mecanismo principal: exige medição humana por sessão e não cobre falas novas — vira o override, não o mecanismo.
Decisões de engenharia
- Como corrigir o ponto. Opções: A constante global | B mapa medido
videoId → lagemsrc/lib/speechVod.ts| C âncora por vídeo via API do YouTube | C+override. Recomendação: C+override — porque o lag é propriedade do vídeo, a API dá o limite superior (erra para "antes", nunca para "depois") e a medição verificada no browser, quando existe, é exata. Precedência: override medido → âncora da API → sem correção (comportamento de hoje). Rejeitadas: A (evidência 13 s vs 37 s); C puro (997 abriria 44 s antes, sem usar a evidência que já temos); B principal (não escala; vira o override). - Onde o offset corrigido nasce. Opções: (i) no
SpeechDetailPlayer(client) | (ii) no loaderloadSpeechDetailPageData| (iii) notoSpeechDetailViewModel(dono atual). Recomendação: (iii) — porque o intent nameiaspeechViewModels.ts:260como o único ponto ondeyoutubeOffsetSecondsnasce, e player e share já consomem esse único campo; manter o nascimento ali preserva o "um só offset" (questão C) e a pureza do VM (que só passa a receber a âncora já resolvida). Rejeitadas: (i) duplicaria a fórmula por superfície e reintroduziria a divergência; (ii) tiraria o cálculo do dono e espalharia a regra para a camada de I/O. - Fonte/de posse do cliente YouTube. Opções: A editar o dono
src/utilities/socialFeed/youtubeFeed.tsreusandogetYouTubeFeedcomo está | B editar o dono extraindo um cliente puro (URL base + fetch comapiKeyinjetada) e ler a chave direto, sem os toggles do feed | C criar um gêmeosrc/utilities/speech/youtubeAnchor.ts. Recomendação: B — porque o módulo é o dono do cliente (YOUTUBE_API_BASE_URL,loadYouTubeFeed,unstable_cache), masgetYouTubeFeedgateia emsettings.enabled === false || settings.youtubeEnabled === false(youtubeFeed.ts:256-257): reusá-lo acoplaria a correção do Acervo ao kill switch do feed público — desligar a home derrubaria o seek em silêncio. O anchor lê sósettings.youtubeApiKey(ausente → null antes da rede). Rejeitadas: A (kill switch do feed público vazando para o acervo); C (cliente/constante duplicados, twin). - Comportamento com offset desconhecido. Opções: (i) omitir
t=sempre que a âncora faltar | (ii) fail-closed para o comportamento de hoje (offset de sessão sem correção) quando a âncora faltar, e omitirt=só quando o offset de base for nulo (já hoje). Recomendação: (ii) — porque a intenção admite explicitamente "o comportamento é o de hoje/omitir"; omitir sempre regride o C162 (seek do transcrito e embedstart) em ambientes/execuções sem chave e no dev/test, e transforma uma melhoria em regressão. Rejeitada: (i) por regredir contrato existente sem ganho de evidência. - Cache/latência da âncora. Opções: A
unstable_cacheporvideoId+ bound de timeout + fail-closed (padrão do dono) | Bcache()do React (por request) | C sem cache. Recomendação: A — porqueactualStartTimeé imutável após a transmissão; uma chamada por vídeo por janela é barata (1 unidade de quota), e o padrão do repo (tagsocial-feed+revalidate) já permite bustar ao salvar o global. Rejeitadas: B (paga rede a cada render, latência real no caminho de render); C (idem + sem dedupe entregenerateMetadatae a página).
Componentes / mudanças
sessionLagSeconds+speechVideoLagSeconds+correctedExcerptOffsetSeconds(src/lib/speechVod.ts, puro, client-safe, sem I/O):sessionLagSeconds(videoStartAt, eventStartAt)lê o instante ISO da âncora no mesmo relógio de parede BRT queexcerptOffsetSeconds(reusawallClockSeconds/naiveWallClockSeconds;Date.parsedo ISO) e devolve a diferença; null quando não-parseável,≤ 0(o offset atual já é "antes") ou> 3600 s(URL que não é daquela sessão — fail-closed).speechVideoLagSeconds(videoId, videoStartAt, eventStartAt)= override medido (MEASURED_VIDEO_LAG_SECONDS, mapa privadovideoId → lagcom as quatro entradas datadas:DC_i9Kp1LVk: 13da fala 997/#1082,2cX_gKkJH7Q: 37da fala 641/C163,hAUJ3fXgsIQ: 31da fala 981/staging ehZ9Yl4MFHQs: 10da fala 973/staging) senãosessionLagSeconds;correctedExcerptOffsetSeconds(baseOffset, lagSeconds)=baseOffsetquandolagSecondsé null (fail-closed), senãoMath.max(0, Math.floor(baseOffset − lagSeconds))(null sebaseOffsetnull).excerptOffsetSecondsfica intocado (C163).parseYouTubeLiveStartResponse/loadYouTubeVideoStart/getYouTubeVideoStart(src/utilities/socialFeed/youtubeFeed.ts, server-only, editando o dono): parser puro deitems[0].liveStreamingDetails.actualStartTime(null quando ausente/forma errada);loadYouTubeVideoStart({ apiKey, videoId, fetchImpl, baseUrl })chamavideos.list?part=liveStreamingDetails&id=<videoId>comfetchImplinjetável (padrãoloadYouTubeFeed) eAbortSignal.timeout(...);getYouTubeVideoStart(videoId)=unstable_cachepor argumento (['youtube-video-start'],tags: [REVALIDATE_SOCIAL_FEED_TAG], revalidate longo), lê sósocial-feed-settings.youtubeApiKeye engole qualquer falha → null (chave ausente → null antes da rede; não-2xx/rede/timeout → null).toSpeechDetailViewModel(src/utilities/speech/speechViewModels.ts): ganhayoutubeVideoStartAt: string | null; emiteyoutubeOffsetSeconds: correctedExcerptOffsetSeconds(excerptOffsetSeconds(excerptTMs, eventStartAt), sessionLagSeconds(youtubeVideoStartAt, eventStartAt)). Campo e nome inalterados — um só offset para player e share.loadSpeechDetailPageData(src/utilities/speech/speechPageData.ts): resolveyoutubeVideoId(viaparseYoutubeVideoId, puro) e a âncora por um resolver injetável (resolveYoutubeVideoStart, defaultgetYouTubeVideoStart), passayoutubeVideoStartAtao VM. A injeção mantém os int tests herméticos (sem rede/Next cache).SpeechDetailPlayer.tsx/SpeechExcerptShare.tsx/speechShare.ts/SpeechCutDialog: nenhuma mudança de contrato — já consomemyoutubeOffsetSeconds(player nostartdo embed e no seek do transcrito; share nobuildSpeechExcerptYoutubeUrl). O único efeito é o valor corrigido que chega.scripts/cityReportSnapshot.mjs/cityReportBlocks.mjs: intocados — seguem importandoexcerptOffsetSecondse subtraindo o37próprio (prova de não-dupla-subtração).- Migration: não (sem schema).
- Access / Consent: não toca access; a leitura da chave segue via o global (bypass por desenho, igual ao
getYouTubeFeed); nenhuma chave/PII vai ao cliente. - UI: Impeccable A — N/A; nenhum shell/componente novo.
Dados → forma (se aplicável)
- Não aplicável. A intenção declara "não apresento dados" e não há superfície nova. O "dado" é um literal de comportamento (o segundo do
t=/start), não um número exibido; nenhuma forma de apresentação é escolhida ou rejeitada. A forma da URL permanecewatch?v=<id>&t=(a troca para/live/<id>?t=segue fora de escopo).
Fases verificáveis
- Fase 0 — Tracer + gate de evidência (quota ~1–2 h). — EXECUTADA 2026-09-16.
- O combinador foi verificado contra os literais conhecidos:
correctedExcerptOffsetSeconds(11962, 13) === 11949(fala 997) ecorrectedExcerptOffsetSeconds(645, 37) === 608(fala 641) — entram como pin de unit. - Gate (HTTP público, zero DB): feito com a YouTube Data API v3 (
videos.list?part=liveStreamingDetailsparaDC_i9Kp1LVke2cX_gKkJH7Q) +dataHoraInicioda API de eventos da Câmara e ost=/clocks das páginas dos eventos (https://www.camara.leg.br/evento-legislativo/{82867,50867}). Resultado na seção "Resultado da Fase 0": a API existe e serve como limite superior (erra para "antes"), mas não reproduz o lag exato ⇒ C+override (decisão do gate humano). - Sem DB de produção em nenhum passo do gate.
- Registrar o resultado (valores medidos + data) numa entrada
docs/changelog/2026-09-16-c172-*.md.
- O combinador foi verificado contra os literais conhecidos:
- Fase 1 — Server + nascimento do offset (quota ~3–4 h).
- Estender
youtubeFeed.ts(parser + loader + cache fail-closed) e cobrir com unit (fetch mockado; sem rede). - Ligar
loadSpeechDetailPageData→toSpeechDetailViewModel(resolver injetável);excerptOffsetSecondsintocado; player/share sem edição de contrato. - Unit de
sessionLagSeconds(ISOZ× naive BRT; DST; negativo → null; inválido → null) e decorrectedExcerptOffsetSeconds(lag null → base; piso;base − lag < 0→ 0).
- Estender
- Fase 2 — Testes e gates (quota ~1–2 h).
pnpm gate:fast(lint + typecheck + unit) →pnpm test:int→ e2e curado do acervo; depoispnpm push.- Specs que pinam literais e o que acontece:
tests/unit/speechVod.unit.spec.ts— estende (novos helpers); os literais deexcerptOffsetSeconds(2634/9008/DST/midnight) permanecem (pin da C163).tests/unit/youtubeFeed.unit.spec.ts— estende (parseYouTubeLiveStartResponse;loadYouTubeVideoStartcom fetch mockado).tests/unit/speechShare.unit.spec.ts— inalterado (pin C166:t=2677, omissão det=).tests/unit/speechDetailPlayer.unit.spec.tsx— inalterado (o player só recebe o campo único; os literais2634/2677/2734seguem como prop).tests/int/speechAcervo.int.spec.ts— o casoyoutubeOffsetSeconds === 2634permanece (no test DB não há chave → fail-closed → sem correção; torna-se o pin do comportamento de hoje). Adicionar um caso com resolver stub devolvendo umactualStartTimee asserção do offset corrigido (fala sintética), provando o nascimento corrigido.tests/e2e/campaignSpeechAcervo.e2e.spec.ts— os literaisstart=2634+43ewatch?v=...&t=2677permanecem (ambiente sem chave → fail-closed; é o pin do "sem evidência, comportamento de hoje"). Opcional: comentário apontando o caminho de correção.tests/unit/cityReportBlocks.unit.spec.ts— inalterado (t=608s); é a prova de que o C163 não sofreu dupla subtração.
- Specs que pinam literais e o que acontece:
Rabbit holes / Não escopo (engenharia)
- Unificar o C163 no mesmo método (aposentar o
YOUTUBE_VIDEO_OFFSET_SECONDS = 37do builder). Fora de escopo: o snapshot é outro pipeline; gatilho de revisitação = quando o mesmogetYouTubeVideoStartjá estiver em produção e o relatório for tocado por outro item. - Reconstruir o modelo de offsets (relógio de sessão × âncora do vídeo, ASR, import) — intenção, Rabbit hole nº 2.
- Controle/tabela/job de offset por fala na UI — intenção, Rabbit hole nº 3.
- Trocar a forma da URL para
/live/<id>?t=— fora de escopo (intenção). - Cache/tabela própria de âncoras — o
unstable_cachedo dono basta; não criar persistência nova. contentDetails.duration/ transcrição do YouTube como fonte alternativa — sem evidência de necessidade; só a âncora interessa.
Riscos e mitigação
- Dupla subtração no C163. Mitigação: não alterar
excerptOffsetSeconds(o snapshot e o builder seguem com o37próprio); helpers novos e separados;cityReportBlocks.unit.spec.ts(t=608s) roda no gate como prova. - Custo/latência da rede no render. Mitigação:
unstable_cacheporvideoId(uma busca por janela),AbortSignal.timeoutcurto e fail-closed → null; o render nunca espera além do timeout nem quebra. - Chave da API ausente. Mitigação: sem
social-feed-settings.youtubeApiKey→ null antes de qualquer rede. Dev/test caem no comportamento de hoje. - Acoplamento ao kill switch do feed público. Mitigação: o anchor não reusa
getYouTubeFeed(que gateia emenabled/youtubeEnabled); lê só a chave. - Erro residual para o lado de "antes" nas sessões sem medição. A âncora da API erra para "antes" (997: 44 s; 641: 9 s) — aceito no gate: melhor abrir antes do que perder o começo. Mitigação: override medido onde há evidência; gatilho de revisitação = se a assessoria reclamar de abrir antes demais, medir o vídeo e registrar o override.
- Âncora ausente / vídeo que não é da sessão. Mitigação:
actualStartTimepresente mas implausível (> 3600 s) → fail-closed no comportamento de hoje; vídeo não-live → parser devolve null → idem. - Regressão dos pins de C162/C166/C167. Mitigação: nenhuma assinatura de player/share/cut muda; um só campo corrigido; rodar unit do player/share + int + e2e do acervo.
unstable_cachefora do runtime do Next (int/unit). Mitigação: resolver injetável emloadSpeechDetailPageData(os int tests passam stub explícito) + try/catch fail-closed no wrapper.- Segredo no cache key. Mitigação: a chave não entra na chave do cache (é lida dentro da função cacheada), evitando materializar o segredo nos metadados.
Aceite de engenharia
- Aceite de produto da intenção ainda coberto: abrir a fala posiciona no mesmo ponto do YouTube; player e link usam o mesmo offset; desvio residual pequeno e explicado por evidência; sem evidência → comportamento de hoje/omitir, nunca palpite.
- Invariantes AGENTS/engineering-standards: sem schema/Consent/migration; contratos de URL pública e de C162 (deep link = segundo de sessão e o player soma o offset), C166 (URL/mensagem) e C167 (start/end de sessão) preservados;
excerptOffsetSecondsintocado (C163 sem dupla subtração);src/libpuro/client-safe e I/O só emutilities(server-only); dono editado, sem twin. - Testes de domínio previstos: unit de
sessionLagSeconds/correctedExcerptOffsetSecondse do parser/loader YouTube; int do nascimento corrigido (resolver stub) + fail-closed (2634); e2e ecityReportBlocksverdes provando os pins preservados. - Gate de evidência da Fase 0 executado e registrado em changelog datado (997 ⇒ ~13 s, 641 ⇒ ~37 s) antes de travar a opção C.
Self-score decision-quality
5/5 — (1) Decisões caras com rejeitadas: as 5 decisões de engenharia (como corrigir, onde nasce, posse do cliente YouTube, comportamento fail-closed, cache) trazem opções, recomendação e rejeitadas explícitas, incluindo a rejeição da constante global que a própria intenção sugeria e do C "puro" sem override. (2) Appetite: ~0,5–1 dia com cortes declarados (unificação do C163 fora de escopo); a Fase 0 foi um tracer barato que travou a decisão antes do grosso. (3) Rabbit holes nomeados: os três da intenção + unificação do C163, persistência própria e fontes alternativas. (4) Depth check: reusa o cliente YouTube do dono (youtubeFeed.ts, sem o gate de kill switch), excerptOffsetSeconds/wallClockSeconds existentes, o padrão unstable_cache+fail-closed, o único campo youtubeOffsetSeconds e o dono atual do cálculo — sem módulo/componente gêmeo. (5) Outcome preservado: a engenharia não reescreveu o aceite; player e share seguem consumindo um único offset, o deep link C162 continua segundo de sessão, e a correção é automática, baseada em evidência, e erra sempre para o lado de "antes".
Débitos do /simplify (triagem, 2026-09-16)
Nenhum atinge o piso de Issue nova (expensive_lock ≥4). Os 6 achados pontuais foram resolvidos no diff; os demais ficam com gatilho:
- Evidência operacional dentro de
lib/(MEASURED_VIDEO_LAG_SECONDScom vídeos reais): decisão do plano; medição nova exige deploy. Gatilho: a medição virar rotina da assessoria (≈>10 overrides). - O 37 s em dois donos (
MEASURED_VIDEO_LAG_SECONDSeYOUTUBE_VIDEO_OFFSET_SECONDSemscripts/lib/cityReportBlocks.mjs): DRY prematuro entre pipelines distintos. Gatilho: o relatório de cidade for tocado comgetYouTubeVideoStartjá em produção. - Semântica por vídeo vs por fala (a evidência é de 1 fala por sessão; a última medição, 89 s, já mostrou que a parcela de julgamento humano varia): não medida. Gatilho: a 2ª fala medida na MESMA sessão divergir >~5 s do override — aí o override vira por fala.
- Costura de teste (resolver injetável no signature do loader, em vez de um core uncached como
queryMunicipalityTicketPartners): mitigação travada no plano. Gatilho: 2º consumidor ou o loader precisar de variante sem cache. - Descartado:
parseYoutubeVideoIdrecalculado no loader e no VM (derivação pura e barata; plumbing sem ganho).