@fuzdev/mdz 0.2.0 → 0.4.0

package/src/lib/mdz_stream_parser_state.ts

@@ -8,8 +8,10 @@
  * @module
  */
 
-import type {MdzNodeTypeContainer, MdzNodeId, MdzOpcode} from './mdz_opcodes.ts';
-import {NEWLINE, has_non_whitespace, mdz_heading_id_from_text} from './mdz_helpers.ts';
+import type { MdzNodeTypeContainer, MdzNodeId, MdzOpcode } from './mdz_opcodes.ts';
+import type { MdzTableCellParser } from './mdz.ts';
+import { NEWLINE, has_non_whitespace, mdz_heading_id_from_text } from './mdz_helpers.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 /**
  * Tri-state result for `try_*` parser handlers.
@@ -112,7 +114,7 @@ export interface MdzBlockquoteState {
 	 * offsets — one per quote line; the line's content and terminating
 	 * newline are contiguous in both coordinate spaces.
 	 */
-	segments: Array<{inner_start: number; source_start: number}>;
+	segments: Array<{ inner_start: number; source_start: number }>;
 	/** Total bytes fed to the inner document so far. */
 	inner_len: number;
 	/**
@@ -214,8 +216,9 @@ export interface MdzStreamParserState {
 	 * is `null` for a top-level table (column-0 rows) or the enclosing list item's
 	 * marker indent for a table nested as a block child (rows skip the indent and
 	 * a dedent to that indent ends the table, returning control to the list).
+	 * `cell_parser` is the table's shared cell parser, rebound per row.
 	 */
-	table: {id: MdzNodeId; item_indent: number | null} | null;
+	table: { id: MdzNodeId; item_indent: number | null; cell_parser: MdzTableCellParser } | null;
 	/**
 	 * Whether the innermost open ListItem's first inline run is current.
 	 * Content then flows directly into the ListItem frame — the sync AST
@@ -243,6 +246,32 @@ export interface MdzStreamParserState {
 	search_memo: Map<string, BufferSearchMemo> | null;
 	/** Open-container counts for `find_open`'s O(1) "nothing open" early exit. */
 	open_counts: OpenInlineCounts;
+	/**
+	 * Count of open `Link`/`Element`/`Component` frames in the current run — the
+	 * streaming analogue of the sync lexer's `#inline_depth`. Kept as an O(1)
+	 * counter (not a stack walk, which would reintroduce the deep-stack
+	 * quadratic `open_counts` exists to avoid) so `try_link_open`/`try_tag_open`
+	 * can cap nesting at `MAX_INLINE_NESTING_DEPTH` — rendering a deeper `[`/`<`
+	 * literal, matching the sync cap on pure/symmetric nesting. It counts
+	 * **optimistic** opens, though, so it diverges from the sync `#inline_depth`
+	 * (which the sync tag path only bumps after a closer precheck) on an
+	 * asymmetric cap-saturating prefix — 100+ *unclosed* `<a>` before a valid
+	 * `[x](/u)` saturates this counter and suppresses the trailing link that sync
+	 * still forms. Adversarial-only, documented not fixed (streaming can't
+	 * precheck closers): see the flip-at-cap case in `mdz_nesting_cap.test.ts`.
+	 * Run-scoped for free like `open_counts`: a
+	 * run close reverts every inline frame above it, decrementing back to zero.
+	 */
+	open_link_tag_depth: number;
+	/**
+	 * Per-name counts of open Element/Component frames, the tag analogue of
+	 * `open_counts`: `try_close_tag` bails in O(1) when the closing name isn't
+	 * open, instead of walking a stack that grows one frame per leaked unclosed
+	 * `<Tag>`. Lazily created on the first tag open — tag-free inputs never
+	 * allocate the map. Run-scoped like `open_counts`: run closes revert every
+	 * inline frame above them, decrementing the counts back to zero.
+	 */
+	open_tag_counts: Map<string, number> | null;
 	/** Whether we're inside a heading (newline ends it). */
 	in_heading: boolean;
 	/** Whether we're inside an optimistic inline Code container. */
@@ -314,7 +343,9 @@ export const create_state = (): MdzStreamParserState => ({
 	last_empty_item_end: 0,
 	base_offset: 0,
 	search_memo: null,
-	open_counts: {Bold: 0, Italic: 0, Strikethrough: 0, Link: 0},
+	open_counts: { Bold: 0, Italic: 0, Strikethrough: 0, Link: 0 },
+	open_link_tag_depth: 0,
+	open_tag_counts: null,
 	in_heading: false,
 	in_code: false,
 	in_paragraph: false,
@@ -326,7 +357,7 @@ export const create_state = (): MdzStreamParserState => ({
 	paragraph_stack_idx: -1,
 	last_text_id: null,
 	last_text_ended_with_newline: false,
-	last_text_was_singleton_newline: false,
+	last_text_was_singleton_newline: false
 });
 
 /** @nodocs */
@@ -346,7 +377,7 @@ export const push_stack_entry = (
 	node_type: MdzNodeTypeContainer,
 	start: number,
 	delimiter: string = '',
-	tag_name?: string,
+	tag_name?: string
 ): void => {
 	state.stack.push({
 		id,
@@ -355,13 +386,20 @@ export const push_stack_entry = (
 		tag_name,
 		has_children: false,
 		has_non_whitespace_content: false,
-		start,
+		start
 	});
 	if (node_type === 'Paragraph') {
 		state.paragraph_stack_idx = state.stack.length - 1;
 	} else {
 		bump_open_count(state, node_type, 1);
 	}
+	if (tag_name !== undefined) {
+		const counts = (state.open_tag_counts ??= new Map());
+		counts.set(tag_name, (counts.get(tag_name) ?? 0) + 1);
+	}
+	// Link/Element/Component contribute to the nesting-depth cap (tag_name is
+	// set for Element/Component only, so `Link || tag_name` is exactly the three)
+	if (node_type === 'Link' || tag_name !== undefined) state.open_link_tag_depth++;
 };
 
 /**
@@ -374,7 +412,7 @@ export const push_stack_entry = (
 const bump_open_count = (
 	state: MdzStreamParserState,
 	node_type: MdzNodeTypeContainer,
-	delta: number,
+	delta: number
 ): void => {
 	const counts = state.open_counts;
 	if (node_type === 'Bold') counts.Bold += delta;
@@ -394,6 +432,16 @@ const bump_open_count = (
 export const pop_stack_entry = (state: MdzStreamParserState): StackEntry => {
 	const entry = state.stack.pop()!;
 	bump_open_count(state, entry.node_type, -1);
+	if (entry.tag_name !== undefined) {
+		const counts = state.open_tag_counts!;
+		// drop zero-count keys so a long stream of many distinct tag names can't
+		// grow the map unboundedly — the `!counts.get(name)` bail in `try_close_tag`
+		// treats a missing key and a 0 count identically, so this is behavior-neutral
+		const remaining = counts.get(entry.tag_name)! - 1;
+		if (remaining === 0) counts.delete(entry.tag_name);
+		else counts.set(entry.tag_name, remaining);
+	}
+	if (entry.node_type === 'Link' || entry.tag_name !== undefined) state.open_link_tag_depth--;
 	return entry;
 };
 
@@ -454,7 +502,7 @@ const memo_index_of = (
 	state: MdzStreamParserState,
 	memo: BufferSearchMemo,
 	needle: string,
-	from: number,
+	from: number
 ): number => {
 	const global_from = state.base_offset + from;
 	const global_end = state.base_offset + state.buffer.length;
@@ -465,7 +513,11 @@ const memo_index_of = (
 			// rescan only the appended tail, overlapping the old boundary so a
 			// straddling needle isn't missed
 			const rescan_from = Math.max(global_from, memo.searched_to - (needle.length - 1));
-			const result = state.buffer.indexOf(needle, rescan_from - state.base_offset);
+			const local_from = rescan_from - state.base_offset;
+			const result = state.buffer.indexOf(needle, local_from);
+			if (mdz_debug_work.enabled) {
+				mdz_debug_work.total += (result === -1 ? state.buffer.length : result) - local_from;
+			}
 			memo.from = global_from;
 			memo.result = result === -1 ? -1 : state.base_offset + result;
 			memo.searched_to = global_end;
@@ -474,6 +526,9 @@ const memo_index_of = (
 		// found result already behind `from` — fall through to a fresh scan
 	}
 	const result = state.buffer.indexOf(needle, from);
+	if (mdz_debug_work.enabled) {
+		mdz_debug_work.total += (result === -1 ? state.buffer.length : result) - from;
+	}
 	memo.from = global_from;
 	memo.result = result === -1 ? -1 : state.base_offset + result;
 	memo.searched_to = global_end;
@@ -493,13 +548,13 @@ const memo_index_of = (
 export const buffer_index_of = (
 	state: MdzStreamParserState,
 	needle: string,
-	from: number,
+	from: number
 ): number => {
 	const map = (state.search_memo ??= new Map());
 	let memo = map.get(needle);
 	if (memo === undefined) {
 		// "scanned [0, 0), found nothing" — memo_index_of handles the full scan
-		memo = {from: 0, result: -1, searched_to: 0};
+		memo = { from: 0, result: -1, searched_to: 0 };
 		map.set(needle, memo);
 	}
 	return memo_index_of(state, memo, needle, from);
@@ -519,8 +574,13 @@ export const emit = (state: MdzStreamParserState, op: MdzOpcode): void => {
 		if (top) {
 			top.has_children = true;
 			// propagate non-whitespace marker to the nearest Paragraph so
-			// whitespace-only paragraphs can be discarded at close
-			if (op.type === 'void' || has_non_whitespace(op.content)) {
+			// whitespace-only paragraphs can be discarded at close — the O(1)
+			// no-paragraph check runs first so codeblock/table-cell emissions
+			// (never inside a Paragraph) skip the content scan entirely
+			if (
+				op.type === 'void' ||
+				(state.paragraph_stack_idx !== -1 && has_non_whitespace(op.content))
+			) {
 				mark_paragraph_non_whitespace(state);
 			}
 		}
@@ -582,7 +642,7 @@ export const emit = (state: MdzStreamParserState, op: MdzOpcode): void => {
 export const accumulate_text = (
 	state: MdzStreamParserState,
 	text: string,
-	start_offset: number,
+	start_offset: number
 ): void => {
 	if (state.accumulated_text.length === 0) {
 		state.accumulated_text_start = start_offset;
@@ -618,7 +678,7 @@ export const flush_text = (state: MdzStreamParserState): void => {
 			type: 'append_text',
 			id: state.active_text_id,
 			content: state.accumulated_text,
-			end: state.accumulated_text_end,
+			end: state.accumulated_text_end
 		});
 	} else {
 		ensure_paragraph(state);
@@ -630,7 +690,7 @@ export const flush_text = (state: MdzStreamParserState): void => {
 			content: state.accumulated_text,
 			text_type: 'Text',
 			start,
-			end: state.accumulated_text_end,
+			end: state.accumulated_text_end
 		});
 		state.active_text_id = id;
 	}
@@ -649,7 +709,7 @@ export const ensure_paragraph = (state: MdzStreamParserState): void => {
 	if (state.in_heading || state.in_paragraph || state.in_list_item_run) return;
 	const id = alloc_id(state);
 	const start = offset(state);
-	emit(state, {type: 'open', id, node_type: 'Paragraph', start});
+	emit(state, { type: 'open', id, node_type: 'Paragraph', start });
 	push_stack_entry(state, id, 'Paragraph', start);
 	state.in_paragraph = true;
 };
@@ -709,7 +769,7 @@ export const revert_above = (state: MdzStreamParserState, target_idx: number): v
 			type: 'revert',
 			id: entry.id,
 			replacement_text: entry.delimiter,
-			start: entry.start,
+			start: entry.start
 		});
 	}
 	state.active_text_id = null;
@@ -744,11 +804,23 @@ export const revert_failed_close = (state: MdzStreamParserState, stack_idx: numb
 	const frames_above = state.stack.length - 1 - stack_idx;
 	state.stack.splice(stack_idx, 1);
 	bump_open_count(state, entry.node_type, -1);
+	if (entry.tag_name !== undefined) {
+		const counts = state.open_tag_counts!;
+		// drop zero-count keys so a long stream of many distinct tag names can't
+		// grow the map unboundedly — the `!counts.get(name)` bail in `try_close_tag`
+		// treats a missing key and a 0 count identically, so this is behavior-neutral
+		const remaining = counts.get(entry.tag_name)! - 1;
+		if (remaining === 0) counts.delete(entry.tag_name);
+		else counts.set(entry.tag_name, remaining);
+	}
+	// only ever reverts an Italic today, but keep the depth counter honest if a
+	// Link/Element/Component is ever failed-closed mid-stack
+	if (entry.node_type === 'Link' || entry.tag_name !== undefined) state.open_link_tag_depth--;
 	state.opcodes.push({
 		type: 'revert',
 		id: entry.id,
 		replacement_text: entry.delimiter,
-		start: entry.start,
+		start: entry.start
 	});
 	// structural opcode seals the prior text run (mirrors `emit`)
 	seal_text_run(state);
@@ -780,7 +852,7 @@ export const trim_trailing_newline = (state: MdzStreamParserState): void => {
 	}
 	if (state.last_text_id === null || !state.last_text_ended_with_newline) return;
 	// emit trim opcode; consumer adjusts content and removes empty nodes
-	emit(state, {type: 'trim_text', id: state.last_text_id, count: 1});
+	emit(state, { type: 'trim_text', id: state.last_text_id, count: 1 });
 	// if this trim empties a singleton text node, clear active_text_id so
 	// subsequent content doesn't merge into a deleted node via append_text
 	if (state.last_text_was_singleton_newline) {
@@ -807,8 +879,8 @@ export const close_paragraph = (state: MdzStreamParserState): void => {
 			emit(
 				state,
 				discard
-					? {type: 'close', id: entry.id, end: offset(state), discard: true}
-					: {type: 'close', id: entry.id, end: offset(state)},
+					? { type: 'close', id: entry.id, end: offset(state), discard: true }
+					: { type: 'close', id: entry.id, end: offset(state) }
 			);
 			state.active_text_id = null;
 			state.in_paragraph = false;
@@ -841,7 +913,7 @@ export const close_heading = (state: MdzStreamParserState): void => {
 	const heading_id = mdz_heading_id_from_text(heading_text);
 	// the heading is now the top of the stack
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state), heading_id});
+	emit(state, { type: 'close', id: entry.id, end: offset(state), heading_id });
 	state.active_text_id = null;
 };
 
@@ -861,7 +933,7 @@ export const close_codeblock_at_eof = (state: MdzStreamParserState): void => {
 	if (state.codeblock.fence_indent === 0) {
 		trim_trailing_newline(state);
 	}
-	emit(state, {type: 'close', id: state.codeblock.id, end: offset(state)});
+	emit(state, { type: 'close', id: state.codeblock.id, end: offset(state) });
 	state.codeblock = null;
 };
 
@@ -915,7 +987,7 @@ export const close_list_item = (state: MdzStreamParserState): void => {
 	emit(state, {
 		type: 'close',
 		id: entry.id,
-		end: entry.has_children ? offset(state) : state.last_empty_item_end,
+		end: entry.has_children ? offset(state) : state.last_empty_item_end
 	});
 	state.active_text_id = null;
 };
@@ -928,7 +1000,7 @@ export const close_list_item = (state: MdzStreamParserState): void => {
 export const close_list_level = (state: MdzStreamParserState): void => {
 	close_list_item(state);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state)});
+	emit(state, { type: 'close', id: entry.id, end: offset(state) });
 	state.list_levels.pop();
 };
 

package/src/lib/mdz_stream_parser_table.ts

@@ -7,22 +7,23 @@
  * whole header emits at once. Body rows then stream one per line. Because a row
  * is always fully buffered before it emits (no within-row streaming), each
  * cell's inline content is parsed with the sync reference (`MdzTableCellParser`,
- * one `MdzLexer`/`MdzTokenParser` shared across the row's cells) and replayed
- * as opcodes — guaranteeing sync↔stream parity by construction.
+ * one `MdzLexer`/`MdzTokenParser` shared across the whole table's cells,
+ * rebound per row) and replayed as opcodes — guaranteeing sync↔stream parity
+ * by construction.
  *
  * @module
  */
 
-import {DEV} from 'esm-env';
+import { DEV } from 'esm-env';
 
 import {
 	NEWLINE,
 	PIPE,
 	is_line_whitespace,
 	mdz_split_table_row,
-	mdz_parse_table_delimiter,
+	mdz_parse_table_delimiter
 } from './mdz_helpers.ts';
-import {MdzTableCellParser, type MdzNode, type MdzTableAlign} from './mdz.ts';
+import { MdzTableCellParser, type MdzNode, type MdzTableAlign } from './mdz.ts';
 import {
 	type MdzStreamParserState,
 	type TryResult,
@@ -32,7 +33,7 @@ import {
 	flush_text,
 	offset,
 	pop_stack_entry,
-	push_stack_entry,
+	push_stack_entry
 } from './mdz_stream_parser_state.ts';
 
 /**
@@ -70,9 +71,13 @@ export const try_table_start = (state: MdzStreamParserState, forced: boolean): T
 
 	const table_id = alloc_id(state);
 	const table_start = offset(state, start);
-	emit(state, {type: 'open', id: table_id, node_type: 'Table', start: table_start, align});
+	emit(state, { type: 'open', id: table_id, node_type: 'Table', start: table_start, align });
 	push_stack_entry(state, table_id, 'Table', table_start);
-	state.table = {id: table_id, item_indent: null};
+	state.table = {
+		id: table_id,
+		item_indent: null,
+		cell_parser: new MdzTableCellParser(state.buffer)
+	};
 
 	emit_table_row(state, header_cells, true, start, header_end);
 
@@ -147,7 +152,7 @@ export const process_table_line = (state: MdzStreamParserState, forced: boolean)
 const process_table_line_in_item = (
 	state: MdzStreamParserState,
 	forced: boolean,
-	item_indent: number,
+	item_indent: number
 ): boolean => {
 	if (state.pos >= state.buffer.length) {
 		if (forced) {
@@ -199,9 +204,9 @@ const process_table_line_in_item = (
  */
 export const close_table = (state: MdzStreamParserState): void => {
 	if (!state.table) return;
-	const {item_indent} = state.table;
+	const { item_indent } = state.table;
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state)});
+	emit(state, { type: 'close', id: entry.id, end: offset(state) });
 	state.table = null;
 	state.active_text_id = null;
 	if (item_indent === null) {
@@ -215,7 +220,7 @@ export const close_table = (state: MdzStreamParserState): void => {
 
 /** A recognized in-item table head: the header row's cells + the delimiter alignment. */
 export interface TableInItemHead {
-	header_cells: Array<{start: number; end: number}>;
+	header_cells: Array<{ start: number; end: number }>;
 	header_end: number;
 	align: Array<MdzTableAlign>;
 	delim_end: number;
@@ -234,9 +239,9 @@ export const match_table_in_item_head = (
 	state: MdzStreamParserState,
 	header_first: number,
 	marker_indent: number,
-	forced: boolean,
+	forced: boolean
 ): TableInItemHead | 'pending' | null => {
-	const {buffer} = state;
+	const { buffer } = state;
 	const header_end = buffer.indexOf('\n', header_first);
 	if (header_end === -1) return forced ? null : 'pending'; // header needs its newline + a delimiter beneath
 	const header_cells = mdz_split_table_row(buffer, header_first, header_end);
@@ -253,7 +258,7 @@ export const match_table_in_item_head = (
 	}
 	const align = mdz_parse_table_delimiter(buffer, 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 };
 };
 
 /**
@@ -268,7 +273,7 @@ export const open_table_in_item = (
 	state: MdzStreamParserState,
 	header_first: number,
 	marker_indent: number,
-	head: TableInItemHead,
+	head: TableInItemHead
 ): void => {
 	const table_id = alloc_id(state);
 	const table_start = offset(state, header_first);
@@ -277,10 +282,14 @@ export const open_table_in_item = (
 		id: table_id,
 		node_type: 'Table',
 		start: table_start,
-		align: head.align,
+		align: head.align
 	});
 	push_stack_entry(state, table_id, 'Table', table_start);
-	state.table = {id: table_id, item_indent: marker_indent};
+	state.table = {
+		id: table_id,
+		item_indent: marker_indent,
+		cell_parser: new MdzTableCellParser(state.buffer)
+	};
 	emit_table_row(state, head.header_cells, true, header_first, head.header_end);
 	// leave the cursor on the delimiter's newline (or EOF) — the in-item body-row
 	// handler reads from the line after it and hands back on this same convention
@@ -292,23 +301,25 @@ export const open_table_in_item = (
 /** Emit one table row: open, each cell, close. */
 const emit_table_row = (
 	state: MdzStreamParserState,
-	cells: Array<{start: number; end: number}>,
+	cells: Array<{ start: number; end: number }>,
 	header: boolean,
 	row_start: number,
-	row_end: number,
+	row_end: number
 ): void => {
 	const row_id = alloc_id(state);
 	const row_off = offset(state, row_start);
-	emit(state, {type: 'open', id: row_id, node_type: 'TableRow', start: row_off, header});
+	emit(state, { type: 'open', id: row_id, node_type: 'TableRow', start: row_off, header });
 	push_stack_entry(state, row_id, 'TableRow', row_off);
-	// one lexer/parser shared across the row's cells (all index into the same
-	// buffer) rather than allocated per cell
-	const cell_parser = new MdzTableCellParser(state.buffer);
+	// one lexer/parser shared across the whole table rather than allocated per
+	// row (or per cell) — rebound per row because the buffer string changes
+	// across feeds; the lexer's search memo survives when it doesn't
+	const cell_parser = state.table!.cell_parser;
+	cell_parser.rebind(state.buffer);
 	for (const cell of cells) {
 		emit_table_cell(state, cell_parser, cell.start, cell.end);
 	}
 	pop_stack_entry(state);
-	emit(state, {type: 'close', id: row_id, end: offset(state, row_end)});
+	emit(state, { type: 'close', id: row_id, end: offset(state, row_end) });
 	state.active_text_id = null;
 };
 
@@ -320,15 +331,15 @@ const emit_table_cell = (
 	state: MdzStreamParserState,
 	cell_parser: MdzTableCellParser,
 	cell_start: number,
-	cell_end: number,
+	cell_end: number
 ): void => {
 	const cell_id = alloc_id(state);
 	const cell_off = offset(state, cell_start);
-	emit(state, {type: 'open', id: cell_id, node_type: 'TableCell', start: cell_off});
+	emit(state, { type: 'open', id: cell_id, node_type: 'TableCell', start: cell_off });
 	push_stack_entry(state, cell_id, 'TableCell', cell_off);
 	emit_inline_nodes(state, cell_parser.parse(cell_start, cell_end));
 	pop_stack_entry(state);
-	emit(state, {type: 'close', id: cell_id, end: offset(state, cell_end)});
+	emit(state, { type: 'close', id: cell_id, end: offset(state, cell_end) });
 	state.active_text_id = null;
 };
 
@@ -346,7 +357,7 @@ const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>):
 					content: node.content,
 					text_type: 'Text',
 					start: offset(state, node.start),
-					end: offset(state, node.end),
+					end: offset(state, node.end)
 				});
 				break;
 			case 'Code':
@@ -356,7 +367,7 @@ const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>):
 					content: node.content,
 					text_type: 'Code',
 					start: offset(state, node.start),
-					end: offset(state, node.end),
+					end: offset(state, node.end)
 				});
 				break;
 			case 'Bold':
