feat(demo): subdomain gateway, readiness probe, IndexedDB cache, interstitial

Service-worker gateway extensions to the existing demo, mirroring the IPFS
service-worker-gateway pattern (https://inbrowser.link) but for Swarm:

* Subdomain detection in sw.js: <cid>.localhost, <cid>.bzz.localhost, and
  <cid>.bytes.localhost (the last routes to bee's /bytes endpoint for raw
  chunk retrieval, the others to /bzz for manifest-style content). The
  subdomain label is passed verbatim to bee, which resolves it via the
  cidv1 resolver (swarm-manifest codec 0xfa, keccak-256 multihash, base32
  multibase) back to the underlying 32-byte chunk address.

* main.js register-and-reload bootstrap: subdomain origins register the SW
  on first visit, then reload so the controller can intercept the next
  navigation.

* Readiness probe (/__bee_ready) backed by /peers + a 20s SW-side startup
  grace. Bee bypasses --warmup-time for light nodes (warmupTime=0 in
  pkg/node/node.go for !FullNodeMode), so kademlia bins haven't populated
  by the time the API opens. The grace gives them time before we let the
  page issue retrieval requests.

* interstitial.js: polls readiness, surfaces distinct states (warming
  grace, peer wait, API not ready), and reloads once truly ready so the
  SW's navigation handler forwards to bee.

* IndexedDB-backed localstore mount: chunks + their leveldb index persist
  across reloads so repeat visits don't re-fetch the same chunks. Other
  paths stay InMemory so identity / kademlia / accounting state doesn't
  leak across sessions.

* navigate-mode waitUntil(10s) keeps the SW alive after responses so bee's
  background cache-write goroutines (Cache().Put scheduled async in
  pkg/storer/netstore.go) have time to flush to IndexedDB before Chrome
  idle-kills the worker.

* Bee error passthrough: 4xx/5xx navigation responses surface bee's actual
  JSON error message in a terminal page instead of a misleading
  'content not reachable' string.

Author: v1rtl

wasm-demo/interstitial.js

@@ -0,0 +1,64 @@
+// Interstitial script — runs on the "Bee node starting…" page that the
+// service worker serves while the in-worker bee node is still warming up
+// (no peers / startup-grace not yet elapsed). Polls /__bee_ready and, when
+// the SW reports ready, navigates to the page so the SW's navigation
+// handler forwards to bee for the real content.
+//
+// Parameters come from this script tag's own src query string, e.g.
+//   <script src="/interstitial.js?m=2&g=20000"></script>
+//   m = minimum peer count (informational; the SW enforces the actual gate)
+//   g = startup grace ms (informational)
+(async () => {
+  const params = new URL(document.currentScript.src).searchParams;
+  const MIN = parseInt(params.get("m") || "2", 10);
+  const s = document.getElementById("s");
+
+  function setStatus(text) {
+    s.textContent = text;
+    console.log("[bzz-page]", text);
+  }
+
+  function statusFor(body) {
+    if (body.reason === "grace") {
+      const sec = Math.ceil((body.graceRemaining || 0) / 1000);
+      return `Warming up bee node (${sec}s, ${body.peers} peers so far)…`;
+    }
+    if (body.reason === "peers") {
+      return `Connecting to Swarm: ${body.peers} / ${MIN} peers…`;
+    }
+    if (body.reason === "api") {
+      return "Bee API not ready yet…";
+    }
+    return `Peers: ${body.peers} / ${MIN}`;
+  }
+
+  // Poll until the SW reports ready, then reload. The SW's navigation
+  // handler will see the reload as a top-level navigation; since readiness
+  // is now true, it'll forward the request to bee and return the content
+  // (or, if the underlying retrieval fails, fall back to this interstitial
+  // again — at which point we just keep polling).
+  for (;;) {
+    await new Promise((r) => setTimeout(r, 2000));
+    let body;
+    try {
+      const r = await fetch("/__bee_ready", { cache: "no-store" });
+      if (!r.ok) {
+        setStatus(`Bee API not ready yet (${r.status})…`);
+        continue;
+      }
+      body = await r.json();
+    } catch {
+      setStatus("Waiting for service worker…");
+      continue;
+    }
+    setStatus(statusFor(body));
+    if (body.ready) {
+      // Bee is ready: navigate so the SW handles the request as a real top-
+      // level GET. The SW already runs the readiness check in its navigation
+      // handler, so if bee actually returns 200 we render the content; if
+      // not, the SW serves the interstitial again and we keep polling.
+      location.reload();
+      return;
+    }
+  }
+})();

wasm-demo/main.js

@@ -1,8 +1,29 @@
+// On "<reference>.localhost" subdomains the service worker serves the bzz
+// content in place. The first hit has no controlling SW yet (so the dev server
+// returns this bootstrap page), so once the SW is registered and controlling
+// the page we reload to let it serve "/bzz/<reference>/".
+const onSubdomain =
+  location.hostname !== "localhost" && location.hostname.endsWith(".localhost");
+
 if ("serviceWorker" in navigator) {
   navigator.serviceWorker
     .register("/sw_bundle.js", { scope: "/" })
-    .then((registration) => {
-      console.log("Service Worker registered successfully:", registration);
+    .then(() => {
+      console.log("Service Worker registered successfully");
+
+      if (!onSubdomain) return;
+
+      if (navigator.serviceWorker.controller) {
+        // SW already controls this page: reload so it serves the content.
+        location.reload();
+      } else {
+        // Wait until the freshly-installed SW takes control, then reload once.
+        navigator.serviceWorker.addEventListener(
+          "controllerchange",
+          () => location.reload(),
+          { once: true },
+        );
+      }
     })
     .catch((error) => {
       console.error("Service Worker registration failed:", error);