panache-cli 2.54.0__tar.gz → 2.55.0__tar.gz

{panache_cli-2.54.0 → panache_cli-2.55.0}/Cargo.lock

@@ -1151,7 +1151,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "2.54.0"
+version = "2.55.0"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1194,7 +1194,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "insta",
  "log",
@@ -1209,7 +1209,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.17.0"
+version = "0.17.1"
 dependencies = [
  "entities",
  "insta",

{panache_cli-2.54.0 → panache_cli-2.55.0}/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "2.54.0"
+version = "2.55.0"
 edition.workspace = true
 readme = "README.md"
 description = "An LSP, formatter, and linter for Markdown, Quarto, and R Markdown"
@@ -49,8 +49,8 @@ path = "src/main.rs"
 required-features = ["cli"]
 
 [dependencies]
-panache-formatter = { path = "crates/panache-formatter", version = "0.12.0" }
-panache-parser = { path = "crates/panache-parser", version = "0.17.0", features = [
+panache-formatter = { path = "crates/panache-formatter", version = "0.13.0" }
+panache-parser = { path = "crates/panache-parser", version = "0.17.1", features = [
     "serde",
     "schema",
 ] }

{panache_cli-2.54.0 → panache_cli-2.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panache-cli
-Version: 2.54.0
+Version: 2.55.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.13.0](https://github.com/jolars/panache/compare/panache-formatter-v0.12.0...panache-formatter-v0.13.0) (2026-06-15)
+
+### Features
+- **formatter:** nest broken binary math continuations by `math-indent` ([`5948ca1`](https://github.com/jolars/panache/commit/5948ca15bb1fa1350e91dbf8fdfc5e11f0e40c32))
+- **formatter:** default `math-indent` to 2 ([`3d0422b`](https://github.com/jolars/panache/commit/3d0422b8355e57b2d9e04b0ac86128da414b75b2))
+
+### Bug Fixes
+- **formatter:** fix(formatter): charge math-indent against display line-break budget ([`754faaa`](https://github.com/jolars/panache/commit/754faaa451ae418a681237f86bc5ad3d6096c92f))
+- **parser:** claim trailing caption for table-first list item ([`a09f066`](https://github.com/jolars/panache/commit/a09f066a9493f3f626b44691023c59c151caafb8))
+- **formatter:** re-emit list marker for table-first item ([`9633b86`](https://github.com/jolars/panache/commit/9633b8632a2f075df3d59852cf414933c9aaba44))
+
+### Dependencies
+- updated crates/panache-parser to v0.17.1
+
 ## [0.12.0](https://github.com/jolars/panache/compare/panache-formatter-v0.11.0...panache-formatter-v0.12.0) (2026-06-13)
 
 ### Features

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.12.0"
+version = "0.13.0"
 edition.workspace = true
 include = [
     "/src/**/*",
@@ -18,7 +18,7 @@ keywords = ["quarto", "pandoc", "markdown", "formatter"]
 categories = ["text-processing"]
 
 [dependencies]
-panache-parser = { path = "../panache-parser", version = "0.17.0" }
+panache-parser = { path = "../panache-parser", version = "0.17.1" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.16.1"
 unicode-width = "0.2"

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/config.rs

@@ -200,7 +200,7 @@ impl Default for Config {
             formatter_extensions: FormatterExtensions::for_flavor(flavor),
             line_ending: Some(LineEnding::Auto),
             line_width: 80,
-            math_indent: 0,
+            math_indent: 2,
             math_delimiter_style: MathDelimiterStyle::default(),
             tab_stops: TabStopMode::Normalize,
             tab_width: 4,

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/formatter/inline.rs

@@ -536,8 +536,13 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
                 result.push_str(&math::format_math(&content, &opts));
                 result.push('\n');
             } else {
-                // Process content: trim overall, then strip common leading whitespace
-                let trimmed_content = content.trim();
+                // Process content: trim surrounding newlines (NOT leading spaces)
+                // and trailing whitespace, strip common leading whitespace, then
+                // re-indent every line by `math_indent`. Trimming only leading
+                // newlines keeps each line's true indent visible to `min_indent`,
+                // so the re-indent is idempotent: a later pass strips the pad as
+                // common indentation before re-applying it, rather than stacking.
+                let trimmed_content = content.trim_start_matches(['\n', '\r']).trim_end();
                 if !trimmed_content.is_empty() {
                     // Find minimum indentation across all non-empty lines
                     let min_indent = trimmed_content
@@ -547,12 +552,18 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
                         .min()
                         .unwrap_or(0);
 
-                    // Strip common indentation from each line
+                    let pad = " ".repeat(config.math_indent);
+                    // Strip common indentation, then re-indent each line.
                     for line in trimmed_content.lines() {
-                        if line.len() >= min_indent {
-                            result.push_str(&line[min_indent..]);
+                        let stripped = if line.len() >= min_indent {
+                            &line[min_indent..]
                         } else {
-                            result.push_str(line);
+                            line
+                        };
+                        // Skip padding blank lines to avoid trailing whitespace.
+                        if !stripped.is_empty() {
+                            result.push_str(&pad);
+                            result.push_str(stripped);
                         }
                         result.push('\n');
                     }

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/formatter/lists.rs

@@ -1,6 +1,7 @@
 use crate::config::WrapMode;
 use crate::formatter::indent_utils::{calculate_list_item_indent, is_alignable_marker};
 use crate::formatter::inline_layout::{self, WrapStrategy};
+use crate::formatter::tables;
 use crate::syntax::{AstNode, BlockQuote, FencedDiv, SyntaxKind, SyntaxNode};
 use rowan::NodeOrToken;
 
@@ -1188,6 +1189,80 @@ impl Formatter {
                         self.format_node_sync(&child, content_indent);
                     }
                 }
+                SyntaxKind::PIPE_TABLE | SyntaxKind::GRID_TABLE => {
+                    // A table can be a LIST_ITEM's sole/first child (the parser
+                    // nests it; e.g. `- | a | b |`). The wrapping pass above
+                    // emits nothing for an item with no PLAIN/PARAGRAPH
+                    // content_node, so re-emit the marker here — otherwise it is
+                    // dropped and the table floats out of the list (and the
+                    // ordered-list re-indent breaks idempotency). The first
+                    // table line sits on the marker line; a bare marker with the
+                    // table indented below would reparse the table as a
+                    // paragraph.
+                    //
+                    // Captioned tables splice too: the parser now nests a
+                    // table-first item's trailing `: cap`/`Table: cap` as the
+                    // table's `TABLE_CAPTION` (matching pandoc), so the whole
+                    // table — caption rendered below by `format_pipe_table` /
+                    // `format_grid_table` at `content_indent` — goes on the
+                    // marker line. The splice strips only the first line's
+                    // indent, so the caption keeps its indentation.
+                    let no_content_emitted = lines.is_empty()
+                        && preserve_lines.is_none()
+                        && sentence_lines.is_none()
+                        && content_node.is_none()
+                        && !has_only_empty_nested_list;
+                    let prev_kind = child.prev_sibling().map(|s| s.kind());
+                    let is_first_real_child = !matches!(
+                        prev_kind,
+                        Some(SyntaxKind::PLAIN)
+                            | Some(SyntaxKind::PARAGRAPH)
+                            | Some(SyntaxKind::HEADING)
+                            | Some(SyntaxKind::CODE_BLOCK)
+                            | Some(SyntaxKind::BLOCK_QUOTE)
+                            | Some(SyntaxKind::LIST)
+                            | Some(SyntaxKind::HORIZONTAL_RULE)
+                            | Some(SyntaxKind::HTML_BLOCK)
+                            | Some(SyntaxKind::HTML_BLOCK_DIV)
+                            | Some(SyntaxKind::PIPE_TABLE)
+                            | Some(SyntaxKind::GRID_TABLE)
+                    );
+                    let content_indent = list_indent.hanging_indent(total_indent);
+                    // The marker prefix occupies exactly `content_indent`
+                    // columns — except under `four_space_rule` (a flat tab
+                    // stop) or a task checkbox (which widens the marker line);
+                    // in those cases the splice would misalign, so fall back.
+                    let prefix_width = total_indent
+                        + list_indent.marker_padding
+                        + marker.len()
+                        + list_indent.spaces_after;
+                    if no_content_emitted
+                        && is_first_real_child
+                        && checkbox.is_none()
+                        && prefix_width == content_indent
+                    {
+                        // First table line on the marker line. Both `prefix` and
+                        // the table's first line are exactly `content_indent`
+                        // ASCII spaces wide, so splicing is byte-safe.
+                        let prefix = format!(
+                            "{}{}{}{}",
+                            " ".repeat(total_indent),
+                            " ".repeat(list_indent.marker_padding),
+                            marker,
+                            " ".repeat(list_indent.spaces_after),
+                        );
+                        let table_str = match child.kind() {
+                            SyntaxKind::PIPE_TABLE => {
+                                tables::format_pipe_table(&child, &self.config, content_indent)
+                            }
+                            _ => tables::format_grid_table(&child, &self.config, content_indent),
+                        };
+                        self.output.push_str(&prefix);
+                        self.output.push_str(&table_str[content_indent..]);
+                    } else {
+                        self.format_node_sync(&child, content_indent);
+                    }
+                }
                 _ => {
                     // Other block elements - format with proper indentation
                     let content_indent = list_indent.hanging_indent(total_indent);

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/formatter/math/STYLE.md

@@ -104,9 +104,11 @@ Returned unchanged, never reflowed:
    every later relation starts a continuation **aligned under the first
    relation's column**. Then any relation segment that is still over-width
    splits before each top-level **binary** operator, with each `+ term` nested
-   one indent step (2 spaces) deeper, under the relation's right-hand side. It
-   is source-cosmetic only --- math ignores whitespace, so the rendered equation
-   is unchanged:
+   one indent step (2 spaces) deeper, under the relation's right-hand side. The
+   width budget charges the flat `math-indent` against `line-width`, so a broken
+   line plus its leading indent still stays within `line-width`. It is
+   source-cosmetic only --- math ignores whitespace, so the rendered equation is
+   unchanged:
 
    ```
    A = aaaaaaaaaa

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/formatter/math/linebreak.rs

@@ -52,6 +52,11 @@
 //! stays on one line, like an unbreakable long word in prose reflow. Inline and
 //! environment-body math are not line-broken.
 //!
+//! On top of that bare geometry, each binary continuation is nested one extra
+//! `math-indent` step (the `cont_indent` argument) so the `+ term` rows sit
+//! below — not flush with — the head/right-hand side they hang under. Relation
+//! continuations keep the bare alignment so relation operators stay in a column.
+//!
 //! ## Idempotency
 //!
 //! Indents are derived from the *logical* row (recomputed every pass), never
@@ -78,7 +83,17 @@ struct Break {
 /// Break one logical free-display row into physical content lines (no base
 /// math-indent, no trailing `\\` — the caller adds those). A row that fits, or
 /// that has no usable relation chain, is returned on one line unchanged.
-pub(super) fn break_free_row(elems: &[SyntaxElement], line_width: usize) -> Vec<String> {
+///
+/// `cont_indent` (the block's `math-indent`) is added to every *binary*
+/// continuation line so the broken `+ term` rows nest one indent step deeper
+/// than the head/right-hand side they hang under. Relation continuations are
+/// not shifted, so the relation operators stay column-aligned. With
+/// `cont_indent == 0` the layout is the bare alignment geometry.
+pub(super) fn break_free_row(
+    elems: &[SyntaxElement],
+    line_width: usize,
+    cont_indent: usize,
+) -> Vec<String> {
     // The unbroken, canonical single-line form — also the exact bytes the old
     // code emitted, so a row that fits is byte-identical to before.
     let single = render::render_inline(elems).trim().to_string();
@@ -94,13 +109,14 @@ pub(super) fn break_free_row(elems: &[SyntaxElement], line_width: usize) -> Vec<
         .collect();
 
     // Zero relations: a standalone binary chain. With no relation, the chain's
-    // first term *is* the head, so each `+ term` aligns flush under it (bin_indent
-    // 0) — the same rule the relation cases follow (a binary continuation aligns
-    // under the first term of its right-hand side). A row with no top-level binary
-    // op either (e.g. a lone wide `\frac`) falls through `break_binary_segment`'s
-    // empty-`bins` guard and stays on one (over-width) line.
+    // first term *is* the head, so each `+ term` aligns under it, nested by
+    // `cont_indent` (the block's math-indent; 0 ⇒ flush) — the same rule the
+    // relation cases follow (a binary continuation aligns under the first term of
+    // its right-hand side, plus the continuation indent). A row with no top-level
+    // binary op either (e.g. a lone wide `\frac`) falls through
+    // `break_binary_segment`'s empty-`bins` guard and stays on one (over-width) line.
     if rels.is_empty() {
-        return break_binary_segment(elems, 0, 0, line_width);
+        return break_binary_segment(elems, 0, cont_indent, line_width);
     }
 
     // Relation continuations align under the first relation's column; binary
@@ -114,7 +130,7 @@ pub(super) fn break_free_row(elems: &[SyntaxElement], line_width: usize) -> Vec<
     } else {
         prefix_width + 1
     };
-    let bin_indent = rel_indent + BINARY_NEST;
+    let bin_indent = rel_indent + BINARY_NEST + cont_indent;
 
     // One relation: the whole row is a single segment. It keeps the lone relation
     // on the opening line; an over-width binary RHS breaks before each `+`, each
@@ -311,8 +327,14 @@ mod tests {
         node.children_with_tokens().collect()
     }
 
+    /// Bare alignment geometry (no extra continuation indent).
     fn lines(content: &str, width: usize) -> Vec<String> {
-        break_free_row(&elems(content), width)
+        break_free_row(&elems(content), width, 0)
+    }
+
+    /// Layout with a continuation indent step (mirrors a non-zero `math-indent`).
+    fn lines_nested(content: &str, width: usize, cont_indent: usize) -> Vec<String> {
+        break_free_row(&elems(content), width, cont_indent)
     }
 
     fn rel_indices(content: &str) -> Vec<usize> {
@@ -423,6 +445,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn continuation_indent_nests_binary_terms_no_relation() {
+        // A non-zero continuation indent nests each `+ term` one step under the
+        // head instead of flush.
+        assert_eq!(
+            lines_nested("aaaa + bbbb + cccc + dddd", 12, 2),
+            vec!["aaaa", "  + bbbb", "  + cccc", "  + dddd"],
+        );
+    }
+
+    #[test]
+    fn continuation_indent_nests_binary_terms_one_relation() {
+        // The `+ term` rows nest one step past the relation's right-hand side
+        // (bare `bin_indent` 4 + continuation indent 2 = 6).
+        assert_eq!(
+            lines_nested("A = aaaaaaaaaa + bbbbbbbbbb + cccccccccc", 20, 2),
+            vec!["A = aaaaaaaaaa", "      + bbbbbbbbbb", "      + cccccccccc"],
+        );
+    }
+
+    #[test]
+    fn continuation_indent_leaves_relation_columns_aligned() {
+        // Relation continuations stay aligned under the first `=`; only the
+        // binary terms pick up the extra continuation indent.
+        assert_eq!(
+            lines_nested(
+                "A = aaaaaaaaaa + bbbbbbbbbb = cccccccccc + dddddddddd",
+                20,
+                2
+            ),
+            vec![
+                "A = aaaaaaaaaa",
+                "      + bbbbbbbbbb",
+                "  = cccccccccc",
+                "      + dddddddddd",
+            ],
+        );
+    }
+
     #[test]
     fn zero_relation_no_binary_stays_one_line() {
         // No relation and no top-level binary (the ops live inside the `\frac`

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-formatter/src/formatter/math/render.rs

@@ -36,7 +36,13 @@ fn render_display(top: &[SyntaxElement], opts: &MathFormatOptions) -> String {
 
     for el in top {
         if el.kind() == SyntaxKind::MATH_ENVIRONMENT {
-            flush_free_rows(&pending, &flat_indent, opts.line_width, &mut lines);
+            flush_free_rows(
+                &pending,
+                &flat_indent,
+                opts.line_width,
+                opts.math_indent,
+                &mut lines,
+            );
             pending.clear();
             if let Some(node) = el.as_node() {
                 lines.extend(render_environment_lines(node, 0, opts));
@@ -45,7 +51,13 @@ fn render_display(top: &[SyntaxElement], opts: &MathFormatOptions) -> String {
             pending.push(el.clone());
         }
     }
-    flush_free_rows(&pending, &flat_indent, opts.line_width, &mut lines);
+    flush_free_rows(
+        &pending,
+        &flat_indent,
+        opts.line_width,
+        opts.math_indent,
+        &mut lines,
+    );
     lines.join("\n")
 }
 
@@ -61,13 +73,17 @@ fn flush_free_rows(
     elems: &[SyntaxElement],
     indent: &str,
     line_width: usize,
+    cont_indent: usize,
     lines: &mut Vec<String>,
 ) {
     for row in split_logical_rows(elems) {
         if row.is_blank() {
             continue;
         }
-        let physical = linebreak::break_free_row(&row.elems, line_width);
+        // Charge the flat math-indent against the budget so packed (and single)
+        // lines genuinely stay within `line_width` once the indent is prepended.
+        let budget = line_width.saturating_sub(indent.chars().count());
+        let physical = linebreak::break_free_row(&row.elems, budget, cont_indent);
         let last = physical.len() - 1;
         for (i, content) in physical.into_iter().enumerate() {
             // The trailing `\\` (if any) rides the final physical line.

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-parser/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.17.1](https://github.com/jolars/panache/compare/panache-parser-v0.17.0...panache-parser-v0.17.1) (2026-06-15)
+
+### Bug Fixes
+- **parser:** claim trailing caption for table-first list item ([`a09f066`](https://github.com/jolars/panache/commit/a09f066a9493f3f626b44691023c59c151caafb8))
+
 ## [0.17.0](https://github.com/jolars/panache/compare/panache-parser-v0.16.0...panache-parser-v0.17.0) (2026-06-13)
 
 ### Features

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-parser"
-version = "0.17.0"
+version = "0.17.1"
 edition.workspace = true
 readme = "README.md"
 include = [

{panache_cli-2.54.0 → panache_cli-2.55.0}/crates/panache-parser/src/parser/core.rs

@@ -601,6 +601,92 @@ impl<'a> Parser<'a> {
         Some(consumed.saturating_sub(1))
     }
 
+    /// When a new list item's marker line *begins a table* that is followed by a
+    /// trailing caption (`- | a | b |\n  | - | - |\n\n  : cap` or the
+    /// `Table:`/`table:` keyword form), parse the whole table-with-caption as the
+    /// item's content here, at the marker line.
+    ///
+    /// A marker-line table is normally buffered and recognized only at item
+    /// close via [`crate::parser::utils::list_item_buffer::ListItemBuffer`]'s
+    /// structural lift. That lift cannot see a *trailing* caption: the blank line
+    /// after the table flushes the buffer (`Table:` form), and a bare `: cap`
+    /// line is additionally claimed by the definition-list parser as a term/
+    /// definition (`: cap` form) — both before the caption ever reaches the
+    /// buffer. Parsing the table at the marker line instead lets the table
+    /// parser's own trailing-caption scan (`find_caption_after_table`) absorb the
+    /// caption, matching pandoc, which always treats `: cap` after a table as the
+    /// table's `Caption`, never a definition list.
+    ///
+    /// Gated on a caption actually being present so the *no-caption* marker-line
+    /// table keeps its existing buffer-lift CST untouched. Returns the number of
+    /// source lines consumed beyond the list-marker line.
+    fn maybe_open_table_with_trailing_caption_in_new_list_item(&mut self) -> Option<usize> {
+        if !self.config.extensions.table_captions {
+            return None;
+        }
+        if !(self.config.extensions.simple_tables
+            || self.config.extensions.multiline_tables
+            || self.config.extensions.grid_tables
+            || self.config.extensions.pipe_tables)
+        {
+            return None;
+        }
+
+        let Some(Container::ListItem {
+            content_col,
+            buffer,
+            ..
+        }) = self.containers.stack.last()
+        else {
+            return None;
+        };
+        // Only the marker line is buffered so far; a multi-segment buffer means
+        // more content already accumulated and this is not a fresh marker line.
+        if buffer.segment_count() != 1 {
+            return None;
+        }
+        // Cheap pre-filter: a table on the marker line begins with `|` or `+`.
+        let first = buffer.first_text()?;
+        if !matches!(
+            first.trim_start().as_bytes().first(),
+            Some(b'|') | Some(b'+')
+        ) {
+            return None;
+        }
+        let content_col = *content_col;
+
+        let bq_depth = self.current_blockquote_depth();
+        let prefix = ContainerPrefix::from_scalars(bq_depth, content_col, bq_depth > 0, 0, true);
+        let window = StrippedLines::new(&self.lines, self.pos, &prefix);
+
+        // A caption-led table (`- : cap` / `- Table: cap` then table) is the
+        // sibling function's job; never double-handle it here.
+        if tables::is_caption_followed_by_table(&window, self.pos) {
+            return None;
+        }
+
+        // Probe into a throwaway builder: only commit when the marker-line table
+        // actually pulls in a trailing caption. Otherwise leave the line buffered
+        // so the no-caption structural lift produces its established CST.
+        let mut probe = GreenNodeBuilder::new();
+        let _ = try_parse_any_table_kind(&window, &mut probe, self.config)?;
+        let probe_root = SyntaxNode::new_root(probe.finish());
+        let has_caption = probe_root
+            .children()
+            .any(|c| c.kind() == SyntaxKind::TABLE_CAPTION);
+        if !has_caption {
+            return None;
+        }
+
+        // Commit: emit the table (with its `TABLE_CAPTION`) as the list item's
+        // content and drop the buffered marker line so it isn't also emitted.
+        let consumed = try_parse_any_table_kind(&window, &mut self.builder, self.config)?;
+        if let Some(Container::ListItem { buffer, .. }) = self.containers.stack.last_mut() {
+            buffer.clear();
+        }
+        Some(consumed.saturating_sub(1))
+    }
+
     /// CommonMark §5.2 rule #2: when a list marker is followed by ≥ 5 columns
     /// of whitespace and non-empty content, the content begins as an indented
     /// code block on the marker line. The marker parser collapses the post-
@@ -1202,6 +1288,11 @@ impl<'a> Parser<'a> {
                     if let Some(extras) = self.maybe_open_caption_table_in_new_list_item() {
                         return extras;
                     }
+                    if let Some(extras) =
+                        self.maybe_open_table_with_trailing_caption_in_new_list_item()
+                    {
+                        return extras;
+                    }
                     self.maybe_open_indented_code_in_new_list_item();
                     return self.dispatch_bq_after_list_item(finish);
                 }
@@ -1223,6 +1314,9 @@ impl<'a> Parser<'a> {
             if let Some(extras) = self.maybe_open_caption_table_in_new_list_item() {
                 return extras;
             }
+            if let Some(extras) = self.maybe_open_table_with_trailing_caption_in_new_list_item() {
+                return extras;
+            }
             self.maybe_open_indented_code_in_new_list_item();
             return self.dispatch_bq_after_list_item(finish);
         }
@@ -1265,6 +1359,9 @@ impl<'a> Parser<'a> {
             if let Some(extras) = self.maybe_open_caption_table_in_new_list_item() {
                 return extras;
             }
+            if let Some(extras) = self.maybe_open_table_with_trailing_caption_in_new_list_item() {
+                return extras;
+            }
             self.maybe_open_indented_code_in_new_list_item();
             return self.dispatch_bq_after_list_item(finish);
         }
@@ -1313,6 +1410,9 @@ impl<'a> Parser<'a> {
         if let Some(extras) = self.maybe_open_caption_table_in_new_list_item() {
             return extras;
         }
+        if let Some(extras) = self.maybe_open_table_with_trailing_caption_in_new_list_item() {
+            return extras;
+        }
         self.maybe_open_indented_code_in_new_list_item();
         self.dispatch_bq_after_list_item(finish)
     }
@@ -2634,6 +2734,10 @@ impl<'a> Parser<'a> {
                         extras
                     } else if let Some(extras) = self.maybe_open_caption_table_in_new_list_item() {
                         extras
+                    } else if let Some(extras) =
+                        self.maybe_open_table_with_trailing_caption_in_new_list_item()
+                    {
+                        extras
                     } else {
                         self.maybe_open_indented_code_in_new_list_item();
                         self.dispatch_bq_after_list_item(finish)
@@ -3656,6 +3760,32 @@ impl<'a> Parser<'a> {
 /// Pandoc parses `Term\n: # Heading\n  Some text` as DefinitionList where the
 /// definition contains [Header, Plain]; the `# Heading` line is a real Header
 /// inside the definition, not text that happens to start with `#`.
+/// Try each enabled table kind in turn (Grid → Multiline → Pipe → Simple),
+/// emitting the first match into `builder` and returning the lines consumed.
+/// Every kind validates before its first `start_node`, so on a full miss the
+/// builder is left untouched and `None` is returned. Mirrors the dispatcher's
+/// `first_kind_at` cascade for the list-item marker-line table paths.
+fn try_parse_any_table_kind(
+    window: &StrippedLines,
+    builder: &mut GreenNodeBuilder<'static>,
+    config: &ParserOptions,
+) -> Option<usize> {
+    let mut consumed = None;
+    if config.extensions.grid_tables {
+        consumed = tables::try_parse_grid_table(window, builder, config);
+    }
+    if consumed.is_none() && config.extensions.multiline_tables {
+        consumed = tables::try_parse_multiline_table(window, builder, config);
+    }
+    if consumed.is_none() && config.extensions.pipe_tables {
+        consumed = tables::try_parse_pipe_table(window, builder, config);
+    }
+    if consumed.is_none() && config.extensions.simple_tables {
+        consumed = tables::try_parse_simple_table(window, builder, config);
+    }
+    consumed
+}
+
 fn emit_definition_plain_or_heading(
     builder: &mut GreenNodeBuilder<'static>,
     text: &str,