@fuzdev/mdz 0.1.0 → 0.3.0

package/dist/mdz_stream_parser_state.js

@@ -8,6 +8,7 @@
  * @module
  */
 import { NEWLINE, has_non_whitespace, mdz_heading_id_from_text } from './mdz_helpers.js';
+import { mdz_debug_work } from './mdz_debug_work.js';
 /** @nodocs */
 export const create_state = () => ({
     buffer: '',
@@ -24,11 +25,14 @@ export const create_state = () => ({
     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,
@@ -68,6 +72,14 @@ export const push_stack_entry = (state, id, node_type, start, delimiter = '', ta
     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++;
 };
 /**
  * Adjust the `open_counts` entry for a counted container type; no-op for
@@ -98,6 +110,19 @@ const bump_open_count = (state, node_type, delta) => {
 export const pop_stack_entry = (state) => {
     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;
 };
 /**
@@ -162,7 +187,11 @@ const memo_index_of = (state, memo, needle, from) => {
             // 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;
@@ -171,6 +200,9 @@ const memo_index_of = (state, memo, needle, from) => {
         // 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;
@@ -210,8 +242,11 @@ export const emit = (state, op) => {
         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);
             }
         }
@@ -435,6 +470,21 @@ export const revert_failed_close = (state, stack_idx) => {
     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/dist/mdz_stream_parser_table.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 { type MdzTableAlign } from './mdz.js';
+import { type MdzStreamParserState, type TryResult } from './mdz_stream_parser_state.js';
+/**
+ * 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 declare const try_table_start: (state: MdzStreamParserState, forced: boolean) => TryResult;
+/**
+ * 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 declare const process_table_line: (state: MdzStreamParserState, forced: boolean) => boolean;
+/**
+ * Close the open table.
+ *
+ * @nodocs
+ */
+export declare 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_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 declare const match_table_in_item_head: (state: MdzStreamParserState, header_first: number, marker_indent: number, forced: boolean) => TableInItemHead | "pending" | null;
+/**
+ * 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 declare const open_table_in_item: (state: MdzStreamParserState, header_first: number, marker_indent: number, head: TableInItemHead) => void;
+//# sourceMappingURL=mdz_stream_parser_table.d.ts.map

package/dist/mdz_stream_parser_table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_table.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAWH,OAAO,EAAmC,KAAK,aAAa,EAAC,MAAM,UAAU,CAAC;AAC9E,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAQd,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAyC9E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,OAyCjF,CAAC;AA2DF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,oBAAoB,KAAG,IAczD,CAAC;AAEF,yFAAyF;AACzF,MAAM,WAAW,eAAe;IAC/B,YAAY,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GACpC,OAAO,oBAAoB,EAC3B,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,QAAQ,OAAO,KACb,eAAe,GAAG,SAAS,GAAG,IAmBhC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,MAAM,eAAe,KACnB,IAsBF,CAAC"}

package/dist/mdz_stream_parser_table.js

@@ -0,0 +1,362 @@
+/**
+ * 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.js';
+import { MdzTableCellParser } from './mdz.js';
+import { alloc_id, close_paragraph, emit, flush_text, offset, pop_stack_entry, push_stack_entry, } from './mdz_stream_parser_state.js';
+/**
+ * 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, forced) => {
+    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, forced) => {
+    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, forced, item_indent) => {
+    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) => {
+    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.
+};
+/**
+ * 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, header_first, marker_indent, forced) => {
+    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, header_first, marker_indent, head) => {
+    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, cells, header, row_start, row_end) => {
+    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, cell_parser, cell_start, cell_end) => {
+    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, nodes) => {
+    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/dist/mdz_stream_parser_text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_text.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqBH,OAAO,EACN,KAAK,oBAAoB,EAIzB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,IAM1F,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,IAsC9D,CAAC"}
+{"version":3,"file":"mdz_stream_parser_text.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,EACN,KAAK,oBAAoB,EAIzB,MAAM,8BAA8B,CAAC;AAGtC;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,IAM1F,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,IA4C9D,CAAC"}

package/dist/mdz_stream_parser_text.js

@@ -3,8 +3,9 @@
  *
  * @module
  */
-import { ASTERISK, BACKTICK, HTTPS_PREFIX_LENGTH, H_LOWER, H_UPPER, LEFT_ANGLE, LEFT_BRACKET, NEWLINE, PERIOD, RIGHT_BRACKET, SLASH, SPACE, TAB, TILDE, UNDERSCORE, is_word_char, match_url_prefix_case_insensitive, } from './mdz_helpers.js';
+import { HTTPS_PREFIX_LENGTH, NEWLINE, SPACE, TAB, 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';
 import { accumulate_text, ensure_paragraph, offset, } from './mdz_stream_parser_state.js';
+import { mdz_debug_work } from './mdz_debug_work.js';
 /**
  * Consume a delimiter at the current position as literal text — the shared
  * tail of every "this delimiter doesn't open/close anything here" decision
@@ -34,33 +35,43 @@ export const consume_text_run = (state) => {
     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))) {
+        // 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;

package/dist/mdz_stream_state.svelte.d.ts

@@ -8,6 +8,7 @@
  * @module
  */
 import type { MdzNodeId, MdzNodeType, MdzOpcode } from './mdz_opcodes.js';
+import type { MdzTableAlign } from './mdz.js';
 /**
  * A reactive node in the stream renderer tree.
  * Fields are `$state` so Svelte re-renders only what changes.
@@ -26,6 +27,10 @@ export declare class MdzStreamNode {
     ordered?: boolean;
     start_number?: number;
     number?: number;
+    /** Per-column alignment (Table nodes). */
+    align?: Array<MdzTableAlign>;
+    /** Whether this is the header row (TableRow nodes). */
+    header?: boolean;
     constructor(id: MdzNodeId, type: MdzNodeType);
 }
 /**

package/dist/mdz_stream_state.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAa;IACzB,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAc;IAC7B,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAE5C,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAY;IAC9B,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,CAAY;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAY;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW;CAI5C;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;;IAC1B,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAqCxC;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA2R9B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;CAK5C"}
+{"version":3,"file":"mdz_stream_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AAE5C;;;GAGG;AACH,qBAAa,aAAa;IACzB,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAc;IAC7B,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAE5C,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAY;IAC9B,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,CAAY;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAY;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC7B,uDAAuD;IACvD,MAAM,CAAC,EAAE,OAAO,CAAC;gBAEL,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW;CAI5C;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;;IAC1B,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAqCxC;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA6R9B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;CAK5C"}