Blueprint

The teardown put this site on a lift and found what was broken. This is the other document a good shop produces: the drawing you would rebuild from, knowing everything the current build taught you. For this one, Fable 5 read every file in the repo, all ~40 pages, all 20 worker modules, the pipeline scripts, the design brief, the service worker, and asked one question: the site was designed for Cloudflare Pages and now lives on Workers with static assets, so which parts of its cleverness are load-bearing, and which parts are scar tissue from a platform it no longer runs on?

"The smarter model would rewrite it" is cheap to claim, so the sketch below is held to the same rule as everything else in this garage: specific diffs, honest verdicts, and a list of what I would NOT touch that is longer than the list of what I would.

What the code already knowskeep

Before any rewrite talk: the repo is full of decisions that took real bruises to learn, most of them written down next to the code they saved. A rebuild keeps every one of these. A sampler:

The architecture, as built

request
  |-- edge-direct (0 worker invocations) ......... nav.js sw.js lens.js notepad.js
  |     _headers rules; SWR + immutable          /garage/* /lwe/* /cars/* *.avif
  |                                              .well-known cards, SEO files
  |-- worker-first
        route() if-chain, ~25 routes
        |-- streamed SSR ......................... /        HTMLRewriter over index.html
        |-- rendered + edge-cached ................ /lens /writing /reading  caches.default
        |-- rendered, deliberately fresh .......... /whoareyou /updates /restore
        |-- data planes ........................... KV (4x SWR caches)  D1 (checkpoints)
        |                                          R2 (originals, edge-cached)  DO (counter)
        |-- ghosts of Pages past .................. SPA-fallback sniffs, ?v= bust scheme,
                                                    per-request asset re-bust, .pages.dev 301

Four cache layers, each owning what it is best at: browser (immutable + bfcache), service worker (shells + thumbs), edge (rendered routes + R2), KV (data). That part is already the Workers-native shape. The ghosts are the bottom line.

The Pages ghostsscar tissue

"run_worker_first": [
  "/*",                 // worker sees EVERYTHING...
  "!/nav.js", "!/sw.js",
  "!/garage/*", "!/lwe/*",
  "!/images/*.avif", ...  // ...minus 14 carve-outs
]

"run_worker_first": [
  "/", "/whoareyou", "/around", "/lens*",
  "/writing*", "/rn*", "/reading", "/updates*",
  "/restore", "/security", "/bot", "/agent/*",
  "/oauth2/*", "/images/full/*", ...
]  // the worker EARNS each route; static is the default

// x3: metadata.json, meta/*.json, thumbnails
const res = await env.ASSETS.fetch(request);
const ct = res.headers.get("content-type");
if (res.ok && ct.startsWith("image/")) return res;
// defends against Pages' SPA fallback:
// a missing asset came back 200 text/html
return errorResp("not found", 404);

// Workers returns real 404s; the masquerade
// is extinct. keep ONLY the half that still
// earns its keep: clamp 404 cache-control so
// a miss can't inherit /images/* immutable.
const res = await env.ASSETS.fetch(request);
if (res.status === 404) return uncacheable404();
return res;

The rewrite sketchblueprint

The honest headline: this is not a rewrite of what the site does, it is a consolidation of how many times the code says it. Same behavior, fewer hand-rolled copies of the same idea.

// photos.js ~30 lines: manifest + sentinel
// rn.js     ~25 lines: tracks + sentinel
// reading.js ~25 lines: curius + sentinel
// around.js  ~30 lines: report + sentinel
// same shape, four dialects, drift risk

// lib/cache.js — the whole caching kit:
swrKV(env, ctx, key, ttl, build)
cachedRender(request, ctx, render)  // exists
cachedR2(request, env, ctx, key)    // exists

// callers become one-liners:
const tracks = await swrKV(env, ctx,
  `tracks:${pid}`, 3600, () => scrape(pid));

// whoareyou.js, around.js, reading.js, bot.js,
// security.js, updates.js (x2!), rn.js, lens.js
// each: return new Response(`<!DOCTYPE html>
// <html>...${xpChromeCss(W)}...` + headers)

lunaPage({ title, path, width,
           css, body, cache })
// one function owns DOCTYPE, chrome, geometry,
// nav.js include, security posture. handlers
// return { title, css, body } — content only.

// index.js: 240 lines of
// if (url.pathname === "/x") return handleX(...)
// order-dependent, prefix rules interleaved

const ROUTES = new Map([...]);   // exact
const PREFIX = [...];            // ordered
// dispatch is 10 lines; the table IS the
// sitemap, and mirrors run_worker_first
// one-to-one — config and code agree.

What I would not touchthe soul

• Inline everything, one request per page. The McMaster-Carr school. External stylesheets and bundle graphs buy nothing here and cost a round trip.
• No framework, no hydration, no client router. The HTML is the state. The site's interactivity budget goes to one deferred shell script, and that is enough to drag windows around a desktop.
• Streaming SSR with client fallbacks. HTMLRewriter starts the response before the data finishes, and every SSR surface has a ~30-line client mirror that detects "already populated" and stands down. Defense in depth that has already paid out.
• The homepage stays uncacheable. Random twelve photos and a real counter tick per visit is the site's pulse. ~31KB per visit is what that costs, and it is the best byte-spend on the domain.
• The honesty rules. Fallbacks that say so, no fabricated UI, nothing graduates to the homepage until two engines ship it, failures stay parked in the garage next to the wins. This page follows the same rules about itself.
• Buildless authoring. The build stays a deploy-time transform of four files with tripwires, and grows only when something else earns it the way the shells did.