diff --git a/CLAUDE.md b/CLAUDE.md
index 001bd87..1b9aa8c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -130,8 +130,8 @@ Self-contained Playwright E2E — `npm test` auto-starts everything (no external
 
 Tests drive the host origin (`http://localhost:4201`). Suites (`tests/`):
 - `build-integrity.spec.js` — `dist/` output: both apps enumerated, absolute URL rewriting,
-  headless markup, stable `dist/style.css` (the marketplace CSS the sub-app pages reference),
-  and single-page bundle expansion (`tests/fixtures/single-page-bundle/` → two apps).
+  headless markup, the content-hashed marketplace stylesheet plus its stable `dist/style.css`
+  alias, and single-page bundle expansion (`tests/fixtures/single-page-bundle/` → two apps).
 - `web-fragment.spec.js` — shadow-DOM isolation (reframed `wf-html`/`wf-body`; chrome must
   not leak in), routing + smooth no-reload SPA transitions, cross-app navigation, asset
   loading (no host-origin 404s), and the documented history limitation (fragment routing is
@@ -140,7 +140,9 @@ Tests drive the host origin (`http://localhost:4201`). Suites (`tests/`):
 
 Two build-pipeline pieces support this: `apps.json` entries may carry a `prebuilt` path
 (tarball or dist dir) consumed by `scripts/build-vite.js` (`preparePrebuilt`) for hermetic
-offline builds; and the build aliases the bundled marketplace CSS to a stable `dist/style.css`.
+offline builds; and the build copies the marketplace stylesheet — identified as the local
+stylesheet the landing page loads — to a stable `dist/style.css` alias. Pages themselves
+reference the content-hashed bundle Astro injects, so nothing depends on that filename.
 
 An entry may also carry `"optional": true`: the build then skips it with a warning when its
 `prebuilt`/`localPath` artifact is missing, instead of failing. That is how the sibling
diff --git a/astro.config.mjs b/astro.config.mjs
index a4b78ac..1525eb1 100644
--- a/astro.config.mjs
+++ b/astro.config.mjs
@@ -25,15 +25,17 @@ export default defineConfig({
       },
     ],
     css: { modules: false },
-    build: {
-      rollupOptions: {
-        output: {
-          // Stable filename so sub-app pages can reference /{PREFIX}/style.css
-          assetFileNames: (info) =>
-            info.names?.some(n => n.endsWith('.css')) ? 'style.css' : '_astro/[name]-[hash][extname]',
-        },
-      },
-    },
+    // No assetFileNames override: CSS is content-hashed like every other asset.
+    //
+    // This used to force the name "style.css" onto every CSS asset so that
+    // /{PREFIX}/style.css was a fixed path. Nothing needs a fixed path — the
+    // <link> on every page is injected by Astro from Base.astro's CSS import, so
+    // it always carries whatever name the bundle was given. Forcing a constant
+    // name only made Rollup disambiguate collisions as style.css / style2.css,
+    // which the build then had to guess between, and it defeated cache-busting
+    // for the one stylesheet every page loads (#50). scripts/build-vite.js still
+    // publishes dist/style.css as an alias of this bundle for anything outside
+    // this repository that refers to it by that path.
   },
 });
 
