From 0df4341a73f9ccef07b5b00142ce999c3d9a0da4 Mon Sep 17 00:00:00 2001
From: Steve Krouse <steveykrouse@gmail.com>
Date: Wed, 29 Jul 2026 22:09:52 -0400
Subject: [PATCH 1/4] Teach versioned immutable asset caching in the UI skills

client-side-js, http-endpoints, and react-ui now teach the versionedAssets
pattern from std/utils as the default way to serve client modules: the shell
stamps /v<version>/ asset URLs, serve() answers them with Cache-Control:
immutable (302 for stale versions), and publishing invalidates instantly.
Measured: repeat visits 665ms -> 157ms with zero asset requests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/versioned-assets-skills.md |  5 +++++
 plugin/skills/client-side-js/SKILL.md | 26 ++++++++++++++++++++++++++
 plugin/skills/http-endpoints/SKILL.md | 10 ++++++++--
 plugin/skills/react-ui/SKILL.md       | 20 ++++++++++++++++++++
 4 files changed, 59 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/versioned-assets-skills.md

diff --git a/.changeset/versioned-assets-skills.md b/.changeset/versioned-assets-skills.md
new file mode 100644
index 0000000..b911f8f
--- /dev/null
+++ b/.changeset/versioned-assets-skills.md
@@ -0,0 +1,5 @@
+---
+"@valtown/skills": patch
+---
+
+Teach the versioned-immutable asset-caching pattern (`versionedAssets` from `std/utils`) as the default way to serve client modules, in the `client-side-js`, `http-endpoints`, and `react-ui` skills. The HTML shell stamps `/v<version>/...` asset URLs, `serve()` answers them with `Cache-Control: immutable` (stale versions 302 to current), and publishing the val bumps the version so invalidation is instant. Measured: repeat visits 665ms → 157ms with zero asset requests.
diff --git a/plugin/skills/client-side-js/SKILL.md b/plugin/skills/client-side-js/SKILL.md
index f4a0b15..2c08724 100644
--- a/plugin/skills/client-side-js/SKILL.md
+++ b/plugin/skills/client-side-js/SKILL.md
@@ -41,6 +41,32 @@ app.get("/client/**/*", (c) => serveFile(c.req.path));
 `serveFile` defaults to the current val. If you call it from a non-entrypoint file
 and paths don't resolve, pass `import.meta.url` as the second argument.
 
