@fuzdev/mdz 0.1.0 → 0.3.0

package/dist/mdz_stream_state.svelte.js

@@ -27,6 +27,10 @@ export class MdzStreamNode {
     ordered;
     start_number;
     number;
+    /** Per-column alignment (Table nodes). */
+    align;
+    /** Whether this is the header row (TableRow nodes). */
+    header;
     constructor(id, type) {
         this.id = id;
         this.type = type;
@@ -96,6 +100,10 @@ export class MdzStreamState {
                     node.start_number = opcode.start_number;
                 if (opcode.number !== undefined)
                     node.number = opcode.number;
+                if (opcode.align !== undefined)
+                    node.align = opcode.align;
+                if (opcode.header !== undefined)
+                    node.header = opcode.header;
                 this.#attach(node);
                 this.#stack.push(opcode.id);
                 break;

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,EAAC,MAAM,UAAU,CAAC;AAGtC;;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,iBA4HF,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

@@ -7,10 +7,10 @@
  *
  * @module
  */
-import { UnreachableError } from '@fuzdev/fuz_util/error.js';
-import { escape_svelte_text } from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
-import { escape_js_string } from '@fuzdev/fuz_util/string.js';
-import { mdz_resolve_relative_path, mdz_is_void_element } from './mdz_helpers.js';
+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_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>`;
@@ -90,6 +88,39 @@ export const mdz_to_svelte = (nodes, options) => {
                 return `<li>${render_nodes(node.children)}</li>`;
             case 'Blockquote':
                 return `<blockquote>${render_nodes(node.children)}</blockquote>`;
+            case 'Table': {
+                const { align } = node;
+                const render_row = (row, tag) => {
+                    let cells = '';
+                    // normalize to the column count: pad short rows, ignore extra cells
+                    for (let i = 0; i < align.length; i++) {
+                        const a = align[i];
+                        const style = a ? ` style="text-align:${a}"` : '';
+                        const cell = row.children[i];
+                        cells += `<${tag}${style}>${cell ? render_nodes(cell.children) : ''}</${tag}>`;
+                    }
+                    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_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':
+            case 'TableCell':
+                // rendered within their `Table`; never reached through `render_nodes`
+                throw new Error(`mdz: ${node.type} must render within a Table`);
             case 'Hr':
                 return '<hr />';
             case 'Heading': {

package/dist/mdz_token_parser.d.ts

@@ -15,6 +15,22 @@ import { type MdzToken } from './mdz_lexer.js';
 export declare class MdzTokenParser {
     #private;
     constructor(tokens: Array<MdzToken>);
+    /**
+     * Rebind to a new token stream and rewind, so one parser instance can be
+     * reused across inputs — the streaming table path reuses one across a row's
+     * cells via `MdzTableCellParser`.
+     *
+     * @nodocs
+     */
+    reset(tokens: Array<MdzToken>): void;
     parse(): Array<MdzNode>;
+    /**
+     * Parse the entire token stream as a single inline run — used for table
+     * cells, whose tokens come from `MdzLexer.lex_table_cell`. Adjacent text
+     * merges as it accumulates, matching `#parse_table_cell`.
+     *
+     * @nodocs
+     */
+    parse_inline_run(): Array<MdzNode>;
 }
 //# sourceMappingURL=mdz_token_parser.d.ts.map

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,EAYP,MAAM,UAAU,CAAC;AAQlB,OAAO,EACN,KAAK,QAAQ,EASb,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,qBAAa,cAAc;;gBAId,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAInC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC;CAyevB"}
+{"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.
@@ -18,9 +31,36 @@ export class MdzTokenParser {
     constructor(tokens) {
         this.#tokens = tokens;
     }
+    /**
+     * Rebind to a new token stream and rewind, so one parser instance can be
+     * reused across inputs — the streaming table path reuses one across a row's
+     * cells via `MdzTableCellParser`.
+     *
+     * @nodocs
+     */
+    reset(tokens) {
+        this.#tokens = tokens;
+        this.#index = 0;
+    }
     parse() {
         return this.#parse_block_stream(false);
     }
+    /**
+     * Parse the entire token stream as a single inline run — used for table
+     * cells, whose tokens come from `MdzLexer.lex_table_cell`. Adjacent text
+     * merges as it accumulates, matching `#parse_table_cell`.
+     *
+     * @nodocs
+     */
+    parse_inline_run() {
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const node = this.#parse_inline();
+            if (node)
+                mdz_push_merging_text(children, node);
+        }
+        return children;
+    }
     /**
      * Parse a run of block-level tokens into nodes — the document root, or a
      * blockquote's contents (a quote's content is a mini-document, so both
@@ -80,6 +120,13 @@ export class MdzTokenParser {
                 nodes.push(this.#parse_blockquote());
                 continue;
             }
+            if (token.type === 'table_open') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    nodes.push(flushed);
+                nodes.push(this.#parse_table());
+                continue;
+            }
             if (token.type === 'paragraph_break') {
                 const flushed = this.#flush_paragraph(paragraph_children, true);
                 if (flushed)
@@ -107,6 +154,63 @@ export class MdzTokenParser {
         const end = children.length > 0 ? children[children.length - 1].end : open.end;
         return { type: 'Blockquote', children, start: open.start, end };
     }
+    #parse_table() {
+        const open = this.#tokens[this.#index];
+        this.#index++;
+        const rows = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_row_open') {
+                rows.push(this.#parse_table_row());
+                continue;
+            }
+            if (t.type === 'table_close') {
+                this.#index++;
+                break;
+            }
+            this.#index++; // skip anything unexpected (defensive)
+        }
+        const end = rows.length > 0 ? rows[rows.length - 1].end : open.end;
+        return { type: 'Table', align: open.align, children: rows, start: open.start, end };
+    }
+    #parse_table_row() {
+        const open = this.#tokens[this.#index];
+        const header = open.header;
+        this.#index++;
+        const cells = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_cell_open') {
+                cells.push(this.#parse_table_cell());
+                continue;
+            }
+            if (t.type === 'table_row_close') {
+                this.#index++;
+                return { type: 'TableRow', header, children: cells, start: open.start, end: t.end };
+            }
+            this.#index++; // skip anything unexpected (defensive)
+        }
+        const end = cells.length > 0 ? cells[cells.length - 1].end : open.end;
+        return { type: 'TableRow', header, children: cells, start: open.start, end };
+    }
+    #parse_table_cell() {
+        const open = this.#tokens[this.#index];
+        const start = open.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_cell_close') {
+                this.#index++;
+                return { type: 'TableCell', children, start, end: t.end };
+            }
+            const node = this.#parse_inline();
+            if (node)
+                mdz_push_merging_text(children, node);
+        }
+        const end = children.length > 0 ? children[children.length - 1].end : open.end;
+        return { type: 'TableCell', children, start, end };
+    }
     #parse_heading() {
         const token = this.#tokens[this.#index];
         const start = token.start;
@@ -188,6 +292,12 @@ export class MdzTokenParser {
                 children.push(this.#parse_blockquote());
                 continue;
             }
+            if (t.type === 'table_open') {
+                flush();
+                in_paragraph = false;
+                children.push(this.#parse_table());
+                continue;
+            }
             if (t.type === 'codeblock') {
                 flush();
                 in_paragraph = false;
@@ -301,13 +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') {
+            if (token_is_block_boundary(t.type)) {
                 break;
             }
             const node = this.#parse_inline();
@@ -342,13 +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') {
+            if (token_is_block_boundary(t.type)) {
                 break;
             }
             const node = this.#parse_inline();

package/dist/svelte_preprocess_mdz.js

@@ -16,8 +16,8 @@
 import { parse } from 'svelte/compiler';
 import MagicString from 'magic-string';
 import { walk } from 'zimmerframe';
-import { should_exclude_path } from '@fuzdev/fuz_util/path.js';
-import { find_attribute, extract_static_string, try_extract_conditional_chain, build_static_bindings, resolve_component_names, has_identifier_in_tree, find_import_insert_position, generate_import_lines, remove_variable_declaration, remove_import_declaration, remove_import_specifier, handle_preprocess_error, } from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
+import { should_exclude_path } from '@fuzdev/fuz_util/path.ts';
+import { find_attribute, extract_static_string, try_extract_conditional_chain, build_static_bindings, resolve_component_names, has_identifier_in_tree, find_import_insert_position, generate_import_lines, remove_variable_declaration, remove_import_declaration, remove_import_specifier, handle_preprocess_error, } from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
 import { mdz_parse } from './mdz.js';
 import { mdz_to_svelte } from './mdz_to_svelte.js';
 const PRECOMPILED_NAME = 'MdzPrecompiled';
@@ -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.1.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": {
@@ -57,15 +60,15 @@
   },
   "devDependencies": {
     "@fuzdev/blake3_wasm": "^0.1.1",
-    "@fuzdev/fuz_code": "^0.46.0",
-    "@fuzdev/fuz_css": "^0.62.0",
-    "@fuzdev/fuz_ui": "^0.204.0",
+    "@fuzdev/fuz_code": "^0.46.1",
+    "@fuzdev/fuz_css": "^0.63.2",
+    "@fuzdev/fuz_ui": "^0.205.1",
     "@fuzdev/fuz_util": "^0.65.1",
-    "@fuzdev/gro": "^0.204.0",
+    "@fuzdev/gro": "^0.205.1",
     "@ryanatkn/eslint-config": "^0.12.1",
     "@sveltejs/acorn-typescript": "^1.0.10",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.65.0",
+    "@sveltejs/kit": "2.64.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/estree": "^1.0.8",
@@ -83,7 +86,7 @@
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
-    "vite": "^7.3.1",
+    "vite": "^7.3.6",
     "vitest": "^4.0.15"
   },
   "prettier": {

package/src/lib/context_helpers.ts

@@ -14,7 +14,7 @@ import {getContext, setContext} from 'svelte';
  * If a `fallback` is provided, the `value` argument to `set` is optional
  * and `get_maybe` is omitted from the type.
  *
- * Vendored from `@fuzdev/fuz_ui/context_helpers.js` — fuz_ui sits above mdz
+ * Vendored from `@fuzdev/fuz_ui/context_helpers.ts` — fuz_ui sits above mdz
  * in the dependency graph, so mdz keeps its own copy for `mdz_contexts.ts`.
  * Consumers should import fuz_ui's.
  *

package/src/lib/mdz.ts

@@ -19,7 +19,7 @@
  * - inline code in backticks (creates `Code` nodes; auto-linking to identifiers/modules
  *   is handled by the rendering layer via `MdzNodeView.svelte`)
  * - paragraph breaks (blank lines)
- * - block elements: headings, horizontal rules, lists, blockquotes, code blocks
+ * - block elements: headings, horizontal rules, lists, blockquotes, code blocks, tables
  * - HTML elements and Svelte components (opt-in via context)
  *
  * Whitespace: the parser preserves whitespace in text node content (single
@@ -50,8 +50,8 @@
  * @module
  */
 
-import {MdzLexer} from './mdz_lexer.js';
-import {MdzTokenParser} from './mdz_token_parser.js';
+import {MdzLexer} from './mdz_lexer.ts';
+import {MdzTokenParser} from './mdz_token_parser.ts';
 
 // TODO design incremental parsing or some system that preserves Svelte components across re-renders when possible
 
@@ -64,6 +64,46 @@ import {MdzTokenParser} from './mdz_token_parser.js';
 export const mdz_parse = (text: string): Array<MdzNode> =>
 	new MdzTokenParser(new MdzLexer(text).tokenize()).parse();
 
+/**
+ * Parses table cells' inline content for the streaming parser, sharing one
+ * `MdzLexer` + `MdzTokenParser` across a row's cells rather than allocating a
+ * fresh pair (and search-memo `Map`) per cell. Bind to the buffer holding the
+ * row, then call `parse` once per cell `[cell_start, cell_end)` span; each
+ * call yields inline `MdzNode`s honoring code-span protection and the `\|`
+ * escape, matching the sync reference exactly — it *is* the sync lexer/parser,
+ * reset per cell, mirroring how the sync lexer already reuses one instance
+ * across a table's cells.
+ *
+ * The sync pipeline never needs this seam: its `MdzLexer` tokenizes a table's
+ * cells in place. Only the streaming path, which parses each fully-buffered
+ * cell out of band, would otherwise allocate per cell.
+ *
+ * @nodocs
+ */
+export class MdzTableCellParser {
+	#lexer: MdzLexer;
+	#parser: MdzTokenParser = new MdzTokenParser([]);
+
+	/** @param text - the buffer the cell spans index into (stable across a row). */
+	constructor(text: string) {
+		this.#lexer = new MdzLexer(text);
+	}
+
+	/**
+	 * Rebind to a new buffer so one instance serves a whole table — the
+	 * streaming path rebinds per row (the buffer string changes across feeds;
+	 * the lexer's search memo survives when it doesn't).
+	 */
+	rebind(text: string): void {
+		this.#lexer.rebind(text);
+	}
+
+	parse(cell_start: number, cell_end: number): Array<MdzNode> {
+		this.#parser.reset(this.#lexer.lex_table_cell(cell_start, cell_end));
+		return this.#parser.parse_inline_run();
+	}
+}
+
 export type MdzNode =
 	| MdzNodeText
 	| MdzNodeCode
@@ -78,6 +118,9 @@ export type MdzNode =
 	| MdzNodeList
 	| MdzNodeListItem
 	| MdzNodeBlockquote
+	| MdzNodeTable
+	| MdzNodeTableRow
+	| MdzNodeTableCell
 	| MdzNodeElement
 	| MdzNodeComponent;
 
@@ -175,6 +218,39 @@ export interface MdzNodeBlockquote extends MdzNodeBase {
 	children: Array<MdzNode>;
 }
 
+/** Per-column text alignment from the delimiter row's colons; `null` is the default (no alignment). */
+export type MdzTableAlign = 'left' | 'center' | 'right' | null;
+
+export interface MdzNodeTable extends MdzNodeBase {
+	type: 'Table';
+	/**
+	 * Per-column alignment, length equal to the delimiter row's column count.
+	 * Rendered as `text-align` on each cell; tooling can read it to re-theme
+	 * (e.g. a CSP-strict consumer that avoids inline styles).
+	 */
+	align: Array<MdzTableAlign>;
+	/** The header row first, then any body rows. */
+	children: Array<MdzNodeTableRow>;
+}
+
+export interface MdzNodeTableRow extends MdzNodeBase {
+	type: 'TableRow';
+	/** `true` for the header row (renders `thead`/`th`); `false` for body rows (`tbody`/`td`). */
+	header: boolean;
+	/**
+	 * The row's authored cells, preserved as written. The renderer normalizes to
+	 * the column count: short rows are padded with empty cells, cells past the
+	 * column count are ignored (their content survives here for tooling).
+	 */
+	children: Array<MdzNodeTableCell>;
+}
+
+export interface MdzNodeTableCell extends MdzNodeBase {
+	type: 'TableCell';
+	/** Inline content only (text, bold, italic, strikethrough, code, links). */
+	children: Array<MdzNode>;
+}
+
 export interface MdzNodeElement extends MdzNodeBase {
 	type: 'Element';
 	/** HTML element name (e.g. `div`, `span`, `aside`). */

package/src/lib/mdz_contexts.ts

@@ -1,6 +1,6 @@
 import type {Component} from 'svelte';
 
-import {create_context} from './context_helpers.js';
+import {create_context} from './context_helpers.ts';
 
 /**
  * Component registry for custom Svelte components that can be used in mdz content.

package/src/lib/mdz_debug_work.ts

@@ -0,0 +1,38 @@
+/**
+ * Deterministic scan-work counter for the complexity-ratio guards
+ * (`mdz_scaling_ratio.test.ts`). Off by default; when `enabled`, the parser hot
+ * paths accumulate the number of characters scanned (and tag-stack frames
+ * walked) into `total`. Unlike wall-clock timing this is a pure function of
+ * input + algorithm — invariant across machines, runs, and thermal state — so a
+ * super-linear regression shows up as a work ratio > ~linear regardless of the
+ * ~2× machine variance that makes absolute timing unusable here. Its sole
+ * consumer is `mdz_scaling_ratio.test.ts`.
+ *
+ * Coverage is the dominant re-scan choke points — `#index_of` + `#tokenize_text`
+ * (sync) and the streaming memo scans, `consume_text_run`, and `try_close_tag`'s
+ * stack walk — not every scan. A super-linear regression isolated to an
+ * *uncounted* probe (e.g. `#has_paragraph_break_between`, the tag-name collection
+ * loop, the URL/path probes) wouldn't move the ratio; extend the instrumentation
+ * if hot cost ever migrates there.
+ *
+ * Zero store when disabled: each instrumented site guards on `enabled` (a single
+ * branch-predicted property load, the same category as the shipped `DEV`
+ * checks). It is deliberately NOT the `esm-env` `DEV` flag — `DEV` is true under
+ * every `gro test`/`gro dev` run, which would leave the counter live in ordinary
+ * development; this flag is flipped true only by the ratio test.
+ *
+ * @nodocs
+ */
+export const mdz_debug_work: {enabled: boolean; total: number} = {enabled: false, total: 0};
+
+/**
+ * Reset the counter and set whether the hot paths accumulate into it. Tests call
+ * `mdz_debug_work_reset()` immediately before a parse and read
+ * `mdz_debug_work.total` immediately after; pass `false` to disable and zero it.
+ *
+ * @nodocs
+ */
+export const mdz_debug_work_reset = (enabled = true): void => {
+	mdz_debug_work.enabled = enabled;
+	mdz_debug_work.total = 0;
+};