@fuzdev/mdz 0.2.0 → 0.4.0

package/src/lib/mdz_lexer.ts

@@ -38,6 +38,7 @@ import {
 	HR_HYPHEN_COUNT,
 	MIN_CODEBLOCK_BACKTICKS,
 	MAX_HEADING_LEVEL,
+	MAX_INLINE_NESTING_DEPTH,
 	MAX_LIST_NUMBER_DIGITS,
 	match_url_prefix_case_insensitive,
 	is_at_absolute_path,
@@ -50,10 +51,15 @@ import {
 	mdz_split_table_row,
 	mdz_parse_table_delimiter,
 	PIPE,
-	BACKSLASH,
+	TEXT_CLASS_BACKSLASH,
+	TEXT_CLASS_NEWLINE,
+	TEXT_CLASS_STOP,
+	TEXT_CLASS_URL,
+	TEXT_SCAN_CLASS
 } from './mdz_helpers.ts';
 
-import type {MdzTableAlign} from './mdz.ts';
+import type { MdzTableAlign } from './mdz.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 //
 // Token types
@@ -289,8 +295,8 @@ export class MdzLexer {
 	#index: number = 0;
 	#tokens: Array<MdzToken> = [];
 	#max_search_index: number = Number.MAX_SAFE_INTEGER;
-	#search_memo: Map<string, {from: number; result: number}> = new Map();
-	#break_memo: {from: number; result: number} | null = null;
+	#search_memo: Map<string, { from: number; result: number }> = new Map();
+	#break_memo: { from: number; result: number } | null = null;
 	/**
 	 * Whether `#tokenize_text` is inside a list-item inline run: single
 	 * newlines are soft breaks whose following structural indent strips from
@@ -304,11 +310,69 @@ export class MdzLexer {
 	 * and `\|` unescapes to a literal pipe.
 	 */
 	#in_table_cell: boolean = false;
+	/**
+	 * Start offsets of markdown-link opens (`[`) that definitively failed — so
+	 * a re-lex from before the `[` short-circuits to literal text instead of
+	 * re-attempting (and re-descending into) the same failing link. Without it,
+	 * the revert-and-re-tokenize failure path is exponential on nested `[`
+	 * (a ~30-byte `[`×n input hangs). A link's outcome (does a valid `](ref)`
+	 * follow?) is independent of `#max_search_index`, so `start` alone keys it.
+	 * The outcome is a pure function of the immutable text, so the memo is valid
+	 * for the whole lex and across table-cell ranges; cleared on `rebind`.
+	 */
+	#failed_link_starts: Set<number> = new Set();
+	/**
+	 * The tag analogue of `#failed_link_starts`, keyed `${start}:${bound}`. A
+	 * tag's closer search respects `#max_search_index`, so the same `start` can
+	 * fail under a narrow bound yet succeed under the wider one a re-lex uses —
+	 * the bound is part of the key.
+	 */
+	#failed_tag: Set<string> = new Set();
+	/**
+	 * Current link/tag nesting depth — the number of open
+	 * `link_text_open`/`tag_open` containers being recursed into. Bumped around
+	 * `#tokenize_markdown_link`/`#tokenize_tag`'s children loops (not by
+	 * delimiters, which can't nest deeply — see `MAX_INLINE_NESTING_DEPTH`). At
+	 * the cap a further `[`/`<` renders literal instead of opening, bounding
+	 * recursion depth (no stack overflow) and, with the failure memos, the
+	 * revert re-scan (linear, not quadratic) on adversarial nesting.
+	 */
+	#inline_depth: number = 0;
+	/**
+	 * Start offsets of `[`/`<` openers suppressed by the nesting-depth cap
+	 * (`#inline_depth >= MAX_INLINE_NESTING_DEPTH`) — position-keyed like
+	 * `#failed_link_starts` so a re-lex from a shallower depth short-circuits to
+	 * literal text rather than re-opening the construct (which would reintroduce
+	 * the quadratic the cap removes). A suppression is bound-independent, so
+	 * `start` alone keys it; cleared on `rebind`.
+	 */
+	#depth_capped: Set<number> = new Set();
 
 	constructor(text: string) {
 		this.#text = text;
 	}
 
+	/**
+	 * Rebind to a new text, so one lexer instance can be reused across inputs —
+	 * the streaming table path reuses one across a table's rows via
+	 * `MdzTableCellParser` instead of allocating a lexer (and its memo `Map`)
+	 * per row. The search memos survive when the text is identical (they're
+	 * valid over the immutable text — the common case for rows parsed from one
+	 * buffered chunk) and clear otherwise. Per-parse cursor state is reset by
+	 * `lex_table_cell` itself.
+	 *
+	 * @nodocs
+	 */
+	rebind(text: string): void {
+		if (this.#text === text) return;
+		this.#text = text;
+		this.#search_memo.clear();
+		this.#break_memo = null;
+		this.#failed_link_starts.clear();
+		this.#failed_tag.clear();
+		this.#depth_capped.clear();
+	}
+
 	/**
 	 * Memoized `String#indexOf` over the immutable text.
 	 *
@@ -325,8 +389,12 @@ export class MdzLexer {
 			return memo.result;
 		}
 		const result = this.#text.indexOf(needle, from);
+		if (mdz_debug_work.enabled) {
+			// scan span: `indexOf` examined [from, result] (found) or [from, EOF)
+			mdz_debug_work.total += (result === -1 ? this.#text.length : result) - from;
+		}
 		if (memo === undefined) {
-			this.#search_memo.set(needle, {from, result});
+			this.#search_memo.set(needle, { from, result });
 		} else {
 			memo.from = from;
 			memo.result = result;
@@ -353,7 +421,7 @@ export class MdzLexer {
 			if (this.#is_at_paragraph_break()) {
 				const start = this.#index;
 				this.#skip_blank_lines();
-				this.#tokens.push({type: 'paragraph_break', start, end: this.#index});
+				this.#tokens.push({ type: 'paragraph_break', start, end: this.#index });
 				continue;
 			}
 
@@ -376,6 +444,9 @@ export class MdzLexer {
 	 */
 	lex_table_cell(cell_start: number, cell_end: number): Array<MdzToken> {
 		this.#tokens = [];
+		// depth is balanced back to 0 per cell, but pin it so a future early-return
+		// between an `#inline_depth++` and its decrement can't leak into the next cell
+		this.#inline_depth = 0;
 		this.#tokenize_cell_inline(cell_start, cell_end);
 		return this.#tokens;
 	}
@@ -469,7 +540,7 @@ export class MdzLexer {
 			type: 'heading_start',
 			level: hash_count as 1 | 2 | 3 | 4 | 5 | 6,
 			start,
-			end: this.#index, // end of "## " prefix
+			end: this.#index // end of "## " prefix
 		});
 
 		// Find end-of-line to bound nested tokenizers (prevents tag scanner from scanning past heading)
@@ -509,7 +580,7 @@ export class MdzLexer {
 		this.#max_search_index = saved_max;
 
 		// Emit heading_end marker so the token parser knows where heading content stops
-		this.#tokens.push({type: 'heading_end', start: this.#index, end: this.#index});
+		this.#tokens.push({ type: 'heading_end', start: this.#index, end: this.#index });
 
 		// Skip newlines after heading
 		this.#skip_blank_lines();
@@ -542,7 +613,7 @@ export class MdzLexer {
 		const start = this.#index;
 		this.#index = i; // consume up to but not including newline
 
-		this.#tokens.push({type: 'hr', start, end: this.#index});
+		this.#tokens.push({ type: 'hr', start, end: this.#index });
 
 		// Skip newlines after HR
 		this.#skip_blank_lines();
@@ -570,7 +641,7 @@ export class MdzLexer {
 	 * Match a quote prefix in the complete sync text — never `'pending'`.
 	 * See `mdz_match_blockquote_prefix`.
 	 */
-	#match_blockquote_prefix(i: number): {depth: number; content_start: number} | null {
+	#match_blockquote_prefix(i: number): { depth: number; content_start: number } | null {
 		const prefix = mdz_match_blockquote_prefix(this.#text, i, true);
 		return prefix === 'pending' ? null : prefix;
 	}
@@ -623,7 +694,7 @@ export class MdzLexer {
 		// quote's content parses exactly like a standalone document (a complete
 		// fence opener line on the last quote line opens an empty fence, not text)
 		const parts: Array<string> = [];
-		const segments: Array<{inner_start: number; source_start: number}> = [];
+		const segments: Array<{ inner_start: number; source_start: number }> = [];
 		let inner_len = 0;
 		let line_first = first;
 		let last_line_end = first;
@@ -631,7 +702,7 @@ export class MdzLexer {
 			const strip = line_first + mdz_blockquote_strip_width(this.#text, line_first);
 			let nl = this.#text.indexOf('\n', line_first);
 			if (nl === -1) nl = this.#text.length;
-			segments.push({inner_start: inner_len, source_start: strip});
+			segments.push({ inner_start: inner_len, source_start: strip });
 			const content = this.#text.slice(Math.min(strip, nl), nl < this.#text.length ? nl + 1 : nl);
 			parts.push(content);
 			inner_len += content.length;
@@ -656,14 +727,14 @@ export class MdzLexer {
 			line_first = next_first;
 		}
 
-		this.#tokens.push({type: 'blockquote_open', start: first, end: first});
+		this.#tokens.push({ type: 'blockquote_open', start: first, end: first });
 		const inner_tokens = new MdzLexer(parts.join('')).tokenize();
 		for (const token of inner_tokens) {
 			token.start = mdz_remap_segments(segments, token.start);
 			token.end = mdz_remap_segments(segments, token.end);
 			this.#tokens.push(token);
 		}
-		this.#tokens.push({type: 'blockquote_close', start: last_line_end, end: last_line_end});
+		this.#tokens.push({ type: 'blockquote_close', start: last_line_end, end: last_line_end });
 		this.#index = last_line_end;
 	}
 
@@ -692,7 +763,7 @@ export class MdzLexer {
 		if (align === null || align.length !== header_cells.length) return false;
 
 		// committed — emit the table; the delimiter row is structural (not emitted)
-		this.#tokens.push({type: 'table_open', align, start: table_start, end: header_end});
+		this.#tokens.push({ type: 'table_open', align, start: table_start, end: header_end });
 		this.#emit_table_row(header_cells, true, table_start, header_end);
 
 		this.#index = delim_end;
@@ -710,23 +781,23 @@ export class MdzLexer {
 			table_end = row_end;
 		}
 
-		this.#tokens.push({type: 'table_close', start: table_end, end: table_end});
+		this.#tokens.push({ type: 'table_close', start: table_end, end: table_end });
 		this.#skip_blank_lines();
 		return true;
 	}
 
 	/** Emit one table row's open / cell / close tokens. */
 	#emit_table_row(
-		cells: Array<{start: number; end: number}>,
+		cells: Array<{ start: number; end: number }>,
 		header: boolean,
 		row_start: number,
-		row_end: number,
+		row_end: number
 	): void {
-		this.#tokens.push({type: 'table_row_open', header, start: row_start, end: row_start});
+		this.#tokens.push({ type: 'table_row_open', header, start: row_start, end: row_start });
 		for (const cell of cells) {
 			this.#emit_table_cell(cell.start, cell.end);
 		}
-		this.#tokens.push({type: 'table_row_close', start: row_end, end: row_end});
+		this.#tokens.push({ type: 'table_row_close', start: row_end, end: row_end });
 	}
 
 	/**
@@ -736,9 +807,9 @@ export class MdzLexer {
 	 * stops at that bound and unescapes `\|`.
 	 */
 	#emit_table_cell(cell_start: number, cell_end: number): void {
-		this.#tokens.push({type: 'table_cell_open', start: cell_start, end: cell_start});
+		this.#tokens.push({ type: 'table_cell_open', start: cell_start, end: cell_start });
 		this.#tokenize_cell_inline(cell_start, cell_end);
-		this.#tokens.push({type: 'table_cell_close', start: cell_end, end: cell_end});
+		this.#tokens.push({ type: 'table_cell_close', start: cell_end, end: cell_end });
 	}
 
 	/**
@@ -767,9 +838,9 @@ export class MdzLexer {
 	 */
 	#match_item_table_head(
 		first: number,
-		marker_indent: number,
+		marker_indent: number
 	): {
-		header_cells: Array<{start: number; end: number}>;
+		header_cells: Array<{ start: number; end: number }>;
 		header_end: number;
 		align: Array<MdzTableAlign>;
 		delim_end: number;
@@ -786,7 +857,7 @@ export class MdzLexer {
 		if (delim_end === -1) delim_end = this.#text.length;
 		const align = mdz_parse_table_delimiter(this.#text, dj, delim_end);
 		if (align === null || align.length !== header_cells.length) return null;
-		return {header_cells, header_end, align, delim_end};
+		return { header_cells, header_end, align, delim_end };
 	}
 
 	/** Whether a table opens at `first` as a block child of an item at `marker_indent`. */
@@ -803,7 +874,12 @@ export class MdzLexer {
 	 */
 	#tokenize_item_table(first: number, marker_indent: number): void {
 		const head = this.#match_item_table_head(first, marker_indent)!;
-		this.#tokens.push({type: 'table_open', align: head.align, start: first, end: head.header_end});
+		this.#tokens.push({
+			type: 'table_open',
+			align: head.align,
+			start: first,
+			end: head.header_end
+		});
 		this.#emit_table_row(head.header_cells, true, first, head.header_end);
 		this.#index = head.delim_end;
 		let table_end = head.delim_end;
@@ -821,7 +897,7 @@ export class MdzLexer {
 			this.#index = row_end;
 			table_end = row_end;
 		}
-		this.#tokens.push({type: 'table_close', start: table_end, end: table_end});
+		this.#tokens.push({ type: 'table_close', start: table_end, end: table_end });
 	}
 
 	// -- List tokenizers --
@@ -893,7 +969,7 @@ export class MdzLexer {
 					}
 					if (levels[levels.length - 1]!.ordered === marker.ordered) {
 						// sibling item
-						this.#tokens.push({type: 'list_item_close', start: first, end: first});
+						this.#tokens.push({ type: 'list_item_close', start: first, end: first });
 						this.#list_item_open(marker);
 					} else {
 						// marker-type switch: close the list, open a new one at this indent
@@ -909,13 +985,13 @@ export class MdzLexer {
 				// empty item: only at an indent exactly matching an open level of
 				// the same marker type — anything else degrades below
 				const level_idx = levels.findIndex(
-					(l) => l.indent === indent && l.ordered === marker.ordered,
+					(l) => l.indent === indent && l.ordered === marker.ordered
 				);
 				if (level_idx !== -1) {
 					while (levels.length - 1 > level_idx) {
 						this.#list_close(levels);
 					}
-					this.#tokens.push({type: 'list_item_close', start: first, end: first});
+					this.#tokens.push({ type: 'list_item_close', start: first, end: first });
 					this.#list_item_open(marker);
 					// consume the marker and any trailing whitespace, leaving #index
 					// at the line's newline (or EOF)
@@ -985,7 +1061,7 @@ export class MdzLexer {
 					while (levels.length - 1 > target_idx) {
 						this.#list_close(levels);
 					}
-					this.#tokens.push({type: 'paragraph_break', start: line_start, end: line_start});
+					this.#tokens.push({ type: 'paragraph_break', start: line_start, end: line_start });
 					this.#list_run(levels, first);
 					continue;
 				}
@@ -1020,13 +1096,13 @@ export class MdzLexer {
 					start: i,
 					marker_end: after,
 					content_start: after,
-					empty: true,
+					empty: true
 				};
 			}
 			if (this.#text.charCodeAt(after) !== SPACE) return null;
 			const content_start = after + 1;
 			const empty = this.#rest_is_blank(content_start);
-			return {ordered: false, number: 0, start: i, marker_end: after, content_start, empty};
+			return { ordered: false, number: 0, start: i, marker_end: after, content_start, empty };
 		}
 		if (c >= ZERO && c <= NINE) {
 			let j = i + 1;
@@ -1048,13 +1124,13 @@ export class MdzLexer {
 					start: i,
 					marker_end: after,
 					content_start: after,
-					empty: true,
+					empty: true
 				};
 			}
 			if (this.#text.charCodeAt(after) !== SPACE) return null;
 			const content_start = after + 1;
 			const empty = this.#rest_is_blank(content_start);
-			return {ordered: true, number, start: i, marker_end: after, content_start, empty};
+			return { ordered: true, number, start: i, marker_end: after, content_start, empty };
 		}
 		return null;
 	}
@@ -1091,26 +1167,31 @@ export class MdzLexer {
 			type: 'list_open',
 			ordered: marker.ordered,
 			start: marker.start,
-			end: marker.start,
+			end: marker.start
 		});
 		this.#list_item_open(marker);
-		levels.push({indent, ordered: marker.ordered});
+		levels.push({ indent, ordered: marker.ordered });
 	}
 
 	/** Emit a `list_item_open` token for `marker`. */
 	#list_item_open(marker: MdzListMarker): void {
 		const end = marker.empty ? marker.marker_end : marker.content_start;
 		if (marker.ordered) {
-			this.#tokens.push({type: 'list_item_open', number: marker.number, start: marker.start, end});
+			this.#tokens.push({
+				type: 'list_item_open',
+				number: marker.number,
+				start: marker.start,
+				end
+			});
 		} else {
-			this.#tokens.push({type: 'list_item_open', start: marker.start, end});
+			this.#tokens.push({ type: 'list_item_open', start: marker.start, end });
 		}
 	}
 
 	/** Close the deepest open level: its current item, then its list. */
 	#list_close(levels: Array<MdzListLevel>): void {
