ompchamber 3.1.1 → 3.3.0

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

@@ -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/code/language.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Language detection for the highlighter: which Shiki grammar a path maps to,
+ * and whether a block of text looks like code at all.
+ *
+ * Both are pure string predicates over the input, with no highlighter state, so
+ * they live beside the tokenizer rather than inside it — the tokenizer needs a
+ * booted Shiki instance, these do not, and a caller that only wants to pick a
+ * language (a tool card deciding whether to render a code surface) does not
+ * have to pull one in.
+ */
+
+/** Map file extension to Shiki language id */
+export function getLanguageFromPath(filePath?: string): string {
+  if (!filePath) return 'javascript';
+  const clean = filePath.split('?')[0].split('#')[0].replace(/:\d+(?:-\d+)?$/, '');
+  const ext = clean.split('.').pop()?.toLowerCase();
+  switch (ext) {
+    case 'ts': return 'typescript';
+    case 'tsx': return 'tsx';
+    case 'js':
+    case 'mjs':
+    case 'cjs': return 'javascript';
+    case 'jsx': return 'jsx';
+    case 'json': return 'json';
+    case 'md':
+    case 'markdown': return 'markdown';
+    case 'css': return 'css';
+    case 'sh':
+    case 'bash':
+    case 'zsh': return 'bash';
+    case 'diff':
+    case 'patch': return 'diff';
+    case 'yaml':
+    case 'yml': return 'yaml';
+    case 'html': return 'html';
+    case 'svg':
+    case 'xml': return 'xml';
+    case 'py': return 'python';
+    case 'go': return 'go';
+    case 'rs': return 'rust';
+    case 'sql': return 'sql';
+    case 'toml': return 'toml';
+    case 'java': return 'java';
+    case 'c':
+    case 'h': return 'c';
+    case 'cpp':
+    case 'cc':
+    case 'hpp': return 'cpp';
+    case 'cs': return 'csharp';
+    case 'rb': return 'ruby';
+    case 'php': return 'php';
+    case 'kt':
+    case 'kts': return 'kotlin';
+    case 'swift': return 'swift';
+    case 'scala': return 'scala';
+    case 'lua': return 'lua';
+    case 'pl': return 'perl';
+    case 'dockerfile': return 'dockerfile';
+    case 'ini':
+    case 'cfg':
+    case 'conf': return 'ini';
+    case 'properties': return 'properties';
+    case 'env': return 'bash';
+    case 'zig': return 'zig';
+    case 'ex':
+    case 'exs': return 'elixir';
+    case 'dart': return 'dart';
+    case 'ml':
+    case 'mli': return 'ocaml';
+    case 'hs': return 'haskell';
+    case 'nix': return 'nix';
+    case 'tf':
+    case 'tfvars':
+    case 'hcl': return 'hcl';
+    case 'graphql':
+    case 'gql': return 'graphql';
+    case 'sol': return 'solidity';
+    case 'r': return 'r';
+    case 'jl': return 'julia';
+    case 'erl': return 'erlang';
+    case 'clj':
+    case 'cljs':
+    case 'cljc':
+    case 'edn': return 'clojure';
+    case 'scm':
+    case 'ss': return 'scheme';
+    case 'rkt': return 'racket';
+    case 'proto': return 'protobuf';
+    case 'makefile':
+    case 'mk': return 'makefile';
+    case 'ps1':
+    case 'psm1': return 'powershell';
+    case 'json5': return 'json5';
+    case 'less': return 'less';
+    case 'scss': return 'scss';
+    case 'sass': return 'sass';
+    case 'styl': return 'stylus';
+    case 'vue': return 'vue';
+    case 'svelte': return 'svelte';
+    case 'astro': return 'astro';
+    // `.m` is genuinely ambiguous (Objective-C vs MATLAB); map to Objective-C,
+    // the common editor default.
+    case 'mm':
+    case 'm': return 'objective-c';
+    case 'groovy':
+    case 'gvy':
+    case 'gradle': return 'groovy';
+    default: return 'javascript';
+  }
+}
+
+/**
+ * The patterns `isCodeLike` probes, at module scope.
+ *
+ * A regex *literal* inside the function body constructs a fresh `RegExp` on
+ * every call, and this runs per render from the notice, task-result and Bash
+ * cards. Compiled once here instead.
+ */
+const CODE_PATTERNS = [
+  /^(?:import|export)\s+.+from\s+['"][^'"]+['"]/m,
+  /^(?:const|let|var|function|class|interface|type|enum)\s+[A-Za-z0-9_$]+/m,
+  /(?:=>|\bconsole\.(?:log|error|warn)|return\s+|async\s+function)/,
+  /^\s*\d+:\s*(?:import|const|let|function|\/\/|\/\*|<|[A-Za-z])/m,
+  /^\s*\[[A-Za-z0-9_./-]+\.[a-zA-Z0-9]+\]\s*\n\d+:/m,
+] as const;
+
+/** Check if a string looks like code or structured programming text */
+export function isCodeLike(text: string): boolean {
+  if (!text || text.length < 5) return false;
+  const trimmed = text.trim();
+  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+    try {
+      JSON.parse(trimmed);
+      return true;
+    } catch {
+      // not valid JSON
+    }
+  }
+
+  return CODE_PATTERNS.some((pattern) => pattern.test(trimmed));
+}