@@ -364,17 +375,17 @@ const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>):
 			case 'Strikethrough': {
 				const id = alloc_id(state);
 				const s = offset(state, node.start);
-				emit(state, {type: 'open', id, node_type: node.type, start: s});
+				emit(state, { type: 'open', id, node_type: node.type, start: s });
 				push_stack_entry(state, id, node.type, s);
 				emit_inline_nodes(state, node.children);
 				pop_stack_entry(state);
-				emit(state, {type: 'close', id, end: offset(state, node.end)});
+				emit(state, { type: 'close', id, end: offset(state, node.end) });
 				break;
 			}
 			case 'Link': {
 				const id = alloc_id(state);
 				const s = offset(state, node.start);
-				emit(state, {type: 'open', id, node_type: 'Link', start: s});
+				emit(state, { type: 'open', id, node_type: 'Link', start: s });
 				push_stack_entry(state, id, 'Link', s);
 				emit_inline_nodes(state, node.children);
 				pop_stack_entry(state);
@@ -383,7 +394,7 @@ const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>):
 					id,
 					end: offset(state, node.end),
 					reference: node.reference,
-					link_type: node.link_type,
+					link_type: node.link_type
 				});
 				break;
 			}
@@ -391,11 +402,11 @@ const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>):
 			case 'Component': {
 				const id = alloc_id(state);
 				const s = offset(state, node.start);
-				emit(state, {type: 'open', id, node_type: node.type, start: s, name: node.name});
+				emit(state, { type: 'open', id, node_type: node.type, start: s, name: node.name });
 				push_stack_entry(state, id, node.type, s, '', node.name);
 				emit_inline_nodes(state, node.children);
 				pop_stack_entry(state);
-				emit(state, {type: 'close', id, end: offset(state, node.end)});
+				emit(state, { type: 'close', id, end: offset(state, node.end) });
 				break;
 			}
 			// cells are inline-only (lexed via `lex_table_cell`); a block node here

