@gavin-hu/my-pi-agent 0.19.0 → 0.20.0

package/extensions/file-browse/files/index.ts

@@ -0,0 +1,90 @@
+/**
+ * The quick-open index: every file path under the root, to `limit`, for the palette.
+ *
+ * A separate walk from the tree on purpose: the palette wants paths and nothing else, and
+ * it reads the whole tree once instead of per folder.
+ */
+
+import type { Dirent } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Directory names the quick-open index never walks. */
+export const INDEX_IGNORED_DIRS = new Set([".git", "node_modules"]);
+
+export interface FileIndex {
+	files: string[];
+	truncated: boolean;
+}
+
+/**
+ * Walk `root` and collect file paths for the quick-open palette. Symlinks and
+ * the ignored directories are skipped, and the walk stops at `limit` files so a
+ * large tree cannot exhaust memory or time. Unreadable directories are skipped.
+ */
+export async function buildFileIndex(root: string, limit: number): Promise<FileIndex> {
+	const files: string[] = [];
+	let truncated = false;
+
+	async function walk(absDir: string, relDir: string): Promise<void> {
+		let dirents: Dirent[];
+		try {
+			dirents = await readdir(absDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		dirents.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+		for (const dirent of dirents) {
+			if (truncated) return;
+			if (dirent.isSymbolicLink()) continue;
+			const rel = relDir ? `${relDir}/${dirent.name}` : dirent.name;
+			if (dirent.isDirectory()) {
+				if (INDEX_IGNORED_DIRS.has(dirent.name)) continue;
+				await walk(join(absDir, dirent.name), rel);
+			} else if (dirent.isFile()) {
+				if (files.length >= limit) {
+					truncated = true;
+					return;
+				}
+				files.push(rel);
+			}
+		}
+	}
+
+	await walk(root, "");
+	files.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()) || a.localeCompare(b));
+	return { files, truncated };
+}
+
+export type FileIndexProvider = () => Promise<FileIndex>;
+
+export interface FileIndexOptions {
+	/** How long a built index is reused, in ms (default 10000). */
+	ttlMs?: number;
+	/** Wall-clock seam; defaults to the real clock. */
+	now?: () => number;
+}
+
+/** A cached `buildFileIndex` for `root`; concurrent calls share one walk. */
+export function createFileIndex(root: string, limit: number, options: FileIndexOptions = {}): FileIndexProvider {
+	const ttlMs = options.ttlMs ?? 10_000;
+	const now = options.now ?? (() => Date.now());
+	let cached: FileIndex | undefined;
+	let checkedAt = 0;
+	let pending: Promise<FileIndex> | undefined;
+	return async () => {
+		const time = now();
+		if (cached && time - checkedAt < ttlMs) return cached;
+		if (pending) return pending;
+		pending = buildFileIndex(root, limit)
+			.then((index) => {
+				cached = index;
+				checkedAt = now();
+				return index;
+			})
+			.finally(() => {
+				pending = undefined;
+			});
+		return pending;
+	};
+}

package/extensions/file-browse/files/list.ts

