@fuzdev/mdz 0.2.0 → 0.3.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,
@@ -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);
             }
         }
@@ -436,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

@@ -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,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

@@ -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
  */
@@ -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;
@@ -236,7 +241,11 @@ export const open_table_in_item = (state, header_first, marker_indent, head) =>
         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);
     }

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_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,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,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"}

package/dist/mdz_token_parser.js

@@ -8,6 +8,19 @@
  */
 import { has_non_whitespace, mdz_extract_single_tag, mdz_heading_id, mdz_merge_adjacent_text, mdz_push_merging_text, } from './mdz_helpers.js';
 import {} from './mdz_lexer.js';
+/**
+ * Whether a token type ends the current inline context — the block-boundary
+ * set shared by the delimiter-pair and link children loops (an unclosed
+ * inline never swallows block structure).
+ */
+const token_is_block_boundary = (type) => type === 'paragraph_break' ||
+    type === 'heading_start' ||
+    type === 'hr' ||
+    type === 'codeblock' ||
+    type === 'list_open' ||
+    type === 'list_item_close' ||
+    type === 'blockquote_open' ||
+    type === 'table_open';
 /**
  * Builds an `MdzNode[]` tree from a lexed `MdzToken[]` stream.
  * Used by `mdz_parse`, which should be preferred for simple usage.
@@ -398,14 +411,7 @@ export class MdzTokenParser {
                 this.#index++;
                 return { type: node_type, children, start, end: t.end };
             }
-            if (t.type === 'paragraph_break' ||
-                t.type === 'heading_start' ||
-                t.type === 'hr' ||
-                t.type === 'codeblock' ||
-                t.type === 'list_open' ||
-                t.type === 'list_item_close' ||
-                t.type === 'blockquote_open' ||
-                t.type === 'table_open') {
+            if (token_is_block_boundary(t.type)) {
                 break;
             }
             const node = this.#parse_inline();
@@ -440,14 +446,7 @@ export class MdzTokenParser {
                 // No link_ref - treat as text
                 return { type: 'Text', content: '[', start, end: start + 1 };
             }
-            if (t.type === 'paragraph_break' ||
-                t.type === 'heading_start' ||
-                t.type === 'hr' ||
-                t.type === 'codeblock' ||
-                t.type === 'list_open' ||
-                t.type === 'list_item_close' ||
-                t.type === 'blockquote_open' ||
-                t.type === 'table_open') {
+            if (token_is_block_boundary(t.type)) {
                 break;
             }
             const node = this.#parse_inline();

package/dist/svelte_preprocess_mdz.js

@@ -138,6 +138,29 @@ const collect_consumed_bindings = (value, bindings) => {
     collect_from_expr(value.expression);
     return consumed;
 };
+/**
+ * Parse a static mdz string and render it to Svelte markup. Returns `null` to
+ * leave the usage for the runtime — either the content raised a parse error
+ * (reported via `on_error`) or it contains unconfigured tags (which the
+ * precompiler emits nothing for; the runtime renders the fallback chrome).
+ */
+const render_static_mdz = (content, base, context) => {
+    let result;
+    try {
+        result = mdz_to_svelte(mdz_parse(content), {
+            components: context.components,
+            elements: context.elements,
+            base,
+            code_component_import: context.code_component_import,
+            codeblock_component_import: context.codeblock_component_import,
+        });
+    }
+    catch (error) {
+        handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
+        return null;
+    }
+    return result.has_unconfigured_tags ? null : result;
+};
 /**
  * Walks the AST to find `Mdz` component usages with static `content` props
  * and generates transformations to replace them with `MdzPrecompiled` children.
@@ -181,25 +204,9 @@ const find_mdz_usages = (ast, mdz_names, context) => {
             // Extract static string value
             const content_value = extract_static_string(content_attr.value, context.bindings);
             if (content_value !== null) {
-                // Parse mdz content and render to Svelte markup
-                let result;
-                try {
-                    const nodes = mdz_parse(content_value);
-                    result = mdz_to_svelte(nodes, {
-                        components: context.components,
-                        elements: context.elements,
-                        base,
-                        code_component_import: context.code_component_import,
-                        codeblock_component_import: context.codeblock_component_import,
-                    });
-                }
-                catch (error) {
-                    handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
-                    return;
-                }
-                // If content has unconfigured tags, skip this usage (fall back to runtime)
-                if (result.has_unconfigured_tags)
-                    return;
+                const result = render_static_mdz(content_value, base, context);
+                if (result === null)
+                    return; // parse error or unconfigured tags — leave for runtime
                 const consumed = collect_consumed_bindings(content_attr.value, context.bindings);
                 const replacement = build_replacement(node, exclude_attrs, result.markup, context.source);
                 transformed_usages.set(node.name, (transformed_usages.get(node.name) ?? 0) + 1);
@@ -219,24 +226,11 @@ const find_mdz_usages = (ast, mdz_names, context) => {
                 return;
             // Parse and render each branch
             const branch_results = [];
-            try {
-                for (const branch of chain) {
-                    const nodes = mdz_parse(branch.value);
-                    const result = mdz_to_svelte(nodes, {
-                        components: context.components,
-                        elements: context.elements,
-                        base,
-                        code_component_import: context.code_component_import,
-                        codeblock_component_import: context.codeblock_component_import,
-                    });
-                    if (result.has_unconfigured_tags)
-                        return;
-                    branch_results.push({ markup: result.markup, imports: result.imports });
-                }
-            }
-            catch (error) {
-                handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
-                return;
+            for (const branch of chain) {
+                const result = render_static_mdz(branch.value, base, context);
+                if (result === null)
+                    return; // parse error or unconfigured tags — leave for runtime
+                branch_results.push({ markup: result.markup, imports: result.imports });
             }
             // Build {#if}/{:else if}/{:else} markup
             let children_markup = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/mdz",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "a strict markdown dialect built for streaming, Svelte authoring, docs websites, and untrusted content",
   "tagline": "markdown for fuz",
   "glyph": "📝",
@@ -30,7 +30,10 @@
     "deploy": "gro deploy",
     "benchmark": "gro run src/benchmarks/mdz.benchmark.ts",
     "benchmark:save": "gro run src/benchmarks/mdz.benchmark.ts --save",
-    "benchmark:clean": "rm -f src/benchmarks/baseline.json"
+    "benchmark:clean": "rm -f src/benchmarks/baseline.json",
+    "benchmark:render": "BENCHMARK_RENDER=1 gro test render.benchmark",
+    "benchmark:render:save": "BENCHMARK_RENDER=save gro test render.benchmark",
+    "benchmark:render:clean": "rm -f src/benchmarks/render/baseline.json"
   },
   "type": "module",
   "engines": {
@@ -67,7 +70,7 @@
     "@sveltejs/adapter-static": "^3.0.10",
     "@sveltejs/kit": "2.64.0",
     "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/estree": "^1.0.8",
     "@types/node": "^24.12.4",
     "@webref/css": "^8.2.0",
@@ -83,7 +86,7 @@
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
-    "vite": "^8.0.16",
+    "vite": "^7.3.6",
     "vitest": "^4.0.15"
   },
   "prettier": {