From 3259c3fb31f423d562e970f5843d07673d08e2c8 Mon Sep 17 00:00:00 2001
From: raiseCatError <315733358+raiseCatError@users.noreply.github.com>
Date: Thu, 22 Oct 2026 02:56:25 +0530
Subject: [PATCH 1/2] Problems: offline static diagnostics for Markdown, HTML
 and CSS (#466)

---
 CHANGELOG.md                            |   1 +
 docs/design/document-workspace.md       |  12 +
 docs/development/v024-ledger.md         |   2 +
 docs/testing/v024-editor-physical-qa.md |   6 +
 src/app/TerminalApp.ts                  |  23 +-
 src/markdown/diagnostics.ts             | 422 ++++++++++++++++++++++++
 src/markdown/sourceMap.ts               |   5 +
 src/viewer/DocumentWorkspace.ts         |  13 +-
 src/viewer/EditorPalette.ts             |   6 +-
 src/viewer/EditorPanel.ts               | 100 +++++-
 src/viewer/problems.ts                  | 108 ++++++
 tests/diagnostics.test.ts               | 146 ++++++++
 tests/problems.test.ts                  | 230 +++++++++++++
 13 files changed, 1062 insertions(+), 12 deletions(-)
 create mode 100644 src/markdown/diagnostics.ts
 create mode 100644 src/viewer/problems.ts
 create mode 100644 tests/diagnostics.test.ts
 create mode 100644 tests/problems.test.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b361e74..c02c1ca5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Added
 
 - **Hybrid Markdown editing** ([#460](https://github.com/raiseCatError/notMyShell/issues/460)). **F3** in a Markdown document (or `H` from the read-only views) shows it *rendered* — headings, emphasis, links, lists, tables, quotes, code — except for the block your caret (or selection) is in, which shows its exact Markdown source and is fully editable. Move on and it renders again. It is another presentation of the same buffer: every key is the editor's (letters always type; snippets, list/table helpers, undo/redo, hunk review, recovery drafts and Save As all work as in the source editor), the caret lives in source positions, and switching views never changes the text. The smallest safe block is revealed — the whole list for a nested item, the whole table, the whole fence — and a selection shows every block it touches as source. The view is anchored to a source line, so revealing a block does not move what is above it. F3 again returns to the source editor; in the split view (F2) F3 switches the text pane between source and hybrid. Limits: Markdown files only (not HTML); images appear as `[image: alt]`; Up/Down move by source line; pointer input is not handled.
+- **Problems: offline static diagnostics** ([#466](https://github.com/raiseCatError/notMyShell/issues/466)). In a Markdown, HTML or CSS document, **F1 then `e`** (the snippet palette's *Problems…* in HTML files; **F1** in a CSS file; **`P`** in the read-only views and the split's preview pane) lists what is wrong: ✖ errors, ▲ warnings, ℹ notes and `?` things that cannot be checked. Markdown: links to files that do not exist, `#fragments` with no heading or id, missing images, images without alt text, undefined `[text][ref]` references and footnotes, unused footnotes, repeated headings. HTML: missing images, stylesheets and scripts, `<img>` without `alt`, form controls without a label, duplicate ids, unresolved `#fragments`, unclosed or unexpected tags. CSS: missing `url()` assets and unbalanced braces. Type to search, Tab filters (all, problems, errors), Enter jumps to the exact text and selects it (Back returns), Del dismisses one, Ctrl+R checks again. Checking starts when you first open Problems, follows the text (typing, undo, snippets, restored drafts, a merge) after a short pause, drops results for text that has since changed, and counts show in the editor's status row. Everything is offline: external URLs are counted, never fetched; no script, style or command is run; files are only looked at (never read except another Markdown file's headings, 256 KiB at most) and only inside the document's project (a path that leaves it, by `..` or a symlink, is reported as not checked); nothing is written. Browser-console diagnostics are a later, separate step.
 - **Footnote renumbering** ([#463](https://github.com/raiseCatError/notMyShell/issues/463)). *Renumber footnotes* in the snippet palette (F1, then `/` in a Markdown file) numbers the footnotes 1, 2, 3… in the order they are first referenced and updates each definition to match, as one undo step. Named footnotes (`[^note]`), escaped references, code spans and fenced code are left alone; a definition nobody references keeps its number unless a renumbered footnote needs it.
 - **Split view for Markdown and HTML documents** ([#461](https://github.com/raiseCatError/notMyShell/issues/461)). **F2** (or `s` in the read-only views) in the document workspace shows the editor beside NMSh's own preview of the *same* buffer: the text on the left, the rendered document on the right, updated as you type, without saving. The preview follows the caret to its block (`l` in the preview pane turns that off), **Ctrl+O** moves between the panes, `x` swaps the sides and `<` `>` change their widths (30–70%). Only the text pane is editable; keys typed while the preview has the focus never reach the text. The preview pane has its own find (`/`) and heading prompt (`#`). Below 100 columns only the focused pane is shown at full width, and widening the terminal brings the split back. Esc leaves for the read-only source view with your unsaved text kept; F2 again returns to editing. The browser-quality preview is not used in the split; the pane is NMSh's renderer. Mouse input in the split is not handled yet.
 - **Heading navigation** ([#462](https://github.com/raiseCatError/notMyShell/issues/462), first slice). In a Markdown or HTML document, **`#`** in the viewer or workspace opens a heading prompt: type to narrow, Up/Down choose, Enter jumps (source or rendered view, any width) and **Backspace** goes back to where you were. In the editor, F1 then `h` (or *Go to heading…* in the snippet palette) lists the headings with their depth; `j` / *Back* returns to the caret position you left, even after edits. `/view README.md#install` opens the file at that heading. Anchors follow GitHub's rules (lower-case, punctuation dropped, `-1`, `-2` for repeats; raw HTML headings listed without an anchor); Jekyll/Kramdown ids are different and are not implemented (see the [architecture note](docs/architecture/document-source-map.md)). Underneath, every parsed Markdown block now knows its source lines and every rendered row its block's line, the shared map the coming split view and hybrid editing build on.
diff --git a/docs/design/document-workspace.md b/docs/design/document-workspace.md
index 93dbbecd..1b4a2ee2 100644
--- a/docs/design/document-workspace.md
+++ b/docs/design/document-workspace.md
@@ -51,6 +51,18 @@ Limits: code fences are recognised by a line scan (indented code blocks and fenc
 
 **Verified by** `tests/markdownEdit.test.ts` (each helper: empty and multi-line selections, nested and mixed lists, quotes, fences, Unicode, very long lines, one undo step, restored drafts) and `tests/markdownEditorKeys.test.ts` (keys, menu at 30–120 columns, non-Markdown files unchanged, CRLF saved as CRLF). Physical Ghostty/Zed: NOT RUN.
 
+## Problems (static diagnostics)
+
+`src/markdown/diagnostics.ts` (engine), `src/viewer/problems.ts` (runner) and the *problems* dialog of `EditorPanel.ts` ([#466](https://github.com/raiseCatError/notMyShell/issues/466)). Reuses `parseBlockLines` (code blocks are skipped through the block spans), `headingsFromLines` and `resolveFragment`; no second parser, no language server.
+
+- **Severities:** `error` (certainly broken: a file that is not there, an undefined reference/footnote/id), `warning` (likely: a missing alt text, an unclosed tag, a fragment other generators might satisfy — a document with raw `id=`/`{#…}` ids gets warnings instead of errors), `info` (a repeated heading), `unverified` (not checked, not claimed wrong: absolute and `~` paths, a path outside the project, a templated attribute, a relative file in a document with no folder yet). External URLs (`http`, `mailto`, `//`, any other scheme) are only counted. `javascript:`, `vbscript:`, `file:` and non-image `data:` links are reported as never followed.
+- **Positions:** every finding has a 0-based line and, when it names exact text (a link destination, an attribute value, an id), UTF-16 columns; Enter selects that text. Without a span the caret goes to the start of the line and nothing pretends otherwise.
+- **Filesystem:** only through `LocalFs`, created per run for the document's folder with the project root (`documentRoot`: the git project within a dozen levels, else the folder). A path is lexically resolved, then `realpath`ed, and must stay inside the real root; for a missing path the deepest existing ancestor is checked, so a symlinked directory cannot be used to probe outside. Only `lstat` and one bounded read of another Markdown file (headings only). At most 400 distinct paths per run; at most 500 findings; HTML over 1.5 MB is skipped and marked truncated; messages never name a path the document did not itself write.
+- **Currency:** checking is off until Problems is first opened. Then `ProblemsRunner` observes the buffer: each change bumps a revision and schedules a run (500 ms); a run snapshots the lines, aborts any run in flight, and its result is dropped if the revision moved. Opening Problems, Ctrl+R, a save and a Save As re-check (files the document names may have changed; no watchers). The runner is disposed with the editor, on reload and on exit, so no timer or observer outlives the document.
+- **Surface:** the dialog lists findings by severity then line with counts and the number of external links not checked; Tab cycles all / problems / errors, typing filters on the message, Del dismisses (until the next report), Esc leaves. In source and preview a jump also scrolls the read-only view to the line; hybrid and the split follow the caret.
+- **Not provided:** a gutter marker in the text, checks of other languages, CSS property validation, link fragments inside another HTML file, following redirects or fetching anything, quick fixes, and the browser console (a separate, gated slice).
+- **Verified by** `tests/diagnostics.test.ts` (each check, hostile paths and symlinks, the filesystem checker, no-folder documents, Unicode and stray CR, HTML and CSS, false-positive stress, bounds) and `tests/problems.test.ts` (runner staleness and disposal, the surface, filters, dismiss, refresh, widths/NO_COLOR/Safe Glyphs, and every mode: source, preview, hybrid, split, edit).
+
 ## Hybrid view
 
 `DocumentMode` gains `'hybrid'` (#460), implemented in `src/viewer/HybridView.ts` over the shared source map (`docs/architecture/document-source-map.md`). It is a presentation of the one `TextBuffer`; there is no second editor and no second document.
diff --git a/docs/development/v024-ledger.md b/docs/development/v024-ledger.md
index 9a46cf2d..926f5225 100644
--- a/docs/development/v024-ledger.md
+++ b/docs/development/v024-ledger.md
@@ -44,6 +44,8 @@ The paused issues #460–#469 are the milestone (the maintainer superseded the e
 8. **#460: hybrid Markdown editing** — branch `feature/v024-hybrid` (from `dev` after #489–#496 merged). Done: hybrid mode, items from the source map, active-block raw editing, anchored viewport, split text-pane toggle, tests, independent review (see its section). **#460 remaining:** images in place, visual-line movement, pointer input, tables as a grid, HTML. **#461** still lacks pointer input, preview→caret sync, vertical orientation and the Chromium preview; **#463** footnote renumbering; **#466**, **#462** (details/Mermaid/math), **#464/#465/#467** not started.
 9. **#463: footnote renumbering** — branch `feature/v024-footnotes`, from `dev`. Done (tests in `footnotes.test.ts`). **#463 acceptance:** every implemented item is covered by automated tests; the only open requirement is the physical Ghostty/Zed pass (NOT RUN), so the issue stays open.
 
+10. **#466: offline static diagnostics** — branch `feature/v024-diagnostics`, from `dev`. Done: engine, runner, Problems surface in all modes, tests, independent review (see its section in the design doc). **#466 remaining:** the optional browser console for trusted previews (separate gated slice, nothing started), a gutter marker, further languages. **#462 next:** `<details>` disclosure, then Mermaid and math (separate slices).
+
 ## Environment notes
 
 Scratch and test runs: `t7run`; focused tests via `/Volumes/T7Tmp/ai-dev/runtests.mjs` (see the testing-gotchas memory). `npm ci` was needed in a fresh worktree (the main checkout's `node_modules` is stale).
diff --git a/docs/testing/v024-editor-physical-qa.md b/docs/testing/v024-editor-physical-qa.md
index b3e783f6..1ee44e03 100644
--- a/docs/testing/v024-editor-physical-qa.md
+++ b/docs/testing/v024-editor-physical-qa.md
@@ -21,6 +21,12 @@ Automated tests cover the logic headlessly. Everything below is **NOT RUN** unti
 - [ ] Mermaid and math entries say they are source text; nothing in the preview claims to render them.
 - [ ] The palette rows and footer fit 30, 50, 80 and 120 columns; NO_COLOR and Safe Glyphs stay legible.
 
+## Problems (#466)
+- [ ] F1 then `e` in a Markdown file with a broken link, a missing image and a bad `#fragment`: the list shows them; Enter selects the exact text; Back returns. `P` in the read-only views and in the split's preview pane.
+- [ ] An HTML file (palette → Problems) and a CSS file (F1); the status row counts; fixing a finding removes it after a moment; undo brings it back.
+- [ ] A symlink out of the project and `/etc/passwd`-style paths are reported as not checked; an external URL is never fetched (watch the network).
+- [ ] 30, 50, 80 and 120 columns; NO_COLOR; Safe Glyphs (E/W/i/?).
+
 ## Hybrid view (#460)
 - [ ] Open a Markdown file, F3 (is F3 delivered by the terminal and by Zed?): headings, bold, links, lists, tables, quotes and fences render; the block under the caret shows its source; moving with the arrows swaps blocks without the screen jumping.
 - [ ] Type in every kind of block; select across blocks with Shift+Down (both show source); undo/redo; insert a snippet and Tab through it.
diff --git a/src/app/TerminalApp.ts b/src/app/TerminalApp.ts
index 697dfd06..b9bff7d0 100644
--- a/src/app/TerminalApp.ts
+++ b/src/app/TerminalApp.ts
@@ -80,6 +80,7 @@ import {createEditor, editorKey, offerDraft, renderEditor, type EditorAction, ty
 import {createScratchFile, openForEdit, saveFile} from '../viewer/fileEdit.js';
 import {headingsOf, resolveFragment} from '../markdown/sourceMap.js';
 import {DraftKeeper, DraftStore, type DraftOffer} from '../viewer/draftRecovery.js';
+import {ProblemsRunner} from '../viewer/problems.js';
 import {applyReview, beginReview, restartReview, sameDiskVersion} from '../viewer/ReviewPanel.js';
 import {bufferText, createDocumentSession, renderDocumentSession, setDocumentMode, syncDocumentViewer, documentSessionKey, documentSessionLook, type DocumentSessionAction, type DocumentMode, type DocumentSession} from '../viewer/DocumentWorkspace.js';
 import {formatForPath} from '../viewer/document.js';
@@ -1063,6 +1064,8 @@ export class TerminalApp {
   private finish!: (exitCode: number) => void;
 
   constructor(connection?: SessionConnection, preset?: SessionPreset) {
+    // A finished check redraws the panel that shows its counts.
+    ProblemsRunner.notify = () => { if (!this.stopped) this.render(); };
     if (preset) {
       if (!connection || connection.mode !== 'service' || connection.attached) throw new Error('Presets require a new live session.');
       this.presetStartup = new PresetStartup(preset);
@@ -4601,6 +4604,7 @@ export class TerminalApp {
         this.drafts().discard(editor);
         editor.file = saved.file;
         if (editor.buffer.lines.length === lines.length && editor.buffer.lines.every((line, index) => line === lines[index])) editor.buffer.markSaved();
+        editor.problems?.refresh();
         editor.note = {text: `Saved as ${saved.file.title}.`, tone: 'success'};
         if (session) { session.viewer.note = editor.note.text; syncDocumentViewer(session, session.mode === 'preview'); }
         if (thenClose) close();
@@ -4614,6 +4618,13 @@ export class TerminalApp {
     })();
   }
 
+  /** An editor is going away (closed, reloaded, replaced): its recovery draft goes and its checking and parsed index stop. */
+  private releaseEditor(editor: EditorState): void {
+    this.drafts().discard(editor);
+    editor.problems?.dispose();
+    editor.index?.dispose();
+  }
+
   private runDraftAction(editor: EditorState, action: Extract<EditorAction, {kind: 'draft' | 'draft-discard' | 'draft-keep'}>): void {
     const keeper = this.drafts();
     if (action.kind === 'draft') keeper.restored(editor, action.target);
@@ -4624,11 +4635,11 @@ export class TerminalApp {
   /** The editor's requests that touch the disk or the clipboard; the panel shows the outcome. */
   private runEditorAction(editor: EditorState, action: EditorAction): void {
     if (action.kind === 'draft' || action.kind === 'draft-discard' || action.kind === 'draft-keep') { this.runDraftAction(editor, action); return; }
-    if (action.kind === 'playground') { this.drafts().discard(editor); this.textEditor = undefined; void this.openPlayground(action.choice); return; }
+    if (action.kind === 'playground') { this.releaseEditor(editor); this.textEditor = undefined; void this.openPlayground(action.choice); return; }
     if (action.kind === 'save-as') { this.saveAs(editor, action.path, Boolean(action.thenClose), () => this.textEditor === editor, () => { this.textEditor = undefined; this.returnFromPanel(); }); return; }
     if (editor.file.scratch && (action.kind === 'review' || action.kind === 'review-apply' || action.kind === 'reload' || action.kind === 'save')) { editor.note = {text: 'A Playground document has no file yet: Save As creates one.', tone: 'info'}; return; }
     if (action.kind === 'review' || action.kind === 'review-apply') { this.reviewDisk(editor, action.kind === 'review-apply', () => this.textEditor === editor); return; }
-    if (action.kind === 'close') { this.drafts().discard(editor); this.textEditor = undefined; this.returnFromPanel(); return; }
+    if (action.kind === 'close') { this.releaseEditor(editor); this.textEditor = undefined; this.returnFromPanel(); return; }
     if (action.kind === 'copy') {
       void this.copyText(action.text, 'Copied').then(note => { if (note && this.textEditor === editor) { editor.note = {text: note, tone: 'success'}; this.render(); } });
       return;
@@ -4654,8 +4665,8 @@ export class TerminalApp {
         // Only what was written is clean: typing during the save stays unsaved.
         if (editor.buffer.lines.length === lines.length && editor.buffer.lines.every((line, index) => line === lines[index])) editor.buffer.markSaved();
         this.drafts().note(editor);
-        if (action.thenClose) { this.drafts().discard(editor); this.textEditor = undefined; this.returnFromPanel(); }
-        else editor.note = {text: `Saved ${editor.file.title}.`, tone: 'success'};
+        if (action.thenClose) { this.releaseEditor(editor); this.textEditor = undefined; this.returnFromPanel(); }
+        else { editor.problems?.refresh(); editor.note = {text: `Saved ${editor.file.title}.`, tone: 'success'}; }
       } else if (result.conflict) {
         editor.dialog = {kind: 'conflict', focus: 0, conflict: result.conflict, reason: result.reason, ...(action.thenClose ? {thenClose: true} : {})};
       } else editor.note = {text: `${result.reason} Your text is still here.`, tone: 'error'};
@@ -4750,7 +4761,7 @@ export class TerminalApp {
     const session = this.docSession;
     if (!session) return;
     this.docSession = undefined;
-    this.drafts().discard(session.editor);
+    this.releaseEditor(session.editor);
     session.preview?.dispose();
     this.releaseViewerImages();
     this.returnFromPanel();
@@ -4802,6 +4813,7 @@ export class TerminalApp {
         if (editor.buffer.lines.length === lines.length && editor.buffer.lines.every((line, index) => line === lines[index])) editor.buffer.markSaved();
         if (action.thenClose) { this.closeDocumentSession(); this.render(); return; }
         this.drafts().note(editor);
+        editor.problems?.refresh();
         editor.note = {text: `Saved ${editor.file.title}.`, tone: 'success'};
         session.viewer.note = `Saved ${editor.file.title}.`;
         syncDocumentViewer(session, session.mode === 'preview');
@@ -13965,6 +13977,7 @@ export class TerminalApp {
     this.docSession?.preview?.dispose();
     // Unsaved editor text is written before the window ends, so closing it never costs the text.
     this.draftKeeper?.dispose();
+    this.textEditor?.problems?.dispose(); this.docSession?.editor.problems?.dispose();
     void this.browserHost?.shutdown();
     this.releaseViewerImages();
     this.graphics?.releaseAll();
diff --git a/src/markdown/diagnostics.ts b/src/markdown/diagnostics.ts
new file mode 100644
index 00000000..75dff080
--- /dev/null
+++ b/src/markdown/diagnostics.ts
@@ -0,0 +1,422 @@
+import {lstat, open, realpath} from 'node:fs/promises';
+import {dirname, isAbsolute, relative, resolve, sep} from 'node:path';
+import {parseBlockLines, type Block} from './blocks.js';
+import {headingsFromLines, resolveFragment} from './sourceMap.js';
+
+/**
+ * Offline static diagnostics for Markdown, HTML and CSS documents (#466). Everything here reads the document's own lines (the
+ * editor's buffer, saved or not) and, only through an injected `LocalFs`, checks that files the document names exist inside
+ * the document's folder or project. It never fetches a URL, runs a script or a command, follows a link out of the root,
+ * writes anything or reports a guess as a fact:
+ *
+ *   error       a reference that is certainly broken (the file is not there, the id/footnote/reference is not defined)
+ *   warning     likely a problem (a missing alt text, an unclosed tag, a fragment that Jekyll ids might satisfy)
+ *   info        worth knowing (a repeated heading)
+ *   unverified  could not be checked, and is not claimed to be wrong (an absolute path, a path outside the project, a templated
+ *               attribute, a relative file of a document that has no folder yet)
+ *
+ * External URLs are only counted. Positions are source lines and UTF-16 columns of the exact text, so a jump can select it.
+ */
+
+export type Severity = 'error' | 'warning' | 'info' | 'unverified';
+
+export interface Diagnostic {
+  id: string;
+  code: string;
+  severity: Severity;
+  message: string;
+  /** 0-based source line. */
+  line: number;
+  column?: number;
+  endColumn?: number;
+  /** The span is exactly the text at fault; otherwise only the line is known. */
+  exact: boolean;
+}
+
+export interface DiagnosticReport {
+  diagnostics: Diagnostic[];
+  /** External references seen and deliberately not checked. */
+  external: number;
+  /** Filesystem checks made. */
+  checked: number;
+  /** Stopped early: too many findings or checks. */
+  truncated: boolean;
+  aborted?: boolean;
+}
+
+export type FileState = 'file' | 'directory' | 'missing' | 'unreadable' | 'outside';
+
+export interface LocalFs {
+  /** The state of a path written in the document (already percent-decoded, relative to the document's folder). */
+  stat(path: string): Promise<FileState>;
+  /** Up to `maxBytes` of a regular file inside the root, for checking a heading fragment in another Markdown file. */
+  readText(path: string, maxBytes: number): Promise<string | undefined>;
+}
+
+export const MAX_DIAGNOSTICS = 500;
+export const MAX_CHECKS = 400;
+const MAX_PATH = 1024;
+const MAX_TARGET_BYTES = 256 * 1024;
+
+/** A checker confined to `root`: lexical `..` and symlinks are both resolved before a path is called inside. */
+export function createLocalFs(docDir: string, root: string): LocalFs {
+  let realRoot: Promise<string> | undefined;
+  const rootReal = () => realRoot ??= realpath(root).catch(() => root);
+  const inside = (base: string, path: string) => { const rel = relative(base, path); return rel === '' || (!rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel)); };
+  async function locate(path: string): Promise<{state: FileState; real?: string}> {
+    if (!path || path.length > MAX_PATH || path.includes('\0')) return {state: 'unreadable'};
+    const resolved = resolve(docDir, path);
+    if (!inside(root, resolved)) return {state: 'outside'};
+    const base = await rootReal();
+    try {
+      const real = await realpath(resolved);
+      if (!inside(base, real)) return {state: 'outside'};
+      const info = await lstat(real);
+      return {state: info.isDirectory() ? 'directory' : info.isFile() ? 'file' : 'unreadable', real};
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === 'EACCES' || code === 'EPERM') return {state: 'unreadable'};
+      if (code !== 'ENOENT' && code !== 'ENOTDIR') return {state: 'unreadable'};
+      // Missing: but a symlinked folder on the way may already lead out of the root.
+      for (let ancestor = dirname(resolved); ancestor !== dirname(ancestor); ancestor = dirname(ancestor)) {
+        try { const real = await realpath(ancestor); return {state: inside(base, real) ? 'missing' : 'outside'}; } catch { /* keep climbing */ }
+      }
+      return {state: 'missing'};
+    }
+  }
+  return {
+    stat: async path => (await locate(path)).state,
+    async readText(path, maxBytes) {
+      const found = await locate(path);
+      if (found.state !== 'file' || !found.real) return undefined;
+      let handle;
+      try { handle = await open(found.real, 'r'); const buffer = Buffer.alloc(maxBytes); const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0); return buffer.subarray(0, bytesRead).toString('utf8'); }
+      catch { return undefined; } finally { await handle?.close().catch(() => undefined); }
+    },
+  };
+}
+
+// ---- Destinations -----------------------------------------------------------------------------------------------
+
+type Target =
+  | {kind: 'fragment'; fragment: string}
+  | {kind: 'local'; path: string; fragment?: string}
+  | {kind: 'external'}
+  | {kind: 'unsafe'; scheme: string}
+  | {kind: 'absolute'}
+  | {kind: 'ignore'};
+
+function classify(destination: string): Target {
+  const text = destination.trim();
+  if (!text) return {kind: 'ignore'};
+  if (text.startsWith('#')) return text.length > 1 ? {kind: 'fragment', fragment: text.slice(1)} : {kind: 'ignore'};
+  const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*):/u.exec(text)?.[1]?.toLowerCase();
+  if (scheme) {
+    if (['javascript', 'vbscript', 'file'].includes(scheme)) return {kind: 'unsafe', scheme};
+    if (scheme === 'data') return /^data:image\//iu.test(text) ? {kind: 'ignore'} : {kind: 'unsafe', scheme};
+    if (scheme.length === 1) return {kind: 'absolute'};
+    return {kind: 'external'};
+  }
+  if (text.startsWith('//')) return {kind: 'external'};
+  if (text.startsWith('/') || text.startsWith('~') || text.startsWith('\\')) return {kind: 'absolute'};
+  const hash = text.indexOf('#');
+  const withoutFragment = hash >= 0 ? text.slice(0, hash) : text;
+  const fragment = hash >= 0 ? text.slice(hash + 1) : undefined;
+  const path = withoutFragment.replace(/\?.*$/u, '');
+  if (!path) return fragment ? {kind: 'fragment', fragment} : {kind: 'ignore'};
+  let decoded = path;
+  try { decoded = decodeURIComponent(path); } catch { /* keep it as written */ }
+  return {kind: 'local', path: decoded, ...(fragment ? {fragment} : {})};
+}
+
+const TEMPLATED = /\{\{|\{%|<%|\$\{|\{#/u;
+
+// ---- The run ----------------------------------------------------------------------------------------------------
+
+export interface DiagnoseInput {
+  lines: readonly string[];
+  format: 'markdown' | 'html' | 'css';
+  fs?: LocalFs;
+  signal?: AbortSignal;
+  maxChecks?: number;
+}
+
+class Run {
+  diagnostics: Diagnostic[] = [];
+  external = 0;
+  truncated = false;
+  private readonly states = new Map<string, Promise<FileState>>();
+  private ids = 0;
+  constructor(readonly input: DiagnoseInput) {}
+  get aborted() { return Boolean(this.input.signal?.aborted); }
+  get checked() { return this.states.size; }
+
+  add(code: string, severity: Severity, message: string, line: number, column?: number, endColumn?: number): void {
+    if (this.diagnostics.length >= MAX_DIAGNOSTICS) { this.truncated = true; return; }
+    this.diagnostics.push({id: `${code}:${line}:${column ?? ''}:${this.ids++}`, code, severity, message, line, exact: column !== undefined && endColumn !== undefined, ...(column === undefined ? {} : {column}), ...(endColumn === undefined ? {} : {endColumn})});
+  }
+
+  stat(path: string): Promise<FileState> | undefined {
+    const known = this.states.get(path);
+    if (known) return known;
+    if (!this.input.fs || this.states.size >= (this.input.maxChecks ?? MAX_CHECKS)) { if (this.input.fs) this.truncated = true; return undefined; }
+    const pending = this.input.fs.stat(path);
+    this.states.set(path, pending);
+    return pending;
+  }
+
+  /** Report a destination written in the document. `kindOfAsset`: a missing file is an error either way; the wording differs. */
+  async reference(destination: string, line: number, column: number, headings: ReturnType<typeof headingsFromLines> | undefined, ids: ReadonlySet<string> | undefined, softFragments: boolean): Promise<void> {
+    const end = column + destination.length;
+    const target = classify(destination);
+    switch (target.kind) {
+      case 'ignore': return;
+      case 'external': this.external += 1; return;
+      case 'unsafe': this.add('unsafe-scheme', 'warning', `A ${target.scheme}: link is never followed or checked here.`, line, column, end); return;
+      case 'absolute': this.add('absolute-path', 'unverified', 'Absolute and home-relative paths are not checked.', line, column, end); return;
+      case 'fragment': {
+        const found = headings ? resolveFragment(headings, target.fragment) : undefined;
+        let decoded = target.fragment;
+        try { decoded = decodeURIComponent(decoded); } catch { /* as written */ }
+        if (found || ids?.has(decoded) || ids?.has(target.fragment) || decoded.toLowerCase() === 'top') return;
+        this.add('broken-fragment', softFragments ? 'warning' : 'error', softFragments ? `No heading or id “${target.fragment}” here (other generators may build ids differently).` : `No heading or id “${target.fragment}” in this document.`, line, column, end);
+        return;
+      }
+      case 'local': {
+        const pending = this.stat(target.path);
+        if (!pending) { if (!this.input.fs) this.add('unverified-local', 'unverified', 'Not checked: this document has no folder yet. Save it to check local files.', line, column, end); return; }
+        const state = await pending;
+        if (this.aborted) return;
+        if (state === 'outside') this.add('outside-root', 'unverified', 'Points outside the document\'s folder or project; not checked.', line, column, end);
+        else if (state === 'unreadable') this.add('unreadable', 'warning', 'This path cannot be read or checked.', line, column, end);
+        else if (state === 'missing') this.add('missing-file', 'error', `No such file: ${target.path}`, line, column, end);
+        else if (state === 'file' && target.fragment && /\.(?:md|markdown)$/iu.test(target.path) && this.input.fs) {
+          const text = await this.input.fs.readText(target.path, MAX_TARGET_BYTES);
+          if (text !== undefined && !resolveFragment(headingsFromLines(text.split('\n')), target.fragment)) this.add('broken-fragment-in-file', 'warning', `No heading “${target.fragment}” in ${target.path}.`, line, column, end);
+        }
+        return;
+      }
+    }
+  }
+}
+
+function codeLines(blocks: readonly Block[], into: Set<number>): void {
+  for (const block of blocks) {
+    if (block.kind === 'code' && block.from !== undefined && block.to !== undefined) for (let line = block.from; line < block.to; line += 1) into.add(line);
+    else if (block.kind === 'quote') codeLines(block.blocks, into);
+    else if (block.kind === 'list') for (const item of block.items) codeLines(item.blocks, into);
+  }
+}
+
+const normalize = (label: string) => label.trim().replace(/\s+/gu, ' ').toLowerCase();
+const maskCode = (text: string) => text.replace(/(`+)[\s\S]*?\1/gu, span => ' '.repeat(span.length));
+
+async function markdown(run: Run): Promise<void> {
+  const lines = run.input.lines;
+  const blocks = parseBlockLines(lines, {html: true});
+  const skip = new Set<number>();
+  codeLines(blocks, skip);
+  if (lines[0]?.trim() === '---') for (let at = 1; at < Math.min(lines.length, 200); at += 1) if (/^(?:---|\.\.\.)\s*$/u.test(lines[at]!)) { for (let line = 0; line <= at; line += 1) skip.add(line); break; }
+  const headings = headingsFromLines(lines, {html: true});
+  const seen = new Map<string, number>();
+  for (const heading of headings) {
+    const key = heading.slug;
+    if (key === undefined) continue;
+    const first = seen.get(heading.text.toLowerCase());
+    if (first !== undefined) run.add('duplicate-heading', 'info', `Same heading text as line ${first + 1}; its anchor is #${key}.`, heading.line);
+    else seen.set(heading.text.toLowerCase(), heading.line);
+  }
+  const soft = lines.some(line => /\bid\s*=|\{#/u.test(line));
+  const definitions = new Set<string>(), footnoteDefs = new Map<string, number>();
+  const refs: Array<{label: string; line: number; start: number; end: number}> = [], notes: Array<{label: string; line: number; start: number; end: number}> = [];
+  const destinations: Array<{destination: string; line: number; column: number; image?: boolean; alt?: string}> = [];
+  lines.forEach((text, line) => {
+    if (skip.has(line) || run.aborted) return;
+    const masked = maskCode(text);
+    let from = 0;
+    const note = /^ {0,3}\[\^([^\]\s]+)\]:/u.exec(masked);
+    const definition = note ? undefined : /^ {0,3}\[([^\]]+)\]:[ \t]*(<[^>\n]*>|\S+)/du.exec(masked);
+    if (note) { footnoteDefs.set(note[1]!, line); from = note[0].length; }
+    if (definition) {
+      definitions.add(normalize(definition[1]!));
+      const raw = definition[2]!;
+      const start = definition.indices![2]![0] + (raw.startsWith('<') ? 1 : 0);
+      destinations.push({destination: raw.startsWith('<') ? raw.slice(1, -1) : raw, line, column: start});
+      from = definition[0].length;
+    }
+    const rest = masked.slice(from);
+    for (const match of rest.matchAll(/(!?)(?<!\\)\[((?:[^\]\\]|\\.)*)\]\(\s*(<[^>\n]*>|[^\s()]*(?:\([^\s()]*\)[^\s()]*)*)/gdu)) {
+      const raw = match[3]!;
+      const [startIndex] = match.indices![3]!;
+      const angle = raw.startsWith('<');
+      destinations.push({destination: angle ? raw.slice(1, -1) : raw, line, column: from + startIndex + (angle ? 1 : 0), ...(match[1] ? {image: true, alt: match[2]!} : {})});
+    }
+    for (const match of rest.matchAll(/(?<![\\!])\[((?:[^\]\\]|\\.)+)\]\[((?:[^\]\\]|\\.)*)\]/gdu)) {
+      if (match[1]!.startsWith('^')) continue;
+      const label = match[2]! || match[1]!;
+      const [start, end] = match.indices![match[2]! ? 2 : 1]!;
+      refs.push({label, line, start: from + start, end: from + end});
+    }
+    for (const match of rest.matchAll(/(?<!\\)\[\^([^\]\s]+)\](?!:)/gdu)) { const [start, end] = match.indices![1]!; notes.push({label: match[1]!, line, start: from + start, end: from + end}); }
+    run.external += [...rest.matchAll(/<([a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]*)>/gu)].filter(autolink => classify(autolink[1]!).kind === 'external').length;
+  });
+  for (const item of destinations) {
+    if (run.aborted) return;
+    if (item.image && !item.alt!.trim()) run.add('image-alt', 'warning', 'This image has no alternative text.', item.line, item.column - 1, item.column - 1 + item.destination.length + 1);
+    await run.reference(item.destination, item.line, item.column, headings, undefined, soft);
+  }
+  for (const ref of refs) if (!definitions.has(normalize(ref.label))) run.add('undefined-reference', 'error', `No link reference definition for “${ref.label}”.`, ref.line, ref.start, ref.end);
+  const used = new Set<string>();
+  for (const note of notes) { used.add(note.label); if (!footnoteDefs.has(note.label)) run.add('undefined-footnote', 'error', `No definition for footnote [^${note.label}].`, note.line, note.start, note.end); }
+  for (const [label, line] of footnoteDefs) if (!used.has(label)) run.add('unreferenced-footnote', 'warning', `Footnote [^${label}] is defined but never referenced.`, line);
+}
+
+// ---- CSS and HTML -----------------------------------------------------------------------------------------------
+
+async function cssUrls(run: Run, text: string, line: number, columnBase: number): Promise<void> {
+  for (const match of text.matchAll(/url\(\s*(?:"([^"\n]*)"|'([^'\n]*)'|([^)\s'"]*))\s*\)/gdu)) {
+    const value = match[1] ?? match[2] ?? match[3] ?? '';
+    const [start] = match.indices![match[1] !== undefined ? 1 : match[2] !== undefined ? 2 : 3]!;
+    if (TEMPLATED.test(value)) { run.add('unverified-dynamic', 'unverified', 'A templated address cannot be checked statically.', line, columnBase + start, columnBase + start + value.length); continue; }
+    await run.reference(value, line, columnBase + start, undefined, undefined, false);
+  }
+}
+
+function cssSyntax(run: Run, lines: readonly string[]): void {
+  const stack: Array<{char: string; line: number; column: number}> = [];
+  let comment = false, quote = '';
+  for (let line = 0; line < lines.length; line += 1) {
+    const text = lines[line]!;
+    for (let column = 0; column < text.length; column += 1) {
+      const char = text[column]!;
+      if (comment) { if (char === '*' && text[column + 1] === '/') { comment = false; column += 1; } continue; }
+      if (quote) { if (char === '\\') column += 1; else if (char === quote) quote = ''; continue; }
+      if (char === '/' && text[column + 1] === '*') { comment = true; column += 1; continue; }
+      if (char === '"' || char === '\'') { quote = char; continue; }
+      if (char === '{' || char === '(') stack.push({char, line, column});
+      else if (char === '}' || char === ')') {
+        const open = stack.pop();
+        if (!open || (open.char === '{') !== (char === '}')) { run.add('css-syntax', 'warning', `Unexpected “${char}”.`, line, column, column + 1); return; }
+      }
+    }
+    quote = '';
+  }
+  const open = stack.at(-1);
+  if (open) run.add('css-syntax', 'warning', `“${open.char}” is never closed.`, open.line, open.column, open.column + 1);
+  else if (comment) run.add('css-syntax', 'warning', 'A comment is never closed.', lines.length - 1);
+}
+
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const OPTIONAL_END = new Set(['p', 'li', 'dt', 'dd', 'tr', 'td', 'th', 'thead', 'tbody', 'tfoot', 'option', 'optgroup', 'colgroup', 'html', 'head', 'body']);
+const RAW_TEXT = new Set(['script', 'style', 'textarea', 'title']);
+const TAG = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>`=]+))?)*)\s*(\/?)>/gdu;
+const ATTRIBUTE = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'<>`=]+)))?/gdu;
+const MAX_HTML_CHARS = 1_500_000;
+
+async function html(run: Run): Promise<void> {
+  const lines = run.input.lines;
+  const starts: number[] = [];
+  let offset = 0;
+  for (const text of lines) { starts.push(offset); offset += text.length + 1; }
+  const source = lines.join('\n');
+  if (source.length > MAX_HTML_CHARS) { run.truncated = true; return; }
+  const where = (position: number) => { let low = 0, high = starts.length - 1; while (low < high) { const mid = (low + high + 1) >> 1; if (starts[mid]! <= position) low = mid; else high = mid - 1; } return {line: low, column: position - starts[low]!}; };
+  const text = source.replace(/<!--[\s\S]*?-->/gu, comment => comment.replace(/[^\n]/gu, ' '));
+  interface Tag {name: string; attributes: Map<string, {value: string; start: number; end: number}>; at: number}
+  const ids = new Map<string, number>(), fragments: Array<{value: string; position: number; end: number}> = [], labelsFor = new Set<string>(), controls: Array<{tag: Tag; labelled: boolean}> = [];
+  const stack: Array<{name: string; at: number}> = [];
+  let dynamic = 0, inLabel = 0;
+  const jobs: Array<() => Promise<void>> = [];
+  let last = 0;
+  for (const match of text.matchAll(TAG)) {
+    if (run.aborted) return;
+    if (match.index! < last) continue;
+    const closing = Boolean(match[1]);
+    const name = match[2]!.toLowerCase();
+    const attributes = new Map<string, {value: string; start: number; end: number}>();
+    const attributeText = match[3] ?? '';
+    const base = match.indices![3]?.[0] ?? match.index!;
+    for (const attribute of attributeText.matchAll(ATTRIBUTE)) {
+      const group = attribute.indices![2] ?? attribute.indices![3] ?? attribute.indices![4];
+      attributes.set(attribute[1]!.toLowerCase(), {value: attribute[2] ?? attribute[3] ?? attribute[4] ?? '', start: base + (group?.[0] ?? attribute.indices![1]![1]), end: base + (group?.[1] ?? attribute.indices![1]![1])});
+    }
+    const tag: Tag = {name, attributes, at: match.index!};
+    const position = where(match.index!);
+    if (closing) {
+      if (name === 'label' && inLabel > 0) inLabel -= 1;
+      const found = stack.map(entry => entry.name).lastIndexOf(name);
+      if (found < 0) { if (!VOID.has(name)) run.add('unexpected-closing-tag', 'warning', `</${name}> has no matching opening tag.`, position.line, position.column, position.column + match[0].length); }
+      else { for (let at = stack.length - 1; at > found; at -= 1) { const open = stack[at]!; if (!OPTIONAL_END.has(open.name)) { const place = where(open.at); run.add('unclosed-tag', 'warning', `<${open.name}> is never closed.`, place.line, place.column, place.column + open.name.length + 1); } } stack.length = found; }
+    } else {
+      if (!VOID.has(name) && !match[4]) {
+        if (OPTIONAL_END.has(name) && stack.at(-1)?.name === name) stack.pop();
+        stack.push({name, at: match.index!});
+      }
+      if (name === 'label') inLabel += 1;
+      const dynamicHere = [...attributes.values()].some(attribute => TEMPLATED.test(attribute.value));
+      if (dynamicHere) { dynamic += 1; const first = [...attributes.values()].find(attribute => TEMPLATED.test(attribute.value))!; const place = where(first.start); run.add('unverified-dynamic', 'unverified', 'A templated attribute cannot be checked statically.', place.line, place.column, place.column + (first.end - first.start)); }
+      const id = attributes.get('id');
+      if (id?.value) { if (ids.has(id.value)) { const place = where(id.start); run.add('duplicate-id', 'error', `The id “${id.value}” is used twice (first on line ${where(ids.get(id.value)!).line + 1}).`, place.line, place.column, place.column + id.value.length); } else ids.set(id.value, id.start); }
+      const named = attributes.get('name');
+      if (name === 'a' && named?.value) ids.set(named.value, named.start);
+      const asset = (attribute: string) => {
+        const entry = attributes.get(attribute);
+        if (!entry || !entry.value || dynamicHere) return;
+        const place = where(entry.start);
+        jobs.push(() => run.reference(entry.value, place.line, place.column, undefined, undefined, false));
+      };
+      if (['img', 'script', 'source', 'video', 'audio', 'embed', 'track', 'iframe'].includes(name)) asset('src');
+      if (name === 'link') asset('href');
+      if (name === 'img' && !attributes.has('alt')) run.add('image-alt', 'warning', 'This image has no alt attribute (use alt="" for a decorative one).', position.line, position.column, position.column + match[0].length);
+      if (name === 'a') { const href = attributes.get('href'); if (href && !dynamicHere) { if (href.value.startsWith('#')) fragments.push({value: href.value.slice(1), position: href.start, end: href.end}); else asset('href'); } }
+      if (name === 'label' && attributes.get('for')) labelsFor.add(attributes.get('for')!.value);
+      if (['input', 'select', 'textarea'].includes(name) && !(name === 'input' && ['hidden', 'submit', 'button', 'image', 'reset'].includes((attributes.get('type')?.value ?? '').toLowerCase())) && !dynamicHere) {
+        controls.push({tag, labelled: inLabel > 0 || attributes.has('aria-label') || attributes.has('aria-labelledby') || attributes.has('title')});
+      }
+      if (RAW_TEXT.has(name) && !match[4]) {
+        // The text of a script, style, textarea or title is not markup: skip it, but read url() addresses out of a style.
+        const contentStart = match.index! + match[0].length;
+        const rest = text.slice(contentStart);
+        const end = new RegExp(`</${name}\\s*>`, 'iu').exec(rest);
+        const content = end ? rest.slice(0, end.index) : rest;
+        if (name === 'style') { const origin = where(contentStart); content.split('\n').forEach((part, index) => jobs.push(() => cssUrls(run, part, origin.line + index, index === 0 ? origin.column : 0))); }
+        last = contentStart + content.length + (end ? end[0].length : 0);
+        if (end) stack.pop();
+      }
+    }
+  }
+  for (const open of stack) if (!OPTIONAL_END.has(open.name)) { const place = where(open.at); run.add('unclosed-tag', 'warning', `<${open.name}> is never closed.`, place.line, place.column, place.column + open.name.length + 1); }
+  for (const fragment of fragments) {
+    let value = fragment.value;
+    try { value = decodeURIComponent(value); } catch { /* as written */ }
+    if (!value || value.toLowerCase() === 'top' || ids.has(value)) continue;
+    const place = where(fragment.position);
+    run.add('broken-fragment', 'error', `No element with the id “${value}” in this document.`, place.line, place.column, place.column + (fragment.end - fragment.position));
+  }
+  for (const control of controls) {
+    const id = control.tag.attributes.get('id')?.value;
+    if (control.labelled || (id && labelsFor.has(id))) continue;
+    const place = where(control.tag.at);
+    run.add('form-label', 'warning', `This <${control.tag.name}> has no label (use <label for>, a wrapping <label> or aria-label).`, place.line, place.column, place.column + control.tag.name.length + 1);
+  }
+  if (dynamic > 0) run.external += 0;
+  for (const job of jobs) { if (run.aborted) return; await job(); }
+}
+
+export async function diagnose(input: DiagnoseInput): Promise<DiagnosticReport> {
+  const run = new Run(input);
+  if (input.signal?.aborted) return {diagnostics: [], external: 0, checked: 0, truncated: false, aborted: true};
+  try {
+    if (input.format === 'markdown') await markdown(run);
+    else if (input.format === 'html') await html(run);
+    else {
+      cssSyntax(run, input.lines);
+      for (let line = 0; line < input.lines.length && !run.aborted; line += 1) await cssUrls(run, input.lines[line]!, line, 0);
+    }
+  } catch (error) {
+    if (!run.aborted) run.add('diagnostics-failed', 'info', `Checking stopped early: ${error instanceof Error ? error.message : 'unknown error'}.`, 0);
+  }
+  if (run.aborted) return {diagnostics: [], external: run.external, checked: run.checked, truncated: run.truncated, aborted: true};
+  run.diagnostics.sort((a, b) => a.line - b.line || (a.column ?? 0) - (b.column ?? 0));
+  return {diagnostics: run.diagnostics, external: run.external, checked: run.checked, truncated: run.truncated};
+}
diff --git a/src/markdown/sourceMap.ts b/src/markdown/sourceMap.ts
index f397e1e4..49a5ef0a 100644
--- a/src/markdown/sourceMap.ts
+++ b/src/markdown/sourceMap.ts
@@ -93,6 +93,11 @@ export function headingsOf(source: string, options: {html?: boolean} = {}): Head
   return outline(parseBlocks(source, {html: options.html ?? false}), lines);
 }
 
+/** The headings of lines already cut (a buffer's), so a stray CR cannot shift a line number. */
+export function headingsFromLines(lines: readonly string[], options: {html?: boolean} = {}): HeadingEntry[] {
+  return outline(parseBlockLines(lines, {html: options.html ?? false}), lines);
+}
+
 /** The heading a `#fragment` names (case-insensitive, percent-decoded), if any. */
 export function resolveFragment(headings: readonly HeadingEntry[], fragment: string): HeadingEntry | undefined {
   let wanted = fragment.replace(/^#/u, '');
diff --git a/src/viewer/DocumentWorkspace.ts b/src/viewer/DocumentWorkspace.ts
index 3d9c26b7..0f2a3351 100644
--- a/src/viewer/DocumentWorkspace.ts
+++ b/src/viewer/DocumentWorkspace.ts
@@ -1,6 +1,6 @@
 import type {Key} from '../terminal/keys.js';
 import type {TextOverlay} from '../arcade/Canvas.js';
-import {createEditor, editorKey, renderEditor, type EditorAction, type EditorState} from './EditorPanel.js';
+import {createEditor, editorKey, openProblems, renderEditor, type EditorAction, type EditorState} from './EditorPanel.js';
 import {formatForPath, type ViewDocument} from './document.js';
 import type {EditableFile} from './fileEdit.js';
 import {displayWidth, stripAnsi, truncateAnsi} from '../util/text.js';
@@ -184,7 +184,14 @@ export function documentSessionKey(state: DocumentSession, key: Key, columns: nu
   const text = key.kind === 'text' ? key.value : undefined;
   state.note = undefined;
   // A save or conflict dialog belongs to the editor, whatever mode raised it.
-  if (editor.dialog || editor.review || editor.input || editor.busy) return fromEditor(state, editorKey(editor, key, columns, height));
+  if (editor.dialog || editor.review || editor.input || editor.busy) {
+    const action = fromEditor(state, editorKey(editor, key, columns, height));
+    // A jump from Problems or the outline moved the caret: the read-only views follow it.
+    const jumped = editor.lastJump;
+    editor.lastJump = undefined;
+    if (jumped !== undefined && (state.mode === 'source' || state.mode === 'preview')) showSourceLine(state.viewer, jumped, columns, height, documentSessionLook(state, look));
+    return action;
+  }
   if (key.kind === 'splitToggle') { setDocumentMode(state, state.mode === 'split' ? (state.split?.hybrid ? 'hybrid' : 'edit') : 'split'); return undefined; }
   if (key.kind === 'hybridToggle') { toggleHybrid(state); return undefined; }
   if (state.mode === 'split') return splitKey(state, key, columns, height, look);
@@ -205,6 +212,7 @@ export function documentSessionKey(state: DocumentSession, key: Key, columns: nu
   if (!searching) {
     if (text === 'e') { setDocumentMode(state, 'edit'); return undefined; }
     if (text === 's') { setDocumentMode(state, 'split'); return undefined; }
+    if (text === 'P') { openProblems(editor); return undefined; }
     if (text === 'H') { toggleHybrid(state); return undefined; }
     if (key.kind === 'toggleDetails' && state.mode === 'preview') { setDocumentMode(state, state.before); return undefined; }
     if (text === 'h' || key.kind === 'toggleDetails') {
@@ -280,6 +288,7 @@ function splitKey(state: DocumentSession, key: Key, columns: number, height: num
   const viewer = state.viewer;
   if (!viewer.input) {
     if (key.kind === 'escape' && !viewer.query) { setDocumentMode(state, 'source'); return undefined; }
+    if (text === 'P') { openProblems(editor); return undefined; }
     if (text === 'x') { split.swapped = !split.swapped; return undefined; }
     if (text === '<' || text === '>') { split.ratio = Math.max(RATIO_MIN, Math.min(RATIO_MAX, split.ratio + (text === '>' ? RATIO_STEP : -RATIO_STEP))); return undefined; }
     if (text === 'l') { split.linked = !split.linked; return undefined; }
diff --git a/src/viewer/EditorPalette.ts b/src/viewer/EditorPalette.ts
index f3e12347..688abc6d 100644
--- a/src/viewer/EditorPalette.ts
+++ b/src/viewer/EditorPalette.ts
@@ -24,6 +24,7 @@ const MARKDOWN_ACTIONS: ReadonlyArray<[action: string, title: string, descriptio
   ['Action.Strike', 'Strikethrough', 'Wrap or unwrap the selection in ~~', 'strike strikethrough wrap'],
   ['Action.Footnote', 'Footnote', 'A numbered reference here and its definition at the end', 'footnote reference note'],
   ['Action.FootnoteRenumber', 'Renumber footnotes', 'Number the footnotes 1, 2, 3… in the order they are referenced', 'footnote footnotes renumber number order'],
+  ['Action.Problems', 'Problems…', 'Check links, images, anchors and footnotes (offline) and jump to each finding', 'problems diagnostics lint check broken links images errors warnings'],
   ['Action.Headings', 'Go to heading…', 'Search the document\'s headings and jump to one', 'heading outline navigate jump toc contents'],
   ['Action.Back', 'Back to previous position', 'Return to where you were before the last jump', 'back return previous jump'],
 ];
@@ -35,9 +36,12 @@ const TABLE_ACTIONS: ReadonlyArray<[string, string, string, string]> = [
   ['Action.Align', 'Table: align column', 'Cycle none, left, centre, right', 'table align alignment'],
 ];
 
+const PROBLEMS_ENTRY: PaletteEntry[] = [{id: 'Action.Problems', title: 'Problems…', description: 'Check links, images, ids and markup (offline) and jump to each finding', run: {kind: 'action', action: 'Action.Problems'}}];
+const words0 = (query: string) => { const words = query.toLowerCase().split(/\s+/u).filter(Boolean); return words.length ? words : undefined; };
+
 export function paletteEntries(format: PaletteFormat, query: string, inTable = false): PaletteEntry[] {
   const snippets: PaletteEntry[] = searchSnippets(query, format).map(snippet => ({id: snippet.id, title: snippet.title, description: snippet.description, run: {kind: 'snippet', snippet}}));
-  if (format !== 'markdown') return snippets;
+  if (format !== 'markdown') return [...snippets, ...(words0(query) ? PROBLEMS_ENTRY.filter(entry => words0(query)!.every(word => `${entry.title} ${entry.description}`.toLowerCase().includes(word))) : PROBLEMS_ENTRY)];
   const words = query.toLowerCase().split(/\s+/u).filter(Boolean);
   const actions: PaletteEntry[] = [...(inTable ? TABLE_ACTIONS : []), ...MARKDOWN_ACTIONS]
     .filter(([, title, description, keywords]) => words.every(word => `${title} ${description} ${keywords}`.toLowerCase().includes(word)))
diff --git a/src/viewer/EditorPanel.ts b/src/viewer/EditorPanel.ts
index bc0c2036..8f130ad3 100644
--- a/src/viewer/EditorPanel.ts
+++ b/src/viewer/EditorPanel.ts
@@ -8,10 +8,13 @@ import {framePanel} from '../ui/PanelShell.js';
 import {foreground, UI_COLORS} from '../ui/palette.js';
 import {displayWidth, truncateAnsi, truncateText} from '../util/text.js';
 import {formatForPath, inert} from './document.js';
+import {getIconStyle} from '../ui/glyphs.js';
 import {alignColumn, deleteColumn, deleteRow, findTable, insertColumn, insertRow, tableStatus, tableTab} from './markdownTable.js';
 import {reviewKey, renderReview, type ReviewState} from './ReviewPanel.js';
 import {paletteEntries, type PaletteEntry, type PaletteFormat} from './EditorPalette.js';
 import {DocumentIndex, SourceAnchor, type HeadingEntry} from '../markdown/sourceMap.js';
+import {ProblemsRunner, SEVERITY_ORDER} from './problems.js';
+import type {Diagnostic, Severity} from '../markdown/diagnostics.js';
 import {advanceSnippet, insertFootnote, insertSnippet, insideSnippet, type SnippetSession} from './snippets.js';
 import {continueList, insertLink, renumberFootnotes, renumberList, shiftListItems, toggleTask, wrapSelection, type EditResult, type WrapKind} from './markdownEdit.js';
 import type {EditableFile, SaveConflict} from './fileEdit.js';
@@ -29,7 +32,9 @@ const REVERSE = '\u001b[7m';
 const WHEEL_ROWS = 3;
 
 export interface EditorDialog {
-  kind: 'unsaved' | 'conflict' | 'recover' | 'markdown' | 'snippets' | 'playground' | 'outline';
+  kind: 'unsaved' | 'conflict' | 'recover' | 'markdown' | 'snippets' | 'playground' | 'outline' | 'problems';
+  /** Problems: which severities are listed (all, problems = errors and warnings, errors). */
+  filter?: 'all' | 'problems' | 'errors';
   /** How many recoverable Playground documents the chooser can offer. */
   recoverable?: number;
   /** The snippet palette's search text. */
@@ -63,6 +68,12 @@ export interface EditorState {
   /** The parsed structure of the buffer (headings), kept until it changes; and where jumps came from, newest last (#462). */
   index?: DocumentIndex;
   jumps?: SourceAnchor[];
+  /** Static diagnostics for the document, once turned on by opening Problems (#466). */
+  problems?: ProblemsRunner;
+  /** The source line of the last jump from a list (the workspace scrolls its read-only views there). */
+  lastJump?: number;
+  /** The caret moved without a key press in the editor (a jump from a list): the next draw scrolls it into view. */
+  revealPending?: boolean;
   /** The editor sits in a document workspace: its footer names the split key. */
   workspace?: boolean;
   note?: {text: string; tone: 'info' | 'error' | 'success'};
@@ -108,7 +119,7 @@ const MARKDOWN_ACTIONS = [
   {id: 'Action.Bold', label: 'Bold', key: 'b'}, {id: 'Action.Italic', label: 'Italic', key: 'i'},
   {id: 'Action.Code', label: 'Code', key: 'c'}, {id: 'Action.Strike', label: 'Strike', key: 's'},
   {id: 'Action.Search', label: 'Snippets…', key: '/'},
-  {id: 'Action.Headings', label: 'Headings…', key: 'h'}, {id: 'Action.Back', label: 'Back', key: 'j'},
+  {id: 'Action.Headings', label: 'Headings…', key: 'h'}, {id: 'Action.Back', label: 'Back', key: 'j'}, {id: 'Action.Problems', label: 'Problems…', key: 'e'},
 ] as const;
 
 export const isMarkdownFile = (state: EditorState) => formatForPath(state.file.path).format === 'markdown';
@@ -143,6 +154,7 @@ function jumpToLine(state: EditorState, line: number): void {
   while (jumps.length > MAX_JUMPS) jumps.shift()!.dispose();
   state.buffer.caret = {line: Math.min(line, state.buffer.lines.length - 1), column: 0};
   state.buffer.anchor = undefined;
+  state.revealPending = true;
 }
 
 function jumpBack(state: EditorState): void {
@@ -150,9 +162,60 @@ function jumpBack(state: EditorState): void {
   if (!last) { state.note = {text: 'No earlier position to go back to.', tone: 'info'}; return; }
   state.buffer.caret = {...last.position};
   state.buffer.anchor = undefined;
+  state.revealPending = true;
   last.dispose();
 }
 
+/** Problems (#466): checking starts the first time it is opened and follows the text from then on. */
+export function openProblems(state: EditorState): void {
+  state.problems ??= new ProblemsRunner(state);
+  if (state.problems.enabled) state.problems.refresh(); else state.problems.enable();
+  state.dialog = {kind: 'problems', focus: 0, query: '', filter: 'all'};
+}
+
+const FILTERS: Array<'all' | 'problems' | 'errors'> = ['all', 'problems', 'errors'];
+
+function problemList(state: EditorState, dialog: EditorDialog): Diagnostic[] {
+  const words = (dialog.query ?? '').toLowerCase().split(/\s+/u).filter(Boolean);
+  const allowed: Severity[] = dialog.filter === 'errors' ? ['error'] : dialog.filter === 'problems' ? ['error', 'warning'] : SEVERITY_ORDER;
+  return (state.problems?.visible() ?? []).filter(item => allowed.includes(item.severity) && words.every(word => `${item.message} ${item.code}`.toLowerCase().includes(word)))
+    .sort((a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity) || a.line - b.line || (a.column ?? 0) - (b.column ?? 0));
+}
+
+/** Go to a finding: its exact text is selected when the span is known, otherwise the caret goes to the start of its line. */
+function jumpToDiagnostic(state: EditorState, item: Diagnostic): void {
+  const jumps = state.jumps ??= [];
+  jumps.push(new SourceAnchor(state.buffer, state.buffer.caret));
+  while (jumps.length > MAX_JUMPS) jumps.shift()!.dispose();
+  const line = Math.min(item.line, state.buffer.lines.length - 1);
+  const length = state.buffer.lines[line]!.length;
+  if (item.exact && item.column !== undefined && item.endColumn !== undefined && item.endColumn <= length) {
+    state.buffer.caret = {line, column: item.endColumn};
+    state.buffer.anchor = {line, column: item.column};
+  } else { state.buffer.caret = {line, column: 0}; state.buffer.anchor = undefined; }
+  state.lastJump = line;
+  state.revealPending = true;
+}
+
+function problemsKey(state: EditorState, dialog: EditorDialog, key: Key): void {
+  const items = problemList(state, dialog);
+  if (key.kind === 'escape' || key.kind === 'interrupt') { state.dialog = undefined; return; }
+  if (key.kind === 'up' || key.kind === 'focusPrevious' || key.kind === 'suggestPrevious') { dialog.focus = Math.max(0, dialog.focus - 1); return; }
+  if (key.kind === 'down' || key.kind === 'suggestNext') { dialog.focus = Math.min(Math.max(0, items.length - 1), dialog.focus + 1); return; }
+  if (key.kind === 'complete') { dialog.filter = FILTERS[(FILTERS.indexOf(dialog.filter ?? 'all') + 1) % FILTERS.length]; dialog.focus = 0; return; }
+  if (key.kind === 'historySearch') { state.problems?.refresh(); return; }
+  if (key.kind === 'delete') { const item = items[dialog.focus]; if (item) state.problems?.dismissed.add(item.id); dialog.focus = Math.max(0, Math.min(dialog.focus, items.length - 2)); return; }
+  if (key.kind === 'enter') {
+    const item = items[dialog.focus];
+    if (!item) return;
+    state.dialog = undefined;
+    jumpToDiagnostic(state, item);
+    return;
+  }
+  const next = editText(dialog.query ?? '', key);
+  if (next !== undefined) { dialog.query = next.slice(0, 80); dialog.focus = 0; }
+}
+
 function outlineKey(state: EditorState, dialog: EditorDialog, key: Key): void {
   const headings = outlineList(state, dialog);
   if (key.kind === 'escape' || key.kind === 'interrupt') { state.dialog = undefined; return; }
@@ -182,6 +245,7 @@ function runPaletteEntry(state: EditorState, entry: PaletteEntry): void {
   if (entry.run.kind === 'snippet') { state.snippet = insertSnippet(state.buffer, entry.run.snippet); return; }
   if (entry.run.action === 'Action.Footnote') { state.snippet = insertFootnote(state.buffer); return; }
   if (entry.run.action === 'Action.FootnoteRenumber') { const result = renumberFootnotes(state.buffer); if (result.note) state.note = {text: result.note, tone: 'info'}; return; }
+  if (entry.run.action === 'Action.Problems') { openProblems(state); return; }
   if (entry.run.action === 'Action.Headings') { state.dialog = {kind: 'outline', focus: 0, query: ''}; return; }
   if (entry.run.action === 'Action.Back') { jumpBack(state); return; }
   const result = runMarkdownAction(state, entry.run.action);
@@ -285,6 +349,7 @@ function dialogKey(state: EditorState, dialog: EditorDialog, key: Key): EditorAc
   }
   if (dialog.kind === 'snippets') { paletteKey(state, dialog, key); return undefined; }
   if (dialog.kind === 'outline') { outlineKey(state, dialog, key); return undefined; }
+  if (dialog.kind === 'problems') { problemsKey(state, dialog, key); return undefined; }
   const controls = dialogControls(dialog);
   const text = key.kind === 'text' ? key.value.toLowerCase() : undefined;
   if (key.kind === 'left' || key.kind === 'focusPrevious') { dialog.focus = (dialog.focus + controls.length - 1) % controls.length; return undefined; }
@@ -297,6 +362,7 @@ function dialogKey(state: EditorState, dialog: EditorDialog, key: Key): EditorAc
     state.dialog = undefined;
     if (chosen === 'Action.Keep') return undefined;
     if (chosen === 'Action.Search') { openPalette(state); return undefined; }
+    if (chosen === 'Action.Problems') { openProblems(state); return undefined; }
     if (chosen === 'Action.Headings') { state.dialog = {kind: 'outline', focus: 0, query: ''}; return undefined; }
     if (chosen === 'Action.Back') { jumpBack(state); return undefined; }
     const result = runMarkdownAction(state, chosen);
@@ -423,6 +489,7 @@ export function editorKey(state: EditorState, key: Key, columns: number, height:
       break;
     }
     case 'palette':
+      if (!isMarkdownFile(state) && !paletteFormat(state) && /\.css$/iu.test(state.file.path)) { openProblems(state); return undefined; }
       if (isMarkdownFile(state)) state.dialog = {kind: 'markdown', focus: 0, ...(findTable(buffer.lines, buffer.caret.line) ? {table: true} : {})};
       else if (paletteFormat(state)) openPalette(state);
       return undefined;
@@ -529,6 +596,29 @@ function recoverMessage(state: EditorState, dialog: EditorDialog): string {
 
 function footerRows(state: EditorState, columns: number): string[] {
   const width = Math.max(1, columns - 4);
+  if (state.dialog?.kind === 'problems') {
+    const dialog = state.dialog;
+    const runner = state.problems;
+    const items = problemList(state, dialog);
+    const accent = foreground(UI_COLORS.accent), subtle = foreground(UI_COLORS.subtle);
+    const safe = getIconStyle() === 'safe';
+    const glyph = (severity: Severity) => safe ? ({error: 'E', warning: 'W', info: 'i', unverified: '?'})[severity] : ({error: '✖', warning: '▲', info: 'ℹ', unverified: '?'})[severity];
+    const tone = (severity: Severity) => severity === 'error' ? foreground(UI_COLORS.failure) : severity === 'warning' ? foreground(UI_COLORS.warning) : subtle;
+    const counts = runner?.counts() ?? {error: 0, warning: 0, info: 0, unverified: 0};
+    const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? '' : 's'}`;
+    const summary = [plural(counts.error, 'error'), plural(counts.warning, 'warning'), ...(counts.info ? [`${counts.info} note${counts.info === 1 ? '' : 's'}`] : []), ...(counts.unverified ? [`${counts.unverified} unverified`] : [])].join(' · ');
+    const size = 6;
+    const start = Math.max(0, Math.min(dialog.focus - Math.floor(size / 2), items.length - size));
+    const shown = items.slice(start, start + size).map((item, offset) => {
+      const focused = start + offset === dialog.focus;
+      return `${focused ? `${accent}▸ ` : '  '}${tone(item.severity)}${glyph(item.severity)}${RESET} ${subtle}${String(item.line + 1).padStart(4)}${RESET} ${truncateText(inert(item.message), Math.max(4, width - 12))}`;
+    });
+    if (!items.length) shown.push(`${subtle}  ${!runner?.report ? 'Checking…' : runner.visible().length ? 'Nothing matches this filter.' : 'No problems found.'}${RESET}`);
+    const external = runner?.report?.external ? ` · ${runner.report.external} external link${runner.report.external === 1 ? '' : 's'} not checked` : '';
+    const state_ = runner?.busy ? ' · checking…' : runner?.report?.truncated ? ' · stopped at the limit' : '';
+    const header = `${foreground(UI_COLORS.warning)}Problems${RESET}${subtle} · ${summary}${external}${state_} · ${dialog.filter ?? 'all'} · ${RESET}${truncateText(inert(dialog.query ?? ''), Math.max(1, width - 40))}${accent}▏${RESET}`;
+    return [truncateAnsi(header, width), ...shown.map(row => truncateAnsi(row, width)), ...renderControlRows([['↑↓', 'choose'], ['Enter', 'go to it'], ['Tab', 'filter'], ['Del', 'dismiss'], ['Ctrl+R', 'check again'], ['Esc', 'back']], width)];
+  }
   if (state.dialog?.kind === 'outline') {
     const dialog = state.dialog;
     const headings = outlineList(state, dialog);
@@ -560,7 +650,7 @@ function footerRows(state: EditorState, columns: number): string[] {
   }
   if (state.dialog) {
     const dialog = state.dialog;
-    const message = dialog.kind === 'playground' ? 'Playground: an unsaved document to write and preview. Nothing is saved unless you Save As. Esc cancels.' : dialog.kind === 'markdown' ? `Markdown · ${dialog.table ? 'r row+ · d row− · o col+ · x col− · a align · ' : ''}t task · n renumber · l link · p image · b bold · i italic · c code · s strike · / snippets · h headings · j back` : dialog.kind === 'unsaved' ? `${state.file.title} has unsaved changes.` : dialog.kind === 'recover' ? recoverMessage(state, dialog)
+    const message = dialog.kind === 'playground' ? 'Playground: an unsaved document to write and preview. Nothing is saved unless you Save As. Esc cancels.' : dialog.kind === 'markdown' ? `Markdown · ${dialog.table ? 'r row+ · d row− · o col+ · x col− · a align · ' : ''}t task · n renumber · l link · p image · b bold · i italic · c code · s strike · / snippets · h headings · j back · e problems` : dialog.kind === 'unsaved' ? `${state.file.title} has unsaved changes.` : dialog.kind === 'recover' ? recoverMessage(state, dialog)
       : dialog.reason ?? `${state.file.title} changed on disk.`;
     const accent = foreground(UI_COLORS.warning);
     const actions = renderActionRow(dialogControls(dialog), {columns: width, keys: true, color: colorLevel() !== 'none'}).rows;
@@ -576,6 +666,7 @@ function footerRows(state: EditorState, columns: number): string[] {
 
 export function renderEditor(state: EditorState, columns: number, height: number): string[] {
   if (state.review) return renderReview(state, columns, height);
+  if (state.revealPending) { state.revealPending = false; reveal(state, columns, height); }
   const width = textWidth(state, columns);
   const rows = textRows(state, columns, height);
   state.top = Math.max(0, Math.min(state.top, Math.max(0, state.buffer.lines.length - 1)));
@@ -596,9 +687,10 @@ export function renderEditor(state: EditorState, columns: number, height: number
   const position = `Ln ${caret.line + 1}, Col ${displayColumn(state.buffer.lines[caret.line]!, caret.column) + 1}`;
   const selected = state.buffer.selection ? ` · ${state.buffer.selectedText().length.toLocaleString('en-US')} selected` : '';
   const table = isMarkdownFile(state) ? tableStatus(state.buffer.lines, caret) : undefined;
+  const problemsNote = state.problems?.report ? (() => { const c = state.problems!.counts(); const safe = getIconStyle() === 'safe'; return [c.error ? `${safe ? 'E' : '✖'} ${c.error}` : '', c.warning ? `${safe ? 'W' : '▲'} ${c.warning}` : ''].filter(Boolean).join(' '); })() : '';
   const status = state.input
     ? `${foreground(UI_COLORS.accent)}${state.input.kind === 'saveas' ? 'Save as (a new file; an existing one is never replaced): ' : 'Find: '}${RESET}${truncateText(inert(state.input.value), Math.max(1, columns - 12))}${foreground(UI_COLORS.accent)}▏${RESET}`
-    : `${subtle}${truncateText(`${position}${selected}${table ? ` · ${table}` : ''}${state.busy ? ' · saving…' : ''}`, Math.max(1, columns - 4))}${RESET}${state.note ? `  ${state.note.tone === 'error' ? foreground(UI_COLORS.failure) : state.note.tone === 'success' ? foreground(UI_COLORS.success) : subtle}${truncateText(inert(state.note.text), Math.max(1, columns - 8 - displayWidth(position + selected)))}${RESET}` : ''}`;
+    : `${subtle}${truncateText(`${position}${selected}${table ? ` · ${table}` : ''}${problemsNote ? ` · ${problemsNote}` : ''}${state.busy ? ' · saving…' : ''}`, Math.max(1, columns - 4))}${RESET}${state.note ? `  ${state.note.tone === 'error' ? foreground(UI_COLORS.failure) : state.note.tone === 'success' ? foreground(UI_COLORS.success) : subtle}${truncateText(inert(state.note.text), Math.max(1, columns - 8 - displayWidth(position + selected)))}${RESET}` : ''}`;
   out.push(`  ${status}`, ...footerRows(state, columns).map(row => `  ${row}`));
   const rule = framePanel([], columns)[0]!;
   if (height <= 1) return [rule].slice(0, Math.max(0, height));
diff --git a/src/viewer/problems.ts b/src/viewer/problems.ts
new file mode 100644
index 00000000..3baa5249
--- /dev/null
+++ b/src/viewer/problems.ts
@@ -0,0 +1,108 @@
+import {dirname, extname} from 'node:path';
+import {createLocalFs, diagnose, type Diagnostic, type DiagnosticReport, type LocalFs, type Severity} from '../markdown/diagnostics.js';
+import {formatForPath} from './document.js';
+import {documentRoot} from './documentImages.js';
+import type {EditorState} from './EditorPanel.js';
+
+/**
+ * Keeps one editor's static diagnostics (#466) current. Checking is off until the person opens Problems (or asks), so a
+ * document nobody is inspecting costs nothing; once on, a change to the buffer (typing, undo, redo, a snippet, a helper, a
+ * restored draft, a review) schedules a run after a short pause. Every run works on a snapshot of the lines and carries the
+ * revision it started from: a result for an older revision is discarded, and a newer change aborts a run in flight. Nothing
+ * here writes a file, opens a watcher or keeps a timer after `dispose`.
+ */
+export interface ProblemsOptions {
+  debounceMs?: number;
+  /** The filesystem the document's references are checked against; undefined for a document with no folder yet. */
+  makeFs?: () => Promise<LocalFs | undefined>;
+}
+
+export class ProblemsRunner {
+  /** Told when a report arrives (the app redraws). */
+  static notify?: () => void;
+  report?: DiagnosticReport;
+  /** Findings the person dismissed; cleared by the next report, so a dismissal never hides a changed document. */
+  readonly dismissed = new Set<string>();
+  disposed = false;
+  private revision = 0;
+  private timer?: NodeJS.Timeout;
+  private controller?: AbortController;
+  private running = 0;
+  private stop?: () => void;
+
+  constructor(private readonly editor: EditorState, private readonly options: ProblemsOptions = {}) {}
+
+  /** A run is pending or in flight. */
+  get busy(): boolean { return this.running > 0 || this.timer !== undefined; }
+  get enabled(): boolean { return this.stop !== undefined; }
+
+  enable(): void {
+    if (this.disposed) return;
+    if (!this.stop) this.stop = this.editor.buffer.observe(() => { this.revision += 1; this.schedule(); });
+    this.refresh();
+  }
+
+  /** Check now (opening Problems, Ctrl+R, after a save: the files the document names may have changed). */
+  refresh(): void {
+    if (this.disposed) return;
+    if (this.timer) { clearTimeout(this.timer); this.timer = undefined; }
+    void this.run();
+  }
+
+  private schedule(): void {
+    if (this.disposed) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => { this.timer = undefined; void this.run(); }, this.options.debounceMs ?? 500);
+    this.timer.unref?.();
+  }
+
+  private async makeFs(): Promise<LocalFs | undefined> {
+    if (this.options.makeFs) return this.options.makeFs();
+    const file = this.editor.file;
+    if (file.scratch) return undefined;
+    const directory = dirname(file.realPath);
+    return createLocalFs(directory, await documentRoot(directory));
+  }
+
+  private async run(): Promise<void> {
+    if (this.disposed) return;
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    const revision = this.revision;
+    this.running += 1;
+    try {
+      const path = this.editor.file.path;
+      const kind = formatForPath(path).format;
+      const format = kind === 'markdown' || kind === 'html' ? kind : extname(path).toLowerCase() === '.css' ? 'css' : undefined;
+      const lines = [...this.editor.buffer.lines];
+      const fs = await this.makeFs();
+      const report = format ? await diagnose({lines, format, ...(fs ? {fs} : {}), signal: controller.signal}) : {diagnostics: [], external: 0, checked: 0, truncated: false};
+      // A result for a text that has since changed is stale: the change has scheduled (or will schedule) its own run.
+      if (this.disposed || controller.signal.aborted || revision !== this.revision) return;
+      this.report = report;
+      this.dismissed.clear();
+      ProblemsRunner.notify?.();
+    } finally { this.running -= 1; }
+  }
+
+  /** The findings that are not dismissed. */
+  visible(): Diagnostic[] { return (this.report?.diagnostics ?? []).filter(item => !this.dismissed.has(item.id)); }
+
+  counts(): Record<Severity, number> {
+    const counts: Record<Severity, number> = {error: 0, warning: 0, info: 0, unverified: 0};
+    for (const item of this.visible()) counts[item.severity] += 1;
+    return counts;
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    this.controller?.abort();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    this.stop?.();
+    this.stop = undefined;
+  }
+}
+
+export const SEVERITY_ORDER: Severity[] = ['error', 'warning', 'info', 'unverified'];
diff --git a/tests/diagnostics.test.ts b/tests/diagnostics.test.ts
new file mode 100644
index 00000000..c349f181
--- /dev/null
+++ b/tests/diagnostics.test.ts
@@ -0,0 +1,146 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync, chmodSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {createLocalFs, diagnose, type Diagnostic} from '../src/markdown/diagnostics.js';
+
+function project() {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), 'nmsh-diag-')));
+  mkdirSync(join(root, 'docs')); mkdirSync(join(root, 'img'));
+  writeFileSync(join(root, 'docs', 'other.md'), '# Other\n\n## Install steps\n');
+  writeFileSync(join(root, 'img', 'pic.png'), 'x'); writeFileSync(join(root, 'style.css'), 'a{}'); writeFileSync(join(root, 'app.js'), '');
+  const outside = realpathSync(mkdtempSync(join(tmpdir(), 'nmsh-diag-out-')));
+  writeFileSync(join(outside, 'secret.txt'), 'secret');
+  return {root, outside, dir: join(root, 'docs'), cleanup: () => { rmSync(root, {recursive: true, force: true}); rmSync(outside, {recursive: true, force: true}); }};
+}
+const run = async (lines: string[], format: 'markdown' | 'html' | 'css', dir?: string, root?: string) =>
+  diagnose({lines, format, ...(dir ? {fs: createLocalFs(dir, root ?? dir)} : {})});
+const codes = (list: Diagnostic[]) => list.map(item => `${item.code}@${item.line}`);
+
+test('markdown links: a missing file and a missing fragment are errors; existing targets and in-file anchors are not; external URLs are not checked', async () => {
+  const p = project();
+  try {
+    const report = await run(['# Title', '', '## Install steps', '', '[ok](other.md) [bad](nope.md) [frag](#install-steps) [badfrag](#missing)', '[site](https://example.com/x) [mail](mailto:a@b.c) <https://example.com>', '[inother](other.md#install-steps) [badother](other.md#nothing)'], 'markdown', p.dir, p.root);
+    assert.deepEqual(codes(report.diagnostics).sort(), ['broken-fragment@4', 'broken-fragment-in-file@6', 'missing-file@4'].sort());
+    assert.equal(report.diagnostics.find(item => item.code === 'missing-file')!.severity, 'error');
+    assert.equal(report.external, 3, 'counted, never fetched, never an error');
+    const bad = report.diagnostics.find(item => item.code === 'missing-file')!;
+    assert.equal(['[ok](other.md) [bad](nope.md) [frag](#install-steps) [badfrag](#missing)'].map(line => line.slice(bad.column!, bad.endColumn!))[0], 'nope.md', 'the span is exactly the destination');
+    assert.equal(bad.exact, true);
+  } finally { p.cleanup(); }
+});
+
+test('images: a missing local image is an error and a missing alt text a warning; the alt check is independent of the file', async () => {
+  const p = project();
+  try {
+    const report = await run(['![pic](../img/pic.png) ![](../img/pic.png) ![gone](../img/gone.png)'], 'markdown', p.dir, p.root);
+    assert.deepEqual(codes(report.diagnostics).sort(), ['image-alt@0', 'missing-file@0']);
+  } finally { p.cleanup(); }
+});
+
+test('reference links and footnotes: undefined ones are errors, unused definitions warnings; shortcut text in brackets is not guessed', async () => {
+  const report = await run(['See [text][ref] and [other][missing] and [collapsed][] and [just brackets] and a footnote[^1] and another[^2].', '', '[ref]: https://example.com', '[collapsed]: other.md', '', '[^1]: ok', '[^3]: unused'], 'markdown');
+  assert.deepEqual(codes(report.diagnostics).sort(), ['undefined-footnote@0', 'undefined-reference@0', 'unreferenced-footnote@6', 'unverified-local@3'].sort());
+});
+
+test('headings: a repeated heading is informational; code fences, code spans, front matter and escaped brackets are not scanned', async () => {
+  const report = await run(['---', 'title: [x](nope.md)', '---', '# Same', '', '# Same', '', '```', '[a](nope.md)', '```', '', 'inline `[b](nope.md)` and \\[c\\](nope.md)'], 'markdown');
+  assert.deepEqual(codes(report.diagnostics), ['duplicate-heading@5']);
+  assert.equal(report.diagnostics[0]!.severity, 'info');
+});
+
+test('hostile destinations are never probed: absolute paths, parent escapes, symlinks out of the root, schemes, huge and odd input', async () => {
+  const p = project();
+  try {
+    symlinkSync(p.outside, join(p.root, 'docs', 'linkout'));
+    const lines = [`[abs](/etc/passwd) [home](~/.ssh/id_rsa) [up](../../${p.outside.split('/').pop()}/secret.txt) [sym](linkout/secret.txt)`, '[js](javascript:alert(1)) [data](data:text/html,<script>) [file](file:///etc/passwd) [nul](a%00b.md) ' + `[long](${'a/'.repeat(600)}x.md)`];
+    const report = await run(lines, 'markdown', p.dir, p.root);
+    const byCode = new Map(report.diagnostics.map(item => [item.code + '@' + item.line, item]));
+    assert.ok(byCode.has('absolute-path@0') && byCode.has('outside-root@0'), JSON.stringify(codes(report.diagnostics)));
+    assert.equal(report.diagnostics.filter(item => item.code === 'outside-root').length, 2, 'the parent escape and the symlink are outside');
+    assert.equal(report.diagnostics.filter(item => item.code === 'absolute-path').length, 2, 'absolute and home paths are never probed');
+    assert.ok(report.diagnostics.every(item => item.code !== 'missing-file' || !/secret|passwd|ssh/u.test(item.message)), 'a probe result never names a path outside the root');
+    assert.ok(report.diagnostics.some(item => item.code === 'unsafe-scheme' && item.line === 1));
+    assert.ok(!report.diagnostics.some(item => item.code === 'ok'));
+  } finally { p.cleanup(); }
+});
+
+test('the filesystem checker: files, directories, missing, unreadable, symlink inside the root, and a bounded number of checks', async () => {
+  const p = project();
+  try {
+    const fs = createLocalFs(p.dir, p.root);
+    assert.equal(await fs.stat('other.md'), 'file');
+    assert.equal(await fs.stat('../img'), 'directory');
+    assert.equal(await fs.stat('nope.md'), 'missing');
+    assert.equal(await fs.stat('../../outside'), 'outside');
+    symlinkSync(join(p.root, 'img', 'pic.png'), join(p.dir, 'alias.png'));
+    assert.equal(await fs.stat('alias.png'), 'file', 'a link that stays inside the root is followed');
+    mkdirSync(join(p.dir, 'locked')); chmodSync(join(p.dir, 'locked'), 0o000);
+    assert.ok(['unreadable', 'missing'].includes(await fs.stat('locked/x.md')));
+    chmodSync(join(p.dir, 'locked'), 0o755);
+    const many = Array.from({length: 900}, (_, index) => `[l](missing-${index}.md)`);
+    const report = await diagnose({lines: many, format: 'markdown', fs, maxChecks: 100});
+    assert.equal(report.truncated, true);
+    assert.ok(report.checked <= 100);
+  } finally { p.cleanup(); }
+});
+
+test('no filesystem (an unsaved document): relative references are unverified, not errors; in-document checks still run', async () => {
+  const report = await run(['# A', '', '[x](other.md) [y](#a) [z](#b)'], 'markdown');
+  assert.deepEqual(codes(report.diagnostics).sort(), ['broken-fragment@2', 'unverified-local@2']);
+  assert.equal(report.diagnostics.find(item => item.code === 'unverified-local')!.severity, 'unverified');
+});
+
+test('CRLF stray carriage returns, BOM text and Unicode keep line and column right', async () => {
+  const report = await run(['日本語 😀 [bad](nope.md)', 'a\rb [also](nope2.md)'], 'markdown');
+  assert.deepEqual(report.diagnostics.map(item => [item.line, item.code]), [[0, 'unverified-local'], [1, 'unverified-local']]);
+  assert.equal('日本語 😀 [bad](nope.md)'.slice(report.diagnostics[0]!.column!, report.diagnostics[0]!.endColumn!), 'nope.md');
+});
+
+test('html: missing assets, alt text, form labels, duplicate ids, unresolved fragments, malformed nesting; templated attributes are unverified, not errors', async () => {
+  const p = project();
+  try {
+    const html = ['<!doctype html>', '<html><head><link rel="stylesheet" href="../style.css"><link rel="stylesheet" href="../gone.css"><script src="../app.js"></script></head>', '<body>', '<img src="../img/pic.png"><img src="../img/gone.png" alt="x"><img src="{{ dynamic }}" alt="d">', '<div id="a"></div><div id="a"></div>', '<a href="#a">ok</a> <a href="#nowhere">bad</a> <a href="https://example.com">ext</a>', '<label for="n">Name</label><input id="n"><input id="m"><input type="hidden" name="h"><label>Wrap <input></label><input aria-label="named">', '<p><b>unclosed</p>', '<ul><li>one<li>two</ul>', '<script>if (a < b) { x = "<img src=nope.png>"; }</script>', '</div>', '</body></html>'];
+    const report = await run(html, 'html', p.dir, p.root);
+    const list = codes(report.diagnostics);
+    for (const expected of ['missing-file@1', 'image-alt@3', 'missing-file@3', 'duplicate-id@4', 'broken-fragment@5', 'form-label@6', 'unclosed-tag@7', 'unexpected-closing-tag@10']) assert.ok(list.includes(expected), `${expected} in ${JSON.stringify(list)}`);
+    assert.ok(!list.some(code => code === 'missing-file@9'), 'text inside a script is not markup');
+    assert.equal(list.filter(code => code.startsWith('form-label')).length, 1, 'only the unlabeled input; labeled, hidden, wrapped and aria-labelled ones are fine');
+    assert.ok(report.diagnostics.some(item => item.code === 'unverified-dynamic' && item.severity === 'unverified'));
+    assert.ok(!list.includes('unclosed-tag@8'), 'optional end tags (li) are valid');
+  } finally { p.cleanup(); }
+});
+
+test('css: url() assets are checked in .css and <style>; unbalanced braces are a warning; data: and fragments are fine', async () => {
+  const p = project();
+  try {
+    const css = await run(['a { background: url(../img/pic.png); }', 'b { background: url("../img/gone.png"); }', 'c { background: url(data:image/png;base64,AAAA); }', 'd { color: red;'], 'css', p.dir, p.root);
+    assert.deepEqual(codes(css.diagnostics).sort(), ['css-syntax@3', 'missing-file@1']);
+    const html = await run(['<style>', 'p { background: url(../img/gone.png) }', '</style>'], 'html', p.dir, p.root);
+    assert.deepEqual(codes(html.diagnostics), ['missing-file@1']);
+  } finally { p.cleanup(); }
+});
+
+test('valid unconventional markup produces nothing: a stress document of legal oddities has no false positives', async () => {
+  const p = project();
+  try {
+    const lines = ['# A', '', '<details><summary>x</summary>', '', 'text [^n]', '', '</details>', '', '[^n]: note', '', '| a | b |', '|---|---|', '| [x](#a) | ![y](../img/pic.png "title") |', '', '<img src="../img/pic.png" alt="">', '', '[ref]: <../img/pic.png> "Title"', '[use][ref] and [Ref][] and autolink <https://x.y/z>', '', '1. [x](../docs/other.md)'];
+    const report = await run(lines, 'markdown', p.dir, p.root);
+    assert.deepEqual(report.diagnostics.map(item => `${item.code}@${item.line}`), [`missing-file@19`].filter(() => false), JSON.stringify(report.diagnostics));
+  } finally { p.cleanup(); }
+});
+
+test('performance: 20,000 lines with many links finish quickly and respect the check bound; an aborted run returns nothing new', async () => {
+  const p = project();
+  try {
+    const lines = Array.from({length: 20_000}, (_, index) => `Line ${index} [a](#h${index % 50}) [b](other.md) text *em*`);
+    const started = process.hrtime.bigint();
+    const report = await diagnose({lines, format: 'markdown', fs: createLocalFs(p.dir, p.root)});
+    assert.ok(Number(process.hrtime.bigint() - started) / 1e9 < 5);
+    assert.ok(report.checked <= 2, 'one file path is checked once, however many links name it');
+    const controller = new AbortController(); controller.abort();
+    const aborted = await diagnose({lines, format: 'markdown', signal: controller.signal});
+    assert.equal(aborted.aborted, true);
+  } finally { p.cleanup(); }
+});
diff --git a/tests/problems.test.ts b/tests/problems.test.ts
new file mode 100644
index 00000000..7eae0ec8
--- /dev/null
+++ b/tests/problems.test.ts
@@ -0,0 +1,230 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {ProblemsRunner} from '../src/viewer/problems.js';
+import {createEditor, editorKey, renderEditor, type EditorState} from '../src/viewer/EditorPanel.js';
+import {createDocumentSession, documentSessionKey, renderDocumentSession, type DocumentSession} from '../src/viewer/DocumentWorkspace.js';
+import {createLocalFs, type LocalFs} from '../src/markdown/diagnostics.js';
+import {createScratchFile, openForEdit} from '../src/viewer/fileEdit.js';
+import {decodeKeys} from '../src/terminal/keys.js';
+import {displayWidth, stripAnsi} from '../src/util/text.js';
+
+const F1 = '\u001bOP', F3 = '\u001bOR', F2 = '\u001bOQ';
+function project() {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), 'nmsh-problems-')));
+  mkdirSync(join(root, '.git')); mkdirSync(join(root, 'docs'));
+  writeFileSync(join(root, 'docs', 'other.md'), '# Other\n');
+  const write = (name: string, text: string) => { const path = join(root, 'docs', name); writeFileSync(path, text); return path; };
+  return {root, write, cleanup: () => rmSync(root, {recursive: true, force: true})};
+}
+async function editorOn(path: string): Promise<EditorState> {
+  const opened = await openForEdit(path, '/');
+  if (!opened.ok) throw new Error(opened.reason);
+  return createEditor(opened.file);
+}
+const press = (editor: EditorState, bytes: string, columns = 100, height = 30) => { for (const key of decodeKeys(bytes)) editorKey(editor, key, columns, height); };
+const screen = (editor: EditorState, columns = 100, height = 30) => renderEditor(editor, columns, height).map(row => stripAnsi(row)).join('\n');
+const settle = async (check: () => boolean, what: string) => { const deadline = process.hrtime.bigint() + 5_000_000_000n; while (!check()) { if (process.hrtime.bigint() > deadline) throw new Error(`timed out waiting for ${what}`); await new Promise(done => setTimeout(done, 5)); } };
+const DOC = '# Title\n\n[good](other.md) [bad](nope.md) [frag](#missing)\n\n![](other.md)\n';
+
+test('runner: the first run reports, an edit re-runs after the debounce, undo and redo update, and nothing stale replaces newer results', async () => {
+  const p = project();
+  try {
+    const editor = await editorOn(p.write('a.md', DOC));
+    let slow = false;
+    const delayed = (inner: LocalFs): LocalFs => ({stat: async path => { if (slow) await new Promise(done => setTimeout(done, 80)); return inner.stat(path); }, readText: (path, max) => inner.readText(path, max)});
+    const runner = new ProblemsRunner(editor, {debounceMs: 10, makeFs: async () => delayed(createLocalFs(join(p.root, 'docs'), p.root))});
+    editor.problems = runner;
+    runner.enable();
+    await settle(() => Boolean(runner.report), 'the first report');
+    assert.deepEqual(runner.report!.diagnostics.map(item => item.code).sort(), ['broken-fragment', 'image-alt', 'missing-file']);
+    editor.buffer.caret = {line: 2, column: 0}; editor.buffer.insert('[x](gone.md) ');
+    await settle(() => runner.report!.diagnostics.filter(item => item.code === 'missing-file').length === 2, 'the re-run');
+    editor.buffer.undo();
+    await settle(() => runner.report!.diagnostics.filter(item => item.code === 'missing-file').length === 1, 'the undo');
+    editor.buffer.redo();
+    await settle(() => runner.report!.diagnostics.filter(item => item.code === 'missing-file').length === 2, 'the redo');
+    // A slow run for an old version must not overwrite the newer result.
+    slow = true;
+    editor.buffer.caret = {line: 0, column: 0}; editor.buffer.insert('[a](stale1.md) ');
+    await new Promise(done => setTimeout(done, 40));
+    slow = false;
+    editor.buffer.undo(); editor.buffer.undo();
+    await settle(() => !runner.busy, 'the runs to finish');
+    assert.equal(runner.report!.diagnostics.filter(item => item.code === 'missing-file').length, 1, 'the report is for the text as it is now');
+    assert.ok(!runner.report!.diagnostics.some(item => /stale1/u.test(item.message)));
+    runner.dispose();
+  } finally { p.cleanup(); }
+});
+
+test('runner: dispose stops everything (no timer, no later result); a disabled runner never runs; typing in an unopened document costs nothing', async () => {
+  const p = project();
+  try {
+    const editor = await editorOn(p.write('a.md', DOC));
+    let runs = 0;
+    const runner = new ProblemsRunner(editor, {debounceMs: 5, makeFs: async () => { runs += 1; return createLocalFs(join(p.root, 'docs'), p.root); }});
+    editor.buffer.insert('x');
+    await new Promise(done => setTimeout(done, 30));
+    assert.equal(runs, 0, 'not enabled: no work');
+    runner.enable();
+    await settle(() => Boolean(runner.report), 'a report');
+    runner.dispose();
+    const before = runs;
+    editor.buffer.insert('y');
+    await new Promise(done => setTimeout(done, 40));
+    assert.equal(runs, before);
+    assert.equal(runner.disposed, true);
+  } finally { p.cleanup(); }
+});
+
+test('a Playground document has no folder: relative references are unverified, and Save As makes them checkable after a refresh', async () => {
+  const p = project();
+  try {
+    const editor = createEditor(createScratchFile('markdown'));
+    editor.buffer.insert('[x](other.md) [y](#nope)');
+    const runner = new ProblemsRunner(editor, {debounceMs: 5});
+    editor.problems = runner; runner.enable();
+    await settle(() => Boolean(runner.report), 'report');
+    assert.deepEqual(runner.report!.diagnostics.map(item => `${item.code}:${item.severity}`).sort(), ['broken-fragment:error', 'unverified-local:unverified']);
+    runner.dispose();
+  } finally { p.cleanup(); }
+});
+
+// ---- The surface ------------------------------------------------------------------------------------------------
+
+test('F1 e opens Problems with counts and the findings; Tab filters, typing searches, Enter selects the exact text and Back returns; nothing is written or changed', async () => {
+  const p = project();
+  try {
+    const path = p.write('a.md', DOC);
+    const editor = await editorOn(path);
+    editor.problems = new ProblemsRunner(editor, {debounceMs: 5});
+    editor.buffer.caret = {line: 4, column: 3};
+    press(editor, F1); press(editor, 'e');
+    assert.equal(editor.dialog?.kind, 'problems');
+    await settle(() => Boolean(editor.problems!.report), 'report');
+    const view = screen(editor);
+    assert.match(view, /Problems/u); assert.match(view, /2 errors/u); assert.match(view, /1 warning/u);
+    assert.match(view, /No such file: nope\.md/u); assert.match(view, /No heading or id “missing”/u);
+    press(editor, 'nope');
+    assert.doesNotMatch(screen(editor), /image/iu);
+    press(editor, '\r');
+    assert.equal(editor.dialog, undefined);
+    assert.equal(editor.buffer.selectedText(), 'nope.md', 'the exact destination is selected');
+    assert.equal(editor.buffer.dirty, false);
+    assert.equal(readFileSync(path, 'utf8'), DOC);
+    press(editor, F1); press(editor, 'j');
+    assert.deepEqual(editor.buffer.caret, {line: 4, column: 3});
+    press(editor, F1); press(editor, 'e');
+    await settle(() => !editor.problems!.busy, 'refresh');
+    press(editor, '\t');
+    assert.match(screen(editor), /errors/u);
+    press(editor, '\t'); press(editor, '\t');
+    press(editor, '\u001b');
+    assert.equal(editor.dialog, undefined);
+    editor.problems!.dispose();
+  } finally { p.cleanup(); }
+});
+
+test('a dismissed finding stays hidden until the text changes; Ctrl+R checks again; a clean document says so', async () => {
+  const p = project();
+  try {
+    const editor = await editorOn(p.write('a.md', '[bad](nope.md)\n'));
+    editor.problems = new ProblemsRunner(editor, {debounceMs: 5});
+    press(editor, F1); press(editor, 'e');
+    await settle(() => Boolean(editor.problems!.report), 'report');
+    assert.match(screen(editor), /nope\.md/u);
+    press(editor, '\u001b[3~');
+    assert.doesNotMatch(screen(editor), /No such file/u);
+    press(editor, '\u0012');
+    await settle(() => !editor.problems!.busy, 'refresh');
+    assert.match(screen(editor), /No such file/u, 'a refresh shows it again');
+    editor.dialog = undefined;
+    editor.buffer.caret = {line: 0, column: 0}; editor.buffer.delete();
+    const clean = await editorOn(p.write('b.md', '# Fine\n\nNothing wrong here.\n'));
+    clean.problems = new ProblemsRunner(clean, {debounceMs: 5});
+    press(clean, F1); press(clean, 'e');
+    await settle(() => Boolean(clean.problems!.report), 'clean report');
+    assert.match(screen(clean), /No problems found/u);
+    editor.problems!.dispose(); clean.problems!.dispose();
+  } finally { p.cleanup(); }
+});
+
+test('HTML files list Problems in the palette; CSS files open it with F1; the status row shows the counts once checking is on', async () => {
+  const p = project();
+  try {
+    const html = await editorOn(p.write('p.html', '<img src="gone.png">\n'));
+    html.problems = new ProblemsRunner(html, {debounceMs: 5});
+    press(html, F1); press(html, 'problems'); press(html, '\r');
+    assert.equal(html.dialog?.kind, 'problems');
+    await settle(() => Boolean(html.problems!.report), 'html report');
+    assert.match(screen(html), /gone\.png/u);
+    press(html, '\u001b');
+    assert.match(screen(html), /✖\s*1/u, 'counts in the status row');
+    const css = await editorOn(p.write('s.css', 'a { background: url(gone.png) }\n'));
+    css.problems = new ProblemsRunner(css, {debounceMs: 5});
+    press(css, F1);
+    assert.equal(css.dialog?.kind, 'problems');
+    await settle(() => Boolean(css.problems!.report), 'css report');
+    assert.match(screen(css), /gone\.png/u);
+    html.problems!.dispose(); css.problems!.dispose();
+  } finally { p.cleanup(); }
+});
+
+test('rows fit 30–120 columns with colour, NO_COLOR and Safe Glyphs; severity never depends on colour alone', async () => {
+  const p = project();
+  const saved = process.env.NO_COLOR;
+  try {
+    const editor = await editorOn(p.write('a.md', `${DOC}\n[very long](${'dir/'.repeat(30)}file.md) 日本語 😀\n`));
+    editor.problems = new ProblemsRunner(editor, {debounceMs: 5});
+    press(editor, F1); press(editor, 'e');
+    await settle(() => Boolean(editor.problems!.report), 'report');
+    for (const noColor of [false, true]) {
+      if (noColor) process.env.NO_COLOR = '1'; else delete process.env.NO_COLOR;
+      for (const columns of [30, 50, 80, 120]) for (const row of renderEditor(editor, columns, 24)) assert.ok(displayWidth(stripAnsi(row)) <= columns, `${columns}: ${stripAnsi(row)}`);
+    }
+    assert.match(screen(editor, 100), /[✖E]\s/u);
+    editor.problems!.dispose();
+  } finally { if (saved === undefined) delete process.env.NO_COLOR; else process.env.NO_COLOR = saved; p.cleanup(); }
+});
+
+// ---- Every mode -------------------------------------------------------------------------------------------------
+
+async function session(path: string): Promise<DocumentSession> {
+  const opened = await openForEdit(path, '/');
+  if (!opened.ok) throw new Error(opened.reason);
+  const state = createDocumentSession(opened.file, 'edit');
+  state.editor.problems = new ProblemsRunner(state.editor, {debounceMs: 5});
+  return state;
+}
+const key = (state: DocumentSession, bytes: string, columns = 120, height = 30) => { for (const k of decodeKeys(bytes)) documentSessionKey(state, k, columns, height); };
+const LONG = ['# Top', '', ...Array.from({length: 40}, (_, index) => `filler ${index}`), '', '[bad](nope.md) here', '', '## End'].join('\n') + '\n';
+
+test('Problems works in source, preview, hybrid and split: P (or F1 e) opens it and a jump lands on the exact source and shows it', async () => {
+  const p = project();
+  try {
+    const target = LONG.split('\n').findIndex(line => line.includes('nope.md'));
+    for (const mode of ['source', 'preview', 'hybrid', 'split-preview', 'split-source', 'edit'] as const) {
+      const state = await session(p.write(`m-${mode}.md`, LONG));
+      state.editor.problems = new ProblemsRunner(state.editor, {debounceMs: 5});
+      if (mode === 'source') key(state, '\u001b');
+      else if (mode === 'preview') { key(state, '\u000f'); }
+      else if (mode === 'hybrid') key(state, F3);
+      else if (mode === 'split-preview') { key(state, F2); key(state, '\u000f'); }
+      else if (mode === 'split-source') key(state, F2);
+      if (mode === 'edit' || mode === 'hybrid' || mode === 'split-source') key(state, F1 + 'e'); else key(state, 'P');
+      assert.equal(state.editor.dialog?.kind, 'problems', mode);
+      await settle(() => Boolean(state.editor.problems!.report), `${mode} report`);
+      assert.match(renderDocumentSession(state, 120, 24).map(row => stripAnsi(row)).join('\n'), /No such file: nope\.md/u, mode);
+      key(state, '\r', 120, 24);
+      assert.equal(state.editor.dialog, undefined, mode);
+      assert.equal(state.editor.buffer.caret.line, target, `${mode}: the caret is on the finding`);
+      assert.equal(state.editor.buffer.selectedText(), 'nope.md', mode);
+      const view = renderDocumentSession(state, 120, 24).map(row => stripAnsi(row)).join('\n');
+      assert.match(view, /nope\.md|bad/u, `${mode}: the place is on screen`);
+      assert.equal(state.editor.buffer.dirty, false, mode);
+      state.editor.problems!.dispose();
+    }
+  } finally { p.cleanup(); }
+});

From 4157cbd72f13df9a203103c0630c5d40135d93cb Mon Sep 17 00:00:00 2001
From: raiseCatError <315733358+raiseCatError@users.noreply.github.com>
Date: Thu, 22 Oct 2026 03:15:42 +0530
Subject: [PATCH 2/2] Problems: fix the findings of the independent review
 (confinement, bounded scanning, false positives and negatives, spans,
 lifecycle)

---
 docs/design/document-workspace.md |   1 +
 src/app/TerminalApp.ts            |   6 +-
 src/markdown/diagnostics.ts       | 306 +++++++++++++++++++++---------
 src/viewer/EditorPanel.ts         |   2 +
 src/viewer/problems.ts            |   2 +
 tests/diagnostics.test.ts         | 115 +++++++++++
 tests/problems.test.ts            |  25 +++
 7 files changed, 368 insertions(+), 89 deletions(-)

diff --git a/docs/design/document-workspace.md b/docs/design/document-workspace.md
index 1b4a2ee2..026bd60f 100644
--- a/docs/design/document-workspace.md
+++ b/docs/design/document-workspace.md
@@ -60,6 +60,7 @@ Limits: code fences are recognised by a line scan (indented code blocks and fenc
 - **Filesystem:** only through `LocalFs`, created per run for the document's folder with the project root (`documentRoot`: the git project within a dozen levels, else the folder). A path is lexically resolved, then `realpath`ed, and must stay inside the real root; for a missing path the deepest existing ancestor is checked, so a symlinked directory cannot be used to probe outside. Only `lstat` and one bounded read of another Markdown file (headings only). At most 400 distinct paths per run; at most 500 findings; HTML over 1.5 MB is skipped and marked truncated; messages never name a path the document did not itself write.
 - **Currency:** checking is off until Problems is first opened. Then `ProblemsRunner` observes the buffer: each change bumps a revision and schedules a run (500 ms); a run snapshots the lines, aborts any run in flight, and its result is dropped if the revision moved. Opening Problems, Ctrl+R, a save and a Save As re-check (files the document names may have changed; no watchers). The runner is disposed with the editor, on reload and on exit, so no timer or observer outlives the document.
 - **Surface:** the dialog lists findings by severity then line with counts and the number of external links not checked; Tab cycles all / problems / errors, typing filters on the message, Del dismisses (until the next report), Esc leaves. In source and preview a jump also scrolls the read-only view to the line; hybrid and the split follow the caret.
+- **Independent review (opus subagent, security focus) and what changed:** (1–3) a dangling symlink, or a symlink to a folder this user cannot read, was told apart from other links outside the root (it leaked whether the outside target exists) and `readText` could be raced into following a link or blocking on a FIFO — the path is now walked component by component from the root, each link resolved (even dangling ones, via `readlink`) and confined before the walk continues, and the read opens with `O_NOFOLLOW|O_NONBLOCK`, `fstat`s a regular file and re-checks the real path; (4) heading checks in another file read it once per path and count against a bound; (5) quadratic regexes on hostile lines (80k characters took 17–38 s) — every quantifier is bounded, lines over 20,000 characters are scanned only that far and say so, and CSS is read by a linear scanner; (6) readers of reload, plain Save As-and-close now release the runner; (7) a failing checker no longer throws into the editor; (8–10) false positives and negatives: HTML comments and code spans across lines, TOML front matter, definitions on the next line or in quotes, escaped destinations, `url()` in CSS comments and strings, `url(#id)` checked against ids in HTML, `<base href>`, ids inside `<template>`, the first of duplicate attributes, an undefined `[text][ref]` (CommonMark shows it as text) is only information; the outer link of a badge, nested brackets, inline `<img>` and `@import` are now checked; (11–12) the `image-alt` span is the image's own text and a value spanning lines is not an exact span; (13) the list focus stays on a row when a new report is shorter.
 - **Not provided:** a gutter marker in the text, checks of other languages, CSS property validation, link fragments inside another HTML file, following redirects or fetching anything, quick fixes, and the browser console (a separate, gated slice).
 - **Verified by** `tests/diagnostics.test.ts` (each check, hostile paths and symlinks, the filesystem checker, no-folder documents, Unicode and stray CR, HTML and CSS, false-positive stress, bounds) and `tests/problems.test.ts` (runner staleness and disposal, the surface, filters, dismiss, refresh, widths/NO_COLOR/Safe Glyphs, and every mode: source, preview, hybrid, split, edit).
 
diff --git a/src/app/TerminalApp.ts b/src/app/TerminalApp.ts
index b9bff7d0..206c8aae 100644
--- a/src/app/TerminalApp.ts
+++ b/src/app/TerminalApp.ts
@@ -4636,7 +4636,7 @@ export class TerminalApp {
   private runEditorAction(editor: EditorState, action: EditorAction): void {
     if (action.kind === 'draft' || action.kind === 'draft-discard' || action.kind === 'draft-keep') { this.runDraftAction(editor, action); return; }
     if (action.kind === 'playground') { this.releaseEditor(editor); this.textEditor = undefined; void this.openPlayground(action.choice); return; }
-    if (action.kind === 'save-as') { this.saveAs(editor, action.path, Boolean(action.thenClose), () => this.textEditor === editor, () => { this.textEditor = undefined; this.returnFromPanel(); }); return; }
+    if (action.kind === 'save-as') { this.saveAs(editor, action.path, Boolean(action.thenClose), () => this.textEditor === editor, () => { this.releaseEditor(editor); this.textEditor = undefined; this.returnFromPanel(); }); return; }
     if (editor.file.scratch && (action.kind === 'review' || action.kind === 'review-apply' || action.kind === 'reload' || action.kind === 'save')) { editor.note = {text: 'A Playground document has no file yet: Save As creates one.', tone: 'info'}; return; }
     if (action.kind === 'review' || action.kind === 'review-apply') { this.reviewDisk(editor, action.kind === 'review-apply', () => this.textEditor === editor); return; }
     if (action.kind === 'close') { this.releaseEditor(editor); this.textEditor = undefined; this.returnFromPanel(); return; }
@@ -4650,7 +4650,7 @@ export class TerminalApp {
         editor.busy = false;
         if (this.textEditor !== editor) return;
         if (!result.ok) { editor.note = {text: result.reason, tone: 'error'}; this.render(); return; }
-        this.drafts().discard(editor);
+        this.releaseEditor(editor);
         this.textEditor = {...createEditor(result.file), note: {text: 'Reloaded from disk; your changes were discarded.', tone: 'info'}};
         this.render();
       });
@@ -4794,7 +4794,7 @@ export class TerminalApp {
         editor.busy = false;
         if (this.docSession !== session) return;
         if (!result.ok) { editor.note = {text: result.reason, tone: 'error'}; session.viewer.note = result.reason; this.render(); return; }
-        this.drafts().discard(editor);
+        this.releaseEditor(editor);
         const fresh = createDocumentSession(result.file, session.mode === 'edit' || session.mode === 'hybrid' ? session.mode : 'source');
         fresh.note = 'Reloaded from disk; your changes were discarded.';
         fresh.viewer.note = fresh.note;
diff --git a/src/markdown/diagnostics.ts b/src/markdown/diagnostics.ts
index 75dff080..a096f5cc 100644
--- a/src/markdown/diagnostics.ts
+++ b/src/markdown/diagnostics.ts
@@ -1,7 +1,8 @@
-import {lstat, open, realpath} from 'node:fs/promises';
-import {dirname, isAbsolute, relative, resolve, sep} from 'node:path';
+import {constants} from 'node:fs';
+import {lstat, open, readlink, realpath} from 'node:fs/promises';
+import {isAbsolute, join, relative, resolve, sep} from 'node:path';
 import {parseBlockLines, type Block} from './blocks.js';
-import {headingsFromLines, resolveFragment} from './sourceMap.js';
+import {headingsFromLines, resolveFragment, type HeadingEntry} from './sourceMap.js';
 
 /**
  * Offline static diagnostics for Markdown, HTML and CSS documents (#466). Everything here reads the document's own lines (the
@@ -57,8 +58,16 @@ export const MAX_DIAGNOSTICS = 500;
 export const MAX_CHECKS = 400;
 const MAX_PATH = 1024;
 const MAX_TARGET_BYTES = 256 * 1024;
+const MAX_TARGET_READS = 50;
+/** Markdown lines longer than this are scanned only this far (the rest is reported, not guessed at). */
+const MAX_LINE = 20_000;
 
-/** A checker confined to `root`: lexical `..` and symlinks are both resolved before a path is called inside. */
+/**
+ * A checker confined to `root`. The path is lexically resolved, then walked one component at a time from the root: a symlink
+ * (even a dangling one, even one into a folder this user cannot read) is resolved at the component where it is met and the
+ * result must stay inside the real root before the walk goes on, so nothing beyond the root is ever looked at and a link
+ * out of it can never be told apart from any other.
+ */
 export function createLocalFs(docDir: string, root: string): LocalFs {
   let realRoot: Promise<string> | undefined;
   const rootReal = () => realRoot ??= realpath(root).catch(() => root);
@@ -68,20 +77,37 @@ export function createLocalFs(docDir: string, root: string): LocalFs {
     const resolved = resolve(docDir, path);
     if (!inside(root, resolved)) return {state: 'outside'};
     const base = await rootReal();
+    const segments = relative(root, resolved).split(sep).filter(Boolean);
+    let current = root;
+    for (let index = 0; index < segments.length; index += 1) {
+      const next = join(current, segments[index]!);
+      let info;
+      try { info = await lstat(next); }
+      catch (error) {
+        const code = (error as NodeJS.ErrnoException).code;
+        return {state: code === 'ENOENT' || code === 'ENOTDIR' ? 'missing' : 'unreadable'};
+      }
+      if (info.isSymbolicLink()) {
+        let target: string;
+        try { target = await realpath(next); }
+        catch (error) {
+          const code = (error as NodeJS.ErrnoException).code;
+          if (code !== 'ENOENT') return {state: 'unreadable'};
+          // Dangling: the place it points to is judged without looking at it.
+          try { return {state: inside(base, resolve(join(current), await readlink(next))) ? 'missing' : 'outside'}; } catch { return {state: 'unreadable'}; }
+        }
+        if (!inside(base, target)) return {state: 'outside'};
+        current = target;
+        continue;
+      }
+      current = next;
+    }
     try {
-      const real = await realpath(resolved);
-      if (!inside(base, real)) return {state: 'outside'};
-      const info = await lstat(real);
-      return {state: info.isDirectory() ? 'directory' : info.isFile() ? 'file' : 'unreadable', real};
+      const info = await lstat(current);
+      return {state: info.isDirectory() ? 'directory' : info.isFile() ? 'file' : 'unreadable', real: current};
     } catch (error) {
       const code = (error as NodeJS.ErrnoException).code;
-      if (code === 'EACCES' || code === 'EPERM') return {state: 'unreadable'};
-      if (code !== 'ENOENT' && code !== 'ENOTDIR') return {state: 'unreadable'};
-      // Missing: but a symlinked folder on the way may already lead out of the root.
-      for (let ancestor = dirname(resolved); ancestor !== dirname(ancestor); ancestor = dirname(ancestor)) {
-        try { const real = await realpath(ancestor); return {state: inside(base, real) ? 'missing' : 'outside'}; } catch { /* keep climbing */ }
-      }
-      return {state: 'missing'};
+      return {state: code === 'ENOENT' || code === 'ENOTDIR' ? 'missing' : 'unreadable'};
     }
   }
   return {
@@ -90,8 +116,17 @@ export function createLocalFs(docDir: string, root: string): LocalFs {
       const found = await locate(path);
       if (found.state !== 'file' || !found.real) return undefined;
       let handle;
-      try { handle = await open(found.real, 'r'); const buffer = Buffer.alloc(maxBytes); const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0); return buffer.subarray(0, bytesRead).toString('utf8'); }
-      catch { return undefined; } finally { await handle?.close().catch(() => undefined); }
+      try {
+        // Never follow a link or wait on a pipe: the file is opened as the regular file it was a moment ago, or not at all.
+        handle = await open(found.real, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0) | (constants.O_NOCTTY ?? 0));
+        const info = await handle.stat();
+        const before = await lstat(found.real);
+        if (!info.isFile() || info.ino !== before.ino || info.dev !== before.dev) return undefined;
+        if (await realpath(found.real) !== found.real) return undefined;
+        const buffer = Buffer.alloc(Math.min(maxBytes, info.size));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return buffer.subarray(0, bytesRead).toString('utf8');
+      } catch { return undefined; } finally { await handle?.close().catch(() => undefined); }
     },
   };
 }
@@ -146,6 +181,7 @@ class Run {
   external = 0;
   truncated = false;
   private readonly states = new Map<string, Promise<FileState>>();
+  private readonly targets = new Map<string, Promise<HeadingEntry[] | undefined>>();
   private ids = 0;
   constructor(readonly input: DiagnoseInput) {}
   get aborted() { return Boolean(this.input.signal?.aborted); }
@@ -165,34 +201,47 @@ class Run {
     return pending;
   }
 
-  /** Report a destination written in the document. `kindOfAsset`: a missing file is an error either way; the wording differs. */
+  /** The headings of another Markdown file, read once per path and counted against the same bound as other file work. */
+  targetHeadings(path: string): Promise<HeadingEntry[] | undefined> | undefined {
+    const known = this.targets.get(path);
+    if (known) return known;
+    if (!this.input.fs || this.targets.size >= MAX_TARGET_READS) { this.truncated = true; return undefined; }
+    const pending = this.input.fs.readText(path, MAX_TARGET_BYTES).then(text => text === undefined ? undefined : headingsFromLines(text.split('\n')));
+    this.targets.set(path, pending);
+    return pending;
+  }
+
+  /** Report a destination written in the document; `exactSpan` false when only the line is known. */
   async reference(destination: string, line: number, column: number, headings: ReturnType<typeof headingsFromLines> | undefined, ids: ReadonlySet<string> | undefined, softFragments: boolean): Promise<void> {
     const end = column + destination.length;
-    const target = classify(destination);
+    const exact = !destination.includes('\n') && !destination.includes('\r');
+    const add = (code: string, severity: Severity, message: string) => this.add(code, severity, message, line, exact ? column : undefined, exact ? end : undefined);
+    const target = classify(destination.replace(/\\([!-/:-@[-`{-~])/gu, '$1'));
     switch (target.kind) {
       case 'ignore': return;
       case 'external': this.external += 1; return;
-      case 'unsafe': this.add('unsafe-scheme', 'warning', `A ${target.scheme}: link is never followed or checked here.`, line, column, end); return;
-      case 'absolute': this.add('absolute-path', 'unverified', 'Absolute and home-relative paths are not checked.', line, column, end); return;
+      case 'unsafe': add('unsafe-scheme', 'warning', `A ${target.scheme}: link is never followed or checked here.`); return;
+      case 'absolute': add('absolute-path', 'unverified', 'Absolute and home-relative paths are not checked.'); return;
       case 'fragment': {
+        if (!headings && !ids) return;
         const found = headings ? resolveFragment(headings, target.fragment) : undefined;
         let decoded = target.fragment;
         try { decoded = decodeURIComponent(decoded); } catch { /* as written */ }
         if (found || ids?.has(decoded) || ids?.has(target.fragment) || decoded.toLowerCase() === 'top') return;
-        this.add('broken-fragment', softFragments ? 'warning' : 'error', softFragments ? `No heading or id “${target.fragment}” here (other generators may build ids differently).` : `No heading or id “${target.fragment}” in this document.`, line, column, end);
+        add('broken-fragment', softFragments ? 'warning' : 'error', softFragments ? `No heading or id “${target.fragment}” here (other generators may build ids differently).` : `No heading or id “${target.fragment}” in this document.`);
         return;
       }
       case 'local': {
         const pending = this.stat(target.path);
-        if (!pending) { if (!this.input.fs) this.add('unverified-local', 'unverified', 'Not checked: this document has no folder yet. Save it to check local files.', line, column, end); return; }
+        if (!pending) { if (!this.input.fs) add('unverified-local', 'unverified', 'Not checked: this document has no folder yet. Save it to check local files.'); return; }
         const state = await pending;
         if (this.aborted) return;
-        if (state === 'outside') this.add('outside-root', 'unverified', 'Points outside the document\'s folder or project; not checked.', line, column, end);
-        else if (state === 'unreadable') this.add('unreadable', 'warning', 'This path cannot be read or checked.', line, column, end);
-        else if (state === 'missing') this.add('missing-file', 'error', `No such file: ${target.path}`, line, column, end);
+        if (state === 'outside') add('outside-root', 'unverified', 'Points outside the document\'s folder or project; not checked.');
+        else if (state === 'unreadable') add('unreadable', 'warning', 'This path cannot be read or checked.');
+        else if (state === 'missing') add('missing-file', 'error', `No such file: ${target.path.replace(/[\r\n]+/gu, ' ')}`);
         else if (state === 'file' && target.fragment && /\.(?:md|markdown)$/iu.test(target.path) && this.input.fs) {
-          const text = await this.input.fs.readText(target.path, MAX_TARGET_BYTES);
-          if (text !== undefined && !resolveFragment(headingsFromLines(text.split('\n')), target.fragment)) this.add('broken-fragment-in-file', 'warning', `No heading “${target.fragment}” in ${target.path}.`, line, column, end);
+          const headingsOfTarget = await this.targetHeadings(target.path);
+          if (headingsOfTarget && !resolveFragment(headingsOfTarget, target.fragment)) add('broken-fragment-in-file', 'warning', `No heading “${target.fragment}” in ${target.path}.`);
         }
         return;
       }
@@ -209,63 +258,100 @@ function codeLines(blocks: readonly Block[], into: Set<number>): void {
 }
 
 const normalize = (label: string) => label.trim().replace(/\s+/gu, ' ').toLowerCase();
-const maskCode = (text: string) => text.replace(/(`+)[\s\S]*?\1/gu, span => ' '.repeat(span.length));
+const blankOut = (text: string) => text.replace(/[^\n]/gu, ' ');
+const MAX_PARAGRAPH_FOR_SPANS = 200_000;
+
+/** The lines to scan: code, front matter, HTML comments and code spans (also across lines of a paragraph) blanked, columns kept. */
+function scannable(lines: readonly string[], skip: ReadonlySet<number>): string[] {
+  let text = lines.map((line, at) => skip.has(at) ? '' : line).join('\n');
+  text = text.replace(/<!--[\s\S]*?-->/gu, blankOut);
+  const cut = text.split('\n');
+  let start = 0;
+  while (start < cut.length) {
+    if (!cut[start]!.trim()) { start += 1; continue; }
+    let end = start;
+    while (end < cut.length && cut[end]!.trim()) end += 1;
+    const paragraph = cut.slice(start, end).join('\n');
+    if (paragraph.includes('`') && paragraph.length <= MAX_PARAGRAPH_FOR_SPANS) cut.splice(start, end - start, ...paragraph.replace(/(`+)[\s\S]*?\1/gu, blankOut).split('\n'));
+    start = end;
+  }
+  return cut;
+}
+
+const LINK = /(!?)(?<!\\)\[((?:[^\[\]\\!]|\\.|\[[^\[\]\\]{0,200}\]|!\[[^\[\]]{0,200}\]\([^()\s]{0,500}\)|!(?!\[)){0,400})\]\(\s*(<[^>\n]{0,1000}>|[^\s()]{0,1000}(?:\([^\s()]{0,300}\)[^\s()]{0,300}){0,5})/gdu;
+const REFERENCE = /(?<![\\!])\[([^\[\]\\]{1,400})\]\[([^\[\]\\]{0,400})\]/gdu;
+const FOOTNOTE = /(?<!\\)\[\^([^\]\s]{1,200})\](?!:)/gdu;
+const DEFINITION = /^((?:[ ]{0,3}>[ ]?)*[ ]{0,3})\[([^\]^][^\]]{0,999})\]:[ \t]*(<[^>\n]{0,1000}>|\S{0,1000})/du;
+const NOTE_DEFINITION = /^((?:[ ]{0,3}>[ ]?)*[ ]{0,3})\[\^([^\]\s]{1,200})\]:/u;
+const INLINE_IMG = /<img\b[^>]{0,2000}?\bsrc\s*=\s*(?:"([^"\n]{0,1000})"|'([^'\n]{0,1000})')/gdiu;
 
 async function markdown(run: Run): Promise<void> {
   const lines = run.input.lines;
   const blocks = parseBlockLines(lines, {html: true});
   const skip = new Set<number>();
   codeLines(blocks, skip);
-  if (lines[0]?.trim() === '---') for (let at = 1; at < Math.min(lines.length, 200); at += 1) if (/^(?:---|\.\.\.)\s*$/u.test(lines[at]!)) { for (let line = 0; line <= at; line += 1) skip.add(line); break; }
+  const fence = lines[0]?.trim();
+  if (fence === '---' || fence === '+++') for (let at = 1; at < Math.min(lines.length, 200); at += 1) if (lines[at]!.trim() === fence || (fence === '---' && lines[at]!.trim() === '...')) { for (let line = 0; line <= at; line += 1) skip.add(line); break; }
   const headings = headingsFromLines(lines, {html: true});
   const seen = new Map<string, number>();
   for (const heading of headings) {
-    const key = heading.slug;
-    if (key === undefined) continue;
+    if (heading.slug === undefined) continue;
     const first = seen.get(heading.text.toLowerCase());
-    if (first !== undefined) run.add('duplicate-heading', 'info', `Same heading text as line ${first + 1}; its anchor is #${key}.`, heading.line);
+    if (first !== undefined) run.add('duplicate-heading', 'info', `Same heading text as line ${first + 1}; its anchor is #${heading.slug}.`, heading.line);
     else seen.set(heading.text.toLowerCase(), heading.line);
   }
   const soft = lines.some(line => /\bid\s*=|\{#/u.test(line));
+  const text = scannable(lines, skip);
   const definitions = new Set<string>(), footnoteDefs = new Map<string, number>();
   const refs: Array<{label: string; line: number; start: number; end: number}> = [], notes: Array<{label: string; line: number; start: number; end: number}> = [];
-  const destinations: Array<{destination: string; line: number; column: number; image?: boolean; alt?: string}> = [];
-  lines.forEach((text, line) => {
+  const destinations: Array<{destination: string; line: number; column: number; alt?: {text: string; start: number; end: number}}> = [];
+  let longLine = false;
+  text.forEach((full, line) => {
     if (skip.has(line) || run.aborted) return;
-    const masked = maskCode(text);
+    if (full.length > MAX_LINE && !longLine) { longLine = true; run.add('long-line', 'info', `This line is over ${MAX_LINE.toLocaleString('en-US')} characters; only its first part is checked.`, line); }
+    const masked = full.length > MAX_LINE ? full.slice(0, MAX_LINE) : full;
     let from = 0;
-    const note = /^ {0,3}\[\^([^\]\s]+)\]:/u.exec(masked);
-    const definition = note ? undefined : /^ {0,3}\[([^\]]+)\]:[ \t]*(<[^>\n]*>|\S+)/du.exec(masked);
-    if (note) { footnoteDefs.set(note[1]!, line); from = note[0].length; }
+    const note = NOTE_DEFINITION.exec(masked);
+    const definition = note ? undefined : DEFINITION.exec(masked);
+    if (note) { footnoteDefs.set(note[2]!, line); from = note[0].length; }
     if (definition) {
-      definitions.add(normalize(definition[1]!));
-      const raw = definition[2]!;
-      const start = definition.indices![2]![0] + (raw.startsWith('<') ? 1 : 0);
-      destinations.push({destination: raw.startsWith('<') ? raw.slice(1, -1) : raw, line, column: start});
+      definitions.add(normalize(definition[2]!));
+      let raw = definition[3]!, at = definition.indices![3]![0], target = line;
+      if (!raw) {
+        // The destination may start the next line.
+        const following = /^\s*(<[^>\n]*>|\S+)/u.exec(text[line + 1] ?? '');
+        if (following) { raw = following[1]!; at = following[0].length - raw.length; target = line + 1; }
+      }
+      if (raw) destinations.push({destination: raw.startsWith('<') ? raw.slice(1, -1) : raw, line: target, column: at + (raw.startsWith('<') ? 1 : 0)});
       from = definition[0].length;
     }
     const rest = masked.slice(from);
-    for (const match of rest.matchAll(/(!?)(?<!\\)\[((?:[^\]\\]|\\.)*)\]\(\s*(<[^>\n]*>|[^\s()]*(?:\([^\s()]*\)[^\s()]*)*)/gdu)) {
+    for (const match of rest.matchAll(LINK)) {
       const raw = match[3]!;
       const [startIndex] = match.indices![3]!;
       const angle = raw.startsWith('<');
-      destinations.push({destination: angle ? raw.slice(1, -1) : raw, line, column: from + startIndex + (angle ? 1 : 0), ...(match[1] ? {image: true, alt: match[2]!} : {})});
+      destinations.push({destination: angle ? raw.slice(1, -1) : raw, line, column: from + startIndex + (angle ? 1 : 0),
+        ...(match[1] ? {alt: {text: match[2]!, start: from + match.index!, end: from + match.index! + 3 + match[2]!.length}} : {})});
     }
-    for (const match of rest.matchAll(/(?<![\\!])\[((?:[^\]\\]|\\.)+)\]\[((?:[^\]\\]|\\.)*)\]/gdu)) {
+    for (const match of rest.matchAll(INLINE_IMG)) {
+      const group = match[1] !== undefined ? 1 : 2;
+      destinations.push({destination: match[group]!, line, column: from + match.indices![group]![0]});
+    }
+    for (const match of rest.matchAll(REFERENCE)) {
       if (match[1]!.startsWith('^')) continue;
       const label = match[2]! || match[1]!;
       const [start, end] = match.indices![match[2]! ? 2 : 1]!;
       refs.push({label, line, start: from + start, end: from + end});
     }
-    for (const match of rest.matchAll(/(?<!\\)\[\^([^\]\s]+)\](?!:)/gdu)) { const [start, end] = match.indices![1]!; notes.push({label: match[1]!, line, start: from + start, end: from + end}); }
-    run.external += [...rest.matchAll(/<([a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]*)>/gu)].filter(autolink => classify(autolink[1]!).kind === 'external').length;
+    for (const match of rest.matchAll(FOOTNOTE)) { const [start, end] = match.indices![1]!; notes.push({label: match[1]!, line, start: from + start, end: from + end}); }
+    run.external += [...rest.matchAll(/<([a-zA-Z][a-zA-Z0-9+.-]{0,30}:[^>\s]{0,1000})>/gu)].filter(autolink => classify(autolink[1]!).kind === 'external').length;
   });
   for (const item of destinations) {
     if (run.aborted) return;
-    if (item.image && !item.alt!.trim()) run.add('image-alt', 'warning', 'This image has no alternative text.', item.line, item.column - 1, item.column - 1 + item.destination.length + 1);
+    if (item.alt && !item.alt.text.trim()) run.add('image-alt', 'warning', 'This image has no alternative text.', item.line, item.alt.start, item.alt.end);
     await run.reference(item.destination, item.line, item.column, headings, undefined, soft);
   }
-  for (const ref of refs) if (!definitions.has(normalize(ref.label))) run.add('undefined-reference', 'error', `No link reference definition for “${ref.label}”.`, ref.line, ref.start, ref.end);
+  for (const ref of refs) if (!definitions.has(normalize(ref.label))) run.add('undefined-reference', 'info', `“${ref.label}” looks like a reference link but nothing defines it; it will show as plain text.`, ref.line, ref.start, ref.end);
   const used = new Set<string>();
   for (const note of notes) { used.add(note.label); if (!footnoteDefs.has(note.label)) run.add('undefined-footnote', 'error', `No definition for footnote [^${note.label}].`, note.line, note.start, note.end); }
   for (const [label, line] of footnoteDefs) if (!used.has(label)) run.add('unreferenced-footnote', 'warning', `Footnote [^${label}] is defined but never referenced.`, line);
@@ -273,43 +359,85 @@ async function markdown(run: Run): Promise<void> {
 
 // ---- CSS and HTML -----------------------------------------------------------------------------------------------
 
-async function cssUrls(run: Run, text: string, line: number, columnBase: number): Promise<void> {
-  for (const match of text.matchAll(/url\(\s*(?:"([^"\n]*)"|'([^'\n]*)'|([^)\s'"]*))\s*\)/gdu)) {
-    const value = match[1] ?? match[2] ?? match[3] ?? '';
-    const [start] = match.indices![match[1] !== undefined ? 1 : match[2] !== undefined ? 2 : 3]!;
-    if (TEMPLATED.test(value)) { run.add('unverified-dynamic', 'unverified', 'A templated address cannot be checked statically.', line, columnBase + start, columnBase + start + value.length); continue; }
-    await run.reference(value, line, columnBase + start, undefined, undefined, false);
-  }
-}
+interface CssUrl {value: string; line: number; column: number}
 
-function cssSyntax(run: Run, lines: readonly string[]): void {
+/** One pass over CSS: its url() and @import addresses (not those in comments or strings) and its first bracket problem. */
+function scanCss(text: string, baseLine: number, baseColumn: number): {urls: CssUrl[]; issue?: {message: string; line: number; column: number}} {
+  const urls: CssUrl[] = [];
   const stack: Array<{char: string; line: number; column: number}> = [];
-  let comment = false, quote = '';
-  for (let line = 0; line < lines.length; line += 1) {
-    const text = lines[line]!;
-    for (let column = 0; column < text.length; column += 1) {
-      const char = text[column]!;
-      if (comment) { if (char === '*' && text[column + 1] === '/') { comment = false; column += 1; } continue; }
-      if (quote) { if (char === '\\') column += 1; else if (char === quote) quote = ''; continue; }
-      if (char === '/' && text[column + 1] === '*') { comment = true; column += 1; continue; }
-      if (char === '"' || char === '\'') { quote = char; continue; }
-      if (char === '{' || char === '(') stack.push({char, line, column});
-      else if (char === '}' || char === ')') {
-        const open = stack.pop();
-        if (!open || (open.char === '{') !== (char === '}')) { run.add('css-syntax', 'warning', `Unexpected “${char}”.`, line, column, column + 1); return; }
+  let issue: {message: string; line: number; column: number} | undefined;
+  let line = baseLine, column = baseColumn;
+  const advance = (char: string) => { if (char === '\n') { line += 1; column = 0; } else column += 1; };
+  for (let at = 0; at < text.length;) {
+    const char = text[at]!;
+    if (char === '/' && text[at + 1] === '*') {
+      const end = text.indexOf('*/', at + 2);
+      const stop = end < 0 ? text.length : end + 2;
+      for (; at < stop; at += 1) advance(text[at]!);
+      if (end < 0 && !issue) issue = {message: 'A comment is never closed.', line, column};
+      continue;
+    }
+    if (char === '"' || char === '\'') {
+      let end = at + 1;
+      while (end < text.length && text[end] !== char) end += text[end] === '\\' ? 2 : 1;
+      const stop = Math.min(text.length, end + 1);
+      for (; at < stop; at += 1) advance(text[at]!);
+      continue;
+    }
+    if (char === '\\') { advance(char); at += 1; if (at < text.length) { advance(text[at]!); at += 1; } continue; }
+    const rest = text.slice(at, at + 7);
+    if (/^url\(/iu.test(rest) || /^@import\s/iu.test(text.slice(at, at + 8))) {
+      const isUrl = /^url\(/iu.test(rest);
+      let cursor = at + (isUrl ? 4 : 7);
+      let startLine = line, startColumn = column + (cursor - at);
+      for (let skipTo = at; skipTo < cursor; skipTo += 1) advance(text[skipTo]!);
+      while (cursor < text.length && /\s/u.test(text[cursor]!)) { advance(text[cursor]!); startLine = line; startColumn = column; cursor += 1; }
+      startLine = line; startColumn = column;
+      const quote = text[cursor] === '"' || text[cursor] === '\'' ? text[cursor]! : undefined;
+      let value = '';
+      let end = cursor;
+      if (quote) {
+        end = cursor + 1;
+        while (end < text.length && text[end] !== quote && value.length < 2000) { value += text[end] === '\\' ? text[end + 1] ?? '' : text[end]; end += text[end] === '\\' ? 2 : 1; }
+        startColumn += 1;
+        end += 1;
+      } else if (isUrl) {
+        while (end < text.length && text[end] !== ')' && !/\s/u.test(text[end]!) && value.length < 2000) { value += text[end]; end += 1; }
       }
+      if (value && (quote || isUrl)) urls.push({value, line: startLine, column: startColumn});
+      for (; cursor < end; cursor += 1) advance(text[cursor]!);
+      // url( ... ): the closing bracket belongs to it.
+      if (isUrl) {
+        while (cursor < text.length && /\s/u.test(text[cursor]!)) { advance(text[cursor]!); cursor += 1; }
+        if (text[cursor] === ')') { advance(')'); cursor += 1; }
+      }
+      at = cursor;
+      continue;
+    }
+    if ((char === '{' || char === '(') ) stack.push({char, line, column});
+    else if (char === '}' || char === ')') {
+      const open = stack.pop();
+      if (!issue && (!open || (open.char === '{') !== (char === '}'))) issue = {message: `Unexpected “${char}”.`, line, column};
     }
-    quote = '';
+    advance(char); at += 1;
   }
   const open = stack.at(-1);
-  if (open) run.add('css-syntax', 'warning', `“${open.char}” is never closed.`, open.line, open.column, open.column + 1);
-  else if (comment) run.add('css-syntax', 'warning', 'A comment is never closed.', lines.length - 1);
+  if (!issue && open) issue = {message: `“${open.char}” is never closed.`, line: open.line, column: open.column};
+  return {urls, ...(issue ? {issue} : {})};
+}
+
+async function cssUrls(run: Run, urls: readonly CssUrl[], ids: ReadonlySet<string> | undefined): Promise<void> {
+  for (const url of urls) {
+    if (run.aborted) return;
+    if (TEMPLATED.test(url.value)) { run.add('unverified-dynamic', 'unverified', 'A templated address cannot be checked statically.', url.line, url.column, url.column + url.value.length); continue; }
+    await run.reference(url.value, url.line, url.column, undefined, ids, false);
+  }
 }
 
 const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
 const OPTIONAL_END = new Set(['p', 'li', 'dt', 'dd', 'tr', 'td', 'th', 'thead', 'tbody', 'tfoot', 'option', 'optgroup', 'colgroup', 'html', 'head', 'body']);
 const RAW_TEXT = new Set(['script', 'style', 'textarea', 'title']);
-const TAG = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>`=]+))?)*)\s*(\/?)>/gdu;
+const TAG = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>`=]+))?)*)\s*(\/?)>/gdu;
 const ATTRIBUTE = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'<>`=]+)))?/gdu;
 const MAX_HTML_CHARS = 1_500_000;
 
@@ -321,16 +449,16 @@ async function html(run: Run): Promise<void> {
   const source = lines.join('\n');
   if (source.length > MAX_HTML_CHARS) { run.truncated = true; return; }
   const where = (position: number) => { let low = 0, high = starts.length - 1; while (low < high) { const mid = (low + high + 1) >> 1; if (starts[mid]! <= position) low = mid; else high = mid - 1; } return {line: low, column: position - starts[low]!}; };
-  const text = source.replace(/<!--[\s\S]*?-->/gu, comment => comment.replace(/[^\n]/gu, ' '));
+  const text = source;
   interface Tag {name: string; attributes: Map<string, {value: string; start: number; end: number}>; at: number}
   const ids = new Map<string, number>(), fragments: Array<{value: string; position: number; end: number}> = [], labelsFor = new Set<string>(), controls: Array<{tag: Tag; labelled: boolean}> = [];
   const stack: Array<{name: string; at: number}> = [];
-  let dynamic = 0, inLabel = 0;
+  let dynamic = 0, inLabel = 0, templateDepth = 0, baseSeen = false;
   const jobs: Array<() => Promise<void>> = [];
   let last = 0;
   for (const match of text.matchAll(TAG)) {
     if (run.aborted) return;
-    if (match.index! < last) continue;
+    if (match.index! < last || match[0].startsWith('<!--')) continue;
     const closing = Boolean(match[1]);
     const name = match[2]!.toLowerCase();
     const attributes = new Map<string, {value: string; start: number; end: number}>();
@@ -338,12 +466,13 @@ async function html(run: Run): Promise<void> {
     const base = match.indices![3]?.[0] ?? match.index!;
     for (const attribute of attributeText.matchAll(ATTRIBUTE)) {
       const group = attribute.indices![2] ?? attribute.indices![3] ?? attribute.indices![4];
-      attributes.set(attribute[1]!.toLowerCase(), {value: attribute[2] ?? attribute[3] ?? attribute[4] ?? '', start: base + (group?.[0] ?? attribute.indices![1]![1]), end: base + (group?.[1] ?? attribute.indices![1]![1])});
+      if (!attributes.has(attribute[1]!.toLowerCase())) attributes.set(attribute[1]!.toLowerCase(), {value: attribute[2] ?? attribute[3] ?? attribute[4] ?? '', start: base + (group?.[0] ?? attribute.indices![1]![1]), end: base + (group?.[1] ?? attribute.indices![1]![1])});
     }
     const tag: Tag = {name, attributes, at: match.index!};
     const position = where(match.index!);
     if (closing) {
       if (name === 'label' && inLabel > 0) inLabel -= 1;
+      if (name === 'template' && templateDepth > 0) templateDepth -= 1;
       const found = stack.map(entry => entry.name).lastIndexOf(name);
       if (found < 0) { if (!VOID.has(name)) run.add('unexpected-closing-tag', 'warning', `</${name}> has no matching opening tag.`, position.line, position.column, position.column + match[0].length); }
       else { for (let at = stack.length - 1; at > found; at -= 1) { const open = stack[at]!; if (!OPTIONAL_END.has(open.name)) { const place = where(open.at); run.add('unclosed-tag', 'warning', `<${open.name}> is never closed.`, place.line, place.column, place.column + open.name.length + 1); } } stack.length = found; }
@@ -353,15 +482,18 @@ async function html(run: Run): Promise<void> {
         stack.push({name, at: match.index!});
       }
       if (name === 'label') inLabel += 1;
+      if (name === 'base' && attributes.has('href')) baseSeen = true;
+      const inert = templateDepth > 0;
+      if (name === 'template') templateDepth += 1;
       const dynamicHere = [...attributes.values()].some(attribute => TEMPLATED.test(attribute.value));
       if (dynamicHere) { dynamic += 1; const first = [...attributes.values()].find(attribute => TEMPLATED.test(attribute.value))!; const place = where(first.start); run.add('unverified-dynamic', 'unverified', 'A templated attribute cannot be checked statically.', place.line, place.column, place.column + (first.end - first.start)); }
-      const id = attributes.get('id');
+      const id = inert ? undefined : attributes.get('id');
       if (id?.value) { if (ids.has(id.value)) { const place = where(id.start); run.add('duplicate-id', 'error', `The id “${id.value}” is used twice (first on line ${where(ids.get(id.value)!).line + 1}).`, place.line, place.column, place.column + id.value.length); } else ids.set(id.value, id.start); }
       const named = attributes.get('name');
       if (name === 'a' && named?.value) ids.set(named.value, named.start);
       const asset = (attribute: string) => {
         const entry = attributes.get(attribute);
-        if (!entry || !entry.value || dynamicHere) return;
+        if (!entry || !entry.value || dynamicHere || inert) return;
         const place = where(entry.start);
         jobs.push(() => run.reference(entry.value, place.line, place.column, undefined, undefined, false));
       };
@@ -379,7 +511,7 @@ async function html(run: Run): Promise<void> {
         const rest = text.slice(contentStart);
         const end = new RegExp(`</${name}\\s*>`, 'iu').exec(rest);
         const content = end ? rest.slice(0, end.index) : rest;
-        if (name === 'style') { const origin = where(contentStart); content.split('\n').forEach((part, index) => jobs.push(() => cssUrls(run, part, origin.line + index, index === 0 ? origin.column : 0))); }
+        if (name === 'style' && !inert) { const origin = where(contentStart); const scanned = scanCss(content, origin.line, origin.column); jobs.push(() => cssUrls(run, scanned.urls, new Set(ids.keys()))); }
         last = contentStart + content.length + (end ? end[0].length : 0);
         if (end) stack.pop();
       }
@@ -400,7 +532,8 @@ async function html(run: Run): Promise<void> {
     run.add('form-label', 'warning', `This <${control.tag.name}> has no label (use <label for>, a wrapping <label> or aria-label).`, place.line, place.column, place.column + control.tag.name.length + 1);
   }
   if (dynamic > 0) run.external += 0;
-  for (const job of jobs) { if (run.aborted) return; await job(); }
+  if (baseSeen) run.add('unverified-dynamic', 'unverified', 'A <base href> changes how relative addresses resolve; local files are not checked in this document.', 0);
+  else for (const job of jobs) { if (run.aborted) return; await job(); }
 }
 
 export async function diagnose(input: DiagnoseInput): Promise<DiagnosticReport> {
@@ -410,8 +543,9 @@ export async function diagnose(input: DiagnoseInput): Promise<DiagnosticReport>
     if (input.format === 'markdown') await markdown(run);
     else if (input.format === 'html') await html(run);
     else {
-      cssSyntax(run, input.lines);
-      for (let line = 0; line < input.lines.length && !run.aborted; line += 1) await cssUrls(run, input.lines[line]!, line, 0);
+      const scanned = scanCss(input.lines.map(line => line.length > MAX_LINE ? line.slice(0, MAX_LINE) : line).join('\n'), 0, 0);
+      if (scanned.issue) run.add('css-syntax', 'warning', scanned.issue.message, scanned.issue.line, scanned.issue.column, scanned.issue.column + 1);
+      await cssUrls(run, scanned.urls, undefined);
     }
   } catch (error) {
     if (!run.aborted) run.add('diagnostics-failed', 'info', `Checking stopped early: ${error instanceof Error ? error.message : 'unknown error'}.`, 0);
diff --git a/src/viewer/EditorPanel.ts b/src/viewer/EditorPanel.ts
index 8f130ad3..b97c739a 100644
--- a/src/viewer/EditorPanel.ts
+++ b/src/viewer/EditorPanel.ts
@@ -199,6 +199,7 @@ function jumpToDiagnostic(state: EditorState, item: Diagnostic): void {
 
 function problemsKey(state: EditorState, dialog: EditorDialog, key: Key): void {
   const items = problemList(state, dialog);
+  dialog.focus = Math.max(0, Math.min(dialog.focus, items.length - 1));
   if (key.kind === 'escape' || key.kind === 'interrupt') { state.dialog = undefined; return; }
   if (key.kind === 'up' || key.kind === 'focusPrevious' || key.kind === 'suggestPrevious') { dialog.focus = Math.max(0, dialog.focus - 1); return; }
   if (key.kind === 'down' || key.kind === 'suggestNext') { dialog.focus = Math.min(Math.max(0, items.length - 1), dialog.focus + 1); return; }
@@ -600,6 +601,7 @@ function footerRows(state: EditorState, columns: number): string[] {
     const dialog = state.dialog;
     const runner = state.problems;
     const items = problemList(state, dialog);
+    dialog.focus = Math.max(0, Math.min(dialog.focus, items.length - 1));
     const accent = foreground(UI_COLORS.accent), subtle = foreground(UI_COLORS.subtle);
     const safe = getIconStyle() === 'safe';
     const glyph = (severity: Severity) => safe ? ({error: 'E', warning: 'W', info: 'i', unverified: '?'})[severity] : ({error: '✖', warning: '▲', info: 'ℹ', unverified: '?'})[severity];
diff --git a/src/viewer/problems.ts b/src/viewer/problems.ts
index 3baa5249..db3ac2df 100644
--- a/src/viewer/problems.ts
+++ b/src/viewer/problems.ts
@@ -83,6 +83,8 @@ export class ProblemsRunner {
       this.report = report;
       this.dismissed.clear();
       ProblemsRunner.notify?.();
+    } catch {
+      // A check that could not run (the folder vanished, a read failed) leaves the last report as it was; it never throws into the editor.
     } finally { this.running -= 1; }
   }
 
diff --git a/tests/diagnostics.test.ts b/tests/diagnostics.test.ts
index c349f181..9041a1fc 100644
--- a/tests/diagnostics.test.ts
+++ b/tests/diagnostics.test.ts
@@ -144,3 +144,118 @@ test('performance: 20,000 lines with many links finish quickly and respect the c
     assert.equal(aborted.aborted, true);
   } finally { p.cleanup(); }
 });
+
+// ---- Findings of the independent review -------------------------------------------------------------------------
+
+import {spawnSync} from 'node:child_process';
+import {lstatSync} from 'node:fs';
+
+test('review 1-3: a dangling or unreadable symlink out of the root is "outside", never "missing" or "unreadable", and readText opens nothing special', async () => {
+  const p = project();
+  try {
+    symlinkSync(join(p.outside, 'real-missing'), join(p.root, 'd1'));
+    symlinkSync(join(p.outside, 'secret.txt'), join(p.root, 'd2'));
+    symlinkSync(join(p.outside, 'nowhere-dir'), join(p.root, 'dangling-dir'));
+    mkdirSync(join(p.outside, 'locked')); writeFileSync(join(p.outside, 'locked', 'f'), 'x'); chmodSync(join(p.outside, 'locked'), 0o000);
+    symlinkSync(join(p.outside, 'locked'), join(p.root, 'l1'));
+    const fs = createLocalFs(p.root, p.root);
+    assert.equal(await fs.stat('d1'), 'outside', 'a dangling link to an outside path');
+    assert.equal(await fs.stat('d2'), 'outside');
+    assert.equal(await fs.stat('dangling-dir/x.md'), 'outside');
+    assert.equal(await fs.stat('l1/f'), 'outside', 'a locked folder behind a link is outside, not unreadable');
+    assert.equal(await fs.stat('l1/nope'), 'outside');
+    chmodSync(join(p.outside, 'locked'), 0o755);
+    assert.equal(await fs.readText('d2', 100), undefined, 'a link out of the root is never read');
+    const fifo = join(p.root, 'pipe.md');
+    spawnSync('mkfifo', [fifo]);
+    if (lstatSync(fifo).isFIFO()) {
+      const started = process.hrtime.bigint();
+      assert.equal(await fs.readText('pipe.md', 100), undefined);
+      assert.ok(Number(process.hrtime.bigint() - started) / 1e9 < 2, 'a FIFO does not block');
+    }
+    assert.equal(await fs.stat('pipe.md'), 'unreadable');
+  } finally { chmodSync(join(p.outside, 'locked'), 0o755); p.cleanup(); }
+});
+
+test('review 4: heading checks in another file read it once, however many links name it', async () => {
+  const p = project();
+  try {
+    let reads = 0;
+    const real = createLocalFs(p.dir, p.root);
+    const counting: LocalFs = {stat: path => real.stat(path), readText: (path, max) => { reads += 1; return real.readText(path, max); }};
+    const lines = Array.from({length: 3000}, (_, index) => `[x](other.md#f${index})`);
+    const report = await diagnose({lines, format: 'markdown', fs: counting});
+    assert.equal(reads, 1);
+    assert.ok(report.diagnostics.length >= 400, 'findings still reported (bounded)');
+  } finally { p.cleanup(); }
+});
+
+test('review 5: hostile long lines finish quickly and an abort is noticed', async () => {
+  for (const [line, format] of [['['.repeat(80_000), 'markdown'], ['[^'.repeat(40_000), 'markdown'], ['[\\]'.repeat(30_000), 'markdown'], ['url('.repeat(40_000), 'css'], ['![a](' .repeat(20_000), 'markdown']] as const) {
+    const started = process.hrtime.bigint();
+    await diagnose({lines: [line], format});
+    assert.ok(Number(process.hrtime.bigint() - started) / 1e9 < 2, `${format}: ${line.slice(0, 6)} took ${Number(process.hrtime.bigint() - started) / 1e9}s`);
+  }
+  const started = process.hrtime.bigint();
+  const lines = Array.from({length: 4000}, () => `${'[a'.repeat(300)} [x](nope.md)`);
+  const controller = new AbortController();
+  const pending = diagnose({lines, format: 'markdown', signal: controller.signal});
+  setTimeout(() => controller.abort(), 20);
+  const report = await pending;
+  assert.ok(Number(process.hrtime.bigint() - started) / 1e9 < 3);
+  assert.ok(report.aborted === true || report.diagnostics.length >= 0);
+});
+
+test('review 8: valid Markdown that was reported before is quiet', async () => {
+  const p = project();
+  try {
+    const lines = ['# T', '', '<!-- [old](missing.md) -->', '<!--', '[old2](missing.md)', '-->', '', 'matrix[i][j] is prose.', '', '[r]:', '  other.md', '> [q]: other.md', '', 'See [a][r] and [b][q].', '', 'a `code', 'span [y](missing.md)` ends', '', '[esc](other\\.md) [esc2](a\\_b.md)', '', '[![badge](../img/pic.png)](other.md) [a [b] c](other.md)'];
+    const report = await run(lines, 'markdown', p.dir, p.root);
+    const bad = report.diagnostics.filter(item => item.severity === 'error');
+    assert.deepEqual(bad.map(item => `${item.code}@${item.line}: ${item.message}`), ['missing-file@18: No such file: a_b.md'], JSON.stringify(report.diagnostics));
+    const toml = await run(['+++', 'link = "[x](missing.md)"', '+++', '', '# After'], 'markdown', p.dir, p.root);
+    assert.deepEqual(toml.diagnostics, [], 'TOML front matter is skipped');
+  } finally { p.cleanup(); }
+});
+
+test('review 8-10: an undefined [text][ref] is only information (CommonMark shows it as text); the outer link of a badge and nested brackets are checked; inline <img> and @import are checked', async () => {
+  const p = project();
+  try {
+    const md = await run(['[x][nope]', '[![CI](../img/pic.png)](gone.md)', '[a [b] c](gone2.md)', '<img src="../img/gone.png" alt="x">'], 'markdown', p.dir, p.root);
+    assert.deepEqual(md.diagnostics.map(item => `${item.code}:${item.severity}@${item.line}`).sort(), ['missing-file:error@1', 'missing-file:error@2', 'missing-file:error@3', 'undefined-reference:info@0'].sort());
+    const css = await run(['@import "gone.css";', '@import url(../style.css);'], 'css', p.dir, p.root);
+    assert.deepEqual(css.diagnostics.map(item => `${item.code}@${item.line}`), ['missing-file@0']);
+  } finally { p.cleanup(); }
+});
+
+test('review 9: valid HTML and CSS that was reported before is quiet', async () => {
+  const p = project();
+  try {
+    const html = await run(['<svg><clipPath id="c"></clipPath></svg>', '<style>', '.a { clip-path: url(#c); background: url(#nope); }', '/* url(missing.png) */', '.b { content: "url(missing.png)"; }', '.c\\{x { color: red }', '</style>', '<template><p id="t"></p></template><p id="t"></p>', '<script>var a = "<!--";</script>', '<img src="../img/pic.png" src="gone.png" alt="">'], 'html', p.dir, p.root);
+    assert.deepEqual(html.diagnostics.map(item => `${item.code}@${item.line}`), ['broken-fragment@2']);
+    const base = await run(['<base href="https://cdn.example/">', '<img src="logo.png" alt="">'], 'html', p.dir, p.root);
+    assert.ok(!base.diagnostics.some(item => item.severity === 'error'), 'a <base> makes relative addresses unverifiable');
+    const css = await run(['a { filter: url(#blur); background: url(x/*.png); }', '/* }} */', '.q { content: "a\\', '}" }'], 'css', p.dir, p.root);
+    assert.ok(!css.diagnostics.some(item => item.code === 'css-syntax' && item.line < 2), JSON.stringify(css.diagnostics));
+  } finally { p.cleanup(); }
+});
+
+test('review 11-12: the image-alt span is the image text; a value that spans lines is not an exact span and its message is one line', async () => {
+  const lines = ['x ![](b.png) y  ![ ](c.png)'];
+  const md = await run(lines, 'markdown');
+  const alt = md.diagnostics.filter(item => item.code === 'image-alt');
+  assert.equal(alt.length, 2);
+  for (const item of alt) assert.ok(lines[0]!.slice(item.column, item.endColumn).startsWith('!['), lines[0]!.slice(item.column, item.endColumn));
+  const p = project();
+  try {
+    const html = await run(['<a href="missing', '2.html">x</a>'], 'html', p.dir, p.root);
+    const item = html.diagnostics.find(entry => entry.code === 'missing-file')!;
+    assert.equal(item.exact, false);
+    assert.ok(!item.message.includes('\n'));
+  } finally { p.cleanup(); }
+});
+
+test('review: a long Markdown source line is scanned only so far and says so; the details scan elsewhere has a budget', async () => {
+  const report = await diagnose({lines: [`${'a '.repeat(15_000)}[x](nope.md)`], format: 'markdown'});
+  assert.ok(report.diagnostics.some(item => item.code === 'long-line'));
+});
diff --git a/tests/problems.test.ts b/tests/problems.test.ts
index 7eae0ec8..906ea965 100644
--- a/tests/problems.test.ts
+++ b/tests/problems.test.ts
@@ -228,3 +228,28 @@ test('Problems works in source, preview, hybrid and split: P (or F1 e) opens it
     }
   } finally { p.cleanup(); }
 });
+
+test('review 6, 7, 13: a failing filesystem factory is not an unhandled rejection; the focus stays on a row when the list shrinks', async () => {
+  const p = project();
+  try {
+    const editor = await editorOn(p.write('a.md', '[a](nope.md) [b](nope2.md) [c](nope3.md)\n'));
+    const rejections: unknown[] = [];
+    const listener = (reason: unknown) => rejections.push(reason);
+    process.on('unhandledRejection', listener);
+    const broken = new ProblemsRunner(editor, {debounceMs: 5, makeFs: async () => { throw new Error('boom'); }});
+    broken.enable();
+    await new Promise(done => setTimeout(done, 40));
+    process.off('unhandledRejection', listener);
+    assert.deepEqual(rejections, []);
+    broken.dispose();
+    editor.problems = new ProblemsRunner(editor, {debounceMs: 5});
+    press(editor, F1); press(editor, 'e');
+    await settle(() => Boolean(editor.problems!.report), 'report');
+    press(editor, '\u001b[B'); press(editor, '\u001b[B');
+    editor.buffer.caret = {line: 0, column: 0}; editor.buffer.delete(); editor.buffer.delete();
+    for (let step = 0; step < 24; step += 1) editor.buffer.delete();
+    await settle(() => editor.problems!.visible().length < 3 && !editor.problems!.busy, 'a shorter report');
+    assert.match(screen(editor), /▸/u, 'a row is still selected');
+    editor.problems!.dispose();
+  } finally { p.cleanup(); }
+});