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

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

@@ -1151,7 +1151,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "2.54.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1194,7 +1194,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "insta",
  "log",
@@ -1202,6 +1202,9 @@ dependencies = [
  "pretty_yaml",
  "pulldown-latex",
  "rowan",
+ "schemars",
+ "serde",
+ "serde_json",
  "similar-asserts",
  "toml",
  "unicode-width",
@@ -1209,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.17.0"
+version = "0.17.2"
 dependencies = [
  "entities",
  "insta",
@@ -1782,9 +1785,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.117"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2132,9 +2135,9 @@ dependencies = [
 
 [[package]]
 name = "which"
-version = "8.0.3"
+version = "8.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c789537cf2f7f55be8e6192f92e464174ee55f91af622777f7f1ceb0dbccd03e"
+checksum = "48d7cd18d4acb58fb3cdfe9ea54e6cd96a4e7d4cc45c56338b236e82dad47248"
 dependencies = [
  "libc",
 ]

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

@@ -7,7 +7,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "2.54.0"
+version = "2.56.0"
 edition.workspace = true
 readme = "README.md"
 description = "An LSP, formatter, and linter for Markdown, Quarto, and R Markdown"
@@ -31,14 +31,6 @@ authors.workspace = true
 
 [workspace]
 members = ["crates/panache-parser", "crates/panache-formatter"]
-# Excluded because this crate must be compiled to wasm32-unknown-unknown to work
-# (it relies on `dprint_core::generate_plugin_code!`, which is only defined on
-# that target). Build with:
-#   cargo build --manifest-path crates/panache-dprint/Cargo.toml \
-#     --release --target wasm32-unknown-unknown
-exclude = [
-    "crates/panache-dprint",
-]
 
 [lib]
 doctest = false
@@ -49,8 +41,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.14.0" }
+panache-parser = { path = "crates/panache-parser", version = "0.17.2", features = [
     "serde",
     "schema",
 ] }

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

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

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

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.14.0](https://github.com/jolars/panache/compare/panache-formatter-v0.13.0...panache-formatter-v0.14.0) (2026-06-17)
+
+### Features
+- **formatter:** expose config-enum JsonSchema behind schema feature ([`5062bb5`](https://github.com/jolars/panache/commit/5062bb52db346572748752210e2c6ec22b97e37d))
+- **formatter:** add `table-indent` config option ([`1365b80`](https://github.com/jolars/panache/commit/1365b801c48fbb8670ff8343884b20e5b427f1c7)), resolves [#344](https://github.com/jolars/panache/issues/344) and [#352](https://github.com/jolars/panache/issues/352)
+- **formatter:** hang math binary continuations flush under the RHS ([`0fae430`](https://github.com/jolars/panache/commit/0fae4303b8a758a7ac3a218170dfc9fb7a0c4409))
+- **formatter:** align assignment-led math chains under the RHS ([`e20d0d6`](https://github.com/jolars/panache/commit/e20d0d6c36b4fa7bae295ea41ddc27d770fa4755))
+
+### Bug Fixes
+- **formatter:** collapse line breaks inside split citations ([`148f69f`](https://github.com/jolars/panache/commit/148f69fb2d97ba5c42eb0b92645163cdc7ee4602))
+
+### Dependencies
+- updated crates/panache-parser to v0.17.2
+
+## [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.56.0}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.12.0"
+version = "0.14.0"
 edition.workspace = true
 include = [
     "/src/**/*",
@@ -18,12 +18,20 @@ 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.2" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.16.1"
+serde = { version = "1.0", features = ["derive"], optional = true }
+schemars = { version = "1.0", optional = true }
 unicode-width = "0.2"
 
+[features]
+default = []
+serde = ["dep:serde", "panache-parser/serde"]
+schema = ["serde", "dep:schemars", "panache-parser/schema"]
+
 [dev-dependencies]
+serde_json = "1.0"
 insta = { version = "1.47.2", features = ["json"] }
 # TEMPORARY: cross-validation oracle only (tests/yaml_cross_validation.rs).
 # The in-tree formatter is the source of truth. Drop this dep (and re-base

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

@@ -15,6 +15,9 @@ fn default_external_max_parallel() -> usize {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum MathDelimiterStyle {
     /// Preserve original delimiter style (\(...\) stays \(...\), $...$ stays $...$)
     #[default]
@@ -25,7 +28,13 @@ pub enum MathDelimiterStyle {
     Backslash,
 }
 
+/// Default indentation (in columns) for top-level tables.
+pub const DEFAULT_TABLE_INDENT: usize = 2;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum TabStopMode {
     /// Normalize tabs to spaces (4-column tab stop).
     #[default]
@@ -43,6 +52,9 @@ pub struct FormatterConfig {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum WrapMode {
     Preserve,
     Reflow,
@@ -53,6 +65,9 @@ pub enum WrapMode {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum LineEnding {
     Auto,
     Lf,
@@ -60,6 +75,9 @@ pub enum LineEnding {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum BlankLines {
     /// Preserve original blank lines (any number)
     Preserve,
@@ -166,6 +184,11 @@ pub struct Config {
     pub line_width: usize,
     pub math_indent: usize,
     pub math_delimiter_style: MathDelimiterStyle,
+    /// Indentation (in columns) applied to top-level pipe, simple, and
+    /// multiline tables. Grid tables ignore this and stay flush at column 0,
+    /// since Pandoc only recognizes a grid table whose border starts at column
+    /// 0. Nested tables honor their container indent instead.
+    pub table_indent: usize,
     pub tab_stops: TabStopMode,
     pub tab_width: usize,
     pub wrap: Option<WrapMode>,
@@ -200,8 +223,9 @@ 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(),
+            table_indent: DEFAULT_TABLE_INDENT,
             tab_stops: TabStopMode::Normalize,
             tab_width: 4,
             wrap: Some(WrapMode::Reflow),
@@ -249,6 +273,11 @@ impl ConfigBuilder {
         self
     }
 
+    pub fn table_indent(mut self, indent: usize) -> Self {
+        self.config.table_indent = indent;
+        self
+    }
+
     pub fn tab_width(mut self, width: usize) -> Self {
         self.config.tab_width = width;
         self
@@ -273,3 +302,49 @@ impl ConfigBuilder {
         self.config
     }
 }
+
+#[cfg(all(test, feature = "schema"))]
+mod schema_tests {
+    use super::*;
+
+    /// Assert the emitted JSON Schema exposes exactly the expected lowercase
+    /// wire values (and no PascalCase variant names). Substring checks keep this
+    /// robust to schemars emitting a flat `enum` array vs. a `oneOf`-of-`const`
+    /// shape — the doc comments on some variants become per-value descriptions.
+    fn assert_wire_values<T: schemars::JsonSchema>(expected: &[&str]) {
+        let s = serde_json::to_string(&schemars::schema_for!(T)).unwrap();
+        for value in expected {
+            assert!(
+                s.contains(&format!("\"{value}\"")),
+                "expected lowercase wire value {value:?} in schema: {s}"
+            );
+        }
+    }
+
+    #[test]
+    fn math_delimiter_style_values_are_lowercase() {
+        assert_wire_values::<MathDelimiterStyle>(&["preserve", "dollars", "backslash"]);
+    }
+
+    #[test]
+    fn tab_stop_mode_values_are_lowercase() {
+        assert_wire_values::<TabStopMode>(&["normalize", "preserve"]);
+    }
+
+    #[test]
+    fn wrap_mode_values_are_lowercase() {
+        assert_wire_values::<WrapMode>(&["preserve", "reflow", "sentence", "semantic"]);
+        let s = serde_json::to_string(&schemars::schema_for!(WrapMode)).unwrap();
+        assert!(!s.contains("\"Reflow\""), "PascalCase variant leaked: {s}");
+    }
+
+    #[test]
+    fn line_ending_values_are_lowercase() {
+        assert_wire_values::<LineEnding>(&["auto", "lf", "crlf"]);
+    }
+
+    #[test]
+    fn blank_lines_values_are_lowercase() {
+        assert_wire_values::<BlankLines>(&["preserve", "collapse"]);
+    }
+}

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

@@ -33,6 +33,85 @@ fn expand_tabs_code_span(text: &str, tab_width: usize) -> String {
     out.trim().to_string()
 }
 
+/// Render a `CITATION` or `CROSSREF` node by concatenating its child tokens.
+///
+/// Both kinds share the same syntax (`[ ... @key ... ]`) and are emitted the
+/// same way: smart-normalize text tokens, skip the whitespace that follows a
+/// blockquote marker, then collapse any internal line break (a citation may be
+/// split across input lines) so the unit reflows like ordinary inline text
+/// instead of pinning a hard newline into the paragraph.
+fn format_citation_like(node: &SyntaxNode, config: &Config) -> String {
+    let mut result = String::new();
+    let mut skip_marker_whitespace = false;
+    for child in node.children_with_tokens() {
+        match child {
+            NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
+                skip_marker_whitespace = true;
+            }
+            NodeOrToken::Token(tok)
+                if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
+            {
+                skip_marker_whitespace = false;
+            }
+            NodeOrToken::Token(tok) => {
+                skip_marker_whitespace = false;
+                result.push_str(
+                    normalize_smart_punctuation(
+                        tok.text(),
+                        config.formatter_extensions.smart,
+                        config.formatter_extensions.smart_quotes,
+                    )
+                    .as_ref(),
+                );
+            }
+            NodeOrToken::Node(n) => {
+                skip_marker_whitespace = false;
+                result.push_str(&n.text().to_string());
+            }
+        }
+    }
+    collapse_internal_newlines(&result).into_owned()
+}
+
+/// Collapse any whitespace run that contains a line break into a single space.
+///
+/// A citation or cross-reference split across input lines leaves a literal
+/// newline inside the assembled string. Emitting it verbatim makes the
+/// surrounding paragraph un-reflowable, so we normalize it the way the wrapper
+/// treats ordinary inter-word whitespace.
+fn collapse_internal_newlines(text: &str) -> std::borrow::Cow<'_, str> {
+    if !text.contains('\n') {
+        return std::borrow::Cow::Borrowed(text);
+    }
+    let mut out = String::with_capacity(text.len());
+    let mut chars = text.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch.is_whitespace() {
+            // Consume the whole whitespace run, tracking whether it contains a
+            // line break.
+            let mut has_newline = ch == '\n';
+            let mut run = String::from(ch);
+            while let Some(&next) = chars.peek() {
+                if next.is_whitespace() {
+                    has_newline |= next == '\n';
+                    run.push(next);
+                    chars.next();
+                } else {
+                    break;
+                }
+            }
+            if has_newline {
+                out.push(' ');
+            } else {
+                out.push_str(&run);
+            }
+        } else {
+            out.push(ch);
+        }
+    }
+    std::borrow::Cow::Owned(out)
+}
+
 /// Format an inline node to normalized string (e.g., emphasis with asterisks)
 pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
     match node.kind() {
@@ -536,8 +615,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 +631,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');
                     }
@@ -604,70 +694,7 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
                 .join(" ");
             format!("^[{}]", normalized)
         }
-        SyntaxKind::CITATION => {
-            let mut result = String::new();
-            let mut skip_marker_whitespace = false;
-            for child in node.children_with_tokens() {
-                match child {
-                    NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
-                        skip_marker_whitespace = true;
-                    }
-                    NodeOrToken::Token(tok)
-                        if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
-                    {
-                        skip_marker_whitespace = false;
-                    }
-                    NodeOrToken::Token(tok) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(
-                            normalize_smart_punctuation(
-                                tok.text(),
-                                config.formatter_extensions.smart,
-                                config.formatter_extensions.smart_quotes,
-                            )
-                            .as_ref(),
-                        );
-                    }
-                    NodeOrToken::Node(n) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(&n.text().to_string());
-                    }
-                }
-            }
-            result
-        }
-        SyntaxKind::CROSSREF => {
-            let mut result = String::new();
-            let mut skip_marker_whitespace = false;
-            for child in node.children_with_tokens() {
-                match child {
-                    NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
-                        skip_marker_whitespace = true;
-                    }
-                    NodeOrToken::Token(tok)
-                        if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
-                    {
-                        skip_marker_whitespace = false;
-                    }
-                    NodeOrToken::Token(tok) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(
-                            normalize_smart_punctuation(
-                                tok.text(),
-                                config.formatter_extensions.smart,
-                                config.formatter_extensions.smart_quotes,
-                            )
-                            .as_ref(),
-                        );
-                    }
-                    NodeOrToken::Node(n) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(&n.text().to_string());
-                    }
-                }
-            }
-            result
-        }
+        SyntaxKind::CITATION | SyntaxKind::CROSSREF => format_citation_like(node, config),
         _ => {
             // For other inline nodes, just return their text
             node.text().to_string()

{panache_cli-2.54.0 → panache_cli-2.56.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);