@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/components/markdown.ts

@@ -6,8 +6,18 @@ import {
 	type TokenizerAndRendererExtension,
 	type TokenizerThis,
 	type Tokens,
+	type TokensList,
 } from "@linxiraos/pi-utils/marked";
-import { mathBlockAt, mathSpanAt, mathSpanInContext, mathStartIndex } from "@linxiraos/pi-utils/math-delimiters";
+import {
+	type MathBlockOpener,
+	mathBlockCloserIndex,
+	mathBlockInContext,
+	mathBlockMayCloseAt,
+	mathBlockOpenerAt,
+	mathSpanInContext,
+	mathStartIndex,
+} from "@linxiraos/pi-utils/math-delimiters";
+import { listMayContinueAt } from "@linxiraos/pi-utils/marked-list";
 import { latexToBlock } from "../latex-block";
 import { isBareMathEnvironment, latexToUnicode } from "../latex-to-unicode";
 import { plainText } from "../native/spans";
@@ -15,6 +25,8 @@ import { md } from "../native/describe";
 import type { DescribeContext, NativeNode } from "../native/node";
 import type { SymbolTheme } from "../symbols";
 import { TERMINAL } from "../terminal-capabilities";
+import { getSymbolTheme, getThemeEpoch } from "../theme/theme";
+import { canCacheMarkdownListItems } from "../theme/tui-adapters";
 import type { Component } from "../tui";
 import {
 	applyBackgroundToLine,
@@ -592,7 +604,6 @@ const markdownParser = new Marked();
 // never math. Inline extensions run before marked's escape tokenizer, so
 // `\(…\)` becomes math while a genuinely escaped `\$` is left to `escape` and
 // renders as a literal dollar.
-const CUSTOM_HR_START_REGEX = /(?:^|\n) {0,3}([-*_─━═=–—])[ \t]*(?:\1[ \t]*){2,}(?:\n+|$)/;
 const CUSTOM_HR_TOKENIZER_REGEX = /^ {0,3}([-*_─━═=–—])[ \t]*(?:\1[ \t]*){2,}(?:\n+|$)/;
 
 function getHrChar(char: string, hrChar: string): string {
@@ -618,15 +629,6 @@ function getHrChar(char: string, hrChar: string): string {
 const customHrExtension: TokenizerAndRendererExtension = {
 	name: "customHr",
 	level: "block",
-	start(src) {
-		const match = CUSTOM_HR_START_REGEX.exec(src);
-		if (!match) return undefined;
-		let idx = match.index;
-		if (src[idx] === "\n") {
-			idx += 1;
-		}
-		return idx;
-	},
 	tokenizer(src) {
 		const match = CUSTOM_HR_TOKENIZER_REGEX.exec(src);
 		if (match) {
@@ -663,7 +665,7 @@ const mathBlockExtension: TokenizerAndRendererExtension = {
 	// No `start` hint: marked only probes block extensions at a block boundary
 	// here and never consults their hints.
 	tokenizer(src) {
-		const block = mathBlockAt(src);
+		const block = mathBlockInContext(this, src);
 		if (!block) return undefined;
 		return { type: "math", raw: block.raw, text: block.body, display: true };
 	},
@@ -680,38 +682,67 @@ const mathBlockExtension: TokenizerAndRendererExtension = {
 // starts at offset 0" guards keep fenced/indented `\begin{cases}` code blocks
 // for marked's own code rules.
 const BARE_ENV_BEGIN = /(?:^|\n)[ \t]{0,3}\\begin\{([A-Za-z]+\*?)\}/;
-function bareMathEnvBlock(src: string): readonly [number, number] | null {
-	const bm = BARE_ENV_BEGIN.exec(src);
-	if (!bm || !isBareMathEnvironment(bm[1])) return null;
-	const beginLineStart = bm.index === 0 ? 0 : bm.index + 1; // skip the matched leading `\n`
+const BLANK_LINE_RE = /\n[ \t]*\n/;
+
+/** Where a search for an `\end{…}` closer in a lexer source started, and what it found. */
+interface EnvCloserSearch {
+	from: number;
+	at: number;
+}
+const envCloserSearches = new WeakMap<TokenizerThis, Map<string, EnvCloserSearch>>();
+
+/**
+ * The first `endToken` at or after `from` in the source of `context`, or -1. Block
+ * starts ask at increasing offsets, so a search is remembered per source: an
+ * unclosed environment otherwise rescans the rest of the document at each one.
+ */
+function envCloserIndex(context: TokenizerThis, source: string, endToken: string, from: number): number {
+	let searches = envCloserSearches.get(context);
+	if (!searches) envCloserSearches.set(context, (searches = new Map()));
+	const last = searches.get(endToken);
+	if (last !== undefined && last.from <= from && (last.at === -1 || from <= last.at)) return last.at;
+	const at = source.indexOf(endToken, from);
+	searches.set(endToken, { from, at });
+	return at;
+}
+
+/** Length of the bare math-environment block that starts at offset 0 of `src`, or 0. */
+function bareMathEnvBlockLength(context: TokenizerThis, src: string): number {
+	// A block at offset 0 has its `\begin` on the first line, or on the second
+	// after an `lhs =` line, so the opener scan stops there.
+	const firstBreak = src.indexOf("\n");
+	const secondBreak = firstBreak === -1 ? -1 : src.indexOf("\n", firstBreak + 1);
+	const bm = BARE_ENV_BEGIN.exec(secondBreak === -1 ? src : src.slice(0, secondBreak));
+	if (!bm || !isBareMathEnvironment(bm[1])) return 0;
+	// Skip a matched leading `\n`, at offset 0 too: a blank line before the block
+	// is a space token of its own, not part of the block.
+	const beginLineStart = src[bm.index] === "\n" ? bm.index + 1 : bm.index;
+	// Pull in one immediately-preceding `lhs =`/open-delimiter line (e.g. `f(x) =`).
+	if (beginLineStart > 0 && !/[=([{]\s*$/.test(src.slice(0, beginLineStart - 1))) return 0;
 	const endToken = `\\end{${bm[1]}}`;
-	const endAt = src.indexOf(endToken, bm.index);
-	if (endAt === -1) return null;
+	const source = context.source ?? src;
+	const base = (context.end ?? source.length) - src.length;
+	const closer = envCloserIndex(context, source, endToken, base + bm.index);
+	if (closer === -1) return 0;
+	const endAt = closer - base;
 	// The `\end` must close before any blank line (i.e. within the same block).
-	if (/\n[ \t]*\n/.test(src.slice(beginLineStart, endAt))) return null;
+	// Scan only up to the closer: the rest of the document is irrelevant here, and
+	// scanning it per block is quadratic across consecutive environments.
+	if (BLANK_LINE_RE.test(src.slice(beginLineStart, endAt))) return 0;
 	let blockEnd = endAt + endToken.length;
 	while (src[blockEnd] === " " || src[blockEnd] === "\t") blockEnd++;
 	if (src[blockEnd] === "\n") blockEnd++;
-	// Pull in one immediately-preceding `lhs =`/open-delimiter line (e.g. `f(x) =`).
-	let start = beginLineStart;
-	if (start > 0 && src[start - 1] === "\n") {
-		const prevStart = src.lastIndexOf("\n", start - 2) + 1;
-		const prevLine = src.slice(prevStart, start - 1);
-		if (/[=([{]\s*$/.test(prevLine)) start = prevStart;
-	}
-	return [start, blockEnd];
+	return blockEnd;
 }
+
 const mathEnvBlockExtension: TokenizerAndRendererExtension = {
 	name: "mathEnvBlock",
 	level: "block",
-	start(src) {
-		const r = bareMathEnvBlock(src);
-		return r ? r[0] : undefined;
-	},
+	// No `start` hint: marked only probes block extensions at a block boundary.
 	tokenizer(src) {
-		const r = bareMathEnvBlock(src);
-		if (r?.[0] !== 0) return undefined; // only consume when the block starts at offset 0
-		const raw = src.slice(0, r[1]);
+		const length = bareMathEnvBlockLength(this, src);
+		if (length === 0) return undefined;
+		const raw = src.slice(0, length);
 		const text = raw.replace(/\n[ \t]*$/, "");
 		if (text.trim().length === 0) return undefined;
 		return { type: "math", raw, text, display: true };
@@ -761,77 +792,13 @@ markdownParser.use({
 	],
 });
 
-// Setext-underline pre-gate for marked's `lheading` rule. The rule's lazy body
-// `((?:.|\n(?!<block-start>))+?)` re-runs its block-start lookahead while
-// expanding character by character, so even a FAILING attempt at offset 0
-// costs O(len × lookahead) — ~26µs per 200-char list-item body, and marked's
-// list tokenizer block-tokenizes every item's content (47.8% of a streaming
-// bench profile). A match REQUIRES the setext underline `\n {0,3}(=+|-+)`
-// somewhere in src, so this O(n) charCode scan never rejects a src the
-// built-in rule would match; single-line srcs (every tight list item) reject
-// on the first indexOf.
-function lheadingPossible(src: string): boolean {
-	let i = src.indexOf("\n");
-	while (i !== -1) {
-		let j = i + 1;
-		const limit = j + 3; // underline allows up to 3 leading spaces
-		while (j < limit && src.charCodeAt(j) === 0x20 /* space */) j++;
-		const c = src.charCodeAt(j); // NaN past the end fails both comparisons
-		if (c === 0x3d /* = */ || c === 0x2d /* - */) return true;
-		i = src.indexOf("\n", j);
-	}
-	return false;
-}
-
 markdownParser.use({
 	tokenizer: {
-		// `false` → marked falls back to the built-in tokenizer;
-		// `undefined` → no token here, built-in never runs.
-		lheading(src: string): Tokens.Heading | undefined | false {
-			return lheadingPossible(src) ? false : undefined;
-		},
 		// Strikethrough is `strikethroughExtension`'s: marked's own looser rule never runs.
 		del: () => undefined,
 	},
 });
 
-// ---------------------------------------------------------------------------
-// Sticky clones of marked's pathological block rules
-// ---------------------------------------------------------------------------
-// Bun's (JSC) regex engine skips the start-anchor fast-fail for several of
-// marked's `^`-anchored block rules — `hr`, `lheading`, `table` and `html` are
-// anchored alternations of quantified branches, and a failing `exec`/`test`
-// rescans the entire remaining source instead of stopping after offset 0.
-// marked's list tokenizer runs `hr.test` and `lheading` per list line against
-// the remaining source, so lexing a long list is quadratic (66% of a streaming
-// bench profile sat in these two regexes). A sticky (`y`) clone with
-// `lastIndex` pinned to 0 attempts the match at offset 0 only.
-//
-// Equivalence: for a flagless rule whose source is `^`-anchored, a sticky
-// clone at `lastIndex = 0` matches exactly when the original matches (same
-// match object, same captures) — `^` already restricted matches to offset 0
-// (no `m` flag), and stickiness only removes the futile later attempts. The
-// flags/anchor guard below skips any rule a future marked version changes.
-class AnchoredAtZero extends RegExp {
-	override exec(str: string): RegExpExecArray | null {
-		this.lastIndex = 0; // sticky matches set lastIndex; rules are shared
-		return super.exec(str);
-	}
-	override test(str: string): boolean {
-		this.lastIndex = 0;
-		return super.test(str);
-	}
-}
-
-for (const table of [Lexer.rules.block.normal, Lexer.rules.block.gfm]) {
-	for (const name of ["hr", "lheading", "table", "html"] as const) {
-		const rule = table[name];
-		if (rule.flags === "" && rule.source.startsWith("^")) {
-			table[name] = new AnchoredAtZero(rule.source, "y");
-		}
-	}
-}
-
 // ---------------------------------------------------------------------------
 // Module-level LRU render cache
 // ---------------------------------------------------------------------------
@@ -897,12 +864,16 @@ function appendLines(dst: string[], src: readonly string[]): void {
 // delta-edge trailingDelimiterSeamHazard check).
 const FAST_DELTA_RE = /[\n\r\\[`<!*_~$#&@\x1b]/;
 
+// Emphasis delimiters, which can pair across the fast path's seam.
+const FAST_EMPHASIS_DELIMITERS = ["*", "_", "~"] as const;
+
 // Disarm when the captured row's RAW tail ends in trailing whitespace (wrap
-// trims it; appending a char moves the trim boundary), a trailing backslash
-// (it can become an escape once the delta supplies the next char — the `\\`
-// clause covers that escape-completion hazard), or a full/partial hex swatch
-// run (a `#` + 3-8 hex is a swatch glyph; the byte range may shift).
-const FAST_RUN_END_RE = /(?:[ \t\\]|#[0-9a-fA-F]{3,8}|#+)$/i;
+// trims it, a no-break space included; appending a char moves the trim
+// boundary), a trailing backslash (it can become an escape once the delta
+// supplies the next char — the `\\` clause covers that escape-completion
+// hazard), or a full/partial hex swatch run (a `#` + 3-8 hex is a swatch
+// glyph; the byte range may shift).
+const FAST_RUN_END_RE = /(?:[\s\\]|#[0-9a-fA-F]{3,8}|#+)$/i;
 
 // A partial `#` + 1-2 hex digits can grow into a 3-8 digit swatch glyph
 // across the seam (delta hex digits are inert).
@@ -957,16 +928,18 @@ const FAST_TABLE_DELIM_ROW_RE = /^\s*(?:\|[\s:]*-+\s*(?:\|[\s:]*-+\s*)*|[\s:]*-+
 
 // A paragraph's LAST line can complete into a different block kind under an
 // inert delta (ATX heading, blockquote, bullet marker, HR, ref-def) — disarm
-// when the grown line starts one (ref-def grammar: REF_DEF_LINE_RE).
+// when the grown line starts one (ref-def grammar: REF_DEF_LINE_RE). A line
+// holding `\end{` can also close a bare math environment the paragraph opened
+// lines above (`\end{al` + `ign}`), making those lines one display block.
 const FAST_LINE_START_HAZARD_RE =
 	// `-` is placed LAST so it is a literal, not a range bound. The other
 	// chars are in ASCENDING code-point order (no reversed ranges that
 	// rely on engine leniency): * + = – — ─ ━ ═ then the literal `-`.
 	/^ {0,3}(?:#{1,6}(?:[ \t]|$)|>|\d{1,9}[.)](?:[ \t]|$)|[*+=–—─━═-](?:[ \t]|$)|(?:[*+=–—─━═-][ \t]*){2,}[ \t]*$)/;
 
-/** @internal exported for tests — the grown-line-start block-kind gate. */
+/** @internal exported for tests — the grown-line block-kind gate. */
 export function fastLineStartHazard(grownLine: string): boolean {
-	return FAST_LINE_START_HAZARD_RE.test(grownLine) || REF_DEF_LINE_RE.test(grownLine);
+	return FAST_LINE_START_HAZARD_RE.test(grownLine) || REF_DEF_LINE_RE.test(grownLine) || grownLine.includes("\\end{");
 }
 
 /** Seam hazards between the captured raw row tail and the delta: the row must
@@ -1038,105 +1011,87 @@ function lexInlineTokens(text: string): Token[] {
 const REF_DEF_LINE_RE = /^ {0,3}\[(?:\\.|[^\]\\])+\]:/;
 const HAS_REF_DEF = new RegExp(REF_DEF_LINE_RE.source, "m");
 
-// marked's list tokenizer (Tokenizer.list, marked v18) continues a list across
-// blank lines only when the remaining source matches
-// `listItemRegex(marker)` = `^( {0,3}${marker})((?:[\t ][^\n]*)?(?:\n|$))`,
-// where `marker` is the exact bullet char for unordered lists (`\${char}`) or
-// 1-9 digits plus the exact delimiter for ordered lists (`\d{1,9}\${delim}`).
-// The marker is derived from the list's FIRST item (`n = t[1].trim()`), which
-// sits at the start of a top-level list token's raw:
-const LIST_MARKER_RE = /^ {0,3}(?:([*+-])|\d{1,9}([.)]))/;
-
-// Streaming-freeze equivalence invariant: lex(prefix) ++ lex(tail) must equal
-// lex(full text) — for the CURRENT text and for every append-only extension of
-// it, because a frozen prefix is sticky (it keeps being reused while the text
-// grows). At a blank-line (`\n\n`) cut directly after a top-level `list`
-// token, the only construct that can straddle the cut is a continuation item
-// of that list: marked consumed the blank line into the last item's raw and
-// re-ran `listItemRegex` at exactly `tailStart`, merging a same-marker item
-// into one renumbered loose list. The cut is safe only when that regex can
-// NEVER match at `tailStart`, no matter what is appended later.
-//
-// Append-only growth means existing characters are immutable while new ones
-// may appear after them, so "closed" may only be concluded from a present
-// character that contradicts every possible continuation (e.g. tail "1x" can
-// never grow into an ordered item, but tail "1" can become "1. c"). Running
-// out of text mid-marker therefore answers "may continue".
-//
-// Returns true when the tail could still continue the list (or the list's
-// marker is unrecognizable) — the conservative "don't freeze" answer. marked
-// may break the list anyway when the matching line is also an hr (`- - -`);
-// treating that as "may continue" merely skips a freeze, never corrupts one.
-function listMayContinueAt(text: string, tailStart: number, listRaw: string): boolean {
-	const marker = LIST_MARKER_RE.exec(listRaw);
-	if (marker === null) return true; // unrecognized list shape — stay conservative
-	const n = text.length;
-	let i = tailStart;
-	// `listItemRegex` allows up to 3 leading spaces (the caller's next-char
-	// guard rejects whitespace at the final cut, but mirror the rule exactly).
-	while (i < n && i - tailStart < 3 && text.charCodeAt(i) === 0x20 /* space */) i++;
-	if (i >= n) return true;
-	const bullet = marker[1];
-	if (bullet !== undefined) {
-		if (text[i] !== bullet) return false; // wrong marker char — closed forever
-		i++;
-	} else {
-		// Ordered: 1-9 digits, then the same `.`/`)` delimiter.
-		let digits = 0;
-		while (i < n && digits < 10) {
-			const c = text.charCodeAt(i);
-			if (c < 0x30 /* 0 */ || c > 0x39 /* 9 */) break;
-			digits++;
-			i++;
-		}
-		if (digits === 0 || digits > 9) return false; // no digit run / too long — closed forever
-		if (i >= n) return true; // delimiter (or more digits) may still arrive
-		if (text[i] !== marker[2]) return false; // wrong delimiter — closed forever
-		i++;
-	}
-	// After the marker: `(?:[\t ][^\n]*)?(?:\n|$)` — tab/space + anything, a
-	// bare newline, or end-of-input (which appends can still extend).
-	if (i >= n) return true;
-	const after = text.charCodeAt(i);
-	return after === 0x20 /* space */ || after === 0x09 /* tab */ || after === 0x0a; /* \n */
+/** The last stable block boundary of a token run: see {@link stableBlockBoundary}. */
+interface BlockBoundary {
+	/** Offset just past the boundary token, or 0 when the run holds none. */
+	end: number;
+	/** Number of tokens up to and including the boundary token, or 0. */
+	count: number;
 }
 
-const NO_BLOCK_BOUNDARY = { end: 0, count: 0 } as const;
+// A whitespace-only line, capturing its terminator: "\n", or "" at the end of the text.
+const WHITESPACE_LINE_RE = /[^\S\n]*(\n|$)/y;
+
+/**
+ * A display-math opener in the frozen streaming prefix whose block an append
+ * could still close: the first such opener of its kind.
+ */
+interface PrefixOpener {
+	kind: MathBlockOpener;
+	/** Offset of the opener's line. */
+	at: number;
+	/** The stable boundary in front of the opener, as a text length and a token count. */
+	rewindEnd: number;
+	rewindCount: number;
+}
+
+const NO_OPENERS: readonly PrefixOpener[] = [];
 
 /**
  * Offset just past the last token in `tokens` that closes a block on a hard
  * `"\n\n"` break, together with the number of tokens up to and including it.
  * `count === 0` means the run holds no usable boundary.
  *
- * `base` is where `tokens[0]` starts inside `text`. A boundary qualifies only
- * when splitting there is invisible to the lexer, i.e. `lex(head) ++ lex(tail)
- * === lex(text)`:
+ * `base` is where `tokens[0]` starts inside `text`; `tokens` lex the rest of
+ * `text`, which appends may still extend (the streaming freeze). A boundary
+ * qualifies only when splitting there is invisible to the lexer, i.e.
+ * `lex(head) ++ lex(tail) === lex(text)`:
  *  - The break must sit inside `text`. At end-of-text the next character is
  *    unknown (and, while streaming, may still arrive), so the cut is deferred.
- *  - The next character must start real block content. Whitespace means the
- *    block separator straddles the cut — e.g. a fence followed by
- *    `"\n\n\n- list"` — and the two lexes desync.
+ *  - The next line must start real block content. A leading space or newline
+ *    means the block separator straddles the cut — e.g. a fence followed by
+ *    `"\n\n\n- list"` — and the two lexes desync. So does a line of any other
+ *    whitespace, such as a no-break space: the lexer's blank line is
+ *    `/^\s*\n$/`, so it joins the blank run in front of the cut. While
+ *    streaming, a whitespace-only last line may still become one.
  *  - A preceding `list` must be provably closed: CommonMark lets a same-marker
  *    item continue the list across the blank line, and marked merges both into
  *    one renumbered loose list (`listMayContinueAt`).
+ *  - Display math: `tokens` are the one-pass lex of `text` as it stands, so
+ *    a block the lex already made is a `math` token, and one that an
+ *    append could still close becomes one only once a closer line arrives,
+ *    which Markdown#lexTokens watches for. With `settle`, the scan instead
+ *    stops at a token whose display-math block an append could still close
+ *    (`mathBlockMayCloseAt`), so no append changes the tokens before the
+ *    boundary it finds. A pair whose closer line has already ended around a
+ *    whitespace-only body (`$$`, ` `, `$$`) is no block whatever follows, so
+ *    that scan goes on past it.
  *
  * `startIndex` resumes the scan at `tokens[startIndex]` (positions still
  * accumulate from `base`). The streaming freeze passes the frozen-prefix
  * token count: that prefix's boundary is permanent under append-only growth
  * (re-verified when frozen), so only the mutable tail can hold a new one.
+ * `endIndex` ends the scan in front of `tokens[endIndex]`, for the last
+ * boundary in front of a given token.
  */
 function stableBlockBoundary(
 	text: string,
 	base: number,
 	tokens: Token[],
-	startIndex = 0,
-): { end: number; count: number } {
+	{
+		startIndex = 0,
+		endIndex = tokens.length,
+		settle = false,
+	}: { startIndex?: number; endIndex?: number; settle?: boolean } = {},
+): BlockBoundary {
 	let pos = base;
 	let end = 0;
 	let count = 0;
-	for (let i = startIndex; i < tokens.length; i++) {
-		const raw = tokens[i].raw;
+	for (let i = startIndex; i < endIndex; i++) {
+		const token = tokens[i];
+		const raw = token.raw;
 		const tokenEnd = pos + raw.length;
+		if (settle && token.type !== "math" && mathBlockMayCloseAt(text, pos)) break;
 		if (raw.endsWith("\n\n")) {
 			const prev = i > 0 ? tokens[i - 1] : undefined;
 			if (prev === undefined || prev.type !== "list" || !listMayContinueAt(text, tokenEnd, prev.raw)) {
@@ -1146,84 +1101,38 @@ function stableBlockBoundary(
 		}
 		pos = tokenEnd;
 	}
-	if (count === 0 || end >= text.length) return NO_BLOCK_BOUNDARY;
+	if (count === 0 || end >= text.length) return { end: 0, count: 0 };
 	const next = text.charCodeAt(end);
-	if (next === 0x20 /* space */ || next === 0x0a /* \n */) return NO_BLOCK_BOUNDARY;
+	if (next === 0x20 /* space */ || next === 0x0a /* \n */) return { end: 0, count: 0 };
+	WHITESPACE_LINE_RE.lastIndex = end;
+	if (WHITESPACE_LINE_RE.test(text)) return { end: 0, count: 0 };
 	return { end, count };
 }
 
-// Bun's regex engine skips the start-anchor optimization for several of marked's
-// block rules — `hr`, `lheading`, `table` and `html` are `^`-anchored
-// alternations of quantified branches — so each failing `exec` rescans the whole
-// remaining source instead of stopping at offset 0. Lexing is then quadratic in
-// document length: an 800 KB message costs ~41 s under Bun where Node/V8 needs
-// ~60 ms, and it runs on the render path, freezing the UI. Bounded windows keep
-// every scan short and restore linear behavior (~0.7 s for that same message).
-const LEX_WINDOW_BYTES = 2 * 1024;
-// Under this size a single pass beats probing for window boundaries; the
-// crossover measured on pathological Markdown sits around 16 KB.
-const WINDOWED_LEX_MIN_BYTES = 16 * 1024;
-
 /**
- * Lex `text` in bounded windows, producing the exact token stream
- * `markdownParser.lexer(text)` would.
- *
- * Window cuts come from marked itself: a throwaway BLOCK-ONLY probe lex of the
- * window reports its last stable block boundary ({@link stableBlockBoundary})
- * and only that confirmed segment is handed to the real lexer; a window
- * holding no boundary doubles until it finds one or reaches the end. Probes
- * never run inline tokenization (their inlineQueue is discarded) — a boundary
- * is a property of block structure alone, and probe inline passes were the
- * dominant cost of an earlier revision. Block tokenization runs per window
- * while inline tokenization is deferred to the end — mirroring `Lexer.lex` —
- * so a `[label]: dest` definition anywhere in the document still resolves for
- * every inline span.
- *
- * A boundary requires some top-level token whose raw ends in `"\n\n"`, so a
- * window that contains no blank line cannot cut: each round starts at the next
- * `"\n\n"` (skipping straight to the end when there is none — e.g. a tail
- * that is one long tight list) instead of probing sizes that cannot succeed.
+ * Lex a whole document with the renderer's rules (math, custom rules,
+ * strikethrough). Callers that split a document along its blocks (table
+ * charts) lex through this so they see the blocks Markdown renders.
  */
-function lexWindowed(text: string): Token[] {
-	const lexer = new Lexer(markdownParser.defaults);
-	let offset = 0;
-	while (offset < text.length) {
-		let segment = "";
-		const nextBlank = text.indexOf("\n\n", offset);
-		if (nextBlank === -1) {
-			segment = text.slice(offset);
-		} else {
-			const minSize = Math.max(LEX_WINDOW_BYTES, nextBlank + 2 - offset);
-			for (let size = minSize; segment.length === 0; size *= 2) {
-				if (offset + size >= text.length) {
-					segment = text.slice(offset);
-					break;
-				}
-				const probe = new Lexer(markdownParser.defaults);
-				probe.blockTokens(text.slice(offset, offset + size), probe.tokens);
-				const boundary = stableBlockBoundary(text, offset, probe.tokens);
-				if (boundary.count > 0) segment = text.slice(offset, boundary.end);
-			}
-		}
-		lexer.blockTokens(segment, lexer.tokens);
-		offset += segment.length;
-	}
-	for (const queued of lexer.inlineQueue) lexer.inlineTokens(queued.src, queued.tokens);
-	lexer.inlineQueue = [];
-	return lexer.tokens;
+export function lexDocument(text: string): TokensList {
+	return markdownParser.lexer(text);
 }
 
-/** Lex a whole document, windowing anything large enough for the quadratic scan to bite. */
-function lexDocument(text: string): Token[] {
-	// A CR shifts every `raw` span (marked normalizes CRLF before tokenizing), so
-	// window offsets would address the wrong characters — lex those in one pass.
-	if (text.length < WINDOWED_LEX_MIN_BYTES || text.includes("\r")) return markdownParser.lexer(text);
-	return lexWindowed(text);
+/**
+ * `source` as a fenced code block in `lang`: the fence is one backtick longer
+ * than any backtick run in the source (at least three), so the block always
+ * closes where intended. `open` leaves it unclosed, the source verbatim, for
+ * a body that is still arriving.
+ */
+export function fencedCode(lang: string, source: string, options?: { open?: boolean }): string {
+	const longest = source.match(/`+/g)?.reduce((max, run) => Math.max(max, run.length), 2) ?? 2;
+	const fence = "`".repeat(longest + 1);
+	return options?.open ? `${fence}${lang}\n${source}` : `${fence}${lang}\n${source.trimEnd()}\n${fence}`;
 }
 
 /** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
 export interface MarkdownLink {
-	/** Visible link text (equals `href` for autolinks and bare URLs). */
+	/** Flattened visible label with whitespace collapsed to one row; falls back to `href` when empty. */
 	text: string;
 	/** Destination exactly as marked resolved it (references resolved, no normalization). */
 	href: string;
@@ -1261,10 +1170,124 @@ export function extractMarkdownLinks(text: string): MarkdownLink[] {
 			if (any.rows) for (const row of any.rows) for (const cell of row) walk(cell.tokens);
 		}
 	};
-	walk(lexDocument(text));
+	walk(markdownParser.lexer(text));
 	return links;
 }
 
+/**
+ * Offset just past the destination that starts at or after `start` in `raw`
+ * (CommonMark link destination grammar), plus where it begins. `null` when no
+ * destination is there.
+ */
+function scanLinkDestination(raw: string, start: number): { start: number; end: number } | null {
+	let i = start;
+	while (i < raw.length && (raw[i] === " " || raw[i] === "\t" || raw[i] === "\n" || raw[i] === "\r")) i++;
+	if (i >= raw.length) return null;
+	if (raw[i] === "<") {
+		for (let j = i + 1; j < raw.length; j++) {
+			if (raw[j] === "\\") j++;
+			else if (raw[j] === ">") return { start: i, end: j + 1 };
+			else if (raw[j] === "<" || raw[j] === "\n") return null;
+		}
+		return null;
+	}
+	let depth = 0;
+	let j = i;
+	for (; j < raw.length; j++) {
+		const ch = raw[j]!;
+		if (ch === "\\") {
+			j++;
+			continue;
+		}
+		if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch.charCodeAt(0) < 0x20) break;
+		if (ch === "(") depth++;
+		else if (ch === ")") {
+			if (depth === 0) break;
+			depth--;
+		}
+	}
+	return j > i ? { start: i, end: j } : null;
+}
+
+/** A destination that stays one destination whatever bytes the target holds. */
+function formatLinkDestination(target: string): string {
+	return /[\s()<>\\]/.test(target) ? `<${target.replaceAll(/[<>\\]/g, ch => encodeURIComponent(ch))}>` : target;
+}
+
+function isListToken(token: Token): token is Tokens.List {
+	return token.type === "list";
+}
+
+function isTableToken(token: Token): token is Tokens.Table {
+	return token.type === "table";
+}
+
+/**
+ * Rewrite the destinations of inline links and link reference definitions in
+ * `text` to `resolve(href)`, leaving everything else byte-for-byte intact.
+ * Hosts that render the Markdown source themselves (a native terminal's `md`
+ * node) resolve relative destinations against their own idea of the working
+ * directory; handing them the session-resolved target keeps links pointing at
+ * what the author meant. Links inside code, images, autolinks and reference
+ * uses (`[x][ref]`, rewritten through their definition) are untouched; a link
+ * whose source cannot be located exactly is left as written.
+ */
+export function rewriteMarkdownLinkDestinations(text: string, resolve: (href: string) => string | undefined): string {
+	const edits: Array<{ start: number; end: number; target: string }> = [];
+	let cursor = 0;
+	const rewrite = (token: Token, labelEnd: number | undefined): void => {
+		const at = text.indexOf(token.raw, cursor);
+		if (at < 0) return;
+		cursor = at + token.raw.length;
+		const href = "href" in token && typeof token.href === "string" ? token.href : "";
+		if (!href || labelEnd === undefined) return;
+		const target = resolve(href);
+		if (!target || target === href) return;
+		const dest = scanLinkDestination(token.raw, labelEnd);
+		if (dest) edits.push({ start: at + dest.start, end: at + dest.end, target });
+	};
+	const walk = (tokens: readonly Token[] | undefined): void => {
+		if (!tokens) return;
+		for (const token of tokens) {
+			if (token.type === "link") {
+				const label = "text" in token && typeof token.text === "string" ? `[${token.text}](` : undefined;
+				rewrite(token, label && token.raw.startsWith(label) ? label.length : undefined);
+				continue;
+			}
+			if (token.type === "def") {
+				const close = token.raw.indexOf("]:");
+				rewrite(token, close < 0 ? undefined : close + 2);
+				continue;
+			}
+			const children = "tokens" in token && Array.isArray(token.tokens) ? token.tokens : undefined;
+			const items = isListToken(token) ? token.items : undefined;
+			const table = isTableToken(token) ? token : undefined;
+			if (token.type === "image" || (!children && !items && !table)) {
+				// A leaf (text, code span, fenced code, html, image…): step past it so a
+				// later link's source is never matched inside it.
+				const at = token.raw ? text.indexOf(token.raw, cursor) : -1;
+				if (at >= 0) cursor = at + token.raw.length;
+				continue;
+			}
+			walk(children);
+			walk(items);
+			if (table) {
+				for (const cell of table.header) walk(cell.tokens);
+				for (const row of table.rows) for (const cell of row) walk(cell.tokens);
+			}
+		}
+	};
+	walk(markdownParser.lexer(text));
+	if (edits.length === 0) return text;
+	let out = "";
+	let last = 0;
+	for (const edit of edits) {
+		out += text.slice(last, edit.start) + formatLinkDestination(edit.target);
+		last = edit.end;
+	}
+	return out + text.slice(last);
+}
+
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export function clearRenderCache(): void {
 	renderCache.clear();
@@ -1290,6 +1313,13 @@ function objectId(o: object): number {
 export interface DefaultTextStyle {
 	/** Foreground color function */
 	color?: (text: string) => string;
+	/**
+	 * The `color` foreground is prose-level: semantically-themed markdown spans
+	 * (headings, links) keep their own `md*` theme colors instead of being
+	 * painted over by it, while plain text runs still use `color`. Unset keeps
+	 * the historical behavior where `color` paints every run.
+	 */
+	proseFg?: boolean;
 	/** Background color function */
 	bgColor?: (text: string) => string;
 	/** Bold text */
@@ -1355,18 +1385,42 @@ export interface MarkdownTheme {
 	 * Return null to fall back to fenced code rendering.
 	 */
 	resolveMermaidAscii?: (source: string, maxWidth?: number) => string | null;
-	symbols: SymbolTheme;
+	/**
+	 * Glyphs for quote borders, rules, tables and color swatches. Optional so themes
+	 * built to the upstream pi-tui `MarkdownTheme` shape (which has no `symbols`)
+	 * still render; omitted symbols fall back to the active theme's set.
+	 */
+	symbols?: SymbolTheme;
 }
 
 interface InlineStyleContext {
 	applyText: (text: string) => string;
 	stylePrefix: string;
+	/** True when the context came from the component's own default style (vs. a caller-supplied one). */
+	isDefault?: boolean;
 }
 
-type ListToken = Token & { items: Array<{ tokens?: Token[] }>; ordered: boolean; start?: number };
+type ListToken = Token & {
+	items: Array<{ raw: string; tokens?: Token[] }>;
+	ordered: boolean;
+	start?: number;
+	loose: boolean;
+};
 type TableCellToken = { tokens?: Token[] };
 type TableToken = Token & { header: TableCellToken[]; rows: TableCellToken[][]; raw?: string };
 
+/** `item` as marked lexes it inside a loose list: tight `text` blocks become paragraphs. */
+function loosenListItem(item: Tokens.ListItem): Tokens.ListItem {
+	if (item.loose) return item;
+	return {
+		...item,
+		loose: true,
+		tokens: item.tokens.map(token =>
+			token.type === "text" ? ({ ...token, type: "paragraph" } as Tokens.Paragraph) : token,
+		),
+	};
+}
+
 function formatHyperlink(text: string, target: string): string {
 	if (!TERMINAL.hyperlinks || !target) {
 		return text;
@@ -1631,6 +1685,15 @@ interface RenderSignature {
 	textSizing: boolean;
 	bgColorProbe: string;
 	headingProbe: string;
+	/** Fallback glyphs for themes without `symbols`; their identity alone cannot tell presets apart. */
+	symbolsProbe: string;
+}
+
+/** A shorter prefix the cached rows grew from: its length, its token count and the row count its rows end at. */
+interface PrefixMark {
+	textEnd: number;
+	tokenCount: number;
+	lineEnd: number;
 }
 
 interface StreamPrefixLineCache extends RenderSignature {
@@ -1639,6 +1702,34 @@ interface StreamPrefixLineCache extends RenderSignature {
 	// Private to the cache and never handed to callers (each frame copies it
 	// into a fresh output array), so an advancing prefix appends in place.
 	lines: string[];
+	// The shorter prefixes the rows grew from, oldest first. Each ends on a
+	// frozen block boundary, so its rows are a render of its tokens alone,
+	// and a rewound prefix keeps the rows of the last one it still covers.
+	marks: PrefixMark[];
+}
+
+/**
+ * `cache` cut back to the rows of its last prefix of at most `tokenCount`
+ * tokens, in fresh arrays, or `undefined` when it has none. A put-aside prefix
+ * may still hold `cache`, so its arrays are never shared.
+ */
+function rewoundLineCache(
+	cache: StreamPrefixLineCache | undefined,
+	tokenCount: number,
+): StreamPrefixLineCache | undefined {
+	if (cache === undefined) return undefined;
+	if (cache.tokenCount <= tokenCount) return { ...cache, lines: cache.lines.slice(), marks: cache.marks.slice() };
+	let i = cache.marks.length - 1;
+	while (i >= 0 && cache.marks[i]!.tokenCount > tokenCount) i--;
+	if (i < 0) return undefined;
+	const mark = cache.marks[i]!;
+	return {
+		...cache,
+		text: cache.text.slice(0, mark.textEnd),
+		tokenCount: mark.tokenCount,
+		lines: cache.lines.slice(0, mark.lineEnd),
+		marks: cache.marks.slice(0, i),
+	};
 }
 /**
  * Per-token row cache for the *unfrozen tail* (PoC H). The tail re-lexes every
@@ -1679,6 +1770,25 @@ interface TailRowCache extends RenderSignature {
 	// type of token[i+1] when the rows were produced (blank/spacing gate).
 	nextTypes: (string | undefined)[];
 }
+interface ListItemRowsCache {
+	signature: RenderSignature;
+	width: number;
+	themeEpoch: number;
+	ordered: boolean;
+	start: number | undefined;
+	loose: boolean;
+	raws: string[];
+	rows: RenderedLine[][];
+}
+
+interface StreamingListCache {
+	text: string;
+	before: Token[];
+	start: number;
+	tailStart: number;
+	stableCount: number;
+	list: Tokens.List;
+}
 /**
  * Mutable per-token record collector passed to #renderContentLines while
  * rendering the streaming tail. The render loop fills `raws`/`nextTypes`
@@ -1691,6 +1801,17 @@ interface TailRenderRecorder {
 	raws: (string | undefined)[];
 	nextTypes: (string | undefined)[];
 }
+/**
+ * The frozen streaming prefix as it stood before a rewind whose only cause was
+ * a closer on the still-growing last line, with the row caches keyed on it.
+ */
+interface RewoundPrefix {
+	text: string;
+	tokens: Token[];
+	openers: readonly PrefixOpener[];
+	lineCache: StreamPrefixLineCache | undefined;
+	tailRowCache: TailRowCache | undefined;
+}
 interface StreamingHighlightCache extends RenderSignature {
 	lang: string | undefined;
 	text: string;
@@ -1719,6 +1840,8 @@ export class Markdown implements Component {
 	#paddingY: number; // Top/bottom padding
 	#defaultTextStyle?: DefaultTextStyle;
 	#theme: MarkdownTheme;
+	#symbols: SymbolTheme;
+	#symbolsProbe: string;
 	#defaultStylePrefix?: string;
 	/** Number of spaces used to indent code block content. */
 	#codeBlockIndent: number;
@@ -1741,6 +1864,20 @@ export class Markdown implements Component {
 	#streamPrefixText?: string;
 	#streamPrefixTokens?: Token[];
 	#streamPrefixLineCache?: StreamPrefixLineCache;
+	// The first display-math opener of each kind in the frozen prefix whose
+	// block an append could still close. The prefix lexes them as the text
+	// stands, which stays right until a tail line could close one of them
+	// (mathBlockCloserIndex). Such a line turns the text from its kind's opener
+	// on into one math block, so the prefix goes back to the boundary in front
+	// of that opener, keeps the openers in front of it, and the rest is re-lexed.
+	#streamPrefixOpeners: readonly PrefixOpener[] = NO_OPENERS;
+	// The frozen prefix's leading run in front of the first of those openers:
+	// no append can change its tokens, so getLastRenderStableText publishes it.
+	#streamSettledText?: string;
+	// The prefix before a rewind that only a closer on the still-growing last
+	// line caused. Once a later text holds no closer line after it, that
+	// prefix is right again, so #lexTokens puts it back.
+	#streamRewound?: RewoundPrefix;
 	// Guard-scan memo (PoC C): the ref-def/CR verdict with the exact text
 	// length it was checked on. Reuse is sound only while setText has been
 	// append-only since (tracked via the startsWith that setText performs): a
@@ -1765,6 +1902,8 @@ export class Markdown implements Component {
 	// the blank-replacement branch of setText and the fallback branch of
 	// #lexTokens.
 	#tailRowCache?: TailRowCache;
+	#listItemRowsCache?: ListItemRowsCache;
+	#streamingListCache?: StreamingListCache;
 	// True while #renderStreamingContentLines renders the frozen token range:
 	// frozen code blocks highlight even in transient mode so their bytes match
 	// the finalized render (they render once into the prefix line cache, so
@@ -1800,6 +1939,9 @@ export class Markdown implements Component {
 		this.#paddingX = paddingX;
 		this.#paddingY = paddingY;
 		this.#theme = theme;
+		this.#symbols = theme.symbols ?? getSymbolTheme();
+		const { quoteBorder, hrChar, colorSwatch, table } = this.#symbols;
+		this.#symbolsProbe = theme.symbols ? "" : [quoteBorder, hrChar, colorSwatch, ...Object.values(table)].join("");
 		this.#defaultTextStyle = defaultTextStyle;
 		this.#codeBlockIndent = Math.max(0, Math.floor(codeBlockIndent));
 	}
@@ -1854,8 +1996,13 @@ export class Markdown implements Component {
 		if (text === this.#text) return false;
 		if (!text.startsWith(this.#text)) {
 			// Non-append edit: the previous frame's guard verdict cannot be
-			// reused — the checked region may have changed anywhere.
+			// reused — the checked region may have changed anywhere. The frozen
+			// prefix, or one a rewind set aside, may still start the new text,
+			// but the line after it was replaced, and a boundary holds only
+			// while that line starts a block of its own.
 			this.#appendOnlySinceLastScan = false;
+			this.#dropStreamPrefix();
+			this.#streamRewound = undefined;
 		}
 		this.#text = text;
 		if (!text.trim()) {
@@ -1863,6 +2010,7 @@ export class Markdown implements Component {
 			// the non-append edit, so drop the frozen stream state here or it
 			// outlives the content it indexed.
 			this.#dropStreamPrefix();
+			this.#listItemRowsCache = undefined;
 			// B+: the captured fast-path rows index the replaced content — drop
 			// the recipe so a fresh stream cannot splice onto stale rows.
 			this.#fastTail = undefined;
@@ -1877,6 +2025,14 @@ export class Markdown implements Component {
 		this.#cachedLines = undefined;
 	}
 
+	releaseRenderCaches(): void {
+		this.invalidate();
+		this.#dropStreamPrefix();
+		this.#streamingHighlightCache = undefined;
+		this.#fastTail = undefined;
+		this.#lastTailCapture = undefined;
+	}
+
 	/**
 	 * The unrendered source as an `md` node, `stream` while the streaming
 	 * (transient) cache is on. Append-only growth yields a fresh node of the
@@ -1896,11 +2052,13 @@ export class Markdown implements Component {
 
 	/**
 	 * Width-independent source prefix of the last render ending at a frozen
-	 * Markdown block boundary. Only meaningful while streaming (transient
-	 * render cache on); grows monotonically under append-only `setText`.
+	 * Markdown block boundary that no append can move: it stops in front of a
+	 * display-math opener whose block an append could still close. Only
+	 * meaningful while streaming (transient render cache on); grows
+	 * monotonically under append-only `setText`.
 	 */
 	getLastRenderStableText(): string {
-		return this.#transientRenderCache ? (this.#streamPrefixText ?? "") : "";
+		return this.#transientRenderCache ? (this.#streamSettledText ?? "") : "";
 	}
 
 	get transientRenderCache(): boolean {
@@ -1930,7 +2088,10 @@ export class Markdown implements Component {
 			// render consumes it (see #lexTokens / the L2 hit path).
 			this.#streamPrefixLineCache = undefined;
 			this.#tailRowCache = undefined;
+			this.#listItemRowsCache = undefined;
 			this.#streamingHighlightCache = undefined;
+			this.#streamingListCache = undefined;
+			this.#streamRewound = undefined;
 		}
 		this.invalidate();
 	}
@@ -1942,15 +2103,25 @@ export class Markdown implements Component {
 	// raw-span offsets). Every fallback is correctness-preserving — only speed
 	// differs; the render loop sees the identical token list either way.
 	#lexTokens(text: string): Token[] {
-		// When a frozen prefix exists, it was already verified ref-def-free when
-		// frozen (#freezeStablePrefix only runs when canStream was true). The prefix
-		// ends at a "\n\n" block boundary (stableBlockBoundary), so the tail starts
-		// at a fresh line — scanning only the tail for ref defs is sufficient and
-		// avoids re-scanning the grown prefix every frame (O(n²) → O(n) overall).
+		// A prefix is frozen only while canStream holds and its lex registered no
+		// definitions, and it ends at a "\n\n" block boundary (stableBlockBoundary),
+		// so the tail starts at a fresh line. The scan below then catches a
+		// top-level definition or CR in the new text and the tail lex's links catch
+		// a nested one, so the grown prefix is never re-scanned (O(n²) → O(n)).
+		if (this.#streamRewound !== undefined) this.#restoreRewoundPrefix(text);
+		const frozenText = this.#streamPrefixText;
+		const frozenTokens = this.#streamPrefixTokens;
+		const grewPastPrefix = frozenText !== undefined && text.length > frozenText.length && text.startsWith(frozenText);
+		// A tail line that could close a display-math block the prefix holds open
+		// makes the text from that block's opener on one `math` token, so the
+		// prefix goes back to the boundary in front of the opener, and the rest
+		// is lexed again. The check reads only the tail, which is lexed anyway.
+		if (grewPastPrefix && frozenTokens !== undefined && this.#streamPrefixOpeners.length > 0) {
+			this.#rewindForCloser(text, frozenText, frozenTokens);
+		}
 		const prefix = this.#streamPrefixText;
 		const prefixTokens = this.#streamPrefixTokens;
-		const hasPrefix =
-			prefix !== undefined && prefixTokens !== undefined && text.length > prefix.length && text.startsWith(prefix);
+		const hasPrefix = grewPastPrefix && prefix !== undefined && prefixTokens !== undefined;
 		const refDefText = hasPrefix ? text.slice(prefix.length) : text;
 		// Guard-scan memo (PoC C): while setText has been append-only and the
 		// grown delta introduces no "[", "]", ":", "\n" or "\r", the previous
@@ -1996,37 +2167,201 @@ export class Markdown implements Component {
 		}
 		this.#lastScanLength = text.length;
 		this.#lastScanCanStream = canStream;
+		if (!canStream) this.#listItemRowsCache = undefined;
 		this.#lastScanValid = true;
 		this.#appendOnlySinceLastScan = true;
+		if (canStream && retainPrefix) {
+			const tokens = this.#resumeStreamingList(text);
+			if (tokens !== undefined) {
+				this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
+				this.#checkpointStreamingList(text, tokens);
+				return tokens;
+			}
+		}
 		if (canStream && hasPrefix) {
 			const tailTokens = lexDocument(refDefText);
-			const tokens = [...prefixTokens, ...tailTokens];
-			if (retainPrefix) this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
-			else this.#dropStreamPrefix();
-			return tokens;
+			// A definition at any nesting depth registers for the whole document
+			// and can resolve a reference in the frozen prefix, which was lexed
+			// without it, so any definition in the tail sends the text to a full lex.
+			if (Object.keys(tailTokens.links).length === 0) {
+				const tokens = [...prefixTokens, ...tailTokens];
+				if (retainPrefix) this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
+				else this.#dropStreamPrefix();
+				if (retainPrefix) this.#checkpointStreamingList(text, tokens);
+				return tokens;
+			}
 		}
 		const tokens = lexDocument(text);
-		if (canStream && retainPrefix) {
+		const hasReferenceDefinitions = Object.keys(tokens.links).length > 0;
+		if (hasReferenceDefinitions) this.#lastScanCanStream = false;
+		// A definition frozen into the prefix would be missing from every later
+		// tail lex, so a full lex that registered any definition freezes nothing.
+		if (canStream && retainPrefix && !hasReferenceDefinitions) {
 			this.#freezeStablePrefix(text, tokens, { preserveExisting: false });
+			this.#checkpointStreamingList(text, tokens);
 		} else {
 			this.#dropStreamPrefix();
 		}
 		return tokens;
 	}
 
-	/** Drop the frozen lex prefix and the transient row caches keyed on it. */
+	#resumeStreamingList(text: string): Token[] | undefined {
+		const cached = this.#streamingListCache;
+		if (cached === undefined || text.length <= cached.text.length || !text.startsWith(cached.text)) return undefined;
+		const tail = lexDocument(text.slice(cached.tailStart));
+		if (Object.keys(tail.links).length > 0) return undefined;
+		const first = tail[0];
+		if (first?.type !== "list") return undefined;
+		const list = first as Tokens.List;
+		if (!listMayContinueAt(list.raw, 0, cached.list.raw)) return undefined;
+		const loose = cached.list.loose || list.loose;
+		const completed = cached.list.items.slice(0, cached.stableCount);
+		const items = [...completed, ...list.items];
+		const merged: Tokens.List = {
+			...cached.list,
+			raw: text.slice(cached.start, cached.tailStart + list.raw.length),
+			loose,
+			items: loose ? items.map(loosenListItem) : items,
+		};
+		return [...cached.before, merged, ...tail.slice(1)];
+	}
+
+	#checkpointStreamingList(text: string, tokens: Token[]): void {
+		const previous = this.#streamingListCache;
+		this.#streamingListCache = undefined;
+		let index = tokens.length - 1;
+		while (tokens[index]?.type === "space") index--;
+		const token = tokens[index];
+		if (token?.type !== "list") return;
+		const list = token as Tokens.List;
+		let start = 0;
+		for (let i = 0; i < index; i++) start += tokens[i]!.raw.length;
+		// Late block delimiters can absorb an unfrozen preceding region. Bare
+		// environments can also absorb list items through an equation prefix.
+		if (start !== (this.#streamPrefixText?.length ?? 0) || BARE_ENV_BEGIN.test(list.raw)) return;
+		const canResume = previous !== undefined && previous.start === start && text.startsWith(previous.text);
+		let cursor = canResume ? previous.tailStart : start;
+		let tailStart = start;
+		let stableCount = 0;
+		const indent = /^ */.exec(list.raw)![0].length;
+		for (let i = canResume ? previous.stableCount : 0; i < list.items.length; i++) {
+			const item = list.items[i]!;
+			const position = text.indexOf(item.raw, cursor);
+			if (position < cursor || position >= start + list.raw.length) return;
+			// List continuation uses the first item's indentation. Resume only at
+			// an item with that same indentation so the lexer sees the same context.
+			if (/^ */.exec(item.raw)![0].length === indent) {
+				tailStart = position;
+				stableCount = i;
+			}
+			cursor = position + item.raw.length;
+		}
+		this.#streamingListCache = { text, before: tokens.slice(0, index), start, tailStart, stableCount, list };
+	}
+
+	/**
+	 * Drop the frozen lex prefix and the transient row caches keyed on it. A
+	 * prefix set aside for #restoreRewoundPrefix checks itself against each
+	 * later text, so it stays until a non-append edit.
+	 */
 	#dropStreamPrefix(): void {
 		this.#streamPrefixText = undefined;
 		this.#streamPrefixTokens = undefined;
+		this.#streamPrefixOpeners = NO_OPENERS;
+		this.#streamSettledText = undefined;
 		this.#streamPrefixLineCache = undefined;
 		this.#tailRowCache = undefined;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
+	}
+
+	/**
+	 * Rewind the frozen prefix `prefix` (its tokens `tokens`) for a line of the
+	 * tail after it that could close one of its openers: back to the boundary
+	 * in front of the first opener whose closer a tail line holds. When that
+	 * closer, and no other, is on the still-growing last line, the next chunk
+	 * can turn the line into text again, so the prefix is set aside for
+	 * #restoreRewoundPrefix.
+	 */
+	#rewindForCloser(text: string, prefix: string, tokens: Token[]): void {
+		let target: PrefixOpener | undefined;
+		let lastLineOnly = false;
+		for (const opener of this.#streamPrefixOpeners) {
+			const closer = mathBlockCloserIndex(text, prefix.length, opener.kind);
+			if (closer === undefined) continue;
+			lastLineOnly = target === undefined && !text.includes("\n", closer);
+			target ??= opener;
+		}
+		if (target === undefined) return;
+		this.#streamRewound = lastLineOnly
+			? {
+					text: prefix,
+					tokens,
+					openers: this.#streamPrefixOpeners,
+					lineCache: this.#streamPrefixLineCache,
+					tailRowCache: this.#tailRowCache,
+				}
+			: undefined;
+		this.#rewindStreamPrefix(target.rewindEnd, target.rewindCount);
+	}
+
+	/**
+	 * Cut the frozen prefix back to the boundary `end` characters and `count`
+	 * tokens in, keeping the openers in front of it and the rows of the prefix
+	 * that remains, and dropping the tail row cache keyed on the old prefix.
+	 */
+	#rewindStreamPrefix(end: number, count: number): void {
+		this.#streamPrefixLineCache = rewoundLineCache(this.#streamPrefixLineCache, count);
+		this.#tailRowCache = undefined;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
+		if (count === 0) {
+			this.#streamPrefixText = undefined;
+			this.#streamPrefixTokens = undefined;
+			this.#streamPrefixOpeners = NO_OPENERS;
+			return;
+		}
+		this.#streamPrefixText = this.#streamPrefixText?.slice(0, end);
+		this.#streamPrefixTokens = this.#streamPrefixTokens?.slice(0, count);
+		this.#streamPrefixOpeners = this.#streamPrefixOpeners.filter(opener => opener.at < end);
+	}
+
+	/**
+	 * Put back the prefix #rewindForCloser set aside once no line of `text`
+	 * after it could close one of its openers: the last line it rewound for
+	 * has grown into text, so the prefix lexes as the text stands again. A
+	 * closer line that has ended stays one under every append, so a prefix
+	 * with one after it can never come back.
+	 */
+	#restoreRewoundPrefix(text: string): void {
+		const rewound = this.#streamRewound;
+		if (rewound === undefined) return;
+		if (text.length <= rewound.text.length || !text.startsWith(rewound.text)) {
+			this.#streamRewound = undefined;
+			return;
+		}
+		for (const opener of rewound.openers) {
+			const closer = mathBlockCloserIndex(text, rewound.text.length, opener.kind);
+			if (closer === undefined) continue;
+			if (text.includes("\n", closer)) this.#streamRewound = undefined;
+			return;
+		}
+		this.#streamRewound = undefined;
+		this.#streamPrefixText = rewound.text;
+		this.#streamPrefixTokens = rewound.tokens;
+		this.#streamPrefixOpeners = rewound.openers;
+		this.#streamPrefixLineCache = rewound.lineCache;
+		this.#tailRowCache = rewound.tailRowCache;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
 	}
 
 	// Freeze the largest run of leading blocks that end on a hard "\n\n" boundary
-	// (complete and immutable under append-only growth) so the next streaming
-	// render re-lexes only the unfrozen tail. Caller guarantees no CR / no
-	// reference definitions, so each token's `raw` is a verbatim slice of `text`
-	// and the summed offsets address `text` exactly.
+	// (complete, and immutable under append-only growth until a tail line could
+	// close a display-math block it holds open) so the next streaming render
+	// re-lexes only the unfrozen tail. Caller guarantees no CR / no reference
+	// definitions, so each token's `raw` is a verbatim slice of `text` and the
+	// summed offsets address `text` exactly.
 	#freezeStablePrefix(text: string, tokens: Token[], opts: { preserveExisting: boolean }): void {
 		// On the streaming-concat path (preserveExisting), tokens[0..prefixCount)
 		// ARE the previously frozen prefix and the text above it is byte-
@@ -2037,19 +2372,50 @@ export class Markdown implements Component {
 		// path (preserveExisting: false) re-derives the whole stream, so it
 		// must keep walking from 0.
 		const skipPrefix = opts.preserveExisting ? (this.#streamPrefixTokens?.length ?? 0) : 0;
-		const frozen = stableBlockBoundary(
-			text,
-			skipPrefix > 0 ? (this.#streamPrefixText?.length ?? 0) : 0,
-			tokens,
-			skipPrefix,
-		);
-		if (frozen.count > 0) {
-			this.#streamPrefixText = text.slice(0, frozen.end);
-			this.#streamPrefixTokens = tokens.slice(0, frozen.count);
+		const base = skipPrefix > 0 ? (this.#streamPrefixText?.length ?? 0) : 0;
+		const frozen = stableBlockBoundary(text, base, tokens, { startIndex: skipPrefix });
+		if (frozen.count === 0) {
+			if (!opts.preserveExisting) this.#dropStreamPrefix();
 			return;
 		}
-
-		if (!opts.preserveExisting) this.#dropStreamPrefix();
+		let openers = skipPrefix > 0 ? this.#streamPrefixOpeners : NO_OPENERS;
+		if (openers.length === 0) {
+			// The prefix so far is all settled, so the settled part grows up to the
+			// last boundary in front of the first opener an append could close.
+			const settled = stableBlockBoundary(text, base, tokens, { startIndex: skipPrefix, settle: true });
+			if (settled.count > 0) {
+				this.#streamSettledText = text.slice(0, settled.end);
+			} else if (skipPrefix === 0) {
+				this.#streamSettledText = undefined;
+			}
+		}
+		// Record the first opener of each kind in the newly frozen tokens that an
+		// append could still close, with the boundary a closer of its kind
+		// rewinds to: the last one in front of it, or the prefix end when the new
+		// tokens hold none. It is never in front of an earlier opener's, so the
+		// first opener whose closer a tail line holds has the earliest boundary.
+		let pos = base;
+		for (let i = skipPrefix; i < frozen.count && openers.length < 2; i++) {
+			const token = tokens[i];
+			if (token.type !== "math") {
+				const kind = mathBlockOpenerAt(text, pos);
+				if (kind !== undefined && !openers.some(opener => opener.kind === kind) && mathBlockMayCloseAt(text, pos)) {
+					const boundary = stableBlockBoundary(text, base, tokens, { startIndex: skipPrefix, endIndex: i });
+					let rewindEnd = boundary.count > 0 ? boundary.end : base;
+					let rewindCount = boundary.count > 0 ? boundary.count : skipPrefix;
+					const earlier = openers.at(-1);
+					if (earlier !== undefined && earlier.rewindEnd > rewindEnd) {
+						rewindEnd = earlier.rewindEnd;
+						rewindCount = earlier.rewindCount;
+					}
+					openers = [...openers, { kind, at: pos, rewindEnd, rewindCount }];
+				}
+			}
+			pos += token.raw.length;
+		}
+		this.#streamPrefixText = text.slice(0, frozen.end);
+		this.#streamPrefixTokens = tokens.slice(0, frozen.count);
+		this.#streamPrefixOpeners = openers;
 	}
 
 	render(width: number): readonly string[] {
@@ -2131,11 +2497,16 @@ export class Markdown implements Component {
 					(!markerDelta && recipe.rowRaw.endsWith("$") && /^[0-9]/.test(deltaTabs));
 				// A delta opening a pairing char when the captured row ENDS with the
 				// same char can re-pair across the seam: cold lex of the joined run
-				// makes ONE token (x *a**b* → em("a**b")), the splice keeps two.
-				// An image marker (`x!` + `[a](u)`) re-pairs the same way.
+				// makes ONE token (x *a**b* → em("a**b")), the splice keeps two. So
+				// can an emphasis delimiter in the delta and the same char anywhere
+				// in the row, once the joined text makes the row's one flanking
+				// (`a_{3` + `} + b_{` renders `{3} + b` emphasized): the delta lexed
+				// alone has nothing to pair with. An image marker (`x!` + `[a](u)`)
+				// re-pairs the same way.
 				const pairSeamHazard =
 					markerDelta &&
 					((/^[*~`]/.test(deltaTabs) && /[*~`]$/.test(recipe.rowRaw)) ||
+						FAST_EMPHASIS_DELIMITERS.some(c => deltaTabs.includes(c) && recipe.rowRaw.includes(c)) ||
 						// "x!" + "[a](u)": cold lexes text("x") + image(alt); the splice would
 						// keep "x!" + a styled link byte-run.
 						(deltaTabs.startsWith("[") && recipe.rowRaw.endsWith("!")));
@@ -2161,7 +2532,7 @@ export class Markdown implements Component {
 							: renderTextWithSwatches(
 									normalizeHtmlEntitiesForTerminal(deltaTabs),
 									applyText,
-									this.#theme.symbols.colorSwatch || DEFAULT_COLOR_SWATCH_GLYPH,
+									this.#symbols.colorSwatch || DEFAULT_COLOR_SWATCH_GLYPH,
 								));
 					const wrapped = wrapTextWithAnsi(grown, contentWidth);
 					const fastPaddingX = this.#ignoreTight ? this.#paddingX : getPaddingX(this.#paddingX);
@@ -2214,8 +2585,14 @@ export class Markdown implements Component {
 			// removed): the guard-scan memo's checked region is no longer
 			// byte-identical, and a cached false verdict may have been based
 			// on the very CR/ref-def line that was deleted. Invalidate so the
-			// next #lexTokens re-derives on the repaired buffer.
+			// next #lexTokens re-derives on the repaired buffer. The text past
+			// the frozen prefix is no append of what was frozen against either
+			// (a fence line right after the prefix leaves the tail opening on
+			// blank lines a one-pass lex joins to the ones above), so drop it,
+			// and any prefix a rewind set aside.
 			this.#lastScanValid = false;
+			this.#dropStreamPrefix();
+			this.#streamRewound = undefined;
 		}
 
 		// L2: module-level LRU — survives component disposal/recreation across
@@ -2327,6 +2704,7 @@ export class Markdown implements Component {
 			textSizing: TERMINAL.textSizing,
 			bgColorProbe,
 			headingProbe,
+			symbolsProbe: this.#symbolsProbe,
 		};
 	}
 	// All-primitive signature — compare via the canonical render-cache encoding.
@@ -2335,7 +2713,7 @@ export class Markdown implements Component {
 	}
 
 	#renderCacheKey(normalizedText: string, signature: RenderSignature): string {
-		return `${normalizedText}\x00${signature.width}\x00${signature.paddingX}\x00${signature.paddingY}\x00${signature.codeBlockIndent}\x00${signature.themeId}\x00${signature.defaultTextStyleId}\x00${signature.imageProtocol}\x00${signature.hyperlinks ? 1 : 0}\x00${signature.textSizing ? 1 : 0}\x00${signature.bgColorProbe}\x00${signature.headingProbe}`;
+		return `${normalizedText}\x00${signature.width}\x00${signature.paddingX}\x00${signature.paddingY}\x00${signature.codeBlockIndent}\x00${signature.themeId}\x00${signature.defaultTextStyleId}\x00${signature.imageProtocol}\x00${signature.hyperlinks ? 1 : 0}\x00${signature.textSizing ? 1 : 0}\x00${signature.bgColorProbe}\x00${signature.headingProbe}\x00${signature.symbolsProbe}`;
 	}
 
 	#renderStreamingContentLines(
@@ -2344,6 +2722,7 @@ export class Markdown implements Component {
 		signature: RenderSignature,
 		contentWidth: number,
 	): string[] {
+		if (tokens[tokens.length - 1]?.type !== "list") this.#listItemRowsCache = undefined;
 		const stableText = this.#streamPrefixText;
 		const stableTokenCount = this.#streamPrefixTokens?.length ?? 0;
 		if (stableText === undefined || stableTokenCount === 0 || !normalizedText.startsWith(stableText)) {
@@ -2356,10 +2735,15 @@ export class Markdown implements Component {
 		// of prefix + tail, so no array handed to a caller is ever mutated.
 		const reusablePrefix = this.#matchingStreamPrefixLineCache(normalizedText, stableText, signature);
 		let prefixLines: string[] = [];
+		let marks: PrefixMark[] = [];
 		let renderedUntil = 0;
 		if (reusablePrefix && reusablePrefix.tokenCount <= stableTokenCount) {
 			prefixLines = reusablePrefix.lines;
+			marks = reusablePrefix.marks;
 			renderedUntil = reusablePrefix.tokenCount;
+			if (renderedUntil < stableTokenCount) {
+				marks.push({ textEnd: reusablePrefix.text.length, tokenCount: renderedUntil, lineEnd: prefixLines.length });
+			}
 		}
 
 		if (renderedUntil < stableTokenCount) {
@@ -2382,6 +2766,7 @@ export class Markdown implements Component {
 			text: stableText,
 			tokenCount: stableTokenCount,
 			lines: prefixLines,
+			marks,
 		};
 
 		if (renderedUntil >= tokens.length) return prefixLines.slice();
@@ -2431,11 +2816,11 @@ export class Markdown implements Component {
 		}
 
 		const recorder: TailRenderRecorder = {
-			// [suppressed] render-cache length preallocation
+			// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 			rows: new Array(tokens.length - spliceEnd).fill(undefined),
-			// [suppressed] render-cache length preallocation
+			// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 			raws: new Array(tokens.length - spliceEnd).fill(undefined),
-			// [suppressed] render-cache length preallocation
+			// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 			nextTypes: new Array(tokens.length - spliceEnd).fill(undefined),
 		};
 		const fresh = this.#renderContentLines(tokens, spliceEnd, tokens.length, contentWidth, signature, recorder);
@@ -2448,11 +2833,11 @@ export class Markdown implements Component {
 		// `start`), so a mostly-frozen document allocates only for the
 		// unfrozen tail instead of the whole token list every frame.
 		const tailCount = tokens.length - start;
-		// [suppressed] render-cache length preallocation
+		// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 		const rows: (readonly string[] | undefined)[] = new Array(tailCount).fill(undefined);
-		// [suppressed] render-cache length preallocation
+		// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 		const raws: (string | undefined)[] = new Array(tailCount).fill(undefined);
-		// [suppressed] render-cache length preallocation
+		// oxlint-disable-next-line unicorn/no-new-array -- render-cache length preallocation
 		const nextTypes: (string | undefined)[] = new Array(tailCount).fill(undefined);
 		if (cache !== undefined && cache.tokenStart === start) {
 			for (let i = start; i < Math.min(cache.cachedThrough, spliceEnd); i++) {
@@ -2914,6 +3299,37 @@ export class Markdown implements Component {
 		return {
 			applyText: (text: string) => this.#applyDefaultStyle(text),
 			stylePrefix: this.#getDefaultStylePrefix(),
+			isDefault: true,
+		};
+	}
+
+	/**
+	 * Style context for semantically-themed spans (headings, links) under a
+	 * `proseFg` default style: plain runs keep the prose foreground, but the
+	 * span's own `md*` theme color must stay the innermost (winning) SGR, so
+	 * `applyText` keeps decorations (bold/italic/…) while dropping the
+	 * prose color. Non-`proseFg` styles and caller-supplied contexts pass
+	 * through unchanged.
+	 */
+	#proseFgExemptContext(styleContext: InlineStyleContext | undefined): InlineStyleContext | undefined {
+		// A caller-supplied context (blockquote identity styling) already governs
+		// this subtree and wins; exemption applies only to the component's own
+		// default style (undefined resolves to it downstream), and stays applied
+		// through nested recursion.
+		if (styleContext && !styleContext.isDefault) return styleContext;
+		if (!this.#defaultTextStyle?.color || !this.#defaultTextStyle?.proseFg) return styleContext;
+		const applyExceptColor = (text: string): string => {
+			let styled = text;
+			if (this.#defaultTextStyle?.bold) styled = this.#theme.bold(styled);
+			if (this.#defaultTextStyle?.italic) styled = this.#theme.italic(styled);
+			if (this.#defaultTextStyle?.strikethrough) styled = this.#theme.strikethrough(styled);
+			if (this.#defaultTextStyle?.underline) styled = this.#theme.underline(styled);
+			return styled;
+		};
+		return {
+			applyText: applyExceptColor,
+			stylePrefix: this.#getStylePrefix(applyExceptColor),
+			isDefault: true,
 		};
 	}
 
@@ -2945,7 +3361,7 @@ export class Markdown implements Component {
 			case "heading": {
 				const headingLevel = token.depth;
 				const headingPrefix = `${"#".repeat(headingLevel)} `;
-				const headingText = this.#renderInlineTokens(token.tokens || [], styleContext);
+				const headingText = this.#renderInlineTokens(token.tokens || [], this.#proseFgExemptContext(styleContext));
 				const headingPlainText = plainInlineTokens(token.tokens || []);
 				let styledHeading: string;
 				if (headingLevel === 1 && TERMINAL.textSizing) {
@@ -3108,7 +3524,7 @@ export class Markdown implements Component {
 
 	/** Render a horizontal rule line themed to `width`, matching `sourceChar` when given. */
 	#renderHrLine(width: number, sourceChar = ""): string {
-		const fillChar = getHrChar(sourceChar, this.#theme.symbols.hrChar);
+		const fillChar = getHrChar(sourceChar, this.#symbols.hrChar);
 		return this.#theme.hr(fillChar.repeat(Math.min(width, 80)));
 	}
 
@@ -3140,7 +3556,7 @@ export class Markdown implements Component {
 			} else {
 				const styledLine = applyQuoteStyle(quoteLine.text);
 				for (const wrappedLine of wrapTextWithAnsi(styledLine, quoteContentWidth)) {
-					lines.push(renderedLine(this.#theme.quoteBorder(`${this.#theme.symbols.quoteBorder} `) + wrappedLine));
+					lines.push(renderedLine(this.#theme.quoteBorder(`${this.#symbols.quoteBorder} `) + wrappedLine));
 				}
 			}
 		}
@@ -3201,7 +3617,10 @@ export class Markdown implements Component {
 			const segments: string[] = text.split("\n");
 			return segments.map((segment: string) => (segment === "" ? "" : applyText(segment))).join("\n");
 		};
-		const swatchGlyph = this.#theme.symbols.colorSwatch || DEFAULT_COLOR_SWATCH_GLYPH;
+		const swatchGlyph = this.#symbols.colorSwatch || DEFAULT_COLOR_SWATCH_GLYPH;
+		// Set by a line break: the next line's own leading whitespace is dropped.
+		// Every token consumes it, so the space after a styled span that starts
+		// the line stays; a token that renders nothing passes it on.
 		let trimLeadingWhitespace = false;
 		const htmlState = createHtmlNormalizationState();
 		const markHtmlItemWhenContent = (text: string): void => {
@@ -3209,6 +3628,8 @@ export class Markdown implements Component {
 		};
 
 		for (const token of collapseInlineHtml(tokens)) {
+			const lineStart: boolean = trimLeadingWhitespace;
+			trimLeadingWhitespace = false;
 			if (isMathToken(token)) {
 				markHtmlItemWhenContent(token.text);
 				result += applyTextWithNewlines(renderMathToken(token.text));
@@ -3216,9 +3637,8 @@ export class Markdown implements Component {
 			}
 			switch (token.type) {
 				case "text": {
-					const rawText = trimLeadingWhitespace ? token.text.replace(/^\s+/, "") : token.text;
+					const rawText = lineStart ? token.text.replace(/^\s+/, "") : token.text;
 					const text = normalizeHtmlEntitiesForTerminal(rawText);
-					trimLeadingWhitespace = false;
 					markHtmlItemWhenContent(text);
 					if (token.tokens) markHtmlItemWhenContent(plainInlineTokens(token.tokens));
 					// Text tokens in list items can have nested tokens for inline formatting
@@ -3259,7 +3679,10 @@ export class Markdown implements Component {
 
 				case "link": {
 					markHtmlItemWhenContent(token.text);
-					const linkText = this.#renderInlineTokens(token.tokens || [], resolvedStyleContext);
+					const linkText = this.#renderInlineTokens(
+						token.tokens || [],
+						this.#proseFgExemptContext(resolvedStyleContext),
+					);
 					const styledLinkText = this.#theme.link(this.#theme.underline(linkText));
 					const href = typeof token.href === "string" ? token.href : "";
 					const target = (href && this.#theme.resolveLink?.(href)) || href;
@@ -3299,8 +3722,8 @@ export class Markdown implements Component {
 						result += applyTextWithNewlines(cleaned);
 						if (cleaned.endsWith("\n")) {
 							trimLeadingWhitespace = true;
-						} else if (cleaned.length > 0) {
-							trimLeadingWhitespace = false;
+						} else if (cleaned.length === 0) {
+							trimLeadingWhitespace = lineStart;
 						}
 					}
 					break;
@@ -3308,11 +3731,12 @@ export class Markdown implements Component {
 				default:
 					// Handle any other inline token types as plain text
 					if ("text" in token && typeof token.text === "string") {
-						const rawText = trimLeadingWhitespace ? token.text.replace(/^\s+/, "") : token.text;
+						const rawText = lineStart ? token.text.replace(/^\s+/, "") : token.text;
 						const text = normalizeHtmlEntitiesForTerminal(rawText);
-						trimLeadingWhitespace = false;
 						markHtmlItemWhenContent(text);
 						result += applyTextWithNewlines(text);
+					} else {
+						trimLeadingWhitespace = lineStart;
 					}
 			}
 		}
@@ -3336,6 +3760,41 @@ export class Markdown implements Component {
 		const indent = "  ".repeat(depth);
 		// Use the list's start property (defaults to 1 for ordered lists)
 		const startNumber = token.start ?? 1;
+		const signature =
+			depth === 0 &&
+			styleContext === undefined &&
+			this.#defaultTextStyle === undefined &&
+			this.#transientRenderCache &&
+			!this.#renderingStablePrefix &&
+			this.#lastScanCanStream &&
+			canCacheMarkdownListItems(this.#theme)
+				? this.#activeRenderSignature
+				: undefined;
+		const themeEpoch = signature === undefined ? undefined : getThemeEpoch();
+		const previous = this.#listItemRowsCache;
+		const reusable =
+			signature !== undefined &&
+			themeEpoch !== undefined &&
+			previous !== undefined &&
+			previous.width === width &&
+			previous.themeEpoch === themeEpoch &&
+			previous.ordered === token.ordered &&
+			previous.start === token.start &&
+			previous.loose === token.loose &&
+			this.#signatureEquals(previous.signature, signature)
+				? previous
+				: undefined;
+		let reusableCount = 0;
+		if (reusable !== undefined) {
+			while (
+				reusableCount < token.items.length &&
+				token.items[reusableCount]?.raw === reusable.raws[reusableCount]
+			) {
+				reusableCount++;
+			}
+		}
+		const raws: string[] | undefined = signature === undefined ? undefined : [];
+		const rows: RenderedLine[][] | undefined = signature === undefined ? undefined : [];
 		const pushWrapped = (line: RenderedLine, firstPrefix: string, continuationPrefix: string): void => {
 			if (line.literalCode) {
 				const wrappedLiteralRows = wrapTextWithAnsi(line.text, Math.max(1, width));
@@ -3371,6 +3830,14 @@ export class Markdown implements Component {
 
 		for (let i = 0; i < token.items.length; i++) {
 			const item = token.items[i];
+			if (i < reusableCount && reusable !== undefined && raws !== undefined && rows !== undefined) {
+				const cached = reusable.rows[i]!;
+				for (const row of cached) lines.push(row);
+				raws.push(item.raw);
+				rows.push(cached);
+				continue;
+			}
+			const rowStart = lines.length;
 			const bullet = token.ordered ? `${startNumber + i}. ` : "- ";
 			const firstPrefix = indent + this.#theme.listBullet(bullet);
 			// Continuation rows align under the item text, so the hang matches the
@@ -3400,6 +3867,22 @@ export class Markdown implements Component {
 			} else {
 				lines.push(renderedLine(firstPrefix));
 			}
+			if (raws !== undefined && rows !== undefined) {
+				raws.push(item.raw);
+				rows.push(lines.slice(rowStart));
+			}
+		}
+		if (signature !== undefined && themeEpoch !== undefined && raws !== undefined && rows !== undefined) {
+			this.#listItemRowsCache = {
+				signature,
+				width,
+				themeEpoch,
+				ordered: token.ordered,
+				start: token.start,
+				loose: token.loose,
+				raws,
+				rows,
+			};
 		}
 
 		return lines;
@@ -3575,7 +4058,7 @@ export class Markdown implements Component {
 		let minCellsWidth = minColumnWidths.reduce((a, b) => a + b, 0);
 
 		if (minCellsWidth > availableForCells) {
-			// [suppressed] column-width allocation
+			// oxlint-disable-next-line unicorn/no-new-array -- column-width allocation
 			minColumnWidths = new Array(numCols).fill(1);
 			const remaining = availableForCells - numCols;
 
@@ -3642,7 +4125,7 @@ export class Markdown implements Component {
 			}
 		}
 
-		const t = this.#theme.symbols.table;
+		const t = this.#symbols.table;
 		const h = t.horizontal;
 		const v = t.vertical;