package/src/shared/lib/code/syntax-highlight.test.ts

@@ -7,7 +7,8 @@ import { beforeAll, describe, expect, test } from 'bun:test';
 
 import { bootSyntax, onLanguageReady, requestLanguage } from '@/shared/lib/code/highlighter';
 import { findMatches } from '@/shared/lib/code/editor/find';
-import { getLanguageFromPath, highlightCode, highlightLines } from '@/shared/lib/code/syntax-highlight';
+import { getLanguageFromPath } from '@/shared/lib/code/language';
+import { highlightCode, highlightLines } from '@/shared/lib/code/syntax-highlight';
 import { highlightCodeWindow } from '@/shared/lib/code/windowed-highlight';
 
 /** Shiki emits `<span class="shiki">…` with dual-theme CSS variables per token. */

package/src/shared/lib/code/syntax-highlight.ts

@@ -7,128 +7,6 @@ import { SHIKI_THEMES } from '@/shared/lib/code/shiki-themes';
 
 export type { HighlightLinesOptions };
 
-/** Map file extension to Shiki language id */
-export function getLanguageFromPath(filePath?: string): string {
-  if (!filePath) return 'javascript';
-  const clean = filePath.split('?')[0].split('#')[0].replace(/:\d+(?:-\d+)?$/, '');
-  const ext = clean.split('.').pop()?.toLowerCase();
-  switch (ext) {
-    case 'ts': return 'typescript';
-    case 'tsx': return 'tsx';
-    case 'js':
-    case 'mjs':
-    case 'cjs': return 'javascript';
-    case 'jsx': return 'jsx';
-    case 'json': return 'json';
-    case 'md':
-    case 'markdown': return 'markdown';
-    case 'css': return 'css';
-    case 'sh':
-    case 'bash':
-    case 'zsh': return 'bash';
-    case 'diff':
-    case 'patch': return 'diff';
-    case 'yaml':
-    case 'yml': return 'yaml';
-    case 'html': return 'html';
-    case 'svg':
-    case 'xml': return 'xml';
-    case 'py': return 'python';
-    case 'go': return 'go';
-    case 'rs': return 'rust';
-    case 'sql': return 'sql';
-    case 'toml': return 'toml';
-    case 'java': return 'java';
-    case 'c':
-    case 'h': return 'c';
-    case 'cpp':
-    case 'cc':
-    case 'hpp': return 'cpp';
-    case 'cs': return 'csharp';
-    case 'rb': return 'ruby';
-    case 'php': return 'php';
-    case 'kt':
-    case 'kts': return 'kotlin';
-    case 'swift': return 'swift';
-    case 'scala': return 'scala';
-    case 'lua': return 'lua';
-    case 'pl': return 'perl';
-    case 'dockerfile': return 'dockerfile';
-    case 'ini':
-    case 'cfg':
-    case 'conf': return 'ini';
-    case 'properties': return 'properties';
-    case 'env': return 'bash';
-    case 'zig': return 'zig';
-    case 'ex':
-    case 'exs': return 'elixir';
-    case 'dart': return 'dart';
-    case 'ml':
-    case 'mli': return 'ocaml';
-    case 'hs': return 'haskell';
-    case 'nix': return 'nix';
-    case 'tf':
-    case 'tfvars':
-    case 'hcl': return 'hcl';
-    case 'graphql':
-    case 'gql': return 'graphql';
-    case 'sol': return 'solidity';
-    case 'r': return 'r';
-    case 'jl': return 'julia';
-    case 'erl': return 'erlang';
-    case 'clj':
-    case 'cljs':
-    case 'cljc':
-    case 'edn': return 'clojure';
-    case 'scm':
-    case 'ss': return 'scheme';
-    case 'rkt': return 'racket';
-    case 'proto': return 'protobuf';
-    case 'makefile':
-    case 'mk': return 'makefile';
-    case 'ps1':
-    case 'psm1': return 'powershell';
-    case 'json5': return 'json5';
-    case 'less': return 'less';
-    case 'scss': return 'scss';
-    case 'sass': return 'sass';
-    case 'styl': return 'stylus';
-    case 'vue': return 'vue';
-    case 'svelte': return 'svelte';
-    case 'astro': return 'astro';
-    // `.m` is genuinely ambiguous (Objective-C vs MATLAB); map to Objective-C,
-    // the common editor default.
-    case 'mm':
-    case 'm': return 'objective-c';
-    case 'groovy':
-    case 'gvy':
-    case 'gradle': return 'groovy';
-    default: return 'javascript';
-  }
-}
-
-/** Check if a string looks like code or structured programming text */
-export function isCodeLike(text: string): boolean {
-  if (!text || text.length < 5) return false;
-  const trimmed = text.trim();
-  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-    try {
-      JSON.parse(trimmed);
-      return true;
-    } catch {
-      // not valid JSON
-    }
-  }
-
-  const codePatterns = [
-    /^(?:import|export)\s+.+from\s+['"][^'"]+['"]/m,
-    /^(?:const|let|var|function|class|interface|type|enum)\s+[A-Za-z0-9_$]+/m,
-    /(?:=>|\bconsole\.(?:log|error|warn)|return\s+|async\s+function)/,
-    /^\s*\d+:\s*(?:import|const|let|function|\/\/|\/\*|<|[A-Za-z])/m,
-    /^\s*\[[A-Za-z0-9_./-]+\.[a-zA-Z0-9]+\]\s*\n\d+:/m,
-  ];
-  return codePatterns.some((pattern) => pattern.test(trimmed));
-}
 
 /**
  * Pick a language that can be tokenized *synchronously* right now. A grammar

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

@@ -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

@@ -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

@@ -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/fs/diff-parser.test.ts

@@ -61,7 +61,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds a whitespace-only rewrite into context when ignoring whitespace', () => {
-    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, true);
+    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, { ignoreWhitespace: true });
 
     // The counts the toolbar renders must match what is on screen.
     expect(additions).toBe(0);
@@ -81,7 +81,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('keeps a real change when ignoring whitespace', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, { ignoreWhitespace: true });
 
     expect(additions).toBe(1);
     expect(deletions).toBe(1);
@@ -90,7 +90,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds only the whitespace pair of a mixed hunk', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, { ignoreWhitespace: true });
 
     // Line 1 differs by indentation only; line 2 is a genuine edit.
     expect(additions).toBe(1);
@@ -110,7 +110,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('returns empty results for an empty diff', () => {
-    expect(parseUnifiedDiff('', true)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
-    expect(parseUnifiedDiff('   \n', false)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('', { ignoreWhitespace: true })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('   \n', { ignoreWhitespace: false })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
   });
 });