-		this.#tokens.push({type: 'list_item_close', start: this.#index, end: this.#index});
-		this.#tokens.push({type: 'list_close', start: this.#index, end: this.#index});
+		this.#tokens.push({ type: 'list_item_close', start: this.#index, end: this.#index });
+		this.#tokens.push({ type: 'list_close', start: this.#index, end: this.#index });
 		levels.pop();
 	}
 
@@ -1207,8 +1288,8 @@ export class MdzLexer {
 	 */
 	#match_fence(
 		first: number,
-		fence_indent: number,
-	): {token: MdzTokenCodeblock; end: number} | null {
+		fence_indent: number
+	): { token: MdzTokenCodeblock; end: number } | null {
 		let i = first;
 		let backtick_count = 0;
 		while (i < this.#text.length && this.#text.charCodeAt(i) === BACKTICK) {
@@ -1265,8 +1346,8 @@ export class MdzLexer {
 								? this.#text.slice(content_start, Math.max(content_start, line_start - 1))
 								: content_lines.join('\n');
 						return {
-							token: {type: 'codeblock', lang, content, start: first, end: m},
-							end: m,
+							token: { type: 'codeblock', lang, content, start: first, end: m },
+							end: m
 						};
 					}
 				}
@@ -1276,7 +1357,7 @@ export class MdzLexer {
 			if (fence_indent > 0) {
 				const line_end = nl === -1 ? this.#text.length : nl;
 				content_lines.push(
-					this.#text.slice(line_start + Math.min(fence_indent, line_indent), line_end),
+					this.#text.slice(line_start + Math.min(fence_indent, line_indent), line_end)
 				);
 			}
 			if (nl === -1) break;
@@ -1287,8 +1368,8 @@ export class MdzLexer {
 		let content = fence_indent === 0 ? this.#text.slice(content_start) : content_lines.join('\n');
 		if (content.endsWith('\n')) content = content.slice(0, -1);
 		return {
-			token: {type: 'codeblock', lang, content, start: first, end: this.#text.length},
-			end: this.#text.length,
+			token: { type: 'codeblock', lang, content, start: first, end: this.#text.length },
+			end: this.#text.length
 		};
 	}
 
@@ -1382,7 +1463,7 @@ export class MdzLexer {
 		}
 
 		this.#index = content_end + 1;
-		this.#tokens.push({type: 'code', content, start, end: this.#index});
+		this.#tokens.push({ type: 'code', content, start, end: this.#index });
 	}
 
 	#tokenize_double_delimiter(delimiter: '**' | '~~', kind: 'bold' | 'strikethrough'): void {
@@ -1421,7 +1502,7 @@ export class MdzLexer {
 		const open_type = kind === 'bold' ? 'bold_open' : 'strikethrough_open';
 		const close_type = kind === 'bold' ? 'bold_close' : 'strikethrough_close';
 		const open_token_index = this.#tokens.length;
-		this.#tokens.push({type: open_type, start, end: this.#index});
+		this.#tokens.push({ type: open_type, start, end: this.#index });
 
 		// Set search boundary for nested parsers
 		const saved_max = this.#max_search_index;
@@ -1448,11 +1529,11 @@ export class MdzLexer {
 				return;
 			}
 
-			this.#tokens.push({type: close_type, start: close_index, end: close_index + 2});
+			this.#tokens.push({ type: close_type, start: close_index, end: close_index + 2 });
 			this.#index = close_index + 2;
 		} else {
 			// Didn't reach closing - convert opening to text
-			this.#tokens[open_token_index] = {type: 'text', content: delimiter, start, end: start + 2};
+			this.#tokens[open_token_index] = { type: 'text', content: delimiter, start, end: start + 2 };
 		}
 	}
 
@@ -1495,7 +1576,7 @@ export class MdzLexer {
 		// Emit open token
 		this.#index++;
 		const open_token_index = this.#tokens.length;
-		this.#tokens.push({type: 'italic_open', start, end: this.#index});
+		this.#tokens.push({ type: 'italic_open', start, end: this.#index });
 
 		// Set search boundary for nested parsers
 		const saved_max = this.#max_search_index;
@@ -1525,7 +1606,7 @@ export class MdzLexer {
 			this.#tokens.push({
 				type: 'italic_close',
 				start: close_index,
-				end: close_index + 1,
+				end: close_index + 1
 			});
 			this.#index = close_index + 1;
 		} else {
@@ -1534,26 +1615,45 @@ export class MdzLexer {
 				type: 'text',
 				content: '_',
 				start,
-				end: start + 1,
+				end: start + 1
 			};
 		}
 	}
 
 	#tokenize_markdown_link(): void {
 		const start = this.#index;
