ompchamber 3.3.2 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ompchamber",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "Developer web console and diagnostic chamber for AI Oh-My-Pi — Elysia + Preact on Bun.",
   "license": "UNLICENSED",
   "author": "Wijanarko Putra Rajeb <wijanarko.rajeb@gmail.com>",

package/src/server/lib/assets/font-css.server.test.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `/fonts.css` is derived from the SOURCE stylesheets on every request, and this
+ * is the gate that keeps it that way.
+ *
+ * The sheet used to be assembled from a directory the bundler wrote as a side
+ * effect of bundling a CSS module — so it was produced once per process and
+ * could never be repaired. An `rm -rf` while the server ran, or a fresh clone
+ * that never built, left the route answering 0 bytes for the rest of that
+ * process and the terminal's Nerd symbols face vanished: private-use glyphs
+ * became tofu boxes with no error anywhere. These assertions fail if the sheet
+ * ever depends on a build artifact again.
+ *
+ * The last case is the end-to-end one: every font basename the sheet names must
+ * resolve to a file the server actually serves. A face pointing at a basename
+ * no package ships is a 404 the browser swallows, which looks identical to the
+ * font never having been declared.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { fontStylesheet, serveFontFile } from '@/server/lib/assets/font-css.server';
+import { packageDir } from '@/server/lib/assets/fonts.server';
+
+const sheet = await fontStylesheet();
+
+/** Every `url(...)` target in the sheet. */
+function urls(css: string): string[] {
+  return [...css.matchAll(/url\(\s*(['"]?)([^'")]+)\1\s*\)/g)].map(([, , target]) => target);
+}
+
+describe('/fonts.css is assembled from source, not from a build artifact', () => {
+  test('it declares the bundled Nerd symbols face', () => {
+    expect(sheet).toContain('OMPChamber Nerd Symbols');
+    expect(urls(sheet)).toContain('/fonts/symbols-nerd-font-mono.woff2');
+    // The range is what keeps the 1.1 MB face off every machine that has a
+    // Nerd Font of its own, so a sheet without it is a different contract.
+    expect(sheet).toContain('unicode-range');
+  });
+
+  test('it declares the text faces the bundle cannot carry', () => {
+    expect(sheet).toContain('Fira Code');
+    expect(sheet).toContain('KaTeX_Main');
+    expect(urls(sheet)).toContain('/fonts/fira-code-latin-400-normal.woff2');
+  });
+
+  test('every url is rewritten to the served route — no relative or node_modules path survives', () => {
+    const targets = urls(sheet);
+    expect(targets.length).toBeGreaterThan(20);
+    for (const target of targets) {
+      expect(target.startsWith('/fonts/')).toBe(true);
+    }
+  });
+
+  test('every basename the sheet names resolves to a served file', async () => {
+    for (const target of urls(sheet)) {
+      const response = await serveFontFile(target.slice('/fonts/'.length));
+      expect(response).not.toBeNull();
+      expect(response?.headers.get('content-type')).toMatch(/^font\//);
+    }
+  });
+});
+
+describe('the source tree is resolved by the package, not by the dependencies', () => {
+  // In a hoisted install the package's own files live under
+  // `node_modules/ompchamber/` while its dependencies sit in the parent
+  // `node_modules/` — so `packageRoot()` (the first root holding
+  // `node_modules`) is the PARENT, and looking for `src/` beside the hoisted
+  // packages finds nothing. That served an empty sheet and silently dropped
+  // every `@font-face`; the stylesheet has to resolve through `packageDir()`.
+  test('the stylesheets resolve through packageDir, and it finds the source tree', () => {
+    // This repo is a source checkout, where `packageDir()` and `packageRoot()`
+    // coincide. The assertion that matters is that the source tree is found AT
+    // ALL — the hoisted layout above is the case that breaks, and it cannot be
+    // staged from inside the repo without rewriting the module's own search
+    // roots, so the end-to-end proof for it lives in the manual run against a
+    // simulated published install.
+    expect(existsSync(join(packageDir(), 'src'))).toBe(true);
+    expect(existsSync(join(packageDir(), 'src', 'shared', 'lib', 'fonts', 'nerd-symbols.css'))).toBe(true);
+  });
+});

package/src/server/lib/assets/font-css.server.ts

@@ -10,32 +10,44 @@
  * local `url()`, and a font is always a local file — so a bundled face is either
  * a base64 blob or an absolute filesystem path. `lib/bundler/css.ts` lifts each
  * block out of its stylesheet and rewrites the urls to `<FONT_ROUTE_PREFIX><basename>`;
- * this module serves the result.
+ * this module re-declares them on `/fonts.css`.
  *
  * Two jobs, one route each:
  *
- * - `FONT_STYLESHEET_ROUTE` (`/fonts.css`) concatenates the extracted faces.
- *   Read per request rather than cached: it is a handful of kilobytes, and a
- *   cache is what would keep a stale face alive across an edit to a stylesheet.
- *   A missing directory is an empty stylesheet, not a 404 — the shell links this
- *   unconditionally.
+ * - `FONT_STYLESHEET_ROUTE` (`/fonts.css`) concatenates the faces, read from the
+ *   source stylesheets under `src/` on every request. It is a handful of
+ *   kilobytes and four small files, and reading them is what keeps the sheet
+ *   correct for the process's whole life — the alternative, a directory the
+ *   bundler wrote, is only ever produced as a side effect of a CSS module being
+ *   bundled, so it is written once per process and can never be repaired: an
+ *   `rm -rf` while the server runs (or a fresh clone that never ran a build)
+ *   leaves `/fonts.css` empty for the rest of that process, and the terminal's
+ *   Nerd symbols face silently disappears — the glyphs become tofu boxes with no
+ *   error anywhere.
+ *
+ *   Only a face whose `src` names a local font is re-declared, so a stylesheet
+ *   carrying a remote face contributes nothing (see `font-faces.ts`). The faces
+ *   the client bundle imports all live under `src/`, which is what makes the
+ *   source tree the honest place to read them from: the same files the bundler
+ *   strips are the files the browser is served.
  *
  * - `FONT_ROUTE_PREFIX` (`/fonts/<basename>`) serves the file itself from the
  *   installed packages. The basename is the whole key, so the lookup is an index
  *   rather than a path built from the request; see `fonts.server.ts`.
  */
 
-import { join } from 'path';
+import { dirname, join } from 'path';
 import { Glob } from 'bun';
 
-import { packageRoot, resolveFontFile } from '@/server/lib/assets/fonts.server';
-
-/** Directory holding one extracted face file per source stylesheet. */
-export const FONT_FACE_DIR = join('.ompchamber-build', 'font-faces');
+import { splitFontFaces } from '@/server/lib/assets/font-faces';
+import { packageDir, resolveFontFile } from '@/server/lib/assets/fonts.server';
 
 /** The route the assembled stylesheet is served on. */
 export const FONT_STYLESHEET_ROUTE = '/fonts.css';
 
+/** Where the stylesheets that carry faces live, relative to the package directory. */
+const STYLE_SOURCE_ROOT = 'src';
+
 const FONT_MIME: Record<string, string> = {
   '.woff2': 'font/woff2',
   '.woff': 'font/woff',
@@ -48,20 +60,34 @@ const STYLESHEET_HEADERS = {
   'cache-control': 'no-store',
 } as const;
 
-/** Every extracted face file, concatenated in a stable order. */
-export async function fontStylesheet(): Promise<string> {
-  const dir = join(packageRoot(), FONT_FACE_DIR);
-  const glob = new Glob('*.css');
+/** The absolute path of every stylesheet under the package's `src/`, sorted. */
+function sourceStylesheets(): string[] {
+  const root = join(packageDir(), STYLE_SOURCE_ROOT);
+  const glob = new Glob('**/*.css');
   const files: string[] = [];
   try {
-    for await (const file of glob.scan({ cwd: dir, onlyFiles: true })) files.push(file);
+    for (const file of glob.scanSync({ cwd: root, onlyFiles: true })) files.push(join(root, file));
   } catch {
-    return '';
+    return [];
   }
-  // Sorted so the stylesheet is byte-stable between builds: the browser caches
-  // on the ETag, and an unstable order would invalidate it for no change.
+  // Sorted so the stylesheet is byte-stable between requests: the browser
+  // caches on the ETag, and an unstable order would invalidate it for no change.
   files.sort();
-  const parts = await Promise.all(files.map((file) => Bun.file(join(dir, file)).text()));
+  return files;
+}
+
+/** Every `@font-face` block the source stylesheets declare, concatenated. */
+export async function fontStylesheet(): Promise<string> {
+  const parts: string[] = [];
+  for (const path of sourceStylesheets()) {
+    // A read that fails contributes nothing rather than failing the sheet: the
+    // shell links this unconditionally, and one unreadable file must not take
+    // the faces beside it down with it.
+    const css = await Bun.file(path).text().catch(() => '');
+    if (!css) continue;
+    const { faces } = splitFontFaces(css, dirname(path));
+    if (faces.length > 0) parts.push(...faces);
+  }
   return parts.join('\n');
 }
 

package/src/server/lib/assets/font-faces.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pulling `@font-face` blocks out of a stylesheet, and pointing their `url()`s
+ * at the served route.
+ *
+ * Two callers, one reason to share: the bundler's CSS loader strips faces out
+ * of every module it bundles (`lib/bundler/css.ts`) because Bun resolves each
+ * local `url()` into base64 or an absolute filesystem path, and the server
+ * assembles `/fonts.css` from the same stylesheets
+ * (`lib/assets/font-css.server.ts`). The two must agree byte for byte — a face
+ * stripped from the bundle has to be the one the stylesheet re-declares, or the
+ * font silently never loads.
+ *
+ * Only a block whose `src` names a LOCAL font moves: a face pointing at a
+ * remote url is valid CSS the bundle can keep. `rewriteFontUrls` replaces every
+ * local font url with `<FONT_ROUTE_PREFIX><basename>`, which is the only form
+ * that survives Bun's loader — a same-origin path is not an escape hatch, since
+ * `url("/fonts/x.woff2")` fails the build with "Could not resolve".
+ */
+
+import { basename, isAbsolute, resolve as resolvePath } from 'path';
+
+import { FONT_ROUTE_PREFIX } from '@/server/lib/assets/fonts.server';
+
+/** A `url(...)` whose target is a font file. */
+const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
+const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
+/** Schemes Bun leaves alone, and the prefix this module itself emits. */
+const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
+
+/** One `@font-face` block, braces included. Faces cannot nest. */
+const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
+
+/** Absolute path of a local font url, or null when it is not one. */
+function localFont(specifier: string, cssDir: string): string | null {
+  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
+  if (!FONT_FILE.test(specifier)) return null;
+  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
+}
+
+/** Point every font `url()` at the served path. */
+export function rewriteFontUrls(css: string, cssDir: string): string {
+  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
+    const absolute = localFont(specifier, cssDir);
+    if (!absolute) return whole;
+    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
+  });
+}
+
+/**
+ * Split `@font-face` blocks out of a stylesheet.
+ *
+ * `cssDir` resolves a relative `src` url, so it must be the directory of the
+ * file the text came from — not the bundle's.
+ */
+export function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
+  const faces: string[] = [];
+  const rest = css.replace(FONT_FACE, (block) => {
+    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
+    if (!hasLocal) return block;
+    faces.push(rewriteFontUrls(block, cssDir));
+    return '';
+  });
+  return { rest, faces };
+}

package/src/server/lib/assets/fonts.server.ts

@@ -77,12 +77,16 @@ let index: Record<string, string> | null = null;
 /**
  * The package root — the first search root that holds `node_modules`.
  *
- * Both ends of the build need the same answer: the plugin writes the extracted
- * face files here and the server reads them back, and an AOT bundle runs from
- * `dist/client` while a source checkout runs from the repo. Falling back to the
+ * The AOT bundle runs from `dist/client` while a source checkout runs from the
+ * repo, and both resolve their dependencies through this. Falling back to the
  * cwd keeps a checkout with no `node_modules` (a publish dry-run) working.
+ *
+ * This answers "where are the DEPENDENCIES", which is not the same question as
+ * `packageDir()` below: a hoisted install keeps the package's own files under
+ * `node_modules/ompchamber/` while its dependencies sit in the parent
+ * `node_modules/`, so the first root holding `node_modules` is the PARENT.
  */
-export function packageRoot(): string {
+function packageRoot(): string {
   for (const root of searchRoots()) {
     // `existsSync` rather than `Bun.file().exists()`: the latter is async and
     // file-only, and `node_modules` is a directory.
@@ -91,6 +95,25 @@ export function packageRoot(): string {
   return process.cwd();
 }
 
+/**
+ * The package's own directory — the first search root that holds `src/`.
+ *
+ * The source stylesheets `lib/assets/font-css.server.ts` reads for `/fonts.css`
+ * live there, and they must be found in every install shape. In a source
+ * checkout and a non-hoisted install this is the same directory
+ * `packageRoot()` returns; in a hoisted install it is the package under
+ * `node_modules/`, one level BELOW the root that holds the dependencies.
+ * Resolving the source tree through `packageRoot()` there would look for
+ * `src/` beside the hoisted packages and find nothing, which serves an empty
+ * stylesheet and silently drops every `@font-face`.
+ */
+export function packageDir(): string {
+  for (const root of searchRoots()) {
+    if (existsSync(join(root, 'src'))) return root;
+  }
+  return packageRoot();
+}
+
 async function buildIndex(): Promise<Record<string, string>> {
   const found: Record<string, string> = {};
   const glob = new Glob('*.{woff2,woff,ttf,otf}');

package/src/server/lib/bundler/build-errors.server.ts

@@ -33,9 +33,9 @@
 import { join, relative } from 'path';
 import type { BuildOutput, BunPlugin } from 'bun';
 
-import { packageRoot } from '@/server/lib/assets/fonts.server';
+import { packageDir } from '@/server/lib/assets/fonts.server';
 
-/** The shell bundle's entrypoint, relative to the package root. */
+/** The shell bundle's entrypoint, relative to the package directory. */
 const SHELL_ENTRYPOINT = 'index.html';
 
 /** Bun's own config file, and the section naming the bundle's plugins. */
@@ -109,8 +109,13 @@ function formatLog(log: BundleLog, root: string): string {
 /**
  * The bundle errors behind a shell that would not render, or null when this
  * build is not the reason (a clean bundle means the failure lies elsewhere).
+ *
+ * `root` is the PACKAGE, not `packageRoot()`: the entrypoint is `index.html`
+ * beside the source, and in a hoisted install the first root holding
+ * `node_modules` is the parent, where `index.html` does not exist — so the probe
+ * would report no failure at all and the real build error would never be shown.
  */
-export async function describeShellBuildFailure(root = packageRoot()): Promise<string | null> {
+export async function describeShellBuildFailure(root = packageDir()): Promise<string | null> {
   const entrypoint = join(root, SHELL_ENTRYPOINT);
   if (!(await Bun.file(entrypoint).exists())) return null;
 

package/src/server/lib/bundler/css.ts

@@ -30,18 +30,17 @@
  *    rewrite inside the bundle can work.
  *
  *    The faces therefore leave the bundle. Each block is rewritten to
- *    `<FONT_ROUTE_PREFIX><basename>` and written to its own file under
- *    `FONT_FACE_DIR`, keyed by the stylesheet it came from — a document Bun
- *    never parses, which is what lets the urls survive. The server concatenates
- *    that directory into `/fonts.css` (`lib/assets/font-css.server.ts`) and the
- *    shell links it, so the layout rules stay bundled while the faces stay
+ *    `<FONT_ROUTE_PREFIX><basename>` and dropped from the module, and the server
+ *    re-declares them on `/fonts.css` from the SAME source stylesheets
+ *    (`lib/assets/font-css.server.ts`, `lib/assets/font-faces.ts`). The shell
+ *    links that route, so the layout rules stay bundled while the faces stay
  *    cacheable files.
  *
- *    Per-source files rather than one accumulated file because `onEnd` is NOT
- *    invoked by `serve.static` (verified: `onStart` and `onLoad` fire, `onEnd`
- *    never does), so there is no "build finished" moment to flush at. Writing
- *    each source's faces as its `onLoad` returns is order-independent and works
- *    identically under both entry points.
+ *    The server derives the faces from source rather than from a directory this
+ *    plugin wrote, because `onEnd` is NOT invoked by `serve.static` (verified:
+ *    `onStart` and `onLoad` fire, `onEnd` never does) and a written artifact is
+ *    produced exactly once per process — a `rm -rf` after boot, or a fresh clone
+ *    that never built, would leave `/fonts.css` empty for good.
  *
  * 3. **Nested at-rules are flattened** (`flattenNestedAtRules`, registered
  *    AFTER Tailwind so it sees the expanded tree). Bun's CSS minifier keeps the
@@ -53,57 +52,14 @@
  *    the measurement; this one only has to run it.
  */
 
-import { basename, dirname, isAbsolute, join, resolve as resolvePath } from 'path';
+import { dirname } from 'path';
 import postcss from 'postcss';
 import tailwind from '@tailwindcss/postcss';
 import type { BunPlugin } from 'bun';
 
-import { FONT_FACE_DIR } from '@/server/lib/assets/font-css.server';
-import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
+import { splitFontFaces } from '@/server/lib/assets/font-faces';
 import { flattenNestedAtRules } from '@/server/lib/bundler/nested-at-rules';
 
-/** A `url(...)` whose target is a font file. */
-const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
-const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
-/** Schemes Bun leaves alone, and the prefix this plugin itself emits. */
-const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
-
-/** One `@font-face` block, braces included. Faces cannot nest. */
-const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
-
-/** Absolute path of a local font url, or null when it is not one. */
-function localFont(specifier: string, cssDir: string): string | null {
-  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
-  if (!FONT_FILE.test(specifier)) return null;
-  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
-}
-
-/** Point every font `url()` at the served path. */
-function rewriteFontUrls(css: string, cssDir: string): string {
-  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
-    const absolute = localFont(specifier, cssDir);
-    if (!absolute) return whole;
-    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
-  });
-}
-
-/**
- * Split `@font-face` blocks out of a stylesheet.
- *
- * Only blocks whose `src` names a local font move: a face pointing at a remote
- * url is valid CSS the bundle can keep.
- */
-function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
-  const faces: string[] = [];
-  const rest = css.replace(FONT_FACE, (block) => {
-    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
-    if (!hasLocal) return block;
-    faces.push(rewriteFontUrls(block, cssDir));
-    return '';
-  });
-  return { rest, faces };
-}
-
 const plugin: BunPlugin = {
   name: 'ompchamber-css',
   setup(build) {
@@ -117,12 +73,7 @@ const plugin: BunPlugin = {
       const expanded = await postcss([tailwind(), flattenNestedAtRules()]).process(source, {
         from: args.path,
       });
-      const { rest, faces } = splitFontFaces(expanded.css, dirname(args.path));
-      if (faces.length > 0) {
-        const target = join(packageRoot(), FONT_FACE_DIR, `${basename(args.path)}`);
-        const header = `/* GENERATED from ${args.path} — do not edit. */\n`;
-        await Bun.write(target, header + faces.join('\n') + '\n');
-      }
+      const { rest } = splitFontFaces(expanded.css, dirname(args.path));
       return { contents: rest, loader: 'css' };
     });
   },

package/src/server/plugins/ssr.ts

@@ -135,10 +135,10 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   const themeStyle = `<style id="${THEME_STYLE_ELEMENT_ID}">${themeStyleSheet()}</style>`;
   // The font faces are a stylesheet the bundler cannot carry: Bun resolves every
   // local `url()` in CSS, so a bundled face is either base64 or an absolute
-  // filesystem path. `lib/bundler/css.ts` lifts the blocks out and the route
-  // below serves them, which is why the link is injected here — a
-  // `<link href="/fonts.css">` in index.html would be resolved by the HTML
-  // loader and fail the same way.
+  // filesystem path. `lib/bundler/css.ts` strips the blocks out of the bundle
+  // and `lib/assets/font-css.server.ts` re-declares them on the route below,
+  // which is why the link is injected here — a `<link href="/fonts.css">` in
+  // index.html would be resolved by the HTML loader and fail the same way.
   const fontLink = `<link rel="stylesheet" href="${FONT_STYLESHEET_ROUTE}">`;
 
   // Bun's dev asset URLs move to this server's prefix so the proxy above can add

package/src/server/plugins/static.ts

@@ -2,7 +2,7 @@ import { extname, join, normalize, resolve, sep } from 'path';
 
 import { notModified } from '@/server/lib/assets/conditional.server';
 import { FONT_STYLESHEET_ROUTE, serveFontFile, serveFontStylesheet } from '@/server/lib/assets/font-css.server';
-import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
+import { FONT_ROUTE_PREFIX, packageDir } from '@/server/lib/assets/fonts.server';
 
 /**
  * File serving for `public/` and the font routes.
@@ -21,12 +21,16 @@ import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server
  * catch-all, which would shadow this app's SSR route. Exposing one lookup
  * function lets the web catch-all try a file first and fall back to the shell.
  */
-// Resolved from the package root, not the cwd: `serve --prod` may run the built
-// server from anywhere, and a cwd-relative `public` would not exist — every
-// icon, the manifest and the service worker would 404.
-const PUBLIC_ROOT = resolve(packageRoot(), 'public');
+// Resolved from the package's own directory, not the cwd: `serve --prod` may
+// run the built server from anywhere, and a cwd-relative `public` would not
+// exist — every icon, the manifest and the service worker would 404. The
+// package, NOT `packageRoot()`: in a hoisted install the first root holding
+// `node_modules` is the parent, where `public/` and `dist/client/` do not exist,
+// so the lookup would fall through to the shell and answer an image request with
+// HTML.
+const PUBLIC_ROOT = resolve(packageDir(), 'public');
 /** Where `scripts/build-client.ts` writes the production bundle and its chunks. */
-const CLIENT_ROOT = resolve(packageRoot(), 'dist', 'client');
+const CLIENT_ROOT = resolve(packageDir(), 'dist', 'client');
 
 const IMMUTABLE = 'public, max-age=31536000, immutable';
 const SHORT = 'public, max-age=3600';
@@ -141,12 +145,12 @@ export async function tryServeStatic(pathname: string, request?: Request): Promi
     const filePath = resolveWithin(CLIENT_ROOT, pathname);
     return filePath ? serveFile(filePath, ASSET_CACHE, request) : null;
   }
-  // The extracted `@font-face` stylesheet and the files it names. Bun's CSS
+  // The assembled `@font-face` stylesheet and the files it names. Bun's CSS
   // loader cannot carry either — every local `url()` is resolved, so a bundled
   // face is base64 or an absolute path — which is why they are served rather
-  // than emitted. Both live outside `public/`: the stylesheet is assembled from
-  // the faces `lib/bundler/css.ts` wrote, and the files come from the installed
-  // packages.
+  // than emitted. Both live outside `public/`: the stylesheet re-declares the
+  // faces `lib/bundler/css.ts` stripped, read from the source stylesheets, and
+  // the files come from the installed packages.
   //
   // Neither is given a conditional here: the stylesheet is `no-store` (nothing
   // is ever stored to revalidate) and a font file is `immutable` (the browser