thejayman77/upbeatBytes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove the service worker (protect first loads)

Browse Source 
Per Codex + Jay: the SW was added for nice-to-have PWA/offline caching, but it
sat in the boot path and put first loads at risk (post-deploy tiny-chunk stalls
of 4-10s — fast HTML, then delayed chunks). For a young site where a handful of
visitors a day IS the audience, a broken first impression is a huge share of
traffic. The site's value doesn't need offline caching; browser HTTP cache +
the Cloudflare edge are enough.

Removed cleanly (not just deleted — that strands the old worker on existing
clients):
- Delete src/service-worker.js → SvelteKit stops auto-registering.
- static/service-worker.js is now a one-shot KILL SWITCH: takes over, wipes all
  caches, unregisters itself, no fetch handler (requests go straight to network/
  browser cache). Served no-cache so existing clients pick it up.
- app.html boot script unregisters any worker + clears caches on load, as a
  backstop so no returning visitor stays stuck on the old boot path.

The boot seatbelt (timeout card, preloadError reload-once, telemetry) stays —
that, not the SW, was the real blank-screen protection. Build clean, 11 vitest.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
jay
2026-06-12 08:30:35 -04:00
parent f84d934da5
commit 18c4530721
3 changed files with 44 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frontend/src/app.html
+13
View File
@@ -38,6 +38,19 @@
// screen. Show a calm recovery card if the app hasn't mounted, and reload
// once on a chunk/preload failure (e.g. a just-deployed hashed chunk).
(function () {
// The service worker was removed (it risked first loads). Actively
// unregister any worker a returning visitor still has + wipe its caches,
// so nobody stays stuck on the old boot path. Runs on every load; cheap.
if ('serviceWorker' in navigator) {
try {
navigator.serviceWorker.getRegistrations()
.then(function (rs) { rs.forEach(function (r) { r.unregister(); }); })
.catch(function () {});
if (self.caches && caches.keys) {
caches.keys().then(function (ks) { ks.forEach(function (k) { caches.delete(k); }); }).catch(function () {});
}
} catch (e) { /* best effort */ }
}
var sent = false;
function report(reason) {
if (sent) return; sent = true; // one beacon per page
frontend/src/service-worker.js
-114
View File
@@ -1,114 +0,0 @@
/// <reference types="@sveltejs/kit" />
// Calm, lightweight service worker. It does NOT bulk-precache on install — the
// browser already caches the year-immutable assets on its own, and a cold
// precache storm right after a deploy hammers the (residential) origin and slows
// first loads. Instead: cache the shell for an offline fallback, and cache other
// assets lazily as they're actually used. Live data (API + server-rendered pages)
// is always fetched fresh.
import { version } from '$service-worker';
const CACHE = `upbeat-${version}`;
// How long a navigation may wait on the network before the cached shell is
// served instead. Long enough for a healthy fetch, short enough that a stalled
// cellular/origin hop never reads as a broken site.
const NAV_TIMEOUT_MS = 2500;
// Paths the FastAPI server owns — the SW must NOT intercept or cache these.
function isServerPath(p) {
if (p.startsWith('/api/') || p.startsWith('/a/') || p.startsWith('/docs')) return true;
return p === '/openapi.json' || p === '/healthz' || p === '/today' || p === '/sitemap.xml';
}
// Mutable files Caddy serves with `no-cache` — the browser's HTTP cache
// revalidates these correctly, but SW cache-as-you-go would pin them until the
// next SW version and silently defeat that policy. version.json is the big one
// (it's how the app detects a new deploy); stale word lists could drift from
// the server's validated answer pool. Let the network/browser cache own them.
function isMutablePath(p) {
return (
p === '/service-worker.js' ||
p === '/_app/version.json' ||
p === '/manifest.webmanifest' ||
p === '/words-5.json' ||
p === '/words-6.json' ||
p === '/favicon.svg' ||
p === '/logo.svg' ||
p === '/logo-email.png' ||
p.startsWith('/icon-')
);
}
self.addEventListener('install', (event) => {
// Best-effort: grab the app shell as an offline fallback. No bulk precache.
// Deliberately NO skipWaiting(): a new worker installs quietly and waits, so
// it never seizes a page that's mid-boot. It takes control on the next
// navigation, when the old worker has no clients — the post-deploy first-load
// then completes under the stable old worker (with its cache intact) against
// the warmed edge, instead of having its cache yanked mid-load.
event.waitUntil(caches.open(CACHE).then((c) => c.add('/').catch(() => {})));
});
self.addEventListener('activate', (event) => {
// Runs only when this worker actually activates (next navigation, never
// mid-boot), so deleting old version caches here is safe — and old immutable
// chunks live on at the origin for a 14-day grace window regardless. No
// clients.claim(): pages adopt this worker on their own next navigation.
event.waitUntil(
caches
.keys()
.then((keys) => Promise.all(keys.filter((k) => k !== CACHE).map((k) => caches.delete(k))))
);
});
self.addEventListener('fetch', (event) => {
const { request } = event;
if (request.method !== 'GET') return;
const url = new URL(request.url);
if (url.origin !== location.origin) return;
if (isServerPath(url.pathname) || isMutablePath(url.pathname)) return; // network/browser cache owns these
// Navigations: network-first, but a SLOW network must not mean a white screen —
// "slow" and "failed" both fall back to the cached shell. We race the fetch
// against a short grace timer: network wins → freshest HTML as usual; timer
// wins (or 5xx/failure) → serve the cached shell instantly while the network
// response still lands in the cache for next time. A slightly stale shell is
// safe: deploys keep old immutable chunks for a 14-day grace window.
if (request.mode === 'navigate') {
event.respondWith(
(async () => {
const cache = await caches.open(CACHE);
const cached = await cache.match('/');
const network = fetch(request)
.then((res) => {
if (res && res.ok && (res.headers.get('content-type') || '').includes('text/html')) {
cache.put('/', res.clone()).catch(() => {});
}
return res;
})
.catch(() => null);
if (!cached) return (await network) || Response.error(); // first visit: network only
const winner = await Promise.race([
network,
new Promise((resolve) => setTimeout(() => resolve('slow'), NAV_TIMEOUT_MS)),
]);
return winner && winner !== 'slow' && winner.ok ? winner : cached;
})()
);
return;
}
// Static assets: serve from cache if present, else fetch and cache for next time
// (cache-as-you-go — no install storm). Only cache successful same-origin GETs.
event.respondWith(
caches.match(request).then((cached) => {
if (cached) return cached;
return fetch(request).then((res) => {
if (res && res.ok && res.type === 'basic') {
const copy = res.clone();
caches.open(CACHE).then((c) => c.put(request, copy)).catch(() => {});
}
return res;
});
})
);
});
frontend/static/service-worker.js
+31
View File
@@ -0,0 +1,31 @@
// Kill switch — the app no longer uses a service worker.
//
// It was added for nice-to-have PWA/offline caching, but it sat in the boot
// path and put first loads at risk (post-deploy chunk stalls), which a young
// site with few visitors can't afford. Browser HTTP cache + the Cloudflare edge
// are enough for a news site.
//
// Existing visitors still have the OLD worker registered and controlling their
// pages. This replacement (served at /service-worker.js, no-cache) takes over,
// wipes the old caches, and unregisters itself. There is deliberately NO fetch
// handler, so every request goes straight to the network / browser HTTP cache.
// The app also unregisters any worker on load (see app.html) as a backstop.
self.addEventListener('install', () => self.skipWaiting());
self.addEventListener('activate', (event) => {
event.waitUntil(
(async () => {
try {
const keys = await caches.keys();
await Promise.all(keys.map((k) => caches.delete(k)));
} catch (e) {
/* best effort */
}
try {
await self.registration.unregister();
} catch (e) {
/* best effort */
}
})()
);
});