@fuzdev/mdz 0.1.0 → 0.3.0

package/src/lib/mdz_stream_parser_state.ts

@@ -8,8 +8,10 @@
  * @module
  */
 
-import type {MdzNodeTypeContainer, MdzNodeId, MdzOpcode} from './mdz_opcodes.js';
-import {NEWLINE, has_non_whitespace, mdz_heading_id_from_text} from './mdz_helpers.js';
+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.
@@ -207,6 +209,16 @@ export interface MdzStreamParserState {
 	 * quote (prefix stripping + nested-parser feeding) — see `MdzBlockquoteState`.
 	 */
 	blockquote: MdzBlockquoteState | null;
+	/**
+	 * The open table, or null. While set, each line is consumed as a body row
+	 * (or ends the table) by `process_table_line`. Holds the `Table` frame's id
+	 * so the table can be closed when a non-row line or EOF ends it. `item_indent`
+	 * 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; 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
@@ -234,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. */
@@ -300,11 +338,14 @@ export const create_state = (): MdzStreamParserState => ({
 	codeblock: null,
 	list_levels: [],
 	blockquote: null,
+	table: null,
 	in_list_item_run: false,
 	last_empty_item_end: 0,
 	base_offset: 0,
 	search_memo: null,
 	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,
@@ -352,6 +393,13 @@ export const push_stack_entry = (
 	} 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++;
 };
 
 /**
@@ -384,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;
 };
 
@@ -455,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;
@@ -464,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;
@@ -509,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);
 			}
 		}
@@ -734,6 +804,18 @@ 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,

package/src/lib/mdz_stream_parser_table.ts

@@ -0,0 +1,420 @@
+/**
+ * Table handlers for the streaming mdz parser.
+ *
+ * A table is recognized at a column-0 pipe row whose next line is a valid
+ * delimiter row with a matching column count — a bounded one-line lookahead:
+ * the header row holds (`need_more`) until its delimiter line arrives, then the
+ * 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 whole table's cells,
+ * rebound per row) and replayed as opcodes — guaranteeing sync↔stream parity
+ * by construction.
+ *
+ * @module
+ */
+
+import {DEV} from 'esm-env';
+
+import {
+	NEWLINE,
+	PIPE,
+	is_line_whitespace,
+	mdz_split_table_row,
+	mdz_parse_table_delimiter,
+} from './mdz_helpers.ts';
+import {MdzTableCellParser, type MdzNode, type MdzTableAlign} from './mdz.ts';
+import {
+	type MdzStreamParserState,
+	type TryResult,
+	alloc_id,
+	close_paragraph,
+	emit,
+	flush_text,
+	offset,
+	pop_stack_entry,
+	push_stack_entry,
+} from './mdz_stream_parser_state.ts';
+
+/**
+ * Try to open a table at a column-0 pipe row. Returns `need_more` until both
+ * the header line and its delimiter line are buffered (or, in forced mode,
+ * resolvable), `not_match` when the two lines aren't a valid header+delimiter
+ * pair, and `consumed` once the table opens (closing any open paragraph first,
+ * emitting the header row, and leaving `state.pos` at the first body line).
+ *
+ * @nodocs
+ */
+export const try_table_start = (state: MdzStreamParserState, forced: boolean): TryResult => {
+	const start = state.pos;
+	const header_end = state.buffer.indexOf('\n', start);
+	// a table needs a header line plus a delimiter line — without the header's
+	// newline there's no room for a delimiter (at EOF it can never be a table)
+	if (header_end === -1) return forced ? 'not_match' : 'need_more';
+
+	const header_cells = mdz_split_table_row(state.buffer, start, header_end);
+	if (header_cells === null) return 'not_match';
+
+	const delim_start = header_end + 1;
+	let delim_end = state.buffer.indexOf('\n', delim_start);
+	if (delim_end === -1) {
+		if (!forced) return 'need_more'; // delimiter line not complete yet
+		delim_end = state.buffer.length;
+	}
+
+	const align = mdz_parse_table_delimiter(state.buffer, delim_start, delim_end);
+	if (align === null || align.length !== header_cells.length) return 'not_match';
+
+	// committed — the delimiter row is structural, never emitted
+	flush_text(state);
+	close_paragraph(state);
+
+	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});
+	push_stack_entry(state, table_id, 'Table', table_start);
+	state.table = {
+		id: table_id,
+		item_indent: null,
+		cell_parser: new MdzTableCellParser(state.buffer),
+	};
+
+	emit_table_row(state, header_cells, true, start, header_end);
+
+	// skip past the delimiter row to the first potential body line
+	state.pos = delim_end === state.buffer.length ? delim_end : delim_end + 1;
+	state.column = 0;
+	state.prev_char = NEWLINE;
+	return 'consumed';
+};
+
+/**
+ * Process the line at `state.pos` while a table is open: emit it as a body row,
+ * or close the table when it isn't a valid pipe row. Returns false (need more
+ * input) only when a pipe-row line is started but not yet complete. A non-pipe
+ * line (including a blank line) ends the table and is left for normal
+ * processing.
+ *
+ * @nodocs
+ */
+export const process_table_line = (state: MdzStreamParserState, forced: boolean): boolean => {
+	const item_indent = state.table!.item_indent;
+	if (item_indent !== null) {
+		return process_table_line_in_item(state, forced, item_indent);
+	}
+
+	if (state.pos >= state.buffer.length) {
+		// the table may continue with more rows in a later chunk
+		if (forced) {
+			close_table(state);
+			return true;
+		}
+		return false;
+	}
+
+	const row_start = state.pos;
+	// a body row must start with `|` at column 0; anything else ends the table
+	// (decided without waiting for the line's newline)
+	if (state.buffer.charCodeAt(row_start) !== PIPE) {
+		close_table(state);
+		return true;
+	}
+
+	let row_end = state.buffer.indexOf('\n', row_start);
+	if (row_end === -1) {
+		if (!forced) return false; // pipe-row line not complete — hold
+		row_end = state.buffer.length;
+	}
+
+	const cells = mdz_split_table_row(state.buffer, row_start, row_end);
+	if (cells === null) {
+		// starts with `|` but isn't a valid row (e.g. no trailing pipe) — table ends
+		close_table(state);
+		return true;
+	}
+
+	emit_table_row(state, cells, false, row_start, row_end);
+	state.pos = row_end === state.buffer.length ? row_end : row_end + 1;
+	state.column = 0;
+	state.prev_char = NEWLINE;
+	return true;
+};
+
+/**
+ * Process body rows of an in-item table. Unlike the top-level path this keeps
+ * `state.pos` on the newline that ends each row — a row boundary the buffer
+ * never compacts past, since it's the active cursor. So when a dedent (to the
+ * item's `marker_indent` or shallower), a blank line, or a non-pipe line ends
+ * the table, `close_table` leaves the cursor on that newline and the list's
+ * newline handler re-classifies the following line — the same control-return
+ * shape as the in-item codeblock, robust across chunk boundaries.
+ */
+const process_table_line_in_item = (
+	state: MdzStreamParserState,
+	forced: boolean,
+	item_indent: number,
+): boolean => {
+	if (state.pos >= state.buffer.length) {
+		if (forced) {
+			close_table(state);
+			return true;
+		}
+		return false;
+	}
+	// `state.pos` sits on the newline ending the previous row (or the delimiter);
+	// the candidate next row is the line after it
+	const line_start = state.pos + 1;
+	let j = line_start;
+	while (j < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(j))) {
+		j++;
+	}
+	if (j >= state.buffer.length) {
+		if (forced) {
+			close_table(state);
+			return true;
+		}
+		return false; // indent-only / incomplete line — hold
+	}
+	if (j - line_start <= item_indent || state.buffer.charCodeAt(j) !== PIPE) {
+		// a dedent to the marker (or shallower), a blank line, or a non-pipe line
+		// ends the table; the cursor stays on the row-boundary newline so the
+		// list resumes via its newline handler
+		close_table(state);
+		return true;
+	}
+	let row_end = state.buffer.indexOf('\n', j);
+	if (row_end === -1) {
+		if (!forced) return false; // pipe-row line not complete — hold
+		row_end = state.buffer.length;
+	}
+	const cells = mdz_split_table_row(state.buffer, j, row_end);
+	if (cells === null) {
+		close_table(state);
+		return true;
+	}
+	emit_table_row(state, cells, false, j, row_end);
+	state.pos = row_end; // stay on this row's terminating newline (or EOF)
+	return true;
+};
+
+/**
+ * Close the open table.
+ *
+ * @nodocs
+ */
+export const close_table = (state: MdzStreamParserState): void => {
+	if (!state.table) return;
+	const {item_indent} = state.table;
+	const entry = pop_stack_entry(state);
+	emit(state, {type: 'close', id: entry.id, end: offset(state)});
+	state.table = null;
+	state.active_text_id = null;
+	if (item_indent === null) {
+		// top-level: the trailing newline + any blank lines absorb at the loop top
+		state.skip_blank_lines = true;
+	}
+	// in-item: the cursor is left on a row-boundary newline (or EOF). The list's
+	// newline handler re-classifies the following line; at EOF, `finish` closes
+	// the list. No skip_blank_lines — the list owns blank-line containment.
+};
+
+/** 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_end: number;
+	align: Array<MdzTableAlign>;
+	delim_end: number;
+}
+
+/**
+ * Recognize a table opening as a block child of a list item: a pipe row at
+ * `header_first` (the line's indent already skipped) whose next line is a
+ * delimiter row, both indented past `marker_indent` (so both stay inside the
+ * item). Returns the parsed head, `'pending'` when the two-line lookahead isn't
+ * fully buffered, or `null` when it isn't a table.
+ *
+ * @nodocs
+ */
+export const match_table_in_item_head = (
+	state: MdzStreamParserState,
+	header_first: number,
+	marker_indent: number,
+	forced: boolean,
+): TableInItemHead | 'pending' | null => {
+	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);
+	if (header_cells === null) return null;
+	const delim_line_start = header_end + 1;
+	let dj = delim_line_start;
+	while (dj < buffer.length && is_line_whitespace(buffer.charCodeAt(dj))) dj++;
+	if (dj >= buffer.length) return forced ? null : 'pending'; // delimiter line not buffered yet
+	if (dj - delim_line_start <= marker_indent) return null; // delimiter dedented out of the item
+	let delim_end = buffer.indexOf('\n', dj);
+	if (delim_end === -1) {
+		if (!forced) return 'pending'; // delimiter line incomplete
+		delim_end = buffer.length;
+	}
+	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};
+};
+
+/**
+ * Open a table as a block child of a list item at `marker_indent`, given a
+ * `head` from `match_table_in_item_head`. Emits the `Table` open + header row
+ * and enters table mode (with `item_indent`), leaving `state.pos` at the first
+ * body line. The caller closes the item's run and pops to the attach level first.
+ *
+ * @nodocs
+ */
+export const open_table_in_item = (
+	state: MdzStreamParserState,
+	header_first: number,
+	marker_indent: number,
+	head: TableInItemHead,
+): void => {
+	const table_id = alloc_id(state);
+	const table_start = offset(state, header_first);
+	emit(state, {
+		type: 'open',
+		id: table_id,
+		node_type: 'Table',
+		start: table_start,
+		align: head.align,
+	});
+	push_stack_entry(state, table_id, 'Table', table_start);
+	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
+	state.pos = head.delim_end;
+	state.column = 0;
+	state.prev_char = NEWLINE;
+};
+
+/** Emit one table row: open, each cell, close. */
+const emit_table_row = (
+	state: MdzStreamParserState,
+	cells: Array<{start: number; end: number}>,
+	header: boolean,
+	row_start: 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});
+	push_stack_entry(state, row_id, 'TableRow', row_off);
+	// 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)});
+	state.active_text_id = null;
+};
+
+/**
+ * Emit one cell: open, its inline content (parsed with the sync reference over
+ * the fully-buffered span via the row's shared `cell_parser`), close.
+ */
+const emit_table_cell = (
+	state: MdzStreamParserState,
+	cell_parser: MdzTableCellParser,
+	cell_start: 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});
+	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)});
+	state.active_text_id = null;
+};
+
+/**
+ * Replay sync-parsed inline nodes as opcodes. Cell content is inline-only;
+ * positions are local to `state.buffer` and lifted to global via `offset`.
+ */
+const emit_inline_nodes = (state: MdzStreamParserState, nodes: Array<MdzNode>): void => {
+	for (const node of nodes) {
+		switch (node.type) {
+			case 'Text':
+				emit(state, {
+					type: 'text',
+					id: alloc_id(state),
+					content: node.content,
+					text_type: 'Text',
+					start: offset(state, node.start),
+					end: offset(state, node.end),
+				});
+				break;
+			case 'Code':
+				emit(state, {
+					type: 'text',
+					id: alloc_id(state),
+					content: node.content,
+					text_type: 'Code',
+					start: offset(state, node.start),
+					end: offset(state, node.end),
+				});
+				break;
+			case 'Bold':
+			case 'Italic':
+			case 'Strikethrough': {
+				const id = alloc_id(state);
+				const s = offset(state, node.start);
+				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)});
+				break;
+			}
+			case 'Link': {
+				const id = alloc_id(state);
+				const s = offset(state, node.start);
+				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);
+				emit(state, {
+					type: 'close',
+					id,
+					end: offset(state, node.end),
+					reference: node.reference,
+					link_type: node.link_type,
+				});
+				break;
+			}
+			case 'Element':
+			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});
+				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)});
+				break;
+			}
+			// cells are inline-only (lexed via `lex_table_cell`); a block node here
+			// would mean a sync/stream grammar drift — fail loud in dev
+			default:
+				if (DEV) {
+					throw new Error(`mdz table cell: unexpected inline node type '${node.type}'`);
+				}
+		}
+	}
+};

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,
-} from './mdz_helpers.js';
+} from './mdz_helpers.ts';
 import {
 	type MdzStreamParserState,
 	accumulate_text,
 	ensure_paragraph,
 	offset,
-} from './mdz_stream_parser_state.js';
+} 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;