+		// a link open at this offset already failed, or was suppressed by the
+		// nesting cap — emit `[` as text instead of re-descending into the same
+		// failing children (exponential on nested `[`); the short-circuit
+		// reproduces the revert's exact net effect (`[` text, cursor at start + 1)
+		if (this.#failed_link_starts.has(start) || this.#depth_capped.has(start)) {
+			this.#index = start + 1;
+			this.#emit_text('[', start);
+			return;
+		}
+		// nesting-depth cap: too deep to open — render literal and record the
+		// suppression so a shallower re-lex short-circuits here too
+		if (this.#inline_depth >= MAX_INLINE_NESTING_DEPTH) {
+			this.#depth_capped.add(start);
+			this.#index = start + 1;
+			this.#emit_text('[', start);
+			return;
+		}
 		this.#index++; // consume [ (dispatch guarantees it)
 
 		// Emit link_text_open
-		this.#tokens.push({type: 'link_text_open', start, end: this.#index});
+		this.#tokens.push({ type: 'link_text_open', start, end: this.#index });
 
 		// Tokenize children until ] — only `]` delimits link text; a bare `)`
 		// is ordinary content (matching the streaming parser, which has no `)`
 		// dispatch case — the reference scan finds its own `)` after `](`)
+		this.#inline_depth++;
 		while (this.#index < this.#text.length) {
 			if (this.#text.charCodeAt(this.#index) === RIGHT_BRACKET) break;
 			if (this.#is_at_paragraph_break()) break;
 			this.#tokenize_inline();
 		}
+		this.#inline_depth--;
 
 		// Check for ]
 		if (this.#index >= this.#text.length || this.#text.charCodeAt(this.#index) !== RIGHT_BRACKET) {
@@ -1567,7 +1667,7 @@ export class MdzLexer {
 		this.#tokens.push({
 			type: 'link_text_close',
 			start: bracket_close_start,
-			end: this.#index,
+			end: this.#index
 		});
 
 		// Check for (
@@ -1617,11 +1717,18 @@ export class MdzLexer {
 			reference,
 			link_type,
 			start: bracket_close_start + 1, // after ]
-			end: this.#index,
+			end: this.#index
 		});
 	}
 
 	#revert_tokens_from_link_open(start: number): void {