@@ -0,0 +1,261 @@
+/**
+ * Directory listings and single-file reads: what a folder holds, capped and sorted, and
+ * what one file's bytes are.
+ *
+ * The filesystem reads are injected (`DirectoryFs`) so a test can count them: the property
+ * worth holding is that a directory is read once per entry, not once per row drawn.
+ */
+
+import { join } from "node:path";
+import { lstat, readdir, readFile, stat } from "node:fs/promises";
+import type { Stats } from "node:fs";
+import { mapConcurrent } from "../../../lib/pool.ts";
+import { HttpError } from "./paths.ts";
+import {
+	classifyByName,
+	contentTypeFor,
+	type EntryKind,
+	isImageName,
+	isMarkdownName,
+	isProbablyText,
+} from "./classify.ts";
+
+export interface DirEntry {
+	name: string;
+	/** Root-relative posix path. */
+	rel: string;
+	isDir: boolean;
+	isSymlink: boolean;
+	broken: boolean;
+	size: number;
+	mtimeMs: number;
+	kind: EntryKind;
+	isImage: boolean;
+}
+
+export interface Listing {
+	entries: DirEntry[];
+	total: number;
+	truncated: boolean;
+}
+
+export interface FileMeta {
+	size: number;
+	mtimeMs: number;
+	mime: string;
+}
+
+export type FileView =
+	| (FileMeta & { kind: "text"; lines: string[]; truncated: boolean; totalLines: number })
+	| (FileMeta & { kind: "markdown"; lines: string[]; truncated: boolean; totalLines: number })
+	| (FileMeta & { kind: "image" })
+	| (FileMeta & { kind: "binary" })
+	| (FileMeta & { kind: "tooLarge" });
+
+/** Whether the name has an image extension. */
+export function toAbs(root: string, rel: string): string {
+	return rel ? join(root, ...rel.split("/")) : root;
+}
+
+/** The `Dirent` fields a listing reads; a test's fake need not be a real `Dirent`. */
+export interface DirectoryEntryInfo {
+	name: string;
+	isDirectory(): boolean;
+	isSymbolicLink(): boolean;
+}
+
+/** The `Stats` fields a listing reads. */
+export interface DirectoryStats {
+	size: number;
+	mtimeMs: number;
+	isDirectory(): boolean;
+}
+
+/**
+ * The three filesystem reads a listing makes.
+ *
+ * Injected so a test can observe them: the interesting property — a directory is
+ * read once per entry, not once per entry *and* once per row drawn — is a count,
+ * not a value, and a wall-clock assertion would be flaky on a loaded machine.
+ */
+export interface DirectoryFs {
+	readdir(path: string): Promise<DirectoryEntryInfo[]>;
+	lstat(path: string): Promise<DirectoryStats>;
+	stat(path: string): Promise<DirectoryStats>;
+}
+
+/** Production reads; a symlink's size and kind come from the target. */
+const NODE_DIRECTORY_FS: DirectoryFs = {
+	readdir: (path) => readdir(path, { withFileTypes: true }),
+	lstat: (path) => lstat(path),
+	stat: (path) => stat(path),
+};
+
+/** Reads in flight per listing: enough to hide latency, bounded against a burst. */
+const LISTING_CONCURRENCY = 32;
+
+/** A row while it is still missing its metadata. */
+interface Row {
+	name: string;
+	rel: string;
+	isDir: boolean;
+	isSymlink: boolean;
+	broken: boolean;
+	size: number;
+	mtimeMs: number;
+}
+
+/**
+ * Resolve one symlink: the link's own stat, then the target's.
+ *
+ * A symlink's directory-ness is the target's, so this cannot wait until after
+ * the sort; it is also the only entry whose classification needs a read.
+ */
+async function resolveSymlink(fs: DirectoryFs, absDir: string, row: Row): Promise<void> {
+	const abs = join(absDir, row.name);
+	try {
+		const info = await fs.lstat(abs);
+		row.size = info.size;
+		row.mtimeMs = info.mtimeMs;
+	} catch {
+		// Vanished between readdir and lstat: the target read decides below.
+	}
+	try {
+		const target = await fs.stat(abs);
+		row.isDir = target.isDirectory();
+		row.size = target.size;
+		row.mtimeMs = target.mtimeMs;
+	} catch {
+		row.broken = true;
+	}
+}
+
+/**
+ * List a directory, sorted (directories first, then case-insensitive name).
+ *
+ * A listing is latency per entry, not work per entry, so it is read in three
+ * passes instead of one entry at a time:
+ *
+ * 1. `readdir`, whose dirents already say whether each name is a directory;
+ * 2. the symlinks only, resolved through the pool, because their kind is the
+ *    target's and the sort needs it;
+ * 3. the kept rows only, `stat`ed through the pool — so a directory of three
+ *    thousand names pays for the two thousand it draws, not for every name, and
+ *    pays them concurrently instead of in turn.
+ *
+ * `total` is still the directory's full entry count and `truncated` its `> limit`
+ * flip, so the page can say how many were dropped. Ties keep `readdir` order:
+ * `sort` is stable and the rows arrive unsorted.
+ */
+export async function listDirectory(
+	root: string,
+	relDir: string,
+	limit: number,
+	fs: DirectoryFs = NODE_DIRECTORY_FS,
+): Promise<Listing> {
+	const absDir = toAbs(root, relDir);
+	let dirents: DirectoryEntryInfo[];
+	try {
+		dirents = await fs.readdir(absDir);
+	} catch {
+		throw new HttpError(404, "That folder could not be read.");
+	}
+
+	const links: Row[] = [];
+	const rows: Row[] = dirents.map((dirent) => {
+		const row: Row = {
+			name: dirent.name,
+			rel: relDir ? `${relDir}/${dirent.name}` : dirent.name,
+			isDir: dirent.isDirectory(),
+			isSymlink: dirent.isSymbolicLink(),
+			broken: false,
+			size: 0,
+			mtimeMs: 0,
+		};
+		if (row.isSymlink) links.push(row);
+		return row;
+	});
+
+	await mapConcurrent(links, LISTING_CONCURRENCY, (row) => resolveSymlink(fs, absDir, row));
+
+	// Directories first, then case-insensitive name. The sort runs before the cap,
+	// so the rows that survive it are the rows that would have been drawn.
+	rows.sort((a, b) => {
+		if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+		return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+	});
+
+	const total = rows.length;
+	const truncated = total > limit;
+	const kept = truncated ? rows.slice(0, limit) : rows;
+
+	await mapConcurrent(
+		kept.filter((row) => !row.isSymlink),
+		LISTING_CONCURRENCY,
+		async (row) => {
+			try {
+				const info = await fs.stat(join(absDir, row.name));
+				row.size = info.size;
+				row.mtimeMs = info.mtimeMs;
+			} catch {
+				// Directory entry vanished between readdir and stat.
+			}
+		},
+	);
+
+	const entries: DirEntry[] = kept.map((row) => {
+		const kind: EntryKind = row.isDir ? "directory" : classifyByName(row.name);
+		return {
+			name: row.name,
+			rel: row.rel,
+			isDir: row.isDir,
+			isSymlink: row.isSymlink,
+			broken: row.broken,
+			size: row.size,
+			mtimeMs: row.mtimeMs,
+			kind,
+			isImage: !row.isDir && kind === "image",
+		};
+	});
+
+	return { entries, total, truncated };
+}
+
+/** Read a file into a renderable view, honouring the size and line caps. */
+export async function readFileView(
+	root: string,
+	rel: string,
+	maxFileBytes: number,
+	maxTextLines: number,
+	markdownEnabled = true,
+): Promise<FileView> {
+	const abs = toAbs(root, rel);
+	let info: Stats;
+	try {
+		info = await stat(abs);
+	} catch {
+		throw new HttpError(404, "That file could not be read.");
+	}
+	if (info.isDirectory()) throw new HttpError(404, "That path is a folder.");
+
+	const meta: FileMeta = { size: info.size, mtimeMs: info.mtimeMs, mime: contentTypeFor(rel) };
+	if (isImageName(rel)) return { kind: "image", ...meta };
+	if (info.size > maxFileBytes) return { kind: "tooLarge", ...meta };
+
+	let buffer: Buffer;
+	try {
+		buffer = await readFile(abs);
+	} catch {
+		throw new HttpError(404, "That file could not be read.");
+	}
+	if (!isProbablyText(buffer)) return { kind: "binary", ...meta };
+
+	const allLines = buffer.toString("utf-8").split(/\r\n|\r|\n/);
+	const truncated = allLines.length > maxTextLines;
+	const lines = truncated ? allLines.slice(0, maxTextLines) : allLines;
+	const kind = markdownEnabled && isMarkdownName(rel) ? "markdown" : "text";
+	if (kind === "markdown") {
+		return { kind: "markdown", ...meta, lines, truncated, totalLines: allLines.length };
+	}
+	return { kind: "text", ...meta, lines, truncated, totalLines: allLines.length };
+}

