npm - ompchamber - Versions diffs - 3.2.0 → 3.3.0 - Mend

ompchamber 3.2.0 → 3.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/client/index.html +1 -1
package/dist/client/index.js +239 -230
package/dist/client/static/js/index-bsxxt89j.css +1 -0
package/dist/client/static/js/{index-1q6165r3.js → index-qkt4z7x0.js} +640 -640
package/package.json +4 -3
package/public/sw.js +54 -5
package/src/client/components/mobile/mobile-right-sidebar/FullEditor.tsx +27 -8
package/src/client/components/mobile/mobile-session-sidebar/Item.tsx +1 -0
package/src/client/components/mobile/mobile-session-sidebar/SessionRow.test.ts +84 -0
package/src/client/components/mobile/mobile-session-sidebar/SessionRow.tsx +14 -5
package/src/client/components/settings/Modal.tsx +10 -17
package/src/client/components/settings/categories/AppearanceSettings.tsx +3 -0
package/src/client/components/settings/categories/appearance-settings/EditorFontSection.tsx +78 -0
package/src/client/components/workspace/chat-timeline/SystemNotice.tsx +17 -11
package/src/client/components/workspace/editor/index.tsx +15 -7
package/src/client/components/workspace/terminal-panel/KeyBar.tsx +194 -0
package/src/client/components/workspace/terminal-panel/RealtimeXtermView.tsx +24 -0
package/src/client/components/workspace/terminal-panel/index.tsx +98 -3
package/src/client/components/workspace/terminal-panel/mount.ts +47 -0
package/src/client/data/theme/terminal.ts +25 -8
package/src/client/hooks/editor/font.ts +53 -0
package/src/client/hooks/ui/clipboard.ts +17 -0
package/src/client/hooks/ui/keyboard-inset.test.ts +46 -0
package/src/client/hooks/ui/keyboard-inset.ts +113 -0
package/src/client/hooks/ui/text-overflow.test.ts +152 -0
package/src/client/hooks/ui/text-overflow.ts +78 -0
package/src/client/hooks/ui/touch-device.ts +46 -0
package/src/client/main.tsx +1 -0
package/src/server/index.ts +4 -3
package/src/server/lib/assets/conditional.server.test.ts +74 -0
package/src/server/lib/assets/conditional.server.ts +54 -0
package/src/server/lib/assets/dev-assets.server.test.ts +44 -0
package/src/server/lib/assets/dev-assets.server.ts +121 -0
package/src/server/lib/assets/fonts.server.ts +9 -4
package/src/server/lib/bundler/build-errors.server.ts +136 -0
package/src/server/lib/bundler/build-errors.test.ts +103 -0
package/src/server/lib/bundler/dependencies.test.ts +134 -0
package/src/server/lib/lifecycle/listener.ts +29 -0
package/src/server/plugins/shell.server.ts +52 -13
package/src/server/plugins/ssr.ts +43 -7
package/src/server/plugins/static.ts +51 -18
package/src/shared/lib/code/editor/typography.test.ts +93 -0
package/src/shared/lib/code/editor/typography.ts +86 -0
package/src/shared/lib/fonts/NOTICE.md +44 -0
package/src/shared/lib/fonts/nerd-symbols.css +55 -0
package/src/shared/lib/fonts/nerd-symbols.test.ts +134 -0
package/src/shared/lib/fonts/symbols-nerd-font-mono.woff2 +0 -0
package/src/shared/lib/settings/diff.test.ts +1 -1
package/src/shared/lib/workspace/terminal/keys.test.ts +189 -0
package/src/shared/lib/workspace/terminal/keys.ts +225 -0
package/src/shared/types/settings/state.ts +7 -16
package/dist/client/static/js/index-01dv383b.css +0 -1

package/src/server/plugins/ssr.ts CHANGED Viewed

@@ -1,26 +1,47 @@
 import { Elysia } from 'elysia';
 import { getDb } from '@/server/db.server';
 import { tryServeStatic } from '@/server/plugins/static';
