Processing time do INP: acelere event handlers lentos

Mude primeiro o que o visitante vê, faça yield com scheduler.yield() e corra o tracking e o resto do clique após o frame.

  • Bom ≤ 200 ms
  • Precisa de melhorias ≤ 500 ms
  • Mau > 500 ms
Arjen Karel
Atualizado a · 11 min de leitura
Partilhar

O processing time em resumo

A processing duration, também chamada processing time, é a segunda fase da Interaction to Next Paint (INP): o tempo que os event handlers de um toque ou premir de tecla demoram a correr, do primeiro ao último listener. Nada no ecrã pode mudar antes de terminarem; por isso, a solução é atualizar o ecrã primeiro e correr o resto após o frame seguinte.

O que conta como processing time?

Todos os event listeners dos eventos da interação contam para a processing duration: pointerdown, pointerup e click num toque; keydown e keyup ao premir uma tecla. Isto inclui o handler do próprio botão, o do tema e o trigger de clique de um tag manager que escuta todo o documento, além das promises resolvidas por esses listeners e do layout que forçam.

Timeline of one tap: input delay, then processing duration, then presentation delay up to the frame on screen. Inside processing duration run the listeners on the button, theme and plugin listeners, a tag manager listener on the document, the promises they resolve and the layout they force. The rest of the work, after a yield, runs after the frame.

Um toque desde o input até ao frame, e o trabalho que um yield move para depois do frame.

  • As promises que um listener resolve. Correm antes de o browser avançar, pelo que um await sobre algo já resolvido mantém o resto do código dentro do clique.
  • O layout que um listener força ao ler uma dimensão depois de alterar a página (forced reflow).
  • O render de uma framework quando renderiza a atualização dentro do evento, como o React faz com uma atualização de estado num clique.

O trabalho que um listener agenda para mais tarde corre fora da processing duration: um setTimeout, uma continuação de scheduler.yield() e a resposta de um fetch correm cada um numa tarefa posterior. No Chrome 158, um timeout ou um yield iniciado no clique correu após o frame em cada toque numa página de teste de bilheteira; as especificações deixam essa ordem ao critério do browser. Os callbacks de requestAnimationFrame correm no próprio frame e contam como presentation delay.

O Chrome DevTools chama a esta parte "Processing duration" no detalhe do INP, e a documentação do Chrome chama "High processing duration" a uma duração longa. A biblioteca web-vitals chama-lhe processingDuration, o CoreDash "Processing" e os artigos mais antigos "processing time". A espera antes de o primeiro listener começar é o input delay, e o tempo desde o último listener até ao frame no ecrã é o presentation delay; o guia de INP reúne as três partes.

Quanto dura a processing duration em sites reais?

Nos sites que medem com o CoreDash, a processing duration em telemóveis foi de 60 ms no percentil 75 nos 28 dias até 7 de novembro de 2026: tão longa como o presentation delay e cerca do dobro do input delay (31 ms). Em toques lentos no telemóvel, com um INP de 500 ms ou mais, a mediana foi de cerca de 120 ms, contra cerca de 210 ms de input delay e 140 ms de presentation delay.

Cada parte tem o seu próprio percentil, pelo que as três não somam o INP.

Um bom INP é de 200 ms ou menos no percentil 75. É a sua interação mais lenta que decide por onde começar: o detalhe do INP no Chrome DevTools recomenda corrigir primeiro a parte mais longa.

O que causa uma processing duration elevada?

Uma processing duration elevada resulta de um click handler que faz tudo antes de o ecrã mudar: tracking, gravar dados, recalcular e renderizar. Num trace do toque no Chrome DevTools, o aspeto é este:

  • Tags e tracking no clique. Um trigger de clique do Google Tag Manager, um dataLayer.push() ou um evento do pixel da Meta corre dentro do toque, pelo que aparecem funções do gtm.js ou do fbevents.js sob Event: click.
  • Tudo num único handler. Adicionar ao carrinho também sincroniza o cesto, atualiza as recomendações e regista o clique, o que surge como uma única Function call longa.
  • Um recálculo no clique. Um seletor de datas que constrói meses de preços, ou um formulário de reserva que recalcula tudo a cada escolha de viajantes ou quartos.
  • O render de uma framework. Uma atualização de estado no React dentro de um clique renderiza os componentes alterados antes de o evento terminar, com funções do próprio React sob Event: click.
  • Layout forçado. O handler altera a página e a seguir lê uma dimensão, pelo que surgem blocos de Layout com um triângulo vermelho dentro do evento.
  • Muitos listeners num só toque. O tema, os plugins, as aplicações e as tags adicionam cada um um listener ao mesmo toque, no botão ou no document: várias chamadas Function sob um único evento, ou também sob pointerdown e pointerup.