package/extensions/file-browse/files/tree.ts

@@ -0,0 +1,101 @@
+/**
+ * The sidebar tree: the current path's ancestors expanded, siblings collapsed.
+ *
+ * Its rows are the same `DirEntry` a listing produces, so the tree and the listing cannot
+ * disagree about what one name is.
+ */
+
+import { basename } from "node:path";
+import type { EntryKind } from "./classify.ts";
+import { type Listing, listDirectory } from "./list.ts";
+
+export interface TreeNode {
+	name: string;
+	rel: string;
+	isDir: boolean;
+	isImage: boolean;
+	/** True for a symlink whose target cannot be resolved. */
+	broken: boolean;
+	kind: EntryKind;
+	children: TreeNode[];
+}
+
+/**
+ * Build the sidebar tree: the current path's ancestors are expanded so the
+ * active item is always visible, and siblings are shown collapsed.
+ */
+export async function buildTree(root: string, currentRel: string, limit: number): Promise<TreeNode> {
+	return buildNode(root, "", currentRel, basename(root) || root, limit);
+}
+
+/** A directory page's two views of one directory. */
+export interface DirectoryView {
+	/** The current directory's own rows, for the page's listing. */
+	listing: Listing;
+	/** The sidebar tree, with the current path expanded. */
+	tree: TreeNode;
+}
+
+/**
+ * One walk for a directory page: the listing it draws, and the tree that shows
+ * where it sits.
+ *
+ * `listDirectory` is what decides whether the directory can be read at all, so it
+ * runs first and its 404 is the page's error. The walk then reuses that listing
+ * for the same directory instead of reading it a second time; the ancestors are
+ * still read once each, which is what the tree needs.
+ */
+export async function directoryView(root: string, currentRel: string, limit: number): Promise<DirectoryView> {
+	const listing = await listDirectory(root, currentRel, limit);
+	const tree = await buildNode(root, "", currentRel, basename(root) || root, limit, { rel: currentRel, listing });
+	return { listing, tree };
+}
+
+async function buildNode(
+	root: string,
+	relDir: string,
+	currentRel: string,
+	label: string,
+	limit: number,
+	/** A listing the caller already read for this directory, so it is not re-read. */
+	known?: { rel: string; listing: Listing },
+): Promise<TreeNode> {
+	const node: TreeNode = {
+		name: label,
+		rel: relDir,
+		isDir: true,
+		isImage: false,
+		broken: false,
+		kind: "directory",
+		children: [],
+	};
+	let listing: Listing;
+	if (known && known.rel === relDir) {
+		listing = known.listing;
+	} else {
+		try {
+			listing = await listDirectory(root, relDir, limit);
+		} catch {
+			return node;
+		}
+	}
+	for (const entry of listing.entries) {
+		const child: TreeNode = {
+			name: entry.name,
+			rel: entry.rel,
+			isDir: entry.isDir,
+			isImage: entry.isImage,
+			broken: entry.broken,
+			kind: entry.kind,
+			children: [],
+		};
+		if (entry.isDir) {
+			const onPath = currentRel === entry.rel || currentRel.startsWith(`${entry.rel}/`);
+			if (onPath) {
+				child.children = (await buildNode(root, entry.rel, currentRel, entry.name, limit, known)).children;
+			}
+		}
+		node.children.push(child);
+	}
+	return node;
+}