-import { renderShell } from '@/server/plugins/shell.server';
+import { renderShell, SHELL_MARKER } from '@/server/plugins/shell.server';
+import {
+  DEV_ASSETS_ENABLED,
+  devAssetUpstreamPath,
+  rewriteDevAssetUrls,
+  serveDevAsset,
+} from '@/server/lib/assets/dev-assets.server';
+import { listenerUrl } from '@/server/lib/lifecycle/listener';
 import { FONT_STYLESHEET_ROUTE } from '@/server/lib/assets/font-css.server';
 import { resolveTheme } from '@/shared/lib/theme/catalog';
 import { THEME_STYLE_ELEMENT_ID, themeStyleSheet } from '@/shared/lib/theme/css';
+/** HTML-escape a string for interpolation into the failure page's `<pre>`. */
+function escapeHtmlText(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
 /**
  * Actionable message instead of a bare 500 when the shell cannot be rendered.
  *
  * The shell is a Bun HTML route now, not a file on disk, so "not found" is no
  * longer the failure mode — a bundle error is, and Bun renders its own error
- * page for that. This covers the remaining path: the bundle is fine but the
- * markup could not be read back.
+ * page for that, with the file and line locked inside a payload only the
+ * browser can decode. `plugins/shell.server.ts` rebuilds the entrypoint to get
+ * those facts in readable form and passes them here as the reason, so this page
+ * names the edit that broke the bundle rather than the status it produced.
  */
 function shellUnavailableResponse(reason: string): Response {
+  // Escaped, not interpolated raw: the reason carries the failed build's own
+  // source lines, which are arbitrary code — a `<` in one would otherwise
+  // truncate the page at the first tag.
   return new Response(
     `<!doctype html><meta charset="utf-8"><title>OMPChamber</title>
 <body style="font:14px/1.6 ui-monospace,monospace;padding:2rem">
 <h1 style="font-size:1.1rem">Shell not available</h1>
 <p>The server could not render its HTML shell.</p>
-<pre style="background:#f4f1ea;padding:1rem;border-radius:6px">${reason}</pre>
+<pre style="background:#f4f1ea;padding:1rem;border-radius:6px">${escapeHtmlText(reason)}</pre>
 </body>`,
     { status: 503, headers: HTML_HEADERS },
   );
@@ -83,7 +104,17 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
     });
   }
-  const asset = await tryServeStatic(pathname);
+  // The dev asset proxy, before the static lookup: its prefix is this server's
+  // own, and Bun's table never sees it. See `lib/assets/dev-assets.server`.
+  if (DEV_ASSETS_ENABLED && devAssetUpstreamPath(pathname)) {
+    const base = listenerUrl();
+    if (base) {
+      const proxied = await serveDevAsset(request, pathname, base);
+      if (proxied) return proxied;
+    }
+  }
+  const asset = await tryServeStatic(pathname, request);
   if (asset) return asset;
   const settings = await readSettings();
@@ -110,13 +141,18 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   // 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
+  // the caching headers Bun omits. Rewritten BEFORE the bootstrap is injected,
+  // so a `/_bun/` string inside the settings payload is left alone.
+  const shellHtml = DEV_ASSETS_ENABLED ? rewriteDevAssetUrls(rendered.html) : rendered.html;
   return new Response(
-    rendered.html
+    shellHtml
       .replace('data-theme="paper"', `data-theme="${theme.id}"`)
       .replace('data-theme-variant="light"', `data-theme-variant="${theme.variant}"`)
       .replace('<meta name="theme-color" content="#faf8f3" />', `<meta name="theme-color" content="${theme.canvas}" />`)
       .replace('<!--app-head-->', themeStyle + fontLink)
-      .replace('<!--app-bootstrap-->', `<script>window.__OMP_BOOTSTRAP__=${bootstrap}</script>`),
+      .replace(SHELL_MARKER, `<script>window.__OMP_BOOTSTRAP__=${bootstrap}</script>`),
     { headers: HTML_HEADERS },
   );
 });

package/src/server/plugins/static.ts CHANGED Viewed