Chrome DevTools Performance panel of a click on a React site: the Google Tag Manager and Facebook event callbacks run inside the click event, before the React code that updates the screen.

Um clique num site React no painel Performance do Chrome DevTools.

Os callbacks de clique do Tag Manager e do Facebook correm frequentemente antes do código que atualiza o ecrã, como neste trace. Movidos para depois do frame, continuam a correr e o visitante vê o resultado primeiro. No site de um cliente, mover o dataLayer.push() para depois do paint reduziu o INP em 100 ms.

O clique lento que vejo com mais frequência é num filtro de produtos: o handler atualiza a lista, lê a nova altura, altera algo com base nessa altura e volta a ler a altura. Cada leitura após uma alteração obriga o browser a recalcular o layout dentro do clique; por isso, o handler deve ler todas as dimensões primeiro e alterar a página depois.

Como encontrar o event handler lento?

Um trace do toque lento no painel Performance do Chrome DevTools, gravado com um CPU mais lento, mostra o event handler lento: o detalhe do INP indica a processing duration, e as chamadas Function sob Event: click (ou pointerdown e pointerup) identificam o script e quanto tempo este correu.

  1. Grave um trace do toque lento na largura de telemóvel com o CPU 4x mais lento.
  2. Abra o INP breakdown na barra lateral Insights: amplia a interação e divide-a nas suas três partes.
  3. Sob Event: click, as chamadas Function mostram o ficheiro e a função. O separador Bottom-up, configurado para Group by domain ou Group by URL, soma o tempo gasto por cada ficheiro.
  4. No painel Elements, selecione o botão e abra o separador Event Listeners. Com a opção Ancestors selecionada, como vem por predefinição, lista quem escuta no botão e no document, com o trigger de clique de um tag manager incluído.

Para visitantes reais no Chrome e no Edge, a build de atribuição da biblioteca web-vitals reporta o script mais longo da interação lenta e a parte em que correu:

import { onINP } from 'web-vitals/attribution';

onINP(({ value, attribution }) => {
  const script = attribution.longestScript;
  if (script?.subpart === 'processing-duration') {
    console.log('INP', value, script.entry.invoker, script.entry.sourceURL);
  }
}, { reportAllChanges: true });

Para o botão Add na página de teste de bilhetes mais abaixo, invoker indicava BUTTON#add3.onclick: o elemento e o evento que executaram o script.

No CoreDash, abra INP, Breakdown, filtre por telemóvel e agrupe por LOAF (os scripts em long animation frames): cada linha é um script, e o roxo é a processing duration.

CoreDash Breakdown of Interaction to Next Paint on mobile for acme-pagespeed.com, INP subparts by LOAF sorted by p75 INP: chat-widget.net/loader.js 548 ms with a red dot; ab-split.io/experiment.js 412 ms, /assets/js/app.bundle.js 286 ms and reviews-cdn.com/embed.js 254 ms with a yellow dot; tagcdn.net/tm.js 188 ms and /assets/js/cart-drawer.js 164 ms with a green dot. Each row's bar splits the INP into input delay (green), processing (purple) and presentation (blue).

CoreDash, INP agrupado por LOAF em telemóveis para acme-pagespeed.com.

A Long Animation Frames API indica de quem é o script, e o guia passo a passo de INP vai desde o relatório do Search Console até ao toque lento.

Como reduzir a processing duration?

A processing duration encurta quando o clique corre apenas o código de que o visitante precisa para ver o resultado e agenda tudo o resto para depois do frame seguinte. Numa página de teste de bilheteira, isso reduziu o INP do clique de 200 ms para um único frame. Remova código que não tenha razão para correr no clique, como uma tag que ninguém lê. Comece pelo script identificado no trace ou no CoreDash. Muitas vezes pode desativar ou substituir um plugin, uma aplicação ou uma tag sem código (veja WordPress e Shopify abaixo); o seu próprio código vai para um programador com o padrão de yield.