+## Default: versioned, immutably cached modules
+
+Served this way, every page load refetches and re-transpiles every module. The
+default pattern adds version-stamped URLs with immutable caching on top —
+measured on a 3-module React app, repeat visits went **665ms → 157ms with zero
+asset requests**:
+
+```ts
+import { versionedAssets } from "https://esm.town/v/std/utils/index.ts";
+
+const assets = versionedAssets();
+
+// current version → served with Cache-Control: immutable; stale version → 302
+app.get("/v*", (c) => assets.serve(c.req.raw));
+```
+
+In the HTML shell, stamp the entry module with `assets.url("/frontend/index.tsx")`,
+which returns `/v42/frontend/index.tsx` (42 = the val's current version). Relative
+imports resolve under the same `/v42/` prefix, so the whole client module graph is
+version-addressed automatically — only the entry needs stamping.
+
+Invalidation is automatic: publishing the val bumps its version, the never-cached
+shell stamps the new prefix, and browsers refetch each asset exactly once; requests
+for old versions 302 to the current one. Paths without a `/v<version>/` prefix fall
+through to plain uncached `serveFile`, so unstamped URLs keep working.
+
 ### Alternative: serve directly from esm.town
 
 Every val file already has a public esm.town URL that transpiles on demand, so you
diff --git a/plugin/skills/http-endpoints/SKILL.md b/plugin/skills/http-endpoints/SKILL.md
index 1604503..7521dd6 100644
--- a/plugin/skills/http-endpoints/SKILL.md
+++ b/plugin/skills/http-endpoints/SKILL.md
@@ -25,13 +25,19 @@ When using Hono, export `app.fetch` (not `app`):
 
 ```ts
 import { Hono } from "npm:hono";
-import { parseVal, serveFile } from "https://esm.town/v/std/utils/index.ts";
+import { parseVal, serveFile, versionedAssets } from "https://esm.town/v/std/utils/index.ts";
 
 const app = new Hono();
+const assets = versionedAssets();
 
 app.get("/", (c) => c.text("hello"));
 
-// Serve all frontend files, transpiled, with correct content types
+// Serve frontend files versioned + immutably cached. The HTML shell stamps
+// asset URLs with assets.url("/frontend/index.tsx") → "/v42/frontend/index.tsx";
+// publishing bumps the version, so browsers refetch each asset exactly once.
+app.get("/v*", (c) => assets.serve(c.req.raw));
+
+// Unstamped fallback, transpiled, with correct content types (e.g. the favicon)
 app.get("/frontend/**/*", (c) => serveFile(c.req.path));
 
 // View source redirect
diff --git a/plugin/skills/react-ui/SKILL.md b/plugin/skills/react-ui/SKILL.md
index 4cfea9b..c160730 100644
--- a/plugin/skills/react-ui/SKILL.md
+++ b/plugin/skills/react-ui/SKILL.md
@@ -36,6 +36,26 @@ Then use Tailwind classes directly in JSX:
 
 Avoid inline `<style>` tags, CSS-in-JS objects, or separate `.css` files, unless the user says otherwise.
 
+## Serving assets: versioned + immutable
+
+Serve client modules through `versionedAssets` from `std/utils` so repeat visits
+load them from the browser cache instead of re-transpiling per request (measured:
+repeat visits 665ms → 157ms, zero asset requests). The shell stamps the entry
+module URL; publishing the val bumps the version, which invalidates instantly:
+
+```tsx
+import { versionedAssets } from "https://esm.town/v/std/utils/index.ts";
+const assets = versionedAssets();
+
+// In the HTML shell:
+<script src={assets.url("/frontend/index.tsx")} type="module" />
+
+// In the Hono app — current version → immutable cache, stale → 302 to current:
+app.get("/v*", (c) => assets.serve(c.req.raw));
+```
+
+See the `client-side-js` skill for how modules and their imports are served.
+
 ## View source link
 
 Every UI val should expose a way for users to see and remix its source. Both parts are required:

From f5823f40190f04d137828b36641afeb27863a584 Mon Sep 17 00:00:00 2001
From: Steve Krouse <steveykrouse@gmail.com>
Date: Thu, 30 Jul 2026 09:32:24 -0400
Subject: [PATCH 2/4] Rewrite to the final API:
 serveImmutableFile/immutableFileUrl + /__immutable/<v>/ scheme

Replaces the versionedAssets() factory (assets.url/assets.serve, /v<version>/ URLs)
with the shipped std/utils API: free functions serveImmutableFile and
immutableFileUrl, the reserved /__immutable/<version>/<path> prefix, and the
frontend/root.tsx shell pattern.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/versioned-assets-skills.md |  2 +-
 plugin/skills/client-side-js/SKILL.md | 23 ++++++++++++-----------
 plugin/skills/http-endpoints/SKILL.md | 11 +++++------
 plugin/skills/react-ui/SKILL.md       | 19 ++++++++++---------
 4 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/.changeset/versioned-assets-skills.md b/.changeset/versioned-assets-skills.md
index b911f8f..df406c6 100644
--- a/.changeset/versioned-assets-skills.md
+++ b/.changeset/versioned-assets-skills.md
@@ -2,4 +2,4 @@
 "@valtown/skills": patch
 ---
 
-Teach the versioned-immutable asset-caching pattern (`versionedAssets` from `std/utils`) as the default way to serve client modules, in the `client-side-js`, `http-endpoints`, and `react-ui` skills. The HTML shell stamps `/v<version>/...` asset URLs, `serve()` answers them with `Cache-Control: immutable` (stale versions 302 to current), and publishing the val bumps the version so invalidation is instant. Measured: repeat visits 665ms → 157ms with zero asset requests.
+Teach the immutable asset-caching pattern (`serveImmutableFile` / `immutableFileUrl` from `std/utils`) as the default way to serve client modules, in the `client-side-js`, `http-endpoints`, and `react-ui` skills. The never-cached HTML shell stamps `/__immutable/<version>/...` asset URLs, `serveImmutableFile` answers them with `Cache-Control: immutable` (stale versions 302 to current), and publishing the val bumps the version so invalidation is instant. Measured: repeat visits 665ms → 157ms with zero asset requests.
diff --git a/plugin/skills/client-side-js/SKILL.md b/plugin/skills/client-side-js/SKILL.md
index 2c08724..e142d57 100644
--- a/plugin/skills/client-side-js/SKILL.md
+++ b/plugin/skills/client-side-js/SKILL.md
@@ -44,28 +44,29 @@ and paths don't resolve, pass `import.meta.url` as the second argument.
 ## Default: versioned, immutably cached modules
 
 Served this way, every page load refetches and re-transpiles every module. The
-default pattern adds version-stamped URLs with immutable caching on top —
+default pattern adds version-addressed URLs with immutable caching on top —
 measured on a 3-module React app, repeat visits went **665ms → 157ms with zero
 asset requests**:
 
 ```ts
-import { versionedAssets } from "https://esm.town/v/std/utils/index.ts";
-
-const assets = versionedAssets();
+import { serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
 // current version → served with Cache-Control: immutable; stale version → 302
-app.get("/v*", (c) => assets.serve(c.req.raw));
+app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
 ```
 
-In the HTML shell, stamp the entry module with `assets.url("/frontend/index.tsx")`,
-which returns `/v42/frontend/index.tsx` (42 = the val's current version). Relative
-imports resolve under the same `/v42/` prefix, so the whole client module graph is
-version-addressed automatically — only the entry needs stamping.
+In the HTML shell, stamp the entry module with `immutableFileUrl("/frontend/index.tsx")`,
+which returns `/__immutable/42/frontend/index.tsx` (42 = the val's current version).
+Relative imports resolve under the same `/__immutable/42/` prefix, so the whole client
+module graph is version-addressed automatically — only the entry needs stamping. This
+works for root-level files too: `immutableFileUrl("/logo.png")` → `/__immutable/42/logo.png`.
 
 Invalidation is automatic: publishing the val bumps its version, the never-cached
 shell stamps the new prefix, and browsers refetch each asset exactly once; requests
-for old versions 302 to the current one. Paths without a `/v<version>/` prefix fall
-through to plain uncached `serveFile`, so unstamped URLs keep working.
+for old versions 302 to the current one. Keep a plain `serveFile` route as the
+fallback so unstamped URLs keep working — or point that route at `serveImmutableFile`
+too, which 302s bare paths into `/__immutable/<version>/` (zero config, at the cost
+of one redirect per page view).
 
 ### Alternative: serve directly from esm.town
 
diff --git a/plugin/skills/http-endpoints/SKILL.md b/plugin/skills/http-endpoints/SKILL.md
index 7521dd6..9330c8f 100644
--- a/plugin/skills/http-endpoints/SKILL.md
+++ b/plugin/skills/http-endpoints/SKILL.md
@@ -25,19 +25,18 @@ When using Hono, export `app.fetch` (not `app`):
 
 ```ts
 import { Hono } from "npm:hono";
-import { parseVal, serveFile, versionedAssets } from "https://esm.town/v/std/utils/index.ts";
+import { parseVal, serveFile, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
 const app = new Hono();
-const assets = versionedAssets();
 
 app.get("/", (c) => c.text("hello"));
 
-// Serve frontend files versioned + immutably cached. The HTML shell stamps
-// asset URLs with assets.url("/frontend/index.tsx") → "/v42/frontend/index.tsx";
+// Serve frontend files versioned + immutably cached. The HTML shell stamps asset
+// URLs with immutableFileUrl("/frontend/index.tsx") → "/__immutable/42/frontend/index.tsx";
 // publishing bumps the version, so browsers refetch each asset exactly once.
-app.get("/v*", (c) => assets.serve(c.req.raw));
+app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
 
-// Unstamped fallback, transpiled, with correct content types (e.g. the favicon)
+// Unstamped fallback, transpiled, with correct content types
 app.get("/frontend/**/*", (c) => serveFile(c.req.path));
 
 // View source redirect
diff --git a/plugin/skills/react-ui/SKILL.md b/plugin/skills/react-ui/SKILL.md
index c160730..96ae971 100644
--- a/plugin/skills/react-ui/SKILL.md
+++ b/plugin/skills/react-ui/SKILL.md
@@ -38,20 +38,21 @@ Avoid inline `<style>` tags, CSS-in-JS objects, or separate `.css` files, unless
 
 ## Serving assets: versioned + immutable
 
-Serve client modules through `versionedAssets` from `std/utils` so repeat visits
+Serve client modules through `serveImmutableFile` from `std/utils` so repeat visits
 load them from the browser cache instead of re-transpiling per request (measured:
-repeat visits 665ms → 157ms, zero asset requests). The shell stamps the entry
-module URL; publishing the val bumps the version, which invalidates instantly:
+repeat visits 665ms → 157ms, zero asset requests). A never-cached `frontend/root.tsx`
+shell component (hono/jsx) stamps the entry module and favicon URLs with
+`immutableFileUrl`; publishing the val bumps the version, which invalidates instantly:
 
 ```tsx
-import { versionedAssets } from "https://esm.town/v/std/utils/index.ts";
-const assets = versionedAssets();
+import { immutableFileUrl, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
-// In the HTML shell:
-<script src={assets.url("/frontend/index.tsx")} type="module" />
+// frontend/root.tsx — in the Root() HTML shell:
+<script src={immutableFileUrl("/frontend/index.tsx")} type="module" />
 
-// In the Hono app — current version → immutable cache, stale → 302 to current:
-app.get("/v*", (c) => assets.serve(c.req.raw));
+// index.ts — the Hono app; current version → immutable cache, stale → 302 to current:
+app.get("/", (c) => c.html(Root()));
+app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
 ```
 
 See the `client-side-js` skill for how modules and their imports are served.

From 798572940f5d746a50344df0297aa75425816ba9 Mon Sep 17 00:00:00 2001
From: Steve Krouse <steveykrouse@gmail.com>
Date: Thu, 30 Jul 2026 09:46:27 -0400
Subject: [PATCH 3/4] Stale versions 404; tighten skill sections

Non-current /__immutable/ versions now 404 (Next.js semantics) instead of
redirecting; both template routes go through serveImmutableFile. Each skill
section slimmed to benefit-first sentence, minimal code, and 2 bullet nuances,
with client-side-js owning the full explanation.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/versioned-assets-skills.md |  2 +-
 plugin/skills/client-side-js/SKILL.md | 32 ++++++++++++---------------
 plugin/skills/http-endpoints/SKILL.md | 11 ++++-----
 plugin/skills/react-ui/SKILL.md       | 16 +++++---------
 4 files changed, 25 insertions(+), 36 deletions(-)

diff --git a/.changeset/versioned-assets-skills.md b/.changeset/versioned-assets-skills.md
index df406c6..2230cdd 100644
--- a/.changeset/versioned-assets-skills.md
+++ b/.changeset/versioned-assets-skills.md
@@ -2,4 +2,4 @@
 "@valtown/skills": patch
 ---
 
-Teach the immutable asset-caching pattern (`serveImmutableFile` / `immutableFileUrl` from `std/utils`) as the default way to serve client modules, in the `client-side-js`, `http-endpoints`, and `react-ui` skills. The never-cached HTML shell stamps `/__immutable/<version>/...` asset URLs, `serveImmutableFile` answers them with `Cache-Control: immutable` (stale versions 302 to current), and publishing the val bumps the version so invalidation is instant. Measured: repeat visits 665ms → 157ms with zero asset requests.
+Teach the immutable asset-caching pattern (`serveImmutableFile` / `immutableFileUrl` from `std/utils`) in the `client-side-js`, `http-endpoints`, and `react-ui` skills: the never-cached HTML shell stamps `/__immutable/<version>/...` URLs, served with `Cache-Control: immutable`; publishing bumps the version, invalidating automatically (old-version URLs 404). Measured: repeat visits 665ms → 157ms with zero asset requests.
diff --git a/plugin/skills/client-side-js/SKILL.md b/plugin/skills/client-side-js/SKILL.md
index e142d57..029f956 100644
--- a/plugin/skills/client-side-js/SKILL.md
+++ b/plugin/skills/client-side-js/SKILL.md
@@ -43,30 +43,26 @@ and paths don't resolve, pass `import.meta.url` as the second argument.
 
 ## Default: versioned, immutably cached modules
 
-Served this way, every page load refetches and re-transpiles every module. The
-default pattern adds version-addressed URLs with immutable caching on top —
-measured on a 3-module React app, repeat visits went **665ms → 157ms with zero
-asset requests**:
+`serveImmutableFile` makes your val's frontend faster by letting browsers cache
+files immutably; publishing bumps the val's version, which invalidates
+automatically. Measured: repeat visits **665ms → 157ms with zero asset requests**.
 
 ```ts
-import { serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
+import { immutableFileUrl, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
-// current version → served with Cache-Control: immutable; stale version → 302
 app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
+app.get("/frontend/**/*", (c) => serveImmutableFile(c.req.path)); // bare paths 302 into versioned space
 ```
 
-In the HTML shell, stamp the entry module with `immutableFileUrl("/frontend/index.tsx")`,
-which returns `/__immutable/42/frontend/index.tsx` (42 = the val's current version).
-Relative imports resolve under the same `/__immutable/42/` prefix, so the whole client
-module graph is version-addressed automatically — only the entry needs stamping. This
-works for root-level files too: `immutableFileUrl("/logo.png")` → `/__immutable/42/logo.png`.
-
-Invalidation is automatic: publishing the val bumps its version, the never-cached
-shell stamps the new prefix, and browsers refetch each asset exactly once; requests
-for old versions 302 to the current one. Keep a plain `serveFile` route as the
-fallback so unstamped URLs keep working — or point that route at `serveImmutableFile`
-too, which 302s bare paths into `/__immutable/<version>/` (zero config, at the cost
-of one redirect per page view).
+In the never-cached HTML shell, stamp the entry module:
+`immutableFileUrl("/frontend/index.tsx")` → `/__immutable/42/frontend/index.tsx`
+(42 = the val's current version). Relative imports resolve under the same prefix,
+so only the entry needs stamping.
+
+- Stamping skips the bare-path redirect; unstamped URLs still work, at one
+  redirect per page view.
+- Old-version URLs 404 after a publish (like Next.js build assets); a reload
+  picks up the new version.
 
 ### Alternative: serve directly from esm.town
 
diff --git a/plugin/skills/http-endpoints/SKILL.md b/plugin/skills/http-endpoints/SKILL.md
index 9330c8f..ce1d543 100644
--- a/plugin/skills/http-endpoints/SKILL.md
+++ b/plugin/skills/http-endpoints/SKILL.md
@@ -25,19 +25,16 @@ When using Hono, export `app.fetch` (not `app`):
 
 ```ts
 import { Hono } from "npm:hono";
-import { parseVal, serveFile, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
+import { parseVal, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
 const app = new Hono();
 
 app.get("/", (c) => c.text("hello"));
 
-// Serve frontend files versioned + immutably cached. The HTML shell stamps asset
-// URLs with immutableFileUrl("/frontend/index.tsx") → "/__immutable/42/frontend/index.tsx";
-// publishing bumps the version, so browsers refetch each asset exactly once.
+// Immutable asset caching (see the client-side-js skill): stamped current-version
+// URLs serve immutably, bare paths 302 into versioned space
 app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
-
-// Unstamped fallback, transpiled, with correct content types
-app.get("/frontend/**/*", (c) => serveFile(c.req.path));
+app.get("/frontend/**/*", (c) => serveImmutableFile(c.req.path));
 
 // View source redirect
 app.get("/source", (c) => c.redirect(parseVal().links.self.val));
diff --git a/plugin/skills/react-ui/SKILL.md b/plugin/skills/react-ui/SKILL.md
index 96ae971..dd7af34 100644
--- a/plugin/skills/react-ui/SKILL.md
+++ b/plugin/skills/react-ui/SKILL.md
@@ -38,25 +38,21 @@ Avoid inline `<style>` tags, CSS-in-JS objects, or separate `.css` files, unless
 
 ## Serving assets: versioned + immutable
 
-Serve client modules through `serveImmutableFile` from `std/utils` so repeat visits
-load them from the browser cache instead of re-transpiling per request (measured:
-repeat visits 665ms → 157ms, zero asset requests). A never-cached `frontend/root.tsx`
-shell component (hono/jsx) stamps the entry module and favicon URLs with
-`immutableFileUrl`; publishing the val bumps the version, which invalidates instantly:
+Serve client modules with `serveImmutableFile` from `std/utils` — browsers cache
+them immutably, and publishing bumps the val's version, which invalidates
+automatically (full pattern: the `client-side-js` skill). A never-cached
+`frontend/root.tsx` shell (hono/jsx) stamps the entry and favicon with
+`immutableFileUrl`:
 
 ```tsx
-import { immutableFileUrl, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
-
 // frontend/root.tsx — in the Root() HTML shell:
 <script src={immutableFileUrl("/frontend/index.tsx")} type="module" />
 
-// index.ts — the Hono app; current version → immutable cache, stale → 302 to current:
+// index.ts:
 app.get("/", (c) => c.html(Root()));
 app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
 ```
 
-See the `client-side-js` skill for how modules and their imports are served.
-
 ## View source link
 
 Every UI val should expose a way for users to see and remix its source. Both parts are required:

From 1f9738f0e722569707d6870e3c52abc3eac6af99 Mon Sep 17 00:00:00 2001
From: Steve Krouse <steveykrouse@gmail.com>
Date: Thu, 30 Jul 2026 10:12:21 -0400
Subject: [PATCH 4/4] Skills teach single-route immutable pattern; retrofit
 two-route as aside

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 plugin/skills/client-side-js/SKILL.md | 9 +++++----
 plugin/skills/http-endpoints/SKILL.md | 5 ++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/plugin/skills/client-side-js/SKILL.md b/plugin/skills/client-side-js/SKILL.md
index 029f956..a79dccc 100644
--- a/plugin/skills/client-side-js/SKILL.md
+++ b/plugin/skills/client-side-js/SKILL.md
@@ -51,18 +51,19 @@ automatically. Measured: repeat visits **665ms → 157ms with zero asset request
 import { immutableFileUrl, serveImmutableFile } from "https://esm.town/v/std/utils/index.ts";
 
 app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
-app.get("/frontend/**/*", (c) => serveImmutableFile(c.req.path)); // bare paths 302 into versioned space
 ```
 
 In the never-cached HTML shell, stamp the entry module:
 `immutableFileUrl("/frontend/index.tsx")` → `/__immutable/42/frontend/index.tsx`
 (42 = the val's current version). Relative imports resolve under the same prefix,
-so only the entry needs stamping.
+so only the entry needs stamping — one route and one stamped URL cover the whole
+client graph.
 
-- Stamping skips the bare-path redirect; unstamped URLs still work, at one
-  redirect per page view.
 - Old-version URLs 404 after a publish (like Next.js build assets); a reload
   picks up the new version.
+- Retrofitting an existing val without touching its shell? Also point its old
+  file route at `serveImmutableFile` — bare paths then 302 into versioned space,
+  at one redirect per page view.
 
 ### Alternative: serve directly from esm.town
 
diff --git a/plugin/skills/http-endpoints/SKILL.md b/plugin/skills/http-endpoints/SKILL.md
index ce1d543..bf3c4ff 100644
--- a/plugin/skills/http-endpoints/SKILL.md
+++ b/plugin/skills/http-endpoints/SKILL.md
@@ -31,10 +31,9 @@ const app = new Hono();
 
 app.get("/", (c) => c.text("hello"));
 
-// Immutable asset caching (see the client-side-js skill): stamped current-version
-// URLs serve immutably, bare paths 302 into versioned space
+// Immutable asset caching (see the client-side-js skill): serves the
+// current-version URLs your HTML shell stamps with immutableFileUrl()
 app.get("/__immutable/*", (c) => serveImmutableFile(c.req.path));
-app.get("/frontend/**/*", (c) => serveImmutableFile(c.req.path));
 
 // View source redirect
 app.get("/source", (c) => c.redirect(parseVal().links.self.val));