Back in 2023, in an older version of Joystick, I implemented a per-route caching feature that let me pass a cache policy to res.render() which would basically manage HTML "snapshots" of pages and then, during ssr, render from the cache if it hadn't yet expired (and manage the refresh process).

I don't recall the exact API that I came up with, but now, I want to look at migrating this over to the current version of Joystick (this project).

I've downloaded the source for Joystick from 2023 where this source code exists here: ~/Downloads/joystick_with_page_cache_2023.

I want you to explore that code (specifically: node/src/app/middleware/render.js, which actually utilizes the cache). We'll need to review the options that I had passed and make sure we update to my new snake_case preference for naming and organization.

Let's review that old project, figure out what the API was, and figure out a plan to integrate that functionality back into the current state of Joystick.

Read both files. Here's what the 2023 implementation did:

**Old API (camelCase):**
\`\`\`js
res.render('ui/pages/index/index.js', {
  cache: {
    expiresAfterMinutes: 60,
    diff: async () => 'some-string-to-hash' // optional
  },
});
\`\`\`

**Old behavior (in `middleware/render.js`):**
1. Before SSR: if `cache.expiresAfterMinutes` is set, build a cache filename from the URL path parts joined by `_` (or `"index"` for `/`).
2. If `cache.diff` is provided, call it, then sha256-hash the returned string.
3. Look in `<pageDir>/_cache/` for an HTML snapshot file named `<urlKey>_<expiresAtUnix>.html` and a sibling `diff_<expiresAtUnix>` file.
4. If the file exists, the unix timestamp in its name hasn't passed, AND the stored diff hash equals the current diff hash → serve the cached HTML and skip SSR.
5. If expired or diff changed → delete the stale files.
6. After SSR: write the new HTML + diff hash to disk with `expiresAt = now + expiresAfterMinutes`.

Cache invalidation is purely filename-driven (expiry baked into the filename, no scheduler). Plus optional content-driven invalidation via the `diff` callback's hash.

---

**Proposed new API (snake_case):**
\`\`\`js
res.render('ui/pages/index/index.js', {
  cache: {
    expires_after_minutes: 60,
    diff: async (req) => 'some-string-to-hash', // optional
  },
});
\`\`\`

**Proposed integration into current Joystick:**
- Add `node/src/app/middleware/render/page_cache.js` with two helpers: `read_page_cache({ ... })` and `write_page_cache({ ... })`, plus internal helpers `generate_hash`, `get_cache_diff`, `build_cache_key`.
- Wire into `node/src/app/middleware/render/index.js`:
  - Right after the 404 checks, if `render_options?.cache?.expires_after_minutes` is set → compute current diff, call `read_page_cache(...)`, and if a valid snapshot exists, `res.status(200).send(html)` and return.
  - Right before the final `res.status(200).send(html)`, if caching is enabled → call `write_page_cache(...)`.
- Skip caching when `req.method !== 'GET'`, when the component is a framework component (`joystickdb_gui:`), and (optionally) when there's an authenticated user — keep this simple and not include user-specific caching for v1.

**Decisions I'd like your input on before implementing:**

1. **Storage backend.** Old version wrote HTML files to disk under `<pageDir>/_cache/` inside the build folder. Current Joystick has a robust `cache()` utility (in-memory, optionally Redis-backed via `process.databases.redis`). Three options:
   - **a)** Mirror old behavior: write HTML files to disk under `.joystick/build/_cache/` (simple, survives restarts, no extra deps).
   - **b)** Use Joystick's `cache()` utility with a dedicated cache name like `_page_cache` (in-memory by default, Redis-backed when configured — better for cluster mode).
   - **c)** Both, with `cache.store: 'disk' | 'memory'` option.

2. **Cache key composition.** Old version used URL path parts joined by `_`, ignoring query string. Keep that, or include query string in the key (so `?page=2` caches separately)?

3. **Field naming.** Stick with `expires_after_minutes` to mirror the old name, or rename to `ttl_seconds` / `expires_in` to match the rest of the codebase's TTL conventions (the existing `cache()` utility uses `ttl` in seconds)?

4. **Scope.** Only `res.render` (pages), or also expose for `res.render_email`? I'd recommend pages only.

My recommendation: **1b** (use existing `cache()` utility), **2** include query string, **3** keep `expires_after_minutes` for ergonomics, **4** pages only. Let me know what you want.