package/src/lib/mdz_stream_parser_text.ts

@@ -5,30 +5,25 @@
  */
 
 import {
-	ASTERISK,
-	BACKTICK,
 	HTTPS_PREFIX_LENGTH,
-	H_LOWER,
-	H_UPPER,
-	LEFT_ANGLE,
-	LEFT_BRACKET,
 	NEWLINE,
-	PERIOD,
-	RIGHT_BRACKET,
-	SLASH,
 	SPACE,
 	TAB,
-	TILDE,
-	UNDERSCORE,
+	TEXT_CLASS_NEWLINE,
+	TEXT_CLASS_PATH,
+	TEXT_CLASS_STOP,
+	TEXT_CLASS_URL,
+	TEXT_SCAN_CLASS,
 	is_word_char,
-	match_url_prefix_case_insensitive,
+	match_url_prefix_case_insensitive
 } from './mdz_helpers.ts';
 import {
 	type MdzStreamParserState,
 	accumulate_text,
 	ensure_paragraph,
-	offset,
+	offset
 } from './mdz_stream_parser_state.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 /**
  * Consume a delimiter at the current position as literal text — the shared
@@ -60,35 +55,41 @@ export const consume_text_run = (state: MdzStreamParserState): void => {
 	state.pos++;
 	while (state.pos < state.buffer.length) {
 		const c = state.buffer.charCodeAt(state.pos);
-		if (
-			c === BACKTICK ||
-			c === ASTERISK ||
-			c === UNDERSCORE ||
-			c === TILDE ||
-			c === LEFT_BRACKET ||
-			c === RIGHT_BRACKET ||
-			c === LEFT_ANGLE ||
-			c === NEWLINE ||
-			// URL/path: only break when actually at a URL or path start.
-			// Most h/H/./slash in prose are not URLs/paths — continuing the scan
-			// avoids the full dispatch cycle through process_loop → process_inline.
-			// For `h`/`H` at a word boundary, also break when there isn't enough
-			// buffer left to confirm `https://` / `http://` — process_inline's
-			// speculator then carries the prefix match across chunk boundaries.
-			// Scheme matching is case-insensitive (RFC 3986).
-			((c === H_LOWER || c === H_UPPER) &&
-				(match_url_prefix_case_insensitive(state.buffer, state.pos) > 0 ||
-					(state.buffer.length - state.pos < HTTPS_PREFIX_LENGTH &&
-						!is_word_char(state.buffer.charCodeAt(state.pos - 1))))) ||
-			((c === SLASH || c === PERIOD) &&
-				(state.buffer.charCodeAt(state.pos - 1) === SPACE ||
-					state.buffer.charCodeAt(state.pos - 1) === NEWLINE ||
-					state.buffer.charCodeAt(state.pos - 1) === TAB))
-		) {
-			break;
+		// one table load classifies the char; zero (the common case) continues
+		// the run without any further checks. `TEXT_SCAN_CLASS` is shared with
+		// the sync lexer's `#tokenize_text` (`mdz_lexer.ts`); the dispatch bodies
+		// intentionally differ — that one handles `\|` escapes and list-run
+		// strip, this one URL speculation across chunk boundaries.
+		const char_class = c < 128 ? TEXT_SCAN_CLASS[c]! : 0;
+		if (char_class === 0) {
+			state.pos++;
+			continue;
 		}
+		if ((char_class & (TEXT_CLASS_STOP | TEXT_CLASS_NEWLINE)) !== 0) break;
+		if ((char_class & TEXT_CLASS_URL) !== 0) {
+			// URL: only break when actually at a URL start. Most h/H in prose are
+			// not URLs — continuing the scan avoids the full dispatch cycle
+			// through process_loop → process_inline. At a word boundary, also
+			// break when there isn't enough buffer left to confirm `https://` /
+			// `http://` — process_inline's speculator then carries the prefix
+			// match across chunk boundaries. Scheme matching is case-insensitive
+			// (RFC 3986).
+			if (
+				match_url_prefix_case_insensitive(state.buffer, state.pos) > 0 ||
+				(state.buffer.length - state.pos < HTTPS_PREFIX_LENGTH &&
+					!is_word_char(state.buffer.charCodeAt(state.pos - 1)))
+			) {
+				break;
+			}
+		} else if ((char_class & TEXT_CLASS_PATH) !== 0) {
+			// path (`/` or `.`): only break at a plausible path start
+			const prev = state.buffer.charCodeAt(state.pos - 1);
+			if (prev === SPACE || prev === NEWLINE || prev === TAB) break;
+		}
+		// backslash (or a non-starting path char) — ordinary text
 		state.pos++;
 	}
+	if (mdz_debug_work.enabled) mdz_debug_work.total += state.pos - start;
 	accumulate_text(state, state.buffer.slice(start, state.pos), offset(state, start));
 	state.prev_char = state.buffer.charCodeAt(state.pos - 1);
 	state.column += state.pos - start;