package/extensions/file-browse/transport/router.ts

@@ -15,7 +15,6 @@ import {
 	isLocalHostHeader,
 	jsonError,
 	jsonResponse,
-	pageHeaders,
 	parseRequestUrl,
 	scriptHeaders,
 	type ServeResponse,
@@ -379,7 +378,6 @@ export async function handleRequest(
 	try {
 		if (pathname === "/app.js") return { status: 200, headers: scriptHeaders(), body: CLIENT_JS };
 		if (pathname === THEME_JS_PATH) return { status: 200, headers: scriptHeaders(), body: THEME_JS };
-		if (pathname === "/favicon.ico") return { status: 204, headers: pageHeaders(), body: "" };
 		if (pathname === "/api/tree") return await treeApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/dir-rev") return await dirRevApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/files") return await filesApi(ctx, search.get("q") ?? "");

package/extensions/file-browse/view/emit.ts

@@ -0,0 +1,51 @@
+/**
+ * The elements a page emits for a resolved Markdown link or image.
+ *
+ * Two renderers reach a link: the Markdown renderer (`markdown.ts`) and the raw-HTML
+ * sanitizer (`raw-html.ts`). Both ask `urls.ts` what a destination resolves to, and both
+ * then build the same anchor and the same image — the external-rel attributes, the
+ * `md-img` class, and the lazy decoding — so those live here rather than in a fourth and
+ * fifth copy. Values are escaped here; the callers hand in what the document said.
+ */
+
+import { escapeHtml } from "../../../lib/escape.ts";
+
+/**
+ * The attributes an external link carries, for a caller that is building the element
+ * itself: the raw-HTML sanitizer rewrites an existing tag's attribute list and has no
+ * content string to hand an emitter.
+ *
+ * `noopener` because the target is another origin, and `noreferrer` because the page is a
+ * local view of the reader's own repository and should not tell anyone where they read it.
+ */
+export const EXTERNAL_ATTRS = ' target="_blank" rel="noopener noreferrer"';
+
+/** An `<a>` for one destination; `title` and the rel attributes are omitted when absent. */
+export function emitAnchor(input: { href: string; content: string; title?: string; external: boolean }): string {
+	const title = input.title === undefined ? "" : ` title="${escapeHtml(input.title)}"`;
+	return `<a href="${escapeHtml(input.href)}"${title}${input.external ? EXTERNAL_ATTRS : ""}>${input.content}</a>`;
+}
+
+/**
+ * A link standing in for an image the page may not show: an external `src` is blocked by
+ * the CSP, so the reader gets something to click, labelled by the alt text.
+ */
+export function emitImageLink(href: string, label: string): string {
+	return `<a href="${escapeHtml(href)}"${EXTERNAL_ATTRS}>${escapeHtml(label)}</a>`;
+}
+
+/** An `<img>`: block-level spacing class, alt text, and the sizes a document may pin. */
+export function emitImage(input: {
+	href: string;
+	alt: string;
+	title?: string;
+	/** A document may pin a pixel size; escaped like every other value the page emits. */
+	width?: string | number;
+	height?: string | number;
+}): string {
+	const size = `${input.width === undefined ? "" : ` width="${escapeHtml(String(input.width))}"`}${
+		input.height === undefined ? "" : ` height="${escapeHtml(String(input.height))}"`
+	}`;
+	const title = input.title === undefined ? "" : ` title="${escapeHtml(input.title)}"`;
+	return `<img class="md-img" src="${escapeHtml(input.href)}" alt="${escapeHtml(input.alt)}"${size}${title} loading="lazy" decoding="async">`;
+}

package/extensions/file-browse/view/html.ts

@@ -8,7 +8,7 @@
  * the page-only `browse-*` rules from `styles.ts`.
  */
 
-import { brandLockup, docHead, type KeyHint, keysSheet, themeToggle } from "../../../lib/web/index.ts";
+import { brandLockup, docHead, type KeyHint, keysSheet, tabTitle, themeToggle } from "../../../lib/web/index.ts";
 import { escapeHtml } from "../../../lib/escape.ts";
 import { renderChanges, renderGit, renderLiveChrome, renderLiveStatus, type LivePage } from "./chrome.ts";
 import { type DirEntry, type FileView, type Listing, type TreeNode } from "../files/files.ts";
@@ -87,7 +87,6 @@ function renderLayout(layout: Layout): string {
 <html lang="en">
 <head>
 ${docHead({ title: layout.title, css: BROWSE_CSS })}
-<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Ccircle cx='8' cy='8' r='6' fill='%2358a6ff'/%3E%3C/svg%3E">
 </head>
 <body class="bf-app">
 <a class="skip" href="#main">Skip to content</a>
@@ -221,7 +220,7 @@ ${page.listing.entries.map((entry) => renderRow(entry, page.maxThumbBytes, page.
 		body += `<p class="bf-note">Showing the first ${page.listing.entries.length} of ${page.listing.total} entries.</p>`;
 
 	return renderLayout({
-		title: `browse · ${page.rel || folderName}`,
+		title: tabTitle("browse", page.rel || folderName),
 		rootLabel: page.rootLabel,
 		tree: page.tree,
 		currentRel: page.rel,
@@ -371,7 +370,7 @@ export function renderFilePage(page: FilePage): string {
 	}
 
 	return renderLayout({
-		title: `browse · ${page.rel}`,
+		title: tabTitle("browse", page.rel),
 		rootLabel: page.rootLabel,
 		tree: page.tree,
 		currentRel: page.rel,
@@ -444,7 +443,7 @@ ${page.files.map((file) => renderChangedRow(file, page.mode)).join("\n")}
 </table>`;
 	const stat = page.stat ? `<pre class="browse-diff-stat">${escapeHtml(page.stat)}</pre>` : "";
 	return renderLayout({
-		title: "browse · changes",
+		title: tabTitle("browse", "changes"),
 		rootLabel: page.rootLabel,
 		tree: page.tree,
 		currentRel: "",
@@ -516,7 +515,7 @@ export function renderFileDiffPage(page: FileDiffPage): string {
 		if (page.diff.truncated) note = `<p class="bf-note">Showing the first ${page.diff.lines.length} diff lines.</p>`;
 	}
 	return renderLayout({
-		title: `browse · ${page.rel}`,
+		title: tabTitle("browse", page.rel),
 		rootLabel: page.rootLabel,
 		tree: page.tree,
 		currentRel: page.rel,
@@ -544,7 +543,7 @@ export interface ErrorPage {
 /** Render a status/error page with the same chrome. */
 export function renderErrorPage(page: ErrorPage): string {
 	return renderLayout({
-		title: `browse · ${page.status}`,
+		title: tabTitle("browse", String(page.status)),
 		rootLabel: page.rootLabel,
 		tree: page.tree,
 		currentRel: "",

package/extensions/file-browse/view/markdown.ts

@@ -38,9 +38,9 @@ import {
 	sanitizeHtmlBlock,
 	sanitizeInlineTag,
 } from "./raw-html.ts";
+import { emitAnchor, emitImage, emitImageLink } from "./emit.ts";
 import { resolveImage, resolveLink } from "./urls.ts";
 
-const HTTP_SCHEME = /^https?:/i;
 /** A GFM extended autolink: `http(s)://` or `www.` followed by a domain. */
 const AUTOLINK = /^(?:https?:\/\/|www\.)[^\s<>]*/i;
 
@@ -643,20 +643,17 @@ function renderLink(parsed: ParsedLink, ctx: Context): string {
 	const label = renderInline(parsed.label, ctx);
 	const target = resolveLink(parsed.dest, ctx.baseDir);
 	if (!target) return label;
-	const title = parsed.title ? ` title="${escapeHtml(parsed.title)}"` : "";
-	const external = target.external ? ` target="_blank" rel="noopener noreferrer"` : "";
-	return `<a href="${escapeHtml(target.href)}"${title}${external}>${label}</a>`;
+	// The anchor's shape is `emit.ts`'s, the same one the raw-HTML sanitizer emits: a link
+	// written in Markdown and the same link written as HTML are the same link.
+	return emitAnchor({ href: target.href, content: label, title: parsed.title, external: target.external });
 }
 
 function renderImage(parsed: ParsedLink, ctx: Context): string {
 	const alt = escapeHtml(parsed.label);
 	const target = resolveImage(parsed.dest, ctx.baseDir);
 	if (!target) return alt;
-	if (!target.image) {
-		return `<a href="${escapeHtml(target.href)}" target="_blank" rel="noopener noreferrer">${alt || escapeHtml(parsed.dest)}</a>`;
-	}
-	const title = parsed.title ? ` title="${escapeHtml(parsed.title)}"` : "";
-	return `<img class="md-img" src="${escapeHtml(target.href)}" alt="${alt}" loading="lazy" decoding="async"${title}>`;
+	if (!target.image) return emitImageLink(target.href, parsed.label || parsed.dest);
+	return emitImage({ href: target.href, alt, title: parsed.title });
 }
 
 function matchRun(text: string, start: number, char: string): number {
@@ -812,8 +809,10 @@ function renderInline(text: string, ctx: Context): string {
 			const match = /^<((?:https?|mailto):[^>\s]+)>/i.exec(text.slice(i));
 			if (match) {
 				const href = match[1];
-				const external = HTTP_SCHEME.test(href) ? ` target="_blank" rel="noopener noreferrer"` : "";
-				out += `<a href="${escapeHtml(href)}"${external}>${escapeHtml(href)}</a>`;
+				// Resolved rather than pattern-matched: `urls.ts` owns which schemes open in a
+				// new tab, and a `<mailto:>` link is external but does not.
+				const external = resolveLink(href, ctx.baseDir)?.external ?? false;
+				out += emitAnchor({ href, content: escapeHtml(href), external });
 				i += match[0].length;
 				continue;
 			}
@@ -836,8 +835,7 @@ function renderInline(text: string, ctx: Context): string {
 				// Require a domain, so a bare scheme is not a link.
 				if (dots > 0 && /\.[^./]/.test(label.slice(dots))) {
 					const href = /^www\./i.test(label) ? `http://${label}` : label;
-					const external = HTTP_SCHEME.test(href) ? ` target="_blank" rel="noopener noreferrer"` : "";
-					out += `<a href="${escapeHtml(href)}"${external}>${escapeHtml(label)}</a>`;
+					out += emitAnchor({ href, content: escapeHtml(label), external: true });
 					i += label.length;
 					continue;
 				}