@@ -1,15 +1,20 @@
 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';
 /**
  * File serving for `public/` and the font routes.
  *
- * The client bundle is NOT served from here any more. Bun's own routing owns
- * the assets it emits — `/_bun/asset/*` and `/_bun/client/*` in development,
- * `/chunk-*` in production — and answers them from its bundle table before a
- * request reaches Elysia. `dist/client` no longer exists, so the `/static/`
+ * The client bundle is NOT served from here. Bun's own routing owns the assets
+ * it emits — `/_bun/asset/*` and `/_bun/client/*` in development, `/chunk-*` in
+ * production — and answers them from its bundle table before a request reaches
+ * Elysia. In development those responses are reached a second way, through
+ * `lib/assets/dev-assets.server.ts`: Bun's table wins for the paths it declares,
+ * so the shell points at `/_dev-assets/*` and that module fetches the bytes back
+ * from the listener to add the `Cache-Control` and `ETag`/`304` handling Bun's
+ * dev asset routes lack. `dist/client` no longer exists, so the `/static/`
  * branch and its content-hashed caching went with it.
  *
  * Hand-rolled rather than `@elysiajs/static`: that plugin registers its own
@@ -61,7 +66,17 @@ function resolveWithin(root: string, pathname: string): string | null {
   return candidate;
 }
-async function serveFile(filePath: string, cacheControl: string): Promise<Response | null> {
+/**
+ * The file's own bytes, or null when it cannot be read.
+ *
+ * `If-None-Match` is answered from a weak validator derived from the file's
+ * size and mtime. A content hash would be stronger, but it would mean reading
+ * every asset on every request to compute it — the opposite of the point.
+ * Size+mtime is what `plugins/static.ts` can produce from the `stat` it already
+ * performs, and a wrong `304` from it needs both a same-size edit and a
+ * preserved mtime, which is not something a build or an editor does.
+ */
+async function serveFile(filePath: string, cacheControl: string, request?: Request): Promise<Response | null> {
   let stat;
   try {
     stat = await Bun.file(filePath).stat();
@@ -71,14 +86,24 @@ async function serveFile(filePath: string, cacheControl: string): Promise<Respon
   if (!stat.isFile()) return null;
   const type = MIME[extname(filePath).toLowerCase()] ?? 'application/octet-stream';
-  const stream = Bun.file(filePath).stream();
-  return new Response(stream, {
-    headers: {
-      'content-type': type,
-      'content-length': String(stat.size),
-      'cache-control': cacheControl,
-      'last-modified': stat.mtime.toUTCString(),
-    },
+  const lastModified = stat.mtime.toUTCString();
+  // Weak on purpose: the validator identifies the file as the same version, and
+  // byte equality is not what it promises.
+  const etag = `W/"${stat.size}-${Math.floor(stat.mtimeMs / 1000)}"`;
+  const headers = {
+    'content-type': type,
+    'cache-control': cacheControl,
+    'last-modified': lastModified,
+    etag,
+  };
+  if (request && notModified(request, etag, stat.mtimeMs)) {
+    // No `content-length`: a 304 describes the validator, not a body.
+    return new Response(null, { status: 304, headers });
+  }
+  return new Response(Bun.file(filePath).stream(), {
+    headers: { ...headers, 'content-length': String(stat.size) },
   });
 }
@@ -90,18 +115,22 @@ async function serveFile(filePath: string, cacheControl: string): Promise<Respon
  * going through the SSR route that injects the theme and bootstrap, and the
  * cache stays short because these filenames carry no content hash.
  */
-export async function servePublicAsset(pathname: string, roots: readonly string[]): Promise<Response | null> {
+export async function servePublicAsset(
+  pathname: string,
+  roots: readonly string[],
+  request?: Request,
+): Promise<Response | null> {
   for (const root of roots) {
     const filePath = resolveWithin(root, pathname);
     if (!filePath || filePath.endsWith('.html')) continue;
-    const response = await serveFile(filePath, SHORT);
+    const response = await serveFile(filePath, SHORT, request);
     if (response) return response;
   }
   return null;
 }
 /** A file for `pathname`, or null when the request should reach the app. */
-export async function tryServeStatic(pathname: string): Promise<Response | null> {
+export async function tryServeStatic(pathname: string, request?: Request): Promise<Response | null> {
   // The production bundle's own assets. `scripts/build-client.ts` emits the
   // server into `dist/client` with its chunks under `dist/client/static`, and
   // the generated HTML references them as `./static/...` — a page URL of `/`
@@ -110,7 +139,7 @@ export async function tryServeStatic(pathname: string): Promise<Response | null>
   // `/_bun/client/*`) and never reach here.
   if (pathname.startsWith('/static/')) {
     const filePath = resolveWithin(CLIENT_ROOT, pathname);
-    return filePath ? serveFile(filePath, ASSET_CACHE) : null;
+    return filePath ? serveFile(filePath, ASSET_CACHE, request) : null;
   }
   // The extracted `@font-face` stylesheet and the files it names. Bun's CSS
   // loader cannot carry either — every local `url()` is resolved, so a bundled
@@ -118,9 +147,13 @@ export async function tryServeStatic(pathname: string): Promise<Response | null>
   // 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.
+  //
+  // 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
+  // does not ask again). A validator on either would be dead code.
   if (pathname === FONT_STYLESHEET_ROUTE) return serveFontStylesheet();
   if (pathname.startsWith(FONT_ROUTE_PREFIX)) {
     return serveFontFile(decodeURIComponent(pathname.slice(FONT_ROUTE_PREFIX.length)));
   }
-  return servePublicAsset(pathname, [PUBLIC_ROOT]);
+  return servePublicAsset(pathname, [PUBLIC_ROOT], request);
 }

package/src/shared/lib/code/editor/typography.test.ts ADDED Viewed

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The editor typography contract.
+ *
+ * These are the properties that make one set of constants serve two layouts at
+ * any zoom level. Each one has a silent failure mode:
+ *
+ * - A px line-height does not scale with the font size, so zooming the editor
+ *   leaves the rows at the size they were chosen for at 12px — cramped at 24,
+ *   loose at 8. A ratio cannot.
+ * - The stack must name the bundled face first: `Fira Code` is the only entry
+ *   the app ships, so anything ahead of it would either be a font nobody has or
+ *   silently change the ligatures the whole console is typeset in.
+ * - The bounds must bracket the default, or the editor opens at a size its own
+ *   zoom controls cannot return to (the first click jumps).
+ */
+import { describe, expect, test } from 'bun:test';
+import {
+  EDITOR_DEFAULT_FONT_FAMILY,
+  EDITOR_DEFAULT_FONT_SIZE,
+  EDITOR_FONT_CHOICES,
+  EDITOR_FONT_FAMILY,
+  EDITOR_LINE_HEIGHT,
+  EDITOR_MAX_FONT_SIZE,
+  EDITOR_MIN_FONT_SIZE,
+  editorFontStack,
+} from '@/shared/lib/code/editor/typography';
+describe('editor typography', () => {
+  test('the line box is a ratio, so it scales with the font size', () => {
+    expect(typeof EDITOR_LINE_HEIGHT).toBe('number');
+    expect(EDITOR_LINE_HEIGHT).toBeGreaterThan(1);
+    expect(EDITOR_LINE_HEIGHT).toBeLessThan(3);
+  });
+  test('the stack leads with the bundled face and ends in a generic', () => {
+    expect(EDITOR_FONT_FAMILY.startsWith('"Fira Code"')).toBe(true);
+    expect(EDITOR_FONT_FAMILY.trimEnd().endsWith('monospace')).toBe(true);
+  });
+  test('the zoom bounds bracket the size the editor opens at', () => {
+    expect(EDITOR_MIN_FONT_SIZE).toBeLessThan(EDITOR_DEFAULT_FONT_SIZE);
+    expect(EDITOR_MAX_FONT_SIZE).toBeGreaterThan(EDITOR_DEFAULT_FONT_SIZE);
+  });
+});
+describe('editorFontStack', () => {
+  test('the default and an empty choice both yield the shared stack', () => {
+    expect(editorFontStack(EDITOR_DEFAULT_FONT_FAMILY)).toBe(EDITOR_FONT_FAMILY);
+    expect(editorFontStack('')).toBe(EDITOR_FONT_FAMILY);
+    expect(editorFontStack(undefined)).toBe(EDITOR_FONT_FAMILY);
+    expect(editorFontStack('   ')).toBe(EDITOR_FONT_FAMILY);
+  });
+  test('a chosen face is preferred, with the bundled stack still behind it', () => {
+    const stack = editorFontStack('JetBrains Mono');
+    expect(stack.startsWith('"JetBrains Mono"')).toBe(true);
+    // The fallback is what keeps an uninstalled choice from breaking the editor.
+    expect(stack).toContain(EDITOR_FONT_FAMILY);
+    expect(stack.trimEnd().endsWith('monospace')).toBe(true);
+  });
+  test('a multi-word choice is quoted, so it stays one family name', () => {
+    expect(editorFontStack('Courier New').startsWith('"Courier New"')).toBe(true);
+  });
+  test('the default choice is one the picker offers', () => {
+    expect(EDITOR_FONT_CHOICES.map((choice) => choice.id)).toContain(EDITOR_DEFAULT_FONT_FAMILY);
+  });
+  test('exactly one offered face is the bundled one, and it is the default', () => {
+    const bundled = EDITOR_FONT_CHOICES.filter((choice) => choice.bundled);
+    expect(bundled.map((choice) => choice.id)).toEqual([EDITOR_DEFAULT_FONT_FAMILY]);
+  });
+  test('every choice resolves to a stack that still ends in the bundled face', () => {
+    // The picker offers faces the app does not ship, so the guarantee that makes
+    // that safe is per-choice: a device without the chosen face must land on
+    // Fira Code rather than on a system serif or a blank cell.
+    for (const choice of EDITOR_FONT_CHOICES) {
+      const stack = editorFontStack(choice.id);
+      expect(stack.startsWith(`"${choice.id}"`)).toBe(true);
+      expect(stack).toContain(EDITOR_FONT_FAMILY);
+      expect(stack.trimEnd().endsWith('monospace')).toBe(true);
+    }
+  });
+});

package/src/shared/lib/code/editor/typography.ts ADDED Viewed

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The editor's typography, in one place.
+ *
+ * The desktop editor and the phone's full-screen editor are the same surface on
+ * two layouts, so their text has to be the same text — the same face and the
+ * same line box. It was not: the stack was written out as a literal twice in
+ * the desktop editor and replaced by a bare `monospace` on the phone, which
+ * dropped Fira Code (and the ligatures the whole console is typeset in) and put
+ * the phone's line numbers in a different face from the code beside them — the
+ * gutter was already `font-mono`.
+ *
+ * `EDITOR_LINE_HEIGHT` is a ratio rather than a pixel value for the reason the
+ * desktop editor already used one: the zoom control changes the font size, and
+ * a fixed pixel line box keeps the rows at the size they were chosen for at
+ * 12px — cramped at 18px, loose at 10px. It has to be applied to the gutter as
+ * well as the editor, because with word wrap off the gutter rows carry no
+ * explicit height and take their spacing from their own line-height; a gutter
+ * pinned to a different value drifts out of register with the lines it counts.
+ *
+ * The two layouts keep their own padding and gutter width — a phone has less
+ * room, and the padding is chrome, not type. Everything that decides how a
+ * glyph is drawn lives here.
+ */
+/** Fira Code first (bundled — see `fira-code-fonts.css`), then faces a system may already have. */
+export const EDITOR_FONT_FAMILY = '"Fira Code", "JetBrains Mono", "SF Mono", Consolas, monospace';
+/**
+ * The faces the editor font picker offers, in the order it lists them.
+ *
+ * Each entry is a CSS family name. The editor puts the chosen one FIRST in its
+ * stack and keeps the rest of `EDITOR_FONT_FAMILY` behind it, so a face the
+ * device does not have falls through to the bundled Fira Code rather than
+ * rendering a blank or a system serif — which is what makes this setting safe
+ * to offer without shipping every font in the list. Only Fira Code is bundled;
+ * the others are names a system may or may not have, and the picker says so.
+ *
+ * `id` is the stored value and is deliberately the CSS name itself: a mapping
+ * table would add a second thing to keep in sync, and the name is already the
+ * only thing the renderer needs.
+ */
+export const EDITOR_FONT_CHOICES = [
+  { id: 'Fira Code', label: 'Fira Code', bundled: true },
+  { id: 'JetBrains Mono', label: 'JetBrains Mono', bundled: false },
+  { id: 'SF Mono', label: 'SF Mono', bundled: false },
+  { id: 'Menlo', label: 'Menlo', bundled: false },
+  { id: 'Consolas', label: 'Consolas', bundled: false },
+  { id: 'Monaco', label: 'Monaco', bundled: false },
+  { id: 'Courier New', label: 'Courier New', bundled: false },
+] as const;
+/** The stored setting's default; also the first entry the picker lists. */
+export const EDITOR_DEFAULT_FONT_FAMILY = 'Fira Code';
+/**
+ * The editor's font stack with `family` preferred.
+ *
+ * The chosen face is quoted (the list carries multi-word names) and placed
+ * ahead of the shared stack, so an unknown or uninstalled name degrades to the
+ * bundled Fira Code instead of replacing it. An empty or absent choice yields
+ * the shared stack unchanged, which is what a settings row that predates this
+ * option holds.
+ */
+export function editorFontStack(family?: string | null): string {
+  const chosen = (family ?? '').trim();
+  if (!chosen || chosen === EDITOR_DEFAULT_FONT_FAMILY) return EDITOR_FONT_FAMILY;
+  return `"${chosen}", ${EDITOR_FONT_FAMILY}`;
+}
+/** Line box as a multiple of the font size; apply to the editor AND its gutter. */
+export const EDITOR_LINE_HEIGHT = 1.5;
+/** Font size in px both editors open at. */
+export const EDITOR_DEFAULT_FONT_SIZE = 12;
+/**
+ * Zoom bounds, in px. Shared so the two layouts offer the same range — a phone
+ * clamped to a narrower one is a different editor, not a smaller one.
+ */
+export const EDITOR_MIN_FONT_SIZE = 8;
+export const EDITOR_MAX_FONT_SIZE = 24;

package/src/shared/lib/fonts/NOTICE.md ADDED Viewed

@@ -0,0 +1,44 @@
+# Bundled font: Symbols Nerd Font Mono
+`symbols-nerd-font-mono.woff2` is a subset of **SymbolsNerdFontMono-Regular.ttf**
+from [Nerd Fonts](https://github.com/ryanoasis/nerd-fonts) **v3.5.1**, built by
+`scripts/nerd-symbols-font.mjs`. It is the fallback face for the terminal's
+private-use glyphs (powerline separators, devicons, Font Awesome, Material
+Design icons); see `nerd-symbols.css` for why it is needed and how it is scoped.
+Subset coverage — the private-use areas plus the handful of Nerd-specific
+codepoints outside them:
+    U+E000-F8FF      BMP private use
+    U+F0000-FFFFD    Supplementary private use area-A (Material Design Icons)
+    U+23FB-23FE, U+2630, U+2665, U+26A1, U+276C-2771, U+2B58
+## Licences
+The font is a patched build combining several upstream icon sets. Each is
+redistributed here under its own licence, unchanged in substance (the subset
+keeps the glyph outlines verbatim; only `layout-features` and hinting are
+dropped, which are not licence terms).
+| Icon set                 | Upstream                                              | Licence     |
+|--------------------------|-------------------------------------------------------|-------------|
+| Codicons                 | https://github.com/microsoft/vscode-codicons          | CC BY 4.0   |
+| Devicons                 | https://github.com/devicons/devicon                   | MIT         |
+| extraglyphs              | https://github.com/source-foundry/Hack                | MIT         |
+| Font Awesome             | https://github.com/FortAwesome/Font-Awesome           | CC BY 4.0   |
+| Font Awesome Extension   | https://github.com/AndreLZGava/font-awesome-extension | MIT         |
+| Font Logos               | https://github.com/lukas-w/font-logos                 | unlicensed  |
+| Material Design Icons    | https://github.com/Templarian/MaterialDesign-Font     | Apache 2.0  |
+| Octicons                 | https://github.com/primer/octicons                    | MIT         |
+| Seti and original        | https://github.com/jesseweed/seti-ui                  | MIT         |
+| Pomicons                 | https://github.com/gabrielelana/pomicons              | OFL 1.1 RFN |
+| Powerline Extra Symbols  | https://github.com/ryanoasis/powerline-extra-symbols  | MIT         |
+| Powerline Symbols        | https://github.com/powerline/powerline                | MIT         |
+The Nerd Fonts project itself (the patching, the font metadata and the
+non-icon glyphs) is MIT, Copyright (c) 2014 Ryan L McIntyre. Its licence text
+accompanies the upstream release at
+https://github.com/ryanoasis/nerd-fonts/blob/master/LICENSE.
+"Font Logos" is marked unlicensed upstream; it ships inside the Nerd Fonts
+release that this subset is taken from, and is redistributed on that basis.

package/src/shared/lib/fonts/nerd-symbols.css ADDED Viewed

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*
+ * The bundled Nerd Font symbols face.
+ *
+ * A shell prompt is drawn with private-use symbols — powerline separators,
+ * devicons, Font Awesome, Material Design icons — that no coding webfont
+ * contains. `@fontsource/fira-code`'s latin subset maps 226 codepoints and not
+ * one of them is above U+FFFF, so the terminal's stack can only reach them
+ * through a Nerd Font. Until now the stack named installed families only
+ * (`XTERM_GLYPH_FALLBACKS`), which means the glyphs appeared on the machine
+ * that had one installed and were hollow tofu boxes on every other device — a
+ * phone, a second laptop, a colleague's browser.
+ *
+ * This face closes that gap without taking the choice away: it is declared LAST
+ * in the stack, after every installed Nerd Font family, so a machine that
+ * already has one renders from it and never fetches these bytes.
+ *
+ * `unicode-range` is what makes "never fetches" true rather than aspirational.
+ * A face whose range no laid-out glyph falls in is never downloaded, so a page
+ * that renders only Latin text (or a desktop where an installed family wins)
+ * issues no request at all. Verified: a latin-only document with this
+ * stylesheet loaded fetched only `fira-code-latin-400-normal.woff2` and left
+ * this face `unloaded`; a document laying out U+E0B0 with an installed family
+ * ahead of it fetched nothing.
+ *
+ * `font-display: block` rather than `swap`, unlike the text faces beside it: a
+ * swapped symbol paints a tofu box first and repaints, and in a terminal that
+ * box is exactly the artifact this face exists to remove. `mount.ts` awaits the
+ * face before opening xterm for the same reason — see `ensureNerdGlyphs`.
+ *
+ * Generated by `bun run scripts/nerd-symbols-font.mjs` from
+ * `SymbolsNerdFontMono-Regular.ttf` (Nerd Fonts v3.5.1). See NOTICE.md in this
+ * directory for the icon-set licences.
+ */
+@font-face {
+  font-family: 'OMPChamber Nerd Symbols';
+  font-style: normal;
+  font-weight: 400;
+  font-display: block;
+  unicode-range:
+    U+E000-F8FF,
+    U+F0000-FFFFD,
+    U+23FB-23FE,
+    U+2630,
+    U+2665,
+    U+26A1,
+    U+276C-2771,
+    U+2B58;
+  src: url('./symbols-nerd-font-mono.woff2') format('woff2');
+}

package/src/shared/lib/fonts/nerd-symbols.test.ts ADDED Viewed

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The terminal's Nerd Font coverage is one contract split across three files,
+ * and every way it can break is silent at runtime:
+ *
+ * - The bundled face's family name is written twice — in the stack
+ *   (`XTERM_FONT_FAMILY`) and in the `@font-face` (`nerd-symbols.css`). If they
+ *   drift, the face loads and nothing uses it: prompts render as tofu boxes
+ *   with no error anywhere.
+ * - The face must stay LAST in the stack. Moved ahead of the installed families
+ *   it would win on every machine, which both changes the glyph shapes a user
+ *   with a Nerd Font already sees AND makes every desktop download 1.1 MB it
+ *   never needed. That is a bandwidth regression with no visible symptom on the
+ *   developer's own laptop.
+ * - The font file and its `unicode-range` must agree. A range that names
+ *   codepoints the subset dropped leaves those glyphs as tofu even though the
+ *   face is loaded and "working".
+ *
+ * These assertions are cheap and each one pins a failure this change was made
+ * to prevent, so they are permanent rather than throwaway.
+ */
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  NERD_SYMBOLS_FAMILY,
+  XTERM_FONT_FAMILY,
+  XTERM_GLYPH_FALLBACKS,
+} from '@/client/data/theme/terminal';
+const FONT_DIR = import.meta.dir;
+const CSS = readFileSync(join(FONT_DIR, 'nerd-symbols.css'), 'utf8');
+const WOFF2 = join(FONT_DIR, 'symbols-nerd-font-mono.woff2');
+/** Parse `unicode-range: a, b, c;` into codepoint intervals. */
+function declaredRanges(css: string): Array<[number, number]> {
+  const block = css.match(/unicode-range:\s*([^;]+);/);
+  if (!block) throw new Error('nerd-symbols.css declares no unicode-range');
+  return block[1]
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => {
+      const [start, end] = entry.split('-');
+      const lo = Number.parseInt(start.replace(/^U\+/i, ''), 16);
+      const hi = end ? Number.parseInt(end.replace(/^U\+/i, ''), 16) : lo;
+      return [lo, hi] as [number, number];
+    });
+}
+describe('bundled Nerd Font symbols face', () => {
+  test('the stylesheet declares the family the terminal stack names', () => {
+    const declared = CSS.match(/font-family:\s*'([^']+)'/)?.[1];
+    expect(declared).toBe(NERD_SYMBOLS_FAMILY);
+  });
+  test('the face is LAST in the stack, after every installed family', () => {
+    // A local Nerd Font must win, so the bundled face is only reached on a
+    // machine that has none — which is also what keeps the desktop from
+    // downloading it (its unicode-range is PUA-only, so it is never fetched
+    // when another family supplies the glyph).
+    expect(XTERM_FONT_FAMILY.indexOf(NERD_SYMBOLS_FAMILY)).toBeGreaterThan(
+      XTERM_FONT_FAMILY.indexOf('PowerlineSymbols'),
+    );
+    // Only the generic fallbacks may follow it.
+    const after = XTERM_FONT_FAMILY.slice(XTERM_FONT_FAMILY.indexOf(NERD_SYMBOLS_FAMILY));
+    expect(after).not.toMatch(/Nerd Font Mono'/);
+  });
+  test('every installed family is still offered before the bundled one', () => {
+    for (const family of ['FiraCode Nerd Font Mono', 'JetBrainsMono Nerd Font', 'Symbols Nerd Font Mono']) {
+      expect(XTERM_GLYPH_FALLBACKS).toContain(family);
+      expect(XTERM_FONT_FAMILY.indexOf(family)).toBeLessThan(
+        XTERM_FONT_FAMILY.indexOf(NERD_SYMBOLS_FAMILY),
+      );
+    }
+  });
+  test('the subset actually covers the ranges the stylesheet claims', () => {
+    // Reading the cmap needs fonttools, which is not a project dependency. The
+    // absence is a legitimate skip; a *failure* of the probe is not, so the two
+    // are told apart rather than both being swallowed as "no fonttools".
+    const available = Bun.spawnSync([
+      'python3',
+      '-c',
+      'import fontTools, brotli',
+    ]);
+    if (available.exitCode !== 0) {
+      console.warn('skipping font coverage check: python3 fonttools/brotli unavailable');
+      return;
+    }
+    const probe = Bun.spawnSync([
+      'python3',
+      '-c',
+      `
+import json
+from fontTools.ttLib import TTFont
+cmap = set(TTFont(${JSON.stringify(WOFF2)}).getBestCmap())
+ranges = ${JSON.stringify(declaredRanges(CSS))}
+uncovered = [r for r in ranges if not any(cp in cmap for cp in range(r[0], r[1] + 1))]
+# The prompt glyphs this face exists for.
+required = [0xE0B0, 0xE0B4, 0xE0B6, 0xE606, 0xE7A8, 0xE718, 0xF015, 0xF03E, 0xF121B, 0xF0001]
+print(json.dumps({ "codepoints": len(cmap), "uncovered": uncovered, "missing": [c for c in required if c not in cmap] }))
+`,
+    ]);
+    // fonttools is known to be importable here, so a non-zero exit is a real
+    // failure (a corrupt subset, a bad path) and must not read as a skip.
+    expect(probe.stderr.toString()).toBe('');
+    const result = JSON.parse(probe.stdout.toString()) as {
+      codepoints: number;
+      uncovered: Array<[number, number]>;
+      missing: number[];
+    };
+    expect(result.uncovered).toEqual([]);
+    expect(result.missing).toEqual([]);
+    expect(result.codepoints).toBeGreaterThan(10_000);
+  });
+  test('the face file is present and non-trivial', async () => {
+    const file = Bun.file(WOFF2);
+    expect(await file.exists()).toBe(true);
+    expect(file.size).toBeGreaterThan(100_000);
+  });
+});

package/src/shared/lib/fonts/symbols-nerd-font-mono.woff2 ADDED Viewed

Binary file

package/src/shared/lib/settings/diff.test.ts CHANGED Viewed

@@ -4,7 +4,7 @@ import { diffSettings } from '@/shared/lib/settings/diff';
 describe('diffSettings', () => {
   test('an object patch persists only the keys it actually changed', () => {
-    const prev = { theme: 'paper', soundAlerts: true, binaryPath: '/bin/omp' };
+    const prev = { theme: 'paper', soundAlerts: true, editorFont: 'Fira Code' };
     const next = { ...prev, theme: 'nord-dark' };
     expect(diffSettings(prev, next, { theme: 'nord-dark' })).toEqual({ theme: 'nord-dark' });
   });