@fuzdev/mdz 0.2.0 → 0.4.0

package/dist/mdz_stream_parser_state.d.ts

@@ -8,6 +8,7 @@
  * @module
  */
 import type { MdzNodeTypeContainer, MdzNodeId, MdzOpcode } from './mdz_opcodes.js';
+import type { MdzTableCellParser } from './mdz.js';
 /**
  * Tri-state result for `try_*` parser handlers.
  * - `'consumed'`: input matched and the parser advanced
@@ -206,10 +207,12 @@ 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;
+        cell_parser: MdzTableCellParser;
     } | null;
     /**
      * Whether the innermost open ListItem's first inline run is current.
@@ -238,6 +241,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. */

package/dist/mdz_stream_parser_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_state.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mdz_stream_parser_state.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_state.ts"],"names":[],"mappings":"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"}

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: '',
@@ -30,6 +31,8 @@ export const create_state = () => ({
     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,
@@ -41,7 +44,7 @@ export const create_state = () => ({
     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 */
 export const alloc_id = (state) => state.next_id++;
@@ -61,7 +64,7 @@ export const push_stack_entry = (state, id, node_type, start, delimiter = '', ta
         tag_name,
         has_children: false,
         has_non_whitespace_content: false,
-        start,
+        start
     });
     if (node_type === 'Paragraph') {
         state.paragraph_stack_idx = state.stack.length - 1;
@@ -69,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
@@ -99,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;
 };
 /**
@@ -163,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;
@@ -172,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;
@@ -211,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);
             }
         }
@@ -311,7 +345,7 @@ export const flush_text = (state) => {
             type: 'append_text',
             id: state.active_text_id,
             content: state.accumulated_text,
-            end: state.accumulated_text_end,
+            end: state.accumulated_text_end
         });
     }
     else {
@@ -324,7 +358,7 @@ export const flush_text = (state) => {
             content: state.accumulated_text,
             text_type: 'Text',
             start,
-            end: state.accumulated_text_end,
+            end: state.accumulated_text_end
         });
         state.active_text_id = id;
     }
@@ -402,7 +436,7 @@ export const revert_above = (state, target_idx) => {
             type: 'revert',
             id: entry.id,
             replacement_text: entry.delimiter,
-            start: entry.start,
+            start: entry.start
         });
     }
     state.active_text_id = null;
@@ -436,11 +470,26 @@ 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,
         replacement_text: entry.delimiter,
-        start: entry.start,
+        start: entry.start
     });
     // structural opcode seals the prior text run (mirrors `emit`)
     seal_text_run(state);
@@ -602,7 +651,7 @@ export const close_list_item = (state) => {
     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;
 };

package/dist/mdz_stream_parser_table.d.ts

@@ -7,8 +7,9 @@
  * 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
  */

package/dist/mdz_stream_parser_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_table.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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,SAqC9E,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,IAkBF,CAAC"}
+{"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,EAAoC,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAChF,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;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,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

@@ -7,15 +7,16 @@
  * 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 { NEWLINE, PIPE, is_line_whitespace, mdz_split_table_row, mdz_parse_table_delimiter, } from './mdz_helpers.js';
+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';
+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,
@@ -52,7 +53,11 @@ export const try_table_start = (state, forced) => {
     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 };
+    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;
@@ -233,10 +238,14 @@ export const open_table_in_item = (state, header_first, marker_indent, head) =>
         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
@@ -250,9 +259,11 @@ const emit_table_row = (state, cells, header, row_start, row_end) => {
     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 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);
     }
@@ -288,7 +299,7 @@ const emit_inline_nodes = (state, nodes) => {
                     content: node.content,
                     text_type: 'Text',
                     start: offset(state, node.start),
-                    end: offset(state, node.end),
+                    end: offset(state, node.end)
                 });
                 break;
             case 'Code':
@@ -298,7 +309,7 @@ const emit_inline_nodes = (state, nodes) => {
                     content: node.content,
                     text_type: 'Code',
                     start: offset(state, node.start),
-                    end: offset(state, node.end),
+                    end: offset(state, node.end)
                 });
                 break;
             case 'Bold':
@@ -325,7 +336,7 @@ const emit_inline_nodes = (state, nodes) => {
                     id,
                     end: offset(state, node.end),
                     reference: node.reference,
-                    link_type: node.link_type,
+                    link_type: node.link_type
                 });
                 break;
             }

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 { accumulate_text, ensure_paragraph, offset, } from './mdz_stream_parser_state.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_parser_url.js