+		// record the failure so a re-lex from before this `[` short-circuits.
+		// Keyed by `start` alone — unlike `#failed_tag`'s `start:bound` — because a
+		// link's outcome is bound-independent: the `]`-terminator scan (the children
+		// loop) runs to `text.length` and never consults `#max_search_index`, so a
+		// wider-bound re-lex can't move it. The bound reaches nested tags inside the
+		// link text, but re-attempting those wider never flips the link's net result.
+		this.#failed_link_starts.add(start);
 		// Find and remove link_text_open and all tokens after it
 		let open_idx = -1;
 		for (let i = this.#tokens.length - 1; i >= 0; i--) {
@@ -1639,6 +1746,32 @@ export class MdzLexer {
 
 	#tokenize_tag(): void {
 		const start = this.#index;
+		// short-circuit a re-attempt of a tag open that already failed at this
+		// offset+bound — re-descending into the same failing children is
+		// exponential on nested same-name tags. Keyed by
+		// `#max_search_index` (captured as `bound`) because the closer search is
+		// bound-sensitive, so a wider-bound re-lex can legitimately succeed. The
+		// key string is built only when the memo is non-empty (adversarial
+		// input); prose never allocates it. The short-circuit reproduces a
+		// revert's exact net effect (`<` text, cursor at start + 1).
+		const bound = this.#max_search_index;
+		if (
+			this.#depth_capped.has(start) ||
+			(this.#failed_tag.size !== 0 && this.#failed_tag.has(`${start}:${bound}`))
+		) {
+			this.#index = start + 1;
+			this.#emit_text('<', start);
+			return;
+		}
+		// nesting-depth cap: too deep to open a tag — render literal and record
+		// the suppression (position-keyed) so a shallower re-lex short-circuits
+		// here too, keeping the revert re-scan linear
+		if (this.#inline_depth >= MAX_INLINE_NESTING_DEPTH) {
+			this.#depth_capped.add(start);
+			this.#index = start + 1;
+			this.#emit_text('<', start);
+			return;
+		}
 		this.#index++; // consume <
 
 		// Tag name must start with a letter
@@ -1678,13 +1811,14 @@ export class MdzLexer {
 				name: tag_name,
 				is_component,
 				start,
-				end: this.#index,
+				end: this.#index
 			});
 			return;
 		}
 
 		// Check for >
 		if (this.#index >= this.#text.length || this.#text.charCodeAt(this.#index) !== RIGHT_ANGLE) {
+			this.#failed_tag.add(`${start}:${bound}`);
 			this.#index = start + 1;
 			this.#emit_text('<', start);
 			return;
@@ -1703,11 +1837,13 @@ export class MdzLexer {
 		const search_limit = Math.min(this.#max_search_index, this.#text.length);
 		const closing_tag_pos = this.#index_of(closing_tag, this.#index);
 		if (closing_tag_pos === -1 || closing_tag_pos > search_limit) {
+			this.#failed_tag.add(`${start}:${bound}`);
 			this.#index = start + 1;
 			this.#emit_text('<', start);
 			return;
 		}
 		if (this.#has_paragraph_break_between(this.#index, closing_tag_pos)) {
+			this.#failed_tag.add(`${start}:${bound}`);
 			this.#index = start + 1;
 			this.#emit_text('<', start);
 			return;
@@ -1715,7 +1851,7 @@ export class MdzLexer {
 
 		// Emit tag_open
 		const open_token_index = this.#tokens.length;
-		this.#tokens.push({type: 'tag_open', name: tag_name, is_component, start, end: this.#index});
+		this.#tokens.push({ type: 'tag_open', name: tag_name, is_component, start, end: this.#index });
 
 		// Tokenize children until the closing tag. Each iteration narrows
 		// `#max_search_index` to the next closer so a child's delimiter scan
@@ -1723,8 +1859,10 @@ export class MdzLexer {
 		// the code span). Recomputed per iteration because a nested same-name
 		// tag legitimately consumes the nearest closer (`<b>x<b>y</b></b>`).
 		const saved_max = this.#max_search_index;
+		this.#inline_depth++;
 		while (this.#index < this.#text.length) {
 			if (this.#match(closing_tag)) {
+				this.#inline_depth--;
 				this.#max_search_index = saved_max;
 				const close_start = this.#index;
 				this.#index += closing_tag.length;
@@ -1732,7 +1870,7 @@ export class MdzLexer {
 					type: 'tag_close',
 					name: tag_name,
 					start: close_start,
-					end: this.#index,
+					end: this.#index
 				});
 				return;
 			}
@@ -1747,12 +1885,14 @@ export class MdzLexer {
 			this.#max_search_index = next_close;
 			this.#tokenize_inline();
 		}
+		this.#inline_depth--;
 
 		// No valid closer left — revert: drop the open token and all consumed
 		// children tokens, emit `<` as text, and re-lex from the next char
 		// (the `#revert_tokens_from_link_open` pattern; the old fallthrough
 		// left a dangling `tag_open` whose parser fallback discarded content)
 		this.#max_search_index = saved_max;
+		this.#failed_tag.add(`${start}:${bound}`);
 		this.#tokens.splice(open_token_index);
 		this.#index = start + 1;
 		this.#emit_text('<', start);
@@ -1780,16 +1920,33 @@ export class MdzLexer {
 		let parts: Array<string> | null = null;
 		let part_start = start;
 
-		while (this.#index < this.#text.length) {
+		// in a table cell the trimmed cell end is a hard stop (no newline to
+		// halt on mid-line) — hoisted to the loop bound
+		const scan_end = this.#in_table_cell
+			? Math.min(this.#max_search_index, this.#text.length)
+			: this.#text.length;
+
+		while (this.#index < scan_end) {
 			const char_code = this.#text.charCodeAt(this.#index);
+			// one table load classifies the char; zero (the common case — the
+			// char can't end or interrupt the run) skips the dispatch below.
+			// `TEXT_SCAN_CLASS` is shared with the streaming scanner
+			// (`consume_text_run` in `mdz_stream_parser_text.ts`); the two dispatch
+			// bodies intentionally differ around it — this one handles `\|` escapes
+			// and list-run strip, that one URL speculation across chunk boundaries.
+			const char_class = char_code < 128 ? TEXT_SCAN_CLASS[char_code]! : 0;
+			if (char_class === 0) {
+				this.#index++;
+				continue;
+			}
+
+			// Stop at special characters
+			if ((char_class & TEXT_CLASS_STOP) !== 0) break;
 
-			// in a table cell: the trimmed cell end is a hard stop (no newline to
-			// halt on mid-line), and `\|` is a literal pipe (the only mdz escape,
-			// scoped here)
-			if (this.#in_table_cell) {
-				if (this.#index >= this.#max_search_index) break;
+			if ((char_class & TEXT_CLASS_BACKSLASH) !== 0) {
+				// `\|` is a literal pipe — the only mdz escape, scoped to table cells
 				if (
-					char_code === BACKSLASH &&
+					this.#in_table_cell &&
 					this.#index + 1 < this.#max_search_index &&
 					this.#text.charCodeAt(this.#index + 1) === PIPE
 				) {
@@ -1799,22 +1956,11 @@ export class MdzLexer {
 					part_start = this.#index;
 					continue;
 				}
+				this.#index++;
+				continue;
 			}
 
-			// Stop at special characters
-			if (
-				char_code === BACKTICK ||
-				char_code === ASTERISK ||
-				char_code === UNDERSCORE ||
-				char_code === TILDE ||
-				char_code === LEFT_BRACKET ||
-				char_code === RIGHT_BRACKET ||
-				char_code === LEFT_ANGLE
-			) {
-				break;
-			}
-
-			if (char_code === NEWLINE) {
+			if ((char_class & TEXT_CLASS_NEWLINE) !== 0) {
 				if (this.#list_run_strip) {
 					if (this.#index >= this.#max_search_index) break; // the run's terminator
 					// soft break: keep the newline, strip the next line's leading
@@ -1853,20 +1999,24 @@ export class MdzLexer {
 						break;
 					}
 				}
+				this.#index++; // single newline — ordinary text
+				continue;
 			}
 
-			// Check for URL or internal path mid-text (char code guard avoids startsWith on every char)
-			if (
-				((char_code === 104 /* h */ || char_code === 72) /* H */ && this.#is_at_url()) ||
-				(char_code === SLASH && is_at_absolute_path(this.#text, this.#index)) ||
-				(char_code === PERIOD && is_at_relative_path(this.#text, this.#index))
-			) {
+			// URL or internal path mid-text (class guard avoids probing every char)
+			if ((char_class & TEXT_CLASS_URL) !== 0) {
+				if (this.#is_at_url()) break;
+			} else if (char_code === SLASH) {
+				if (is_at_absolute_path(this.#text, this.#index)) break;
+			} else if (is_at_relative_path(this.#text, this.#index)) {
 				break;
 			}
 
 			this.#index++;
 		}
 
+		if (mdz_debug_work.enabled) mdz_debug_work.total += this.#index - start;
+
 		// Ensure we always consume at least one character
 		if (this.#index === start && this.#index < this.#text.length) {
 			this.#index++;
@@ -1876,7 +2026,7 @@ export class MdzLexer {
 			parts === null
 				? this.#text.slice(start, this.#index)
 				: parts.join('') + this.#text.slice(part_start, this.#index);
-		this.#tokens.push({type: 'text', content, start, end: this.#index});
+		this.#tokens.push({ type: 'text', content, start, end: this.#index });
 	}
 
 	// -- Auto-link tokenizers --
@@ -1905,7 +2055,7 @@ export class MdzLexer {
 			reference,
 			link_type: 'external',
 			start,
-			end: this.#index,
+			end: this.#index
 		});
 	}
 
@@ -1930,14 +2080,14 @@ export class MdzLexer {
 			reference,
 			link_type: 'internal',
 			start,
-			end: this.#index,
+			end: this.#index
 		});
 	}
 
 	// -- Helper methods --
 
 	#emit_text(content: string, start: number): void {
-		this.#tokens.push({type: 'text', content, start, end: start + content.length});
+		this.#tokens.push({ type: 'text', content, start, end: start + content.length });
 	}
 
 	#has_paragraph_break_between(from: number, to: number): boolean {
@@ -1976,7 +2126,7 @@ export class MdzLexer {
 			i = this.#text.indexOf('\n', j);
 		}
 		if (memo === null) {
-			this.#break_memo = {from, result};
+			this.#break_memo = { from, result };
 		} else {
 			memo.from = from;
 			memo.result = result;