Resource hint checker

A preload tells the browser to fetch a specific resource at high priority now, because something later in the page will need it. It is a priority instruction, not a cache instruction.

A preconnect tells the browser to open a connection — resolution, handshake — to an origin before anything requests from it, so the first request does not pay that cost.

A DNS-prefetch asks only for the name resolution, which is cheaper than a full connection and correspondingly less useful.

All three spend something now for a saving later. When the later part does not happen, only the spending remains.

A preload for a resource the page does not reference. The file is fetched at high priority, competing with resources that are needed, and then never used.

A preload missing its type or crossorigin declaration, which for fonts causes the browser to fetch the file twice — once for the preload and once for the real request, because they are not recognised as the same fetch.

A preconnect to an origin the page never contacts, which holds a connection open for nothing.

A long list of preconnects. Connections are a limited resource, and using them speculatively on low-value origins delays the ones that matter.

A DNS-prefetch for an origin that is also preconnected, which is redundant — the preconnect already includes resolution.

Hints are cheap to add and invisible when wrong, so they accumulate. Every performance exercise adds a few and no exercise removes any.

The resources they point at move. A build system renames a bundle, a font is replaced, a third party is dropped — and the hint stays, now pointing at nothing.

The cost is real but diffuse: bandwidth spent on a file nobody wants, and priority taken from files somebody does.

Which makes a hint audit a removal exercise more often than an addition one. Two correct preconnects beat eight speculative ones.

A small number of preloads, each for a resource the page really uses and each on the critical path — typically the font and the image that renders largest.

Font preloads carrying the correct type and crossorigin declaration, so the fetch is reused rather than repeated.

Preconnects only to the origins serving something needed early, not to every third party the page eventually touches.

No DNS-prefetch duplicating a preconnect for the same origin.

`performance.preload` reads the preload declarations and checks their consistency against the resources the page references.

`performance.preconnect` reads preconnect declarations against the third-party domains really used. `performance.dns_prefetch` reads the DNS-prefetch declarations.

`performance.third_party_resources` supplies the origins the page really contacts, which is what the hints are compared against. `performance.request_count` reports how many resources the served HTML references.

Hints are compared against the resources the served HTML references. A resource requested later by script may not be in that inventory, so a preload for it can be reported as unused when it is not.

Whether a hint measurably improves rendering is not established here — that needs field measurement over real visits, not a static comparison.

Priority behaviour differs between browsers. What is checked is the declaration's consistency, not its effect in any particular engine.

An absent hint is not reported as a defect. Most pages need very few, and a page with none is frequently correct.