WordPress

O WordPress dá pouco controlo sobre os scripts que os plugins adicionam, e muitos deles introduzem listeners que não fazem nada no clique a não ser atrasar a Interaction to Next Paint. Sem código:

  • Desative opções do tema de que não precisa, como o scroll suave ou menus animados (abandone o scroll por JavaScript).
  • Encontre o plugin no trace pelo respetivo caminho, /wp-content/plugins/ mais o seu nome. Substitua-o por outro que faça o mesmo com menos JavaScript, ou descarregue-o nas páginas que não o utilizam com o Script Manager do Perfmatters ou o Asset CleanUp (unused JavaScript).
  • No Google Tag Manager, remova as tags que disparam em cada clique e que ninguém utiliza.
  • Escolha um tema leve em vez de um tema que faz tudo ou de um page builder: estes trazem mais scripts e click handlers mais pesados.

Para os seus próprios scripts, envie a um programador o trace do toque lento e peça que a alteração visível seja feita antes do tracking, com o padrão de yield abaixo.

Shopify

Cada aplicação da Shopify adiciona peso a cada clique, e é o código do tema que decide o que corre no Add to cart, não as definições da aplicação. No editor de temas, em App embeds, desative as aplicações uma a uma e grave um trace do toque lento após cada alteração. A parte do tema é trabalho para um programador: o handler de adicionar ao carrinho atualiza primeiro o botão e o contador do carrinho, e deixa o resto para depois do frame, enquanto o cart drawer renderiza apenas o que mudou.

Mude o ecrã primeiro, depois faça yield

Divida um event handler longo com um yield: faça a alteração visível, devolva a main thread e corra o resto após o frame. O helper yieldToMain() faz yield com scheduler.yield() onde o browser for compatível e com setTimeout onde não for:

