A name that carries its own digest

Two builds could contend for one URL, and everything downstream of that was
guesswork. The stopgap — max-age=0 on everything — was the only honest header for
a filename that means different things on different days, but it left the real
hole open: `addAll` fetches through the HTTP cache, so a precache could capture a
new bundle beside an old stylesheet and then serve that pair until the next
deploy. Unlikely, not impossible, and unfalsifiable after the fact.

So every asset now carries a digest of its contents in its name. The mixed cache
stops being unlikely and becomes unrepresentable: the old stylesheet still has
its own name and nothing has overwritten it. Those files are cached for a year
and never revalidated, which is the second thing a digest buys.

Four keep their names, each for its own reason. index.html is the door and needs
a fixed address. sw.js is how an update is noticed at all — a browser compares it
byte for byte — so a hashed one would need updating in order to be updated. The
manifest and its icons are how an installed app is recognised, and moving them
can stop a browser updating it.

The build's order is the dependency order: a font is named before the stylesheet
that points at it is hashed, and the solver worker before the bundle that names
it. The worker's URL is substituted into the bundle before the bundle is hashed,
which dissolves the apparent circularity between them and means a bundle can only
ever reach the worker it was built against. They speak a protocol of their own,
so the alternative is not a missing file but a conversation at cross purposes.

The worker's version is now a digest of everything it precaches, and the manifest
is generated. Both were kept by hand and had drifted: thirteen commits touched the
app and three remembered to bump the version.

And a new version waits. No skipWaiting, so it installs and sits there while the
running one carries on; the app takes it in `begin_play`, the one place a board
starts whichever way it was reached, because that is the only moment a reload
costs a player nothing. Taking over on arrival would swap the code under a board
somebody is halfway through — and would let the new worker's activation delete
assets the running one still means to fetch, since the solver is not loaded until
the first solve. Deleting the old caches on activate is only safe because of
that: activation waits for the last page on the old version to go.

The headers are two rules that cannot both match. Cloudflare joins duplicate
header names with a comma rather than letting the narrower rule win, so a
Cache-Control on /* would be glued to the front of the immutable one and, being
the lower max-age, would beat it. A 404.html is there too: without one Pages
answers a missing asset with index.html and a 200, which fails later, somewhere
else, as a parse error.

Checked end to end against two real builds: the second installs and waits while
the page keeps serving the first, opening a board applies it, the old cache is
deleted, and the JS keeps its name across a stylesheet-only change. Offline the
whole app still comes up from cache, solver included.

commit

65a78924d32ed61869df110711f0e2e9373cd0bf

parent

dbdf91b9aa60aa03365455085b53c0972ca952c6

author

Dami <dami.etoile@gmail.com>