@@ -12,8 +12,8 @@
  *
  * @module
  */
-import { NEWLINE, SPACE, TAB, PERIOD, SLASH, ascii_to_lower, is_valid_path_char, is_word_char, match_url_prefix_case_insensitive, mdz_trim_url_punctuation, } from './mdz_helpers.js';
-import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, offset, } from './mdz_stream_parser_state.js';
+import { NEWLINE, SPACE, TAB, PERIOD, SLASH, ascii_to_lower, is_valid_path_char, is_word_char, match_url_prefix_case_insensitive, mdz_trim_url_punctuation } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, offset } from './mdz_stream_parser_state.js';
 const HTTPS_PREFIX = 'https://';
 const HTTP_PREFIX = 'http://';
 /**
@@ -113,7 +113,7 @@ export const start_pending_url = (state, link_type) => {
         link_type,
         confirmed: true,
         viable_https: false,
-        viable_http: false,
+        viable_http: false
     };
     // don't advance pos — URL chars start at current position, handled by process_url_content
 };
@@ -134,7 +134,7 @@ export const start_speculative_url = (state) => {
         link_type: 'external',
         confirmed: false,
         viable_https: true,
-        viable_http: true,
+        viable_http: true
     };
 };
 /**
@@ -261,7 +261,7 @@ export const complete_pending_url = (state) => {
             start: pu.start,
             end: url_end,
             trim_end,
-            trim_id,
+            trim_id
         });
         state.active_text_id = trim_id;
     }
@@ -274,7 +274,7 @@ export const complete_pending_url = (state) => {
             reference,
             link_type: pu.link_type,
             start: pu.start,
-            end: url_end,
+            end: url_end
         });
         state.active_text_id = null;
     }
@@ -317,7 +317,7 @@ export const scan_auto_link_forced = (state, link_type) => {
         content: reference,
         text_type: 'Text',
         start: link_start,
-        end: link_end,
+        end: link_end
     });
     emit(state, { type: 'close', id: link_id, end: link_end, reference, link_type });
     state.active_text_id = null;

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;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"}
+{"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,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;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"}

package/dist/mdz_to_svelte.d.ts

@@ -27,7 +27,7 @@ export interface MdzToSvelteResult {
  */
 export interface MdzToSvelteOptions {
     /**
-     * Component name to import path mapping (e.g., `{Alert: '$lib/Alert.svelte'}`).
+     * Component name to import path mapping (e.g., `{Alert: '#lib/Alert.svelte'}`).
      * If content references a component not in this map, `has_unconfigured_tags` is set.
      */
     components: Record<string, string>;

package/dist/mdz_to_svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAC,OAAO,EAAkB,MAAM,UAAU,CAAC;AAGvD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAC,CAAC,CAAC;IAEhE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,SAAS,kBAAkB,KACzB,iBA8JF,CAAC"}
+{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAmB,MAAM,UAAU,CAAC;AAGzD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IAElE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,SAAS,kBAAkB,KACzB,iBAsJF,CAAC"}

package/dist/mdz_to_svelte.js

@@ -10,7 +10,7 @@
 import { UnreachableError } from '@fuzdev/fuz_util/error.ts';
 import { escape_svelte_text } from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
 import { escape_js_string } from '@fuzdev/fuz_util/string.ts';
-import { mdz_resolve_relative_path, mdz_is_void_element } from './mdz_helpers.js';
+import { mdz_is_void_element, mdz_classify_link } from './mdz_helpers.js';
 /** Derives an import's local identifier from a `.svelte` import path's basename. */
 const component_local_name = (import_path) => import_path.slice(import_path.lastIndexOf('/') + 1).replace(/\.svelte$/, '');
 /**
@@ -58,24 +58,22 @@ export const mdz_to_svelte = (nodes, options) => {
                 return `<s>${render_nodes(node.children)}</s>`;
             case 'Link': {
                 const children_markup = render_nodes(node.children);
-                if (node.link_type === 'internal') {
-                    if (node.reference.startsWith('.') && base) {
-                        const resolved = mdz_resolve_relative_path(node.reference, base);
-                        imports.set('resolve', { path: '$app/paths', kind: 'named' });
-                        return `<a href={resolve('${escape_js_string(resolved)}')}>${children_markup}</a>`;
-                    }
-                    if (node.reference.startsWith('#') ||
-                        node.reference.startsWith('?') ||
-                        node.reference.startsWith('.') ||
-                        // Bare references (e.g. `foo`) aren't absolute — resolve() throws on them
-                        !node.reference.startsWith('/')) {
-                        return `<a href={'${escape_js_string(node.reference)}'}>${children_markup}</a>`;
-                    }
+                // safety gate + resolve-vs-raw classification shared with the runtime
+                // views via `mdz_classify_link`, so the three renderers can't drift
+                // (an unsafe `javascript:`/`data:` ref renders as plain children, no
+                // `<a>` — defense in depth, since `mdz_to_svelte` is a public entry
+                // callable with hand-built trees that never went through `mdz_parse`)
+                const link = mdz_classify_link(node.reference, node.link_type, base);
+                if (link.kind === 'unsafe')
+                    return children_markup;
+                if (link.kind === 'resolve') {
                     imports.set('resolve', { path: '$app/paths', kind: 'named' });
-                    return `<a href={resolve('${escape_js_string(node.reference)}')}>${children_markup}</a>`;
+                    return `<a href={resolve('${escape_js_string(link.href)}')}>${children_markup}</a>`;
+                }
+                if (link.kind === 'external') {
+                    return `<a href={'${escape_js_string(link.href)}'} target="_blank" rel="noopener">${children_markup}</a>`;
                 }
-                // External link — matches MdzNodeView: target="_blank" rel="noopener"
-                return `<a href={'${escape_js_string(node.reference)}'} target="_blank" rel="noopener">${children_markup}</a>`;
+                return `<a href={'${escape_js_string(link.href)}'}>${children_markup}</a>`;
             }
             case 'Paragraph':
                 return `<p>${render_nodes(node.children)}</p>`;
@@ -103,21 +101,20 @@ export const mdz_to_svelte = (nodes, options) => {
                     }
                     return `<tr>${cells}</tr>`;
                 };
+                // by grammar the header row is always first (and the only one) —
+                // read it by index and skip it in the body, mirroring the node
+                // views (a `.filter()` pair re-partitions every row; see
+                // `MdzNodeView.svelte`'s "Table rendering de-quadratified" note)
                 let out = '<table>';
-                const header_rows = node.children.filter((r) => r.header);
-                const body_rows = node.children.filter((r) => !r.header);
-                if (header_rows.length > 0) {
-                    out += '<thead>';
-                    for (const row of header_rows)
-                        out += render_row(row, 'th');
-                    out += '</thead>';
-                }
-                if (body_rows.length > 0) {
-                    out += '<tbody>';
-                    for (const row of body_rows)
-                        out += render_row(row, 'td');
-                    out += '</tbody>';
-                }
+                const header_row = node.children[0]?.header ? node.children[0] : undefined;
+                if (header_row)
+                    out += '<thead>' + render_row(header_row, 'th') + '</thead>';
+                let body = '';
+                for (const row of node.children)
+                    if (!row.header)
+                        body += render_row(row, 'td');
+                if (body)
+                    out += '<tbody>' + body + '</tbody>';
                 return out + '</table>';
             }
             case 'TableRow':

package/dist/mdz_token_parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_token_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_token_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,OAAO,EAeP,MAAM,UAAU,CAAC;AAQlB,OAAO,EACN,KAAK,QAAQ,EAYb,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,qBAAa,cAAc;;gBAId,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAInC;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKpC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC;IAIvB;;;;;;OAMG;IACH,gBAAgB,IAAI,KAAK,CAAC,OAAO,CAAC;CAikBlC"}
+{"version":3,"file":"mdz_token_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_token_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,OAAO,EAeP,MAAM,UAAU,CAAC;AAQlB,OAAO,EACN,KAAK,QAAQ,EAYb,MAAM,gBAAgB,CAAC;AAiBxB;;;GAGG;AACH,qBAAa,cAAc;;gBAId,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAInC;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKpC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC;IAIvB;;;;;;OAMG;IACH,gBAAgB,IAAI,KAAK,CAAC,OAAO,CAAC;CA+iBlC"}