function yieldToMain() {
  if (globalThis.scheduler?.yield) {
    return scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

button.addEventListener('click', async () => {
  showAdded(button);     // what the visitor sees
  await yieldToMain();   // the browser can paint now
  sendTags();            // the rest runs after the frame
  await yieldToMain();   // room for the next tap
  syncBasket();
  await yieldToMain();
  updateRecommendations();
});

A página de teste é uma bilheteira de festivais onde o botão Add num bilhete também executa três tags de tracking, a sincronização do cesto e novas recomendações: cerca de 190 ms de trabalho. Medido no Chrome 158 em largura de telemóvel com um CPU 4x mais lento, medianas de cinco toques:

  • Tudo no click handler: INP de 200 ms, dos quais 192 ms de processing duration, e "Added" apareceu apenas após todo o trabalho.
  • A alteração visível e depois um único scheduler.yield(): INP de 16 ms ou menos, ou seja, um frame, com "Added" no ecrã em 13 ms. O resto continuou a correr, logo após o frame.
  • O mesmo com setTimeout em vez de scheduler.yield(): também um frame.
INP breakdown insight in the Chrome DevTools Performance panel for the Add tap on a test ticket page with everything in the click handler: INP 203 ms, input delay 1 ms, processing duration 195 ms, presentation delay 7 ms.

Antes: um toque em Add gravado num trace, o que acrescenta alguns milissegundos face às medianas acima: 195 ms de processing duration.

INP breakdown insight in the Chrome DevTools Performance panel for the same Add tap with the visible change first and then scheduler.yield(): INP 13 ms, input delay 1 ms, processing duration 7 ms, presentation delay 6 ms.

Depois: o mesmo toque com scheduler.yield(): 7 ms.

scheduler.yield() funciona no Chrome e no Edge a partir da versão 129 e no Firefox a partir da versão 142. O Safari não o tem, pelo que os iPhones recorrem ao setTimeout como fallback. O guia de INP e a página sobre o presentation delay usam um setTimeout dentro de requestAnimationFrame em alternativa: na página de teste o resultado foi idêntico, ideal para trabalho que deve arrancar assim que o frame é pintado.

Quando o resto tem mais de cerca de 50 ms, faça yield também entre as suas partes, como faz o código acima. Um único bloco longo após o frame faz o toque seguinte esperar por ele, tal como medido no input delay. O artigo Yield para a main thread aborda o scheduler.yield() em detalhe, e agendar eventos do dataLayer apresenta o padrão para o Google Tag Manager.

Armadilhas que mantêm o toque lento

As três primeiras foram medidas na mesma página de bilhetes:

  • O resto no requestAnimationFrame. Corre imediatamente antes do frame, pelo que o INP se manteve nos 200 ms, agora como presentation delay, e "Added" surgiu apenas depois do trabalho. Coloque um setTimeout lá dentro, ou faça yield.
  • Um await que não faz yield. await Promise.resolve() ou queueMicrotask() corre o resto como uma microtarefa dentro do clique: INP de 192 ms, 184 ms dos quais de processing duration. Apenas um await sobre algo que se resolva numa tarefa posterior devolve a main thread.
  • Um yield antes da alteração visível. O INP termina no frame seguinte, independentemente do que esse frame mostrar. Um handler que faça primeiro yield e só depois altere o botão obtém um INP de um único frame, enquanto "Added" surge apenas após todo o trabalho, cerca de 210 ms após o toque. A alteração visível deve vir antes do primeiro yield.
  • requestIdleCallback() sem fallback. O Safari não o tem, pelo que a chamada lança um erro no clique em qualquer iPhone e o trabalho associado nunca corre; o mesmo se aplica a scheduler.postTask(). yieldToMain() inclui o fallback de raiz.

React e outras frameworks

No React, uma atualização de estado num clique renderiza os componentes alterados antes de o evento terminar, pelo que um re-render pesado conta como processing duration. Envolva a atualização pesada em startTransition, ou passe o seu valor através de useDeferredValue: o React renderiza então essa parte após o frame e pode interrompê-la se o visitante voltar a tocar no ecrã. Numa loja React em que trabalhei, um clique no filtro de produtos voltava a renderizar toda a lista de produtos; a solução foi memoizar a lista e colocar a atualização do filtro em startTransition. Mantenha fora de uma transição o valor de um campo onde o visitante escreve; essa atualização tem de continuar urgente. useOptimistic (React 19) mostra o resultado de uma ação de imediato enquanto o request corre.

"Highlight updates when components render" nas React DevTools mostra o que um único clique renderiza. Em outras frameworks a ideia é a mesma: a alteração visível primeiro, a atualização pesada após o frame.

O toque fica mais rápido após a alteração?

Grave novamente o mesmo toque com a mesma configuração de CPU: o detalhe do INP mostra uma processing duration curta, e o trabalho que moveu corre na sua própria tarefa após o frame. Para visitantes reais, a parcela de processamento do elemento que alterou cai no CoreDash poucos dias após a mudança, enquanto o Search Console demora até 28 dias.

O tempo também pode passar para outra parte: o trabalho movido para requestAnimationFrame surge como presentation delay, e um único bloco longo após o frame surge como o input delay do toque seguinte.

Por vezes, o listener lento está num plugin, numa aplicação ou numa tag que não pode alterar, ou o trace mostra o render de uma framework que não consegue associar a um componente específico. Numa Core Web Vitals power hour gravamos juntos esse toque na sua página, e fica a saber exatamente que código retirar do clique e quem o pode alterar.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Precisa de um site mais rápido?

Sou o Arjen e há 17 anos que corrijo sites lentos. Se tem problemas que não consegue resolver sozinho, envie-me o seu URL e falamos.

Envie-me o seu URL
Arjen Karel
Arjen Karel, Consultor de web performance desde 2009

Porque é que o nosso fix não está a funcionar?

Por vezes a CDN ainda serve o HTML antigo, ou o fix foi feito no template de desktop e o mobile usa outro. Envie-me o seu URL e o problema, e respondo com alguns horários. Primeiro analiso os seus field data, depois dedicamos uma hora ao seu site, e no prazo de um dia tem as minhas notas por escrito. 350 € sem IVA.

Envie-me o seu URL

Sem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.

Arjen KarelINP ainda no vermelho em mobile?Envie-me o seu URL