diff --git a/package-lock.json b/package-lock.json
index 9f74cab..7f8626c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,7 +8,8 @@
       "name": "knowledge-base",
       "version": "1.0.0",
       "dependencies": {
-        "ajv": "^8.17.1"
+        "ajv": "^8.17.1",
+        "parse5": "^7.3.0"
       },
       "devDependencies": {
         "@astrojs/check": "^0.9.10",
@@ -3569,7 +3570,6 @@
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
       "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
-      "dev": true,
       "license": "BSD-2-Clause",
       "engines": {
         "node": ">=0.12"
@@ -5117,7 +5117,6 @@
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
       "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "entities": "^6.0.0"
diff --git a/package.json b/package.json
index 8acd925..cd06e7d 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,8 @@
     "test:container": "npx playwright test --config=playwright.config.docker.js"
   },
   "dependencies": {
-    "ajv": "^8.17.1"
+    "ajv": "^8.17.1",
+    "parse5": "^7.3.0"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",
diff --git a/scripts/build-vite.js b/scripts/build-vite.js
index 021914b..5bc0e89 100644
--- a/scripts/build-vite.js
+++ b/scripts/build-vite.js
@@ -238,16 +238,19 @@ async function build() {
   //     when those repos re-publish — so it is fixed here rather than assumed.
   step('1b/4  Hoisting inline scripts → files');
   let hoisted = 0;
+  let droppedBootstraps = 0;
   for (const app of resolvedApps.filter(a => a.type !== 'iframe')) {
     const appDir = join(APPS_DIR, app.slug);
     if (!existsSync(appDir)) continue;
-    const count = hoistAppInlineScripts(appDir, collectHtmlFiles(appDir));
-    if (count > 0) {
-      hoisted += count;
-      ok(app.slug + ': ' + count + ' inline script(s) → ' + HOIST_DIR + '/');
-    }
+    const { hoisted: count, dropped } = hoistAppInlineScripts(appDir, collectHtmlFiles(appDir));
+    hoisted += count;
+    droppedBootstraps += dropped;
+    if (count > 0) ok(app.slug + ': ' + count + ' inline script(s) → ' + HOIST_DIR + '/');
+    // Light-only: a hoisted theme bootstrap would run and re-add `dark`, so it
+    // is deleted here instead — transform.js can only strip it while inline.
+    if (dropped > 0) ok(app.slug + ': ' + dropped + ' theme bootstrap(s) dropped (light-only)');
   }
-  if (hoisted === 0) log('No inline scripts found — every artifact is already CSP-clean');
+  if (hoisted === 0 && droppedBootstraps === 0) log('No inline scripts found — every artifact is already CSP-clean');
 
   // 2. Copy non-HTML sub-app assets → public/{slug}/ so Astro copies them to dist/{slug}/
   //    HTML files are excluded — they're handled by src/pages/[...path].astro.
@@ -261,23 +264,36 @@ async function build() {
     if (existsSync(slugDir)) rmSync(slugDir, { recursive: true });
   }
 
-  function copyAssets(src, dest) {
+  /**
+   * Copies a sub-app's non-HTML assets, rewriting root-relative CSS url()
+   * references on the way through.
+   *
+   * A sub-app's CSS is authored for the root of its own site, so `url(/fonts/x)`
+   * means "this app's /fonts/x" — but the app is served from
+   * /{prefix}/{slug}/. The rewrite targets that absolute path directly rather
+   * than a relative hop: a relative `../` is only correct for a stylesheet
+   * exactly one directory deep, and copyAssets recurses to every depth, so
+   * `{slug}/style.css` used to climb out of the app entirely and
+   * `{slug}/assets/css/a.css` landed one level short (#49). An absolute target
+   * needs no depth arithmetic and matches what transform.js does for HTML.
+   */
+  function copyAssets(src, dest, slug) {
     mkdirSync(dest, { recursive: true });
     for (const entry of readdirSync(src).sort()) {
       const s = join(src, entry);
       const d = join(dest, entry);
-      if (statSync(s).isDirectory()) copyAssets(s, d);
+      if (statSync(s).isDirectory()) copyAssets(s, d, slug);
       else if (!entry.endsWith('.html')) {
         copyFileSync(s, d);
-        // Rewrite root-relative url() references in CSS bundles so they resolve
-        // correctly when served from a sub-path (e.g. /knowledge-base/{slug}/_astro/).
-        // Astro/Vite preserves absolute url(/) paths verbatim; from _astro/*.css
-        // one level up (../) is the slug root, so ../fonts/ becomes
-        // /knowledge-base/{slug}/fonts/ — matching where static assets are served.
         if (entry.endsWith('.css')) {
-          let css = readFileSync(d, 'utf8');
-          // url(/path) | url('/path') | url("/path") → url(../path) etc.
-          const rewritten = css.replace(/url\(\s*(['"]?)\/(?!\/)/g, 'url($1../');
+          const css = readFileSync(d, 'utf8');
+          // url(/path) | url('/path') | url("/path") → url(/{prefix}/{slug}/path).
+          // The (?!\/) guard skips protocol-relative //host/…; data: and #ref
+          // never match, since neither starts with a slash.
+          const rewritten = css.replace(
+            /url\(\s*(['"]?)\/(?!\/)/g,
+            'url($1/' + PATH_PREFIX + '/' + slug + '/',
+          );
           if (rewritten !== css) writeFileSync(d, rewritten);
         }
       }
@@ -287,7 +303,7 @@ async function build() {
   for (const app of packagedResolved) {
     const srcDir = join(APPS_DIR, app.slug);
     if (!existsSync(srcDir)) { warn(app.slug + ': apps/ dir missing, skipping asset copy'); continue; }
-    copyAssets(srcDir, join(PUBLIC_ROOT, app.slug));
+    copyAssets(srcDir, join(PUBLIC_ROOT, app.slug), app.slug);
     ok(app.slug + ' assets → public/' + app.slug + '/');
   }
 
@@ -301,21 +317,38 @@ async function build() {
   execSync('npx astro build', { cwd: ROOT, stdio: 'inherit', env });
   ok('Astro build complete');
 
-  // Sub-app pages hardcode the marketplace stylesheet at /__wf/{prefix}/style.css,
-  // which the gateway/nginx/preview rewrite to /{prefix}/style.css → dist/style.css.
-  // Astro can emit that bundle with a numeric suffix (e.g. style2.css) when the
-  // forced "style.css" asset name clashes, which would 404 the sub-app CSS. Alias
-  // the bundled css to a stable dist/style.css so the reference always resolves.
-  const distRoot  = join(ROOT, 'dist');
-  const stableCss = join(distRoot, 'style.css');
-  if (existsSync(distRoot) && !existsSync(stableCss)) {
-    const rootCss = readdirSync(distRoot).filter(f => /^style\d*\.css$/.test(f));
-    if (rootCss.length > 0) {
-      copyFileSync(join(distRoot, rootCss[0]), stableCss);
-      ok('Marketplace CSS aliased ' + rootCss[0] + ' → style.css');
-    } else {
-      warn('No bundled marketplace CSS at dist root — /' + PATH_PREFIX + '/style.css may 404');
+  // Publish dist/style.css as an alias of the marketplace stylesheet.
+  //
+  // Pages do not need it: Astro injects the <link> from Base.astro's CSS import,
+  // with whatever content-hashed name the bundle got. The alias exists because
+  // /{prefix}/style.css is a URL this deployment has served for a long time and
+  // something outside this repository may still ask for it.
+  //
+  // The bundle is identified by *use*, not by filename: it is the local
+  // stylesheet the marketplace's own landing page loads. That is the definition
+  // of "the marketplace stylesheet", and it cannot drift from what the pages
+  // actually reference the way a filename pattern could (#50).
+  const distRoot = join(ROOT, 'dist');
+  if (existsSync(distRoot)) {
+    const landing = join(distRoot, 'index.html');
+    if (!existsSync(landing)) fail('No dist/index.html — the landing page did not build.');
+
+    const hrefs = [...readFileSync(landing, 'utf8').matchAll(/<link\b[^>]*\brel="stylesheet"[^>]*>/gi)]
+      .map(tag => tag[0].match(/\bhref="([^"]+)"/)?.[1])
+      .filter(href => href?.startsWith('/' + PATH_PREFIX + '/'));
+
+    if (hrefs.length !== 1) {
+      fail(
+        'Expected the landing page to load exactly one local stylesheet — the marketplace bundle — ' +
+        'but found ' + hrefs.length + (hrefs.length ? ': ' + hrefs.join(', ') : '') +
+        '. dist/style.css can only alias an unambiguous one.',
+      );
     }
+
+    const bundle = join(distRoot, hrefs[0].slice(('/' + PATH_PREFIX).length));
+    if (!existsSync(bundle)) fail('The landing page references ' + hrefs[0] + ', which is not in dist/.');
+    copyFileSync(bundle, join(distRoot, 'style.css'));
+    ok('Marketplace CSS ' + hrefs[0] + ' aliased → dist/style.css');
   }
 
   // 4. Summary
diff --git a/scripts/hoist-inline-scripts.js b/scripts/hoist-inline-scripts.js
index 6b180b9..f0d891f 100644
--- a/scripts/hoist-inline-scripts.js
+++ b/scripts/hoist-inline-scripts.js
@@ -27,11 +27,20 @@
  * Only executable scripts are hoisted. `application/ld+json`, `text/template`,
  * `importmap` and friends are data, not code — a CSP does not care about them
  * and moving them would break whatever reads them.
+ *
+ * WHAT IS DELETED
+ *
+ * A sub-app's dark-mode bootstrap is dropped rather than hoisted. The
+ * marketplace is light-only and src/utils/transform.js strips that script — but
+ * only while it is still inline, and this step runs first. Hoisting it would
+ * turn it into an external file the strip can no longer recognise, and it would
+ * then run in the browser and re-add `dark` (#48).
  */
 
 import { createHash } from 'node:crypto';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
+import { isThemeBootstrap } from '../src/utils/transform.js';
 
 /** Directory (relative to an app root) the hoisted files are written to. */
 export const HOIST_DIR = '_kb-inline';
@@ -52,10 +61,11 @@ function isExecutableInline(attrs) {
  * @param {string} html       - document source
  * @param {string} appDir     - app root on disk; hoisted files go under appDir/HOIST_DIR
  * @param {string} fileRelDir - the document's directory relative to appDir ('' at the root)
- * @returns {{html: string, written: number}}
+ * @returns {{html: string, written: number, dropped: number}}
  */
 export function hoistInlineScripts(html, appDir, fileRelDir) {
   let written = 0;
+  let dropped = 0;
 
   const out = html.replace(
     /<script\b([^>]*)>([\s\S]*?)<\/script>/gi,
@@ -63,6 +73,9 @@ export function hoistInlineScripts(html, appDir, fileRelDir) {
       if (!isExecutableInline(attrs)) return match;
       if (body.trim() === '') return match;
 
+      // Light-only: the theme bootstrap is deleted, not relocated.
+      if (isThemeBootstrap(body)) { dropped++; return ''; }
+
       // Content-addressed: two pages sharing a bootstrap share one file, and a
       // rebuild of unchanged input produces an unchanged name.
       const hash = createHash('sha256').update(body).digest('hex').slice(0, 16);
@@ -81,7 +94,7 @@ export function hoistInlineScripts(html, appDir, fileRelDir) {
     },
   );
 
-  return { html: out, written };
+  return { html: out, written, dropped };
 }
 
 /**
@@ -89,18 +102,21 @@ export function hoistInlineScripts(html, appDir, fileRelDir) {
  *
  * @param {string} appDir    - apps/{slug}
  * @param {string[]} htmlFiles - absolute paths to that app's HTML files
- * @returns {number} how many scripts were hoisted
+ * @returns {{hoisted: number, dropped: number}} scripts moved to files, and theme
+ *          bootstraps deleted
  */
 export function hoistAppInlineScripts(appDir, htmlFiles) {
-  let total = 0;
+  let hoisted = 0;
+  let dropped = 0;
   for (const file of htmlFiles) {
     const fileRelDir = relative(appDir, dirname(file)).replace(/\\/g, '/');
     const source = readFileSync(file, 'utf8');
-    const { html, written } = hoistInlineScripts(source, appDir, fileRelDir === '.' ? '' : fileRelDir);
-    if (written > 0) {
-      writeFileSync(file, html);
-      total += written;
+    const result = hoistInlineScripts(source, appDir, fileRelDir === '.' ? '' : fileRelDir);
+    if (result.written > 0 || result.dropped > 0) {
+      writeFileSync(file, result.html);
+      hoisted += result.written;
+      dropped += result.dropped;
     }
   }
-  return total;
+  return { hoisted, dropped };
 }
diff --git a/scripts/setup-test-apps.mjs b/scripts/setup-test-apps.mjs
index aec59f8..7ab008f 100644
--- a/scripts/setup-test-apps.mjs
+++ b/scripts/setup-test-apps.mjs
@@ -110,6 +110,25 @@ const MERMAID_STUB = `/* Test fixture stand-in for the vendored mermaid bundle.
 window.mermaid = { initialize: function () {}, run: function () {} };
 `;
 
+/**
+ * Regression fixture for #49 — a stylesheet two directories deep that references
+ * assets from its app root.
+ *
+ * The build rewrites root-relative `url()` in copied CSS so it still resolves
+ * once the app is served from /{prefix}/{slug}/. That rewrite used to hardcode a
+ * single `../` hop, which is only correct at exactly one level of nesting: from
+ * `{slug}/assets/` it pointed one directory short, and from `{slug}/` it climbed
+ * out of the app and into another one's assets. Nothing shipped by the action
+ * happens to use `url(/…)` today, so without this file the rewrite is untested
+ * at the depth it got wrong. Asserted by tests/build-integrity.spec.js.
+ */
+const DEPTH_CHECK_CSS = `/* Fixture: see scripts/setup-test-apps.mjs (#49). Not referenced by the doc. */
+@font-face { font-family: Demo; src: url(/fonts/demo.woff2) format("woff2"); }
+.a { background-image: url(data:image/gif;base64,R0lGOD); }
+.b { clip-path: url(#clip); }
+.c { background-image: url(//cdn.example.com/x.png); }
+`;
+
 const bundleDocs = [
   {
     slug: 'platform-overview',
@@ -119,6 +138,7 @@ const bundleDocs = [
     tags: ['platform', 'reference'],
     body: PLATFORM_OVERVIEW_BODY,
     usesMermaid: true,
+    depthFixture: true,
   },
   {
     slug: 'release-process',
@@ -147,6 +167,7 @@ function writeSinglePageBundle() {
       hasHeading:  true,
     }));
     writeFileSync(join(docDir, CSS_PATH), DOC_CSS);
+    if (doc.depthFixture) writeFileSync(join(docDir, dirname(CSS_PATH), 'depth-check.css'), DEPTH_CHECK_CSS);
     if (doc.usesMermaid) {
       writeFileSync(join(docDir, MERMAID_PATH), MERMAID_STUB);
       // Real init script, not a stub: it is the thing that must stay out of the
diff --git a/src/utils/transform.js b/src/utils/transform.js
index 95db714..c844a11 100644
--- a/src/utils/transform.js
+++ b/src/utils/transform.js
@@ -7,6 +7,21 @@
 // the layout owns the masthead, fonts, marketplace CSS and <ClientRouter /> for
 // every page. This module rewrites the sub-app URLs and splits the document into
 // the parts the layout needs.
+//
+// WHY A PARSER AND NOT REGEXES
+//
+// The input is third-party HTML from another repository's release artifact, so
+// every "surely no document does that" assumption a regex makes eventually meets
+// a document that does. Pattern matching got this wrong four ways (#48):
+// a `</body>` inside a script truncated the page, a `<` inside the theme
+// bootstrap defeated the strip that keeps the marketplace light-only, several
+// URL-bearing attributes were never rewritten, and `href="/x"` inside a code
+// sample in the prose was rewritten as if it were a link. parse5 is the same
+// tokenizer a browser uses, it is build-time only, and it knows the difference
+// between an attribute, a comment and a text node — so all four stop being
+// possible rather than being patched one at a time.
+
+import { parse, serialize } from 'parse5';
 
 // ── URL rewriting ─────────────────────────────────────────────────────────────
 
@@ -32,68 +47,96 @@ function resolveUrl(url, base, prefix, slug) {
   }
 }
 
+/** Attributes holding exactly one URL. `data` is handled separately — it is only a URL on <object>. */
+const URL_ATTRS = new Set(['href', 'src', 'action', 'formaction', 'poster']);
+
+/** Attributes holding a comma-separated candidate list (`url 2x, url 640w`). */
+const SRCSET_ATTRS = new Set(['srcset', 'imagesrcset']);
+
+/** <meta> property/name values whose `content` is a URL. */
+const URL_META = new Set([
+  'og:image', 'og:image:url', 'og:image:secure_url', 'og:url',
+  'twitter:image', 'twitter:image:src',
+]);
+
+/** Rewrites every `url(...)` reference in a CSS string (inline `style=` or a <style> block). */
+function rewriteCssUrls(css, base, prefix, slug) {
+  return css.replace(
+    /url\(\s*(['"]?)([^'")]*)\1\s*\)/gi,
+    (match, quote, url) => {
+      const abs = resolveUrl(url.trim(), base, prefix, slug);
+      return abs === null ? match : `url(${quote}${abs}${quote})`;
+    },
+  );
+}
+
 /**
- * Rewrites all href/src/action URLs in the HTML to absolute paths.
- * Removes any pre-existing <base> tag.
- *
- * @param {string} html
- * @param {string} prefix  - e.g. 'knowledge-base'
- * @param {string} slug    - app slug, e.g. 'my-app'
- * @param {string} fileRelDir - path of the HTML file relative to the app root,
- *                              e.g. '' for index.html, 'getting-started' for
- *                              getting-started/index.html
+ * Rewrites a `srcset` value candidate by candidate, preserving the descriptors.
+ * A value containing a `data:` URI is left alone: commas inside the payload make
+ * splitting ambiguous, and data: URIs need no rewriting anyway.
  */
-function rewriteUrlsToAbsolute(html, prefix, slug, fileRelDir) {
-  const base = `/${prefix}/${slug}/${fileRelDir ? fileRelDir + '/' : ''}`;
+function rewriteSrcset(value, base, prefix, slug) {
+  if (/data:/i.test(value)) return value;
+  return value
+    .split(',')
+    .map((candidate) => {
+      const match = candidate.match(/^(\s*)(\S+)(\s*.*)$/s);
+      if (!match) return candidate;
+      const [, lead, url, descriptor] = match;
+      const abs = resolveUrl(url, base, prefix, slug);
+      return abs === null ? candidate : `${lead}${abs}${descriptor}`;
+    })
+    .join(',');
+}
 
-  // Remove any <base> tag — all URLs are now explicit
-  html = html.replace(/<base\b[^>]*>/gi, '');
+// ── Tree helpers ──────────────────────────────────────────────────────────────
 
-  // Double-quoted attributes
-  html = html.replace(
-    /((?:href|src|action)\s*=\s*")([^"]*?)(")/gi,
-    (match, pre, url, post) => {
-      const abs = resolveUrl(url, base, prefix, slug);
-      return abs !== null ? `${pre}${abs}${post}` : match;
-    },
-  );
+const attrOf = (el, name) => el?.attrs?.find((a) => a.name === name);
+const attrValue = (el, name) => attrOf(el, name)?.value;
 
-  // Single-quoted attributes
-  html = html.replace(
-    /((?:href|src|action)\s*=\s*')([^']*?)(')/gi,
-    (match, pre, url, post) => {
-      const abs = resolveUrl(url, base, prefix, slug);
-      return abs !== null ? `${pre}${abs}${post}` : match;
-    },
-  );
+/** Depth-first walk over every element in the tree, including <template> content. */
+function* elements(node) {
+  for (const child of node.childNodes ?? []) {
+    if (child.tagName) {
+      yield child;
+      if (child.content) yield* elements(child.content);
+    }
+    yield* elements(child);
+  }
+}
 
-  return html;
+/** Concatenated text of a node's direct text children (what <script>/<title> hold). */
+function textOf(node) {
+  return (node.childNodes ?? [])
+    .filter((c) => c.nodeName === '#text')
+    .map((c) => c.value)
+    .join('');
 }
 
-/**
- * Adds data-astro-transition-persist to every stylesheet <link> so Astro's
- * ClientRouter keeps them in place across page transitions instead of removing
- * and re-adding them. Inside web-fragments, reframed relocates head nodes out of
- * wf-head, so Astro's cleanup can no longer find them and they accumulate
- * unbounded — see web-fragments issue #297.
- */
-function persistStylesheets(html) {
-  return html.replace(
-    /<link(\s[^>]*rel\s*=\s*["']stylesheet["'][^>]*)>/gi,
-    (match, attrs) => {
-      if (attrs.includes('data-astro-transition-persist')) return match;
-      const hrefMatch = attrs.match(/href\s*=\s*["']([^"']+)["']/i);
-      if (!hrefMatch) return match;
-      const id = 'css-' + hrefMatch[1].replace(/[^a-z0-9]/gi, '-').replace(/-{2,}/g, '-').replace(/^-|-$/g, '');
-      const cleanAttrs = attrs.replace(/\s*\/\s*$/, ''); // drop trailing / from self-closing tags
-      return `<link${cleanAttrs} data-astro-transition-persist="${id}">`;
-    },
-  );
+function detach(node) {
+  const siblings = node.parentNode?.childNodes;
+  const index = siblings?.indexOf(node) ?? -1;
+  if (index >= 0) siblings.splice(index, 1);
 }
 
-/** Strips a sub-app's own `localStorage` theme bootstrap — the marketplace is light-only. */
-function stripThemeBootstrap(html) {
-  return html.replace(/<script>[^<]*localStorage[^<]*classList[^<]*<\/script>\s*/gi, '');
+const childElement = (node, tagName) =>
+  (node?.childNodes ?? []).find((c) => c.tagName === tagName);
+
+// ── Light-only enforcement ────────────────────────────────────────────────────
+
+/**
+ * True when a script body is a sub-app's own dark-mode bootstrap.
+ *
+ * Exported because the strip has to happen in two places: here for the `astro
+ * dev` path, and in scripts/hoist-inline-scripts.js for the build, which turns
+ * inline scripts into files before this module ever sees the document — a
+ * hoisted bootstrap would otherwise sail past the strip and re-add `dark` at
+ * runtime, which is exactly the leak the light-only rule exists to prevent.
+ */
+export function isThemeBootstrap(code) {
+  return /\blocalStorage\b/.test(code) &&
+         /\bclassList\b/.test(code) &&
+         /\bdark\b|\btheme\b/i.test(code);
 }
 
 // ── Sub-app HTML transformation ───────────────────────────────────────────────
@@ -103,7 +146,8 @@ function stripThemeBootstrap(html) {
  * needs to re-host it.
  *
  * Steps (in order):
- *  1. Rewrite all relative/root-relative URLs to absolute /{prefix}/{slug}/… paths
+ *  1. Rewrite every URL-bearing attribute to an absolute /{prefix}/{slug}/… path
+ *     and drop any <base> tag
  *  2. Stamp data-astro-transition-persist on every stylesheet link
  *  3. Split off <head> contents, <body> attributes and <body> contents
  *  4. Lift the <title> out of the head (the layout renders it)
@@ -117,37 +161,90 @@ function stripThemeBootstrap(html) {
  * @returns {{headHtml: string, bodyHtml: string, bodyClass: string, title: string|null}}
  */
 export function transformSubAppHtml(html, slug, fileRelDir, prefix) {
-  html = rewriteUrlsToAbsolute(html, prefix, slug, fileRelDir);
-  html = persistStylesheets(html);
-
-  const headMatch = html.match(/<head\b[^>]*>([\s\S]*?)<\/head>/i);
-  const bodyMatch = html.match(/<body\b([^>]*)>([\s\S]*?)<\/body>/i);
+  const base = `/${prefix}/${slug}/${fileRelDir ? fileRelDir + '/' : ''}`;
 
-  let headHtml = headMatch ? headMatch[1] : '';
-  const bodyAttrs = bodyMatch ? bodyMatch[1] : '';
-  // Documents without an explicit <body> are treated as body-only fragments.
-  let bodyHtml = bodyMatch
-    ? bodyMatch[2]
-    : (headMatch ? html.replace(headMatch[0], '') : html);
+  // parse() always yields html > head + body, so a document that ships no
+  // explicit <body> is split the same way a browser would split it — no
+  // "body-only fragment" special case, and no first-`</body>`-wins truncation.
+  const document = parse(html);
+  const root = childElement(document, 'html');
+  const head = childElement(root, 'head');
+  const body = childElement(root, 'body');
+
+  const doomed = [];
+
+  for (const el of elements(root ?? document)) {
+    // 1. URLs. Only attributes of real elements are touched, so a `href="/x"`
+    //    written out in a code sample stays the string the author typed.
+    if (el.tagName === 'base') { doomed.push(el); continue; }
+
+    for (const attr of el.attrs ?? []) {
+      if (URL_ATTRS.has(attr.name) || (attr.name === 'data' && el.tagName === 'object')) {
+        const abs = resolveUrl(attr.value, base, prefix, slug);
+        if (abs !== null) attr.value = abs;
+      } else if (SRCSET_ATTRS.has(attr.name)) {
+        attr.value = rewriteSrcset(attr.value, base, prefix, slug);
+      } else if (attr.name === 'style') {
+        attr.value = rewriteCssUrls(attr.value, base, prefix, slug);
+      } else if (attr.name === 'content' && el.tagName === 'meta') {
+        const key = (attrValue(el, 'property') ?? attrValue(el, 'name') ?? '').toLowerCase();
+        if (URL_META.has(key)) {
+          const abs = resolveUrl(attr.value, base, prefix, slug);
+          if (abs !== null) attr.value = abs;
+        }
+      }
+    }
+
+    if (el.tagName === 'style') {
+      for (const text of el.childNodes ?? []) {
+        if (text.nodeName === '#text') text.value = rewriteCssUrls(text.value, base, prefix, slug);
+      }
+    }
+
+    // 2. Keep stylesheets in place across ClientRouter navigation. Inside
+    //    web-fragments, reframed relocates head nodes out of wf-head, so Astro's
+    //    cleanup can no longer find them and they accumulate unbounded — see
+    //    web-fragments issue #297.
+    if (el.tagName === 'link' && /\bstylesheet\b/i.test(attrValue(el, 'rel') ?? '')) {
+      const href = attrValue(el, 'href');
+      if (href && !attrOf(el, 'data-astro-transition-persist')) {
+        const id = 'css-' + href.replace(/[^a-z0-9]/gi, '-').replace(/-{2,}/g, '-').replace(/^-|-$/g, '');
+        el.attrs.push({ name: 'data-astro-transition-persist', value: id });
+      }
+    }
+
+    // 6a. Light-only marketplace: the sub-app's theme bootstrap never runs.
+    if (el.tagName === 'script' && !attrOf(el, 'src') && isThemeBootstrap(textOf(el))) {
+      doomed.push(el);
+      continue;
+    }
+
+    // 5. Base.astro already declares both; a second <meta charset> is ignored anyway.
+    if (el.tagName === 'meta' &&
+        (attrOf(el, 'charset') || (attrValue(el, 'name') ?? '').toLowerCase() === 'viewport')) {
+      doomed.push(el);
+    }
+  }
 
-  // The layout renders <title> from the manifest title or this one.
+  // 4. The layout renders <title> from the manifest title or this one.
   let title = null;
-  headHtml = headHtml.replace(/<title\b[^>]*>([\s\S]*?)<\/title>/i, (_, t) => {
-    title = t.replace(/\s+/g, ' ').trim() || null;
-    return '';
-  });
-
-  // Base.astro already declares both; a second <meta charset> is ignored anyway.
-  headHtml = headHtml.replace(/<meta\b[^>]*\bcharset\b[^>]*>/gi, '');
-  headHtml = headHtml.replace(/<meta\b[^>]*name\s*=\s*["']viewport["'][^>]*>/gi, '');
-
-  // Light-only marketplace: drop the sub-app's theme bootstrap and `dark` class.
-  headHtml = stripThemeBootstrap(headHtml);
-  bodyHtml = stripThemeBootstrap(bodyHtml);
-  const bodyClass = (bodyAttrs.match(/class\s*=\s*["']([^"']*)["']/i)?.[1] ?? '')
+  const titleEl = childElement(head, 'title');
+  if (titleEl) {
+    title = textOf(titleEl).replace(/\s+/g, ' ').trim() || null;
+    doomed.push(titleEl);
+  }
+
+  for (const el of doomed) detach(el);
+
+  const bodyClass = (attrValue(body, 'class') ?? '')
     .replace(/\bdark\b/g, '')
     .replace(/\s+/g, ' ')
     .trim();
 
-  return { headHtml: headHtml.trim(), bodyHtml, bodyClass, title };
+  return {
+    headHtml: head ? serialize(head).trim() : '',
+    bodyHtml: body ? serialize(body) : '',
+    bodyClass,
+    title,
+  };
 }
diff --git a/tests/build-integrity.spec.js b/tests/build-integrity.spec.js
index 646f85b..480359c 100644
--- a/tests/build-integrity.spec.js
+++ b/tests/build-integrity.spec.js
@@ -14,11 +14,25 @@ import { test, expect } from '@playwright/test';
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, relative } from 'node:path';
+import { isThemeBootstrap } from '../src/utils/transform.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const DIST = join(ROOT, 'dist');
 const read = (rel) => readFileSync(join(DIST, rel), 'utf8');
 
+/**
+ * The marketplace stylesheet a page loads. Astro injects this <link> from
+ * Base.astro's CSS import, so the name is content-hashed and changes whenever
+ * the stylesheet does — assert the shape, never a literal filename.
+ */
+function marketplaceCssHref(html) {
+  const href = [...html.matchAll(/<link\b[^>]*\brel="stylesheet"[^>]*>/gi)]
+    .map((tag) => tag[0].match(/\bhref="([^"]+)"/)?.[1])
+    .find((h) => h?.startsWith('/knowledge-base/_astro/'));
+  expect(href, 'page does not load the marketplace stylesheet').toBeTruthy();
+  return href;
+}
+
 test.describe('Build integrity', () => {
   test('produced dist/ with the landing page', () => {
     expect(existsSync(DIST), 'dist/ should exist after build').toBe(true);
@@ -40,11 +54,13 @@ test.describe('Build integrity', () => {
     }
   });
 
-  test('marketplace stylesheet is emitted at the stable /style.css name', () => {
-    // Every page references /knowledge-base/style.css → dist/style.css (the gateway
-    // also reaches it via /__wf/knowledge-base/style.css). It must exist or every
-    // fragment page 404s its CSS.
-    expect(existsSync(join(DIST, 'style.css')), 'dist/style.css missing — sub-app CSS would 404').toBe(true);
+  test('the marketplace stylesheet is published at the stable /style.css alias too', () => {
+    // Pages reference the content-hashed bundle; /knowledge-base/style.css stays
+    // available as an alias of the same bytes for anything outside this
+    // repository that still asks for it by that path.
+    expect(existsSync(join(DIST, 'style.css')), 'dist/style.css alias missing').toBe(true);
+    expect(read('style.css'), 'the alias is not a copy of the bundle the pages load')
+      .toBe(read(marketplaceCssHref(read('index.html')).slice('/knowledge-base/'.length)));
   });
 
   test('landing lists both app cards with absolute slug links', () => {
@@ -58,7 +74,7 @@ test.describe('Build integrity', () => {
   test('sub-app pages are marked headless and reference the marketplace CSS', () => {
     const html = read('user-guide/index.html');
     expect(html).toContain('data-mp-headless="true"');
-    expect(html).toContain('/knowledge-base/style.css');
+    expect(marketplaceCssHref(html)).toMatch(/\.css$/);
   });
 
   test('sub-app pages are re-hosted by the layout, keeping their own head + body', () => {
@@ -160,7 +176,7 @@ test.describe('single-page onboarding', () => {
   test('is re-hosted by the layout like any packaged page', () => {
     const html = read('platform-overview/index.html');
     expect(html).toContain('data-mp-headless="true"');
-    expect(html).toContain('/knowledge-base/style.css');
+    expect(marketplaceCssHref(html)).toMatch(/\.css$/);
     expect(html.match(/<html\b/gi) ?? []).toHaveLength(1);
     expect(html.match(/<head\b/gi) ?? []).toHaveLength(1);
     expect(html.match(/<body\b/gi) ?? []).toHaveLength(1);
@@ -305,16 +321,68 @@ test.describe('no inline scripts in the build output', () => {
   });
 
   test('hoisted scripts are referenced by absolute prefixed paths', () => {
-    // A nested page: the fixture's inline scripts live on inner pages, so this
+    // A nested page: the fixture's inline script lives on an inner page, so this
     // also covers the ../ depth computation — a hoisted script referenced from
-    // user-guide/docs/ must still resolve to the app root, not one level up.
-    const html = read('user-guide/docs/index.html');
+    // user-guide/admin/ must still resolve to the app root, not one level up.
+    const html = read('user-guide/admin/index.html');
     const srcs = [...html.matchAll(/<script[^>]+src="([^"]+)"/g)].map((m) => m[1]);
     const hoisted = srcs.filter((s) => s.includes('_kb-inline'));
-    expect(hoisted.length, 'user-guide/docs should reference hoisted scripts').toBeGreaterThan(0);
+    expect(hoisted.length, 'user-guide/admin should reference hoisted scripts').toBeGreaterThan(0);
     for (const src of hoisted) {
       expect(src, 'hoisted script must be rewritten like every other URL').toMatch(/^\/knowledge-base\/user-guide\/_kb-inline\//);
       expect(existsSync(join(DIST, src.replace(/^\/knowledge-base\//, ''))), `${src} is not in dist/`).toBe(true);
     }
   });
+
+  test('the sub-app theme bootstrap is deleted, not hoisted into a file', () => {
+    // The docs-example fixture ships a `localStorage`-driven dark-mode bootstrap.
+    // Hoisting it would turn it into an external script the light-only strip can
+    // no longer see, and it would then re-add `dark` in the browser (#48).
+    const offenders = htmlFiles(DIST)
+      .flatMap((file) => {
+        const html = readFileSync(file, 'utf8');
+        const srcs = [...html.matchAll(/<script[^>]+src="([^"]+)"/g)].map((m) => m[1]);
+        return srcs
+          .filter((s) => s.includes('_kb-inline'))
+          .map((s) => join(DIST, s.replace(/^\/knowledge-base\//, '')))
+          .filter((p) => existsSync(p) && isThemeBootstrap(readFileSync(p, 'utf8')))
+          .map((p) => `${relative(DIST, file)} → ${relative(DIST, p)}`);
+      });
+    expect(offenders, 'a theme bootstrap survived as a hoisted file — the page can still go dark').toEqual([]);
+  });
+});
+
+// ── CSS asset handling (#49, #50) ───────────────────────────────────────────
+test.describe('stylesheet emission', () => {
+  test('the marketplace stylesheet is content-hashed, not pinned to a constant name', () => {
+    // Forcing "style.css" onto every CSS asset made Rollup disambiguate the
+    // collisions as style.css / style2.css / …, which the build then had to
+    // guess between — and it left the one stylesheet every page loads unable to
+    // be cache-busted (#50). Every page's <link> is Astro-injected, so nothing
+    // needed the constant name in the first place.
+    expect(marketplaceCssHref(read('index.html')))
+      .toMatch(/^\/knowledge-base\/_astro\/[^/]+\.[A-Za-z0-9_-]{8,}\.css$/);
+    expect(readdirSync(DIST).filter((f) => /^style\d+\.css$/.test(f)),
+      'a style2.css means two bundles collided on one name again').toEqual([]);
+  });
+
+  test('every CSS asset carries a content hash', () => {
+    const astroDir = join(DIST, '_astro');
+    const unhashed = (existsSync(astroDir) ? readdirSync(astroDir) : [])
+      .filter((f) => f.endsWith('.css') && !/[.-][A-Za-z0-9_-]{8,}\.css$/.test(f));
+    expect(unhashed, 'an unhashed CSS asset cannot be cached immutably').toEqual([]);
+  });
+
+  test('root-relative url() in sub-app CSS is rebased onto the app, at any depth', () => {
+    // The rewrite used to hardcode `../`, which is only correct for a stylesheet
+    // exactly one directory deep; from {slug}/assets/ it pointed outside the app
+    // and from {slug}/ it escaped the app entirely (#49).
+    const css = read('platform-overview/assets/depth-check.css');
+    expect(css).toContain('url(/knowledge-base/platform-overview/fonts/demo.woff2)');
+    expect(css, 'a relative hop from assets/ resolves outside the app').not.toContain('url(../');
+    // Untouched forms stay untouched.
+    expect(css).toContain('url(data:image/gif;base64,R0lGOD)');
+    expect(css).toContain('url(#clip)');
+    expect(css).toContain('url(//cdn.example.com/x.png)');
+  });
 });
diff --git a/tests/container.spec.js b/tests/container.spec.js
index 84f8032..a3f2682 100644
--- a/tests/container.spec.js
+++ b/tests/container.spec.js
@@ -231,10 +231,12 @@ test.describe('CSP in a browser', () => {
       if (req.url().includes('_kb-inline')) loaded.push(req.url());
     });
 
-    // A nested page, not the app index: the docs-example fixture's inline
-    // scripts live on its inner pages, and this also exercises the ../ depth
-    // computation in scripts/hoist-inline-scripts.js.
-    await page.goto('/knowledge-base/user-guide/docs/', { waitUntil: 'networkidle' });
+    // A nested page, not the app index: the docs-example fixture's remaining
+    // inline script lives on its admin page, and this also exercises the ../
+    // depth computation in scripts/hoist-inline-scripts.js. (The fixture's other
+    // inline script was its dark-mode bootstrap, which the build now deletes
+    // rather than hoisting — see #48.)
+    await page.goto('/knowledge-base/user-guide/admin/', { waitUntil: 'networkidle' });
 
     expect(loaded.length, 'no hoisted script was requested — did the hoist step run?').toBeGreaterThan(0);
     expect(blocked, 'a hoisted script failed to load').toEqual([]);
diff --git a/tests/fixtures/single-page-bundle/platform-overview/assets/depth-check.css b/tests/fixtures/single-page-bundle/platform-overview/assets/depth-check.css
new file mode 100644
index 0000000..4e68ce8
--- /dev/null
+++ b/tests/fixtures/single-page-bundle/platform-overview/assets/depth-check.css
@@ -0,0 +1,5 @@
+/* Fixture: see scripts/setup-test-apps.mjs (#49). Not referenced by the doc. */
+@font-face { font-family: Demo; src: url(/fonts/demo.woff2) format("woff2"); }
+.a { background-image: url(data:image/gif;base64,R0lGOD); }
+.b { clip-path: url(#clip); }
+.c { background-image: url(//cdn.example.com/x.png); }
diff --git a/tests/nginx-config.spec.js b/tests/nginx-config.spec.js
index dedaee4..a4c4793 100644
--- a/tests/nginx-config.spec.js
+++ b/tests/nginx-config.spec.js
@@ -46,8 +46,13 @@ function locationBlocks(conf) {
   return blocks;
 }
 
-/** Strips `#` comments so assertions never match commentary. */
-const uncomment = (text) => text.split('\n').map((l) => l.replace(/#.*$/, '')).join('\n');
+/**
+ * Strips `#` comments so assertions never match commentary.
+ * `.` does not match `\r`, so a CRLF checkout (the default on Windows, where
+ * there is no .gitattributes to force LF) needs the line ending trimmed first.
+ */
+const uncomment = (text) =>
+  text.split('\n').map((l) => l.replace(/\r$/, '').replace(/#.*$/, '')).join('\n');
 
 test.describe('nginx.conf header inheritance', () => {
   test('the shared header set is defined once, in nginx.headers.conf', () => {
diff --git a/tests/standalone.spec.js b/tests/standalone.spec.js
index 5907df4..ce4fe61 100644
--- a/tests/standalone.spec.js
+++ b/tests/standalone.spec.js
@@ -175,7 +175,7 @@ test.describe('CSS link stability (#297)', () => {
       // from a CSS `import`; that link is framework-managed and cannot carry the attribute.
       // Astro keeps it across navigation by href-match, and the behavioural
       // "CSS link count does not grow" test below is the authoritative #297 guard.
-      if (/^\/knowledge-base\/style\d*\.css$/.test(href ?? '')) continue;
+      if (/^\/knowledge-base\/_astro\/.+\.css$/.test(href ?? '')) continue;
       const persist = await links.nth(i).getAttribute('data-astro-transition-persist');
       expect(
         persist,
@@ -205,7 +205,7 @@ test.describe('CSS link stability (#297)', () => {
       const href = await links.nth(i).getAttribute('href');
       // Same exemption as the landing page: the bundled marketplace stylesheet is
       // injected by Astro from the layout's CSS import and cannot carry the attribute.
-      if (/^\/knowledge-base\/style\d*\.css$/.test(href ?? '')) continue;
+      if (/^\/knowledge-base\/_astro\/.+\.css$/.test(href ?? '')) continue;
       const persist = await links.nth(i).getAttribute('data-astro-transition-persist');
       expect(
         persist,
diff --git a/tests/transform.spec.js b/tests/transform.spec.js
new file mode 100644
index 0000000..43fa05c
--- /dev/null
+++ b/tests/transform.spec.js
@@ -0,0 +1,159 @@
+/**
+ * tests/transform.spec.js
+ *
+ * Unit tests for src/utils/transform.js — the one place third-party HTML is
+ * rewritten and split before Base.astro re-hosts it.
+ *
+ * These run against the function, not the built site, because the interesting
+ * inputs are the ones no fixture app happens to ship: a `</body>` inside a
+ * script, a `<` inside the theme bootstrap, a code sample in the prose that
+ * merely *looks* like markup. Each case below is a way the previous regex
+ * implementation silently produced a broken page (#48).
+ */
+
+import { test, expect } from '@playwright/test';
+import { transformSubAppHtml, isThemeBootstrap } from '../src/utils/transform.js';
+
+const PREFIX = 'knowledge-base';
+const SLUG = 'demo';
+
+/** Transforms a document as if it were apps/demo/{dir}/index.html. */
+const run = (html, dir = '') => transformSubAppHtml(html, SLUG, dir, PREFIX);
+
+/** Wraps body markup in a minimal document. */
+const doc = (body, head = '') => `<!DOCTYPE html><html><head><title>T</title>${head}</head><body>${body}</body></html>`;
+
+test.describe('document splitting', () => {
+  test('a </body> inside a script does not truncate the page', () => {
+    const { bodyHtml } = run(doc(
+      '<p id="before">before</p>' +
+      '<script>var end = "</body></html>";</script>' +
+      '<p id="after">after</p>',
+    ));
+    expect(bodyHtml).toContain('id="before"');
+    expect(bodyHtml, 'everything after the literal </body> was dropped').toContain('id="after"');
+  });
+
+  test('a </head> inside a comment does not truncate the head', () => {
+    const { headHtml } = run(doc('<p>x</p>', '<!-- </head> --><meta name="generator" content="demo">'));
+    expect(headHtml).toContain('name="generator"');
+  });
+
+  test('a document with no <body> is still split, not mistaken for a fragment', () => {
+    const { headHtml, bodyHtml } = run('<title>T</title><link rel="canonical" href="/c"><p id="loose">x</p>');
+    expect(headHtml).toContain('rel="canonical"');
+    expect(bodyHtml).toContain('id="loose"');
+  });
+
+  test('the title is lifted and the layout duplicates are dropped', () => {
+    const { title, headHtml } = run(doc('<p>x</p>', '<meta charset="utf-8"><meta name="viewport" content="width=device-width">'));
+    expect(title).toBe('T');
+    expect(headHtml).not.toContain('<title');
+    expect(headHtml).not.toContain('charset');
+    expect(headHtml).not.toContain('viewport');
+  });
+
+  test('the body class survives, minus `dark`', () => {
+    expect(run('<html><body class="docs dark theme-x"><p>x</p></body></html>').bodyClass)
+      .toBe('docs theme-x');
+  });
+});
+
+test.describe('light-only enforcement', () => {
+  const BOOTSTRAP =
+    "<script>for(let i=0;i<1;i++){if(localStorage.getItem('theme')==='dark')" +
+    "document.documentElement.classList.add('dark')}</script>";
+
+  test('the theme bootstrap is stripped even when it contains a `<`', () => {
+    const { bodyHtml } = run(doc(BOOTSTRAP + '<p id="keep">x</p>'));
+    expect(bodyHtml, 'the bootstrap would re-add `dark` at runtime').not.toContain('localStorage');
+    expect(bodyHtml).toContain('id="keep"');
+  });
+
+  test('it is stripped from the head too', () => {
+    expect(run(doc('<p>x</p>', BOOTSTRAP)).headHtml).not.toContain('localStorage');
+  });
+
+  test('an unrelated localStorage script is left alone', () => {
+    const script = "<script>localStorage.setItem('sidebar','open')</script>";
+    expect(isThemeBootstrap("localStorage.setItem('sidebar','open')")).toBe(false);
+    expect(run(doc(script)).bodyHtml).toContain('localStorage');
+  });
+});
+
+test.describe('URL rewriting', () => {
+  test('rewrites the single-URL attributes', () => {
+    const { bodyHtml } = run(doc(
+      '<a href="page/">a</a>' +
+      '<img src="/img/logo.png">' +
+      '<form action="search"><button formaction="/submit">go</button></form>' +
+      '<video poster="poster.jpg"></video>' +
+      '<object data="/model.svg"></object>',
+    ), 'docs');
+    expect(bodyHtml).toContain('href="/knowledge-base/demo/docs/page/"');
+    expect(bodyHtml).toContain('src="/knowledge-base/demo/img/logo.png"');
+    expect(bodyHtml).toContain('action="/knowledge-base/demo/docs/search"');
+    expect(bodyHtml).toContain('formaction="/knowledge-base/demo/submit"');
+    expect(bodyHtml).toContain('poster="/knowledge-base/demo/docs/poster.jpg"');
+    expect(bodyHtml).toContain('data="/knowledge-base/demo/model.svg"');
+  });
+
+  test('rewrites srcset candidates, keeping their descriptors', () => {
+    const { bodyHtml, headHtml } = run(doc(
+      '<img src="a.png" srcset="a.png 1x, /b/a@2x.png 2x">',
+      '<link rel="preload" as="image" href="/hero.png" imagesrcset="/hero.png 1x">',
+    ), 'docs');
+    expect(bodyHtml).toContain('srcset="/knowledge-base/demo/docs/a.png 1x, /knowledge-base/demo/b/a@2x.png 2x"');
+    expect(headHtml).toContain('imagesrcset="/knowledge-base/demo/hero.png 1x"');
+  });
+
+  test('rewrites url() in inline styles and <style> blocks', () => {
+    const { bodyHtml, headHtml } = run(doc(
+      '<div style="background:url(/bg.png) no-repeat"></div>',
+      "<style>.hero{background-image:url('img/hero.png')}</style>",
+    ), 'docs');
+    expect(bodyHtml).toContain('url(/knowledge-base/demo/bg.png)');
+    expect(headHtml).toContain("url('/knowledge-base/demo/docs/img/hero.png')");
+  });
+
+  test('rewrites URL-bearing meta content', () => {
+    const { headHtml } = run(doc('<p>x</p>', '<meta property="og:image" content="/card.png"><meta name="description" content="/not-a-url">'));
+    expect(headHtml).toContain('content="/knowledge-base/demo/card.png"');
+    expect(headHtml).toContain('content="/not-a-url"');
+  });
+
+  test('leaves external, anchor and data URLs alone', () => {
+    const { bodyHtml } = run(doc(
+      '<a href="https://example.com/x">e</a>' +
+      '<a href="#top">t</a>' +
+      '<a href="mailto:x@y.z">m</a>' +
+      '<a href="//cdn.example.com/x">p</a>' +
+      '<img src="data:image/gif;base64,R0lGOD">',
+    ));
+    expect(bodyHtml).toContain('href="https://example.com/x"');
+    expect(bodyHtml).toContain('href="#top"');
+    expect(bodyHtml).toContain('href="mailto:x@y.z"');
+    expect(bodyHtml).toContain('href="//cdn.example.com/x"');
+    expect(bodyHtml).toContain('src="data:image/gif;base64,R0lGOD"');
+  });
+
+  test('does not rewrite markup quoted in prose or comments', () => {
+    const { bodyHtml } = run(doc(
+      '<pre><code>&lt;a href="/docs/api"&gt;API&lt;/a&gt;</code></pre>' +
+      '<!-- <a href="/docs/api">API</a> -->',
+    ));
+    expect(bodyHtml, 'a code sample is text, not a link').not.toContain('/knowledge-base/demo/docs/api');
+    expect(bodyHtml).toContain('href="/docs/api"');
+  });
+
+  test('removes <base>, which would re-resolve every rewritten URL', () => {
+    const { headHtml } = run(doc('<p>x</p>', '<base href="/some/root/">'));
+    expect(headHtml).not.toContain('<base');
+  });
+
+  test('stamps stylesheet links so ClientRouter keeps them across transitions', () => {
+    const { headHtml } = run(doc('<p>x</p>', '<link rel="stylesheet" href="style.css">'), 'docs');
+    expect(headHtml).toContain('href="/knowledge-base/demo/docs/style.css"');
+    expect(headHtml).toContain('data-astro-transition-persist="css-knowledge-base-demo-docs-style-css"');
+  });
+});