panache-cli 3.0.1__tar.gz → 3.0.2__tar.gz

{panache_cli-3.0.1 → panache_cli-3.0.2}/Cargo.lock

@@ -220,9 +220,9 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.6.7"
+version = "4.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db8b397918185f0161ff3d6fcaa9e4bfc09b8367caf6e1d4a2848e5477ed027b"
+checksum = "b1f84a88507dbd05c695f2cb5e8558e747179134005e9893882dec964190ed89"
 dependencies = [
  "clap",
 ]
@@ -430,13 +430,13 @@ dependencies = [
 
 [[package]]
 name = "displaydoc"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.3",
 ]
 
 [[package]]
@@ -883,9 +883,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "jiff"
-version = "0.2.34"
+version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e184d09547b80eb7e20d141ba2fb1fbac843ca53f4cf1b31210adc4c1adc6e16"
+checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
 dependencies = [
  "defmt",
  "jiff-core",
@@ -907,9 +907,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.34"
+version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "323da076b7a6faf914dc677cb05a4b907742ff7375c8322c9e7f5061e5e0e9de"
+checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"
 dependencies = [
  "jiff-core",
  "proc-macro2",
@@ -1205,7 +1205,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "3.0.1"
+version = "3.0.2"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1249,7 +1249,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.20.1"
+version = "0.20.2"
 dependencies = [
  "insta",
  "log",
@@ -1267,7 +1267,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.22.1"
+version = "0.22.2"
 dependencies = [
  "entities",
  "insta",
@@ -1663,9 +1663,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+checksum = "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a"
 dependencies = [
  "dyn-clone",
  "ref-cast",
@@ -1676,14 +1676,14 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d115b50f4aaeea07e79c1912f645c7513d81715d0420f8bc77a18c6260b307f"
+checksum = "d98c67716b46af2f0b8cf752abc930f6f9aecfbf671ecfb531db8a31dbe4e2ba"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.119",
+ "syn 3.0.3",
 ]
 
 [[package]]
@@ -1724,13 +1724,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive_internals"
-version = "0.29.1"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+checksum = "f852137cce035d6a4df67ccce505ff6b3e9fd3a10e3e52b24dc71e650bb1a9bd"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.3",
 ]
 
 [[package]]
@@ -1909,9 +1909,9 @@ checksum = "f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233"
 
 [[package]]
 name = "thin-vec"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0f7e269b48f0a7dd0146680fa24b50cc67fc0373f086a5b2f99bd084639b482"
+checksum = "79def32ffcd477db1ff26f76dab9e3a91f0bd42a85ca96577089b24623056f9d"
 
 [[package]]
 name = "thiserror"
@@ -1951,9 +1951,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "1.1.3+spec-1.1.0"
+version = "1.1.4+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53c96ecdfa941c8fc4fcaed14f99ada8ebed502eef533015095a07e3301d4c3c"
+checksum = "3aace63f4bbcdfc2c965b059de67119c89c4017a70d633be6c104910f67056f5"
 dependencies = [
  "indexmap",
  "serde_core",
@@ -1975,9 +1975,9 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.1.2+spec-1.1.0"
+version = "1.1.3+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"
 dependencies = [
  "winnow 1.0.4",
 ]

{panache_cli-3.0.1 → panache_cli-3.0.2}/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "3.0.1"
+version = "3.0.2"
 edition.workspace = true
 # `distill_quarto_schema` is a dev-only vendoring bin (src/bin/); keep bare
 # `cargo run` resolving to the CLI for tooling like the pre-commit format hook.
@@ -48,8 +48,8 @@ path = "src/main.rs"
 required-features = ["cli"]
 
 [dependencies]
-panache-formatter = { path = "crates/panache-formatter", version = "0.20.1" }
-panache-parser = { path = "crates/panache-parser", version = "0.22.1", features = [
+panache-formatter = { path = "crates/panache-formatter", version = "0.20.2" }
+panache-parser = { path = "crates/panache-parser", version = "0.22.2", features = [
     "serde",
     "schema",
 ] }

{panache_cli-3.0.1 → panache_cli-3.0.2}/PKG-INFO

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

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-formatter/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.20.2](https://github.com/jolars/panache/compare/panache-formatter-v0.20.1...panache-formatter-v0.20.2) (2026-07-28)
+
+### Bug Fixes
+- stabilize divs and code blocks in list items ([`3c47658`](https://github.com/jolars/panache/commit/3c476588af1cbdcf1e9f002a5dc904373fbc800e)), closes [#439](https://github.com/jolars/panache/issues/439)
+
+### Dependencies
+- updated crates/panache-parser to v0.22.2
+
 ## [0.20.1](https://github.com/jolars/panache/compare/panache-formatter-v0.20.0...panache-formatter-v0.20.1) (2026-07-25)
 
 ### Bug Fixes

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.20.1"
+version = "0.20.2"
 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.22.1" }
+panache-parser = { path = "../panache-parser", version = "0.22.2" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.16.1"
 serde = { version = "1.0.228", features = ["derive"], optional = true }

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-formatter/src/formatter/core.rs

@@ -278,7 +278,7 @@ impl Formatter {
         code_blocks::format_code_block(node, &self.config, &self.formatted_code, &mut self.output);
     }
 
-    fn format_code_block_to_string(&mut self, node: &SyntaxNode) -> String {
+    pub(super) fn format_code_block_to_string(&mut self, node: &SyntaxNode) -> String {
         let saved_output = self.output.clone();
         self.output.clear();
         self.format_code_block(node);

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-formatter/src/formatter/lists.rs

@@ -697,6 +697,123 @@ impl Formatter {
             return;
         }
 
+        // Same-line leading-block case: a LIST_ITEM whose first non-blank child
+        // is a FENCED_DIV or CODE_BLOCK (no preceding PLAIN/PARAGRAPH).
+        // Examples: `- ::: note`, ``- ```rust``. Without this the item has no
+        // content node, so the generic path below never emits the marker and
+        // the block swallows it (issue #439). Emit the outer marker, then format
+        // the block at indent=0 so its opening fence abuts the marker; splice
+        // the outer item's hanging indent into subsequent lines. Mirrors the
+        // leading-BQ path.
+        if let Some(leading_block) = first_non_blank_child.as_ref()
+            && matches!(
+                leading_block.kind(),
+                SyntaxKind::FENCED_DIV | SyntaxKind::CODE_BLOCK
+            )
+            && Self::find_content_node(node).is_none()
+        {
+            self.output.push_str(&" ".repeat(total_indent));
+            self.output
+                .push_str(&" ".repeat(list_indent.marker_padding));
+            self.output.push_str(&marker);
+            self.output.push_str(&" ".repeat(list_indent.spaces_after));
+            if let Some(ref cb) = checkbox {
+                self.output.push_str(cb);
+                self.output.push(' ');
+            }
+            let block_start = self.output.len();
+            if leading_block.kind() == SyntaxKind::CODE_BLOCK {
+                // A code block on the marker line carries no fence-indent token
+                // (its indent was consumed as the marker's trailing space), so
+                // the shared renderer leaves the list indent embedded in the
+                // content. Render it bare, abut the opening fence to the marker,
+                // then re-indent: dedent the content by its own common indent
+                // and re-apply the hanging column. The closing fence renders at
+                // column 0 and just takes the hanging prefix.
+                let raw = self.format_code_block_to_string(leading_block);
+                let raw = raw.strip_suffix('\n').unwrap_or(&raw);
+                let block_lines: Vec<&str> = raw.split('\n').collect();
+                let prefix = " ".repeat(hanging);
+                let last = block_lines.len().saturating_sub(1);
+                let content_indent = block_lines
+                    .get(1..last)
+                    .unwrap_or(&[])
+                    .iter()
+                    .filter(|l| !l.trim().is_empty())
+                    .map(|l| l.len() - l.trim_start().len())
+                    .min()
+                    .unwrap_or(0);
+                for (i, line) in block_lines.iter().enumerate() {
+                    if i == 0 {
+                        // Opening fence abuts the marker already emitted above.
+                        self.output.push_str(line.trim_start());
+                    } else if line.trim().is_empty() {
+                        // Leave blank content lines bare (no trailing spaces).
+                    } else if i == last {
+                        // Closing fence renders at column 0; just add hanging.
+                        self.output.push_str(&prefix);
+                        self.output.push_str(line);
+                    } else {
+                        // Content line: dedent its embedded list indent, re-indent.
+                        self.output.push_str(&prefix);
+                        let cut = content_indent.min(line.len());
+                        self.output.push_str(&line[cut..]);
+                    }
+                    self.output.push('\n');
+                }
+            } else {
+                // A fenced div's body is re-formatted from child blocks, so
+                // format it at indent 0 and splice the hanging indent into
+                // every subsequent non-blank line.
+                self.format_node_sync(leading_block, 0);
+                if self.output.as_bytes().get(block_start) == Some(&b'\n') {
+                    self.output.remove(block_start);
+                }
+                if hanging > 0 {
+                    let block_text = self.output.split_off(block_start);
+                    let prefix = " ".repeat(hanging);
+                    let mut first = true;
+                    for line in block_text.split_inclusive('\n') {
+                        let is_blank = line.trim_end_matches('\n').is_empty();
+                        if !first && !is_blank {
+                            self.output.push_str(&prefix);
+                        }
+                        self.output.push_str(line);
+                        first = false;
+                    }
+                }
+            }
+
+            // Emit trailing children (further blocks after the leading block) at
+            // hanging indent, preserving a single blank-line separator between
+            // loose blocks. Dropping the blank would glue two sibling divs
+            // (`:::` immediately followed by `:::  other`), which re-parses into
+            // a different shape and breaks idempotency (issue #439).
+            let mut reached_leading = false;
+            let mut pending_blank = false;
+            for child in node.children() {
+                if &child == leading_block {
+                    reached_leading = true;
+                    continue;
+                }
+                if !reached_leading {
+                    continue;
+                }
+                if child.kind() == SyntaxKind::BLANK_LINE {
+                    pending_blank = true;
+                    continue;
+                }
+                if pending_blank {
+                    if !self.output.ends_with("\n\n") {
+                        self.output.push('\n');
+                    }
+                    pending_blank = false;
+                }
+                self.format_node_sync(&child, hanging);
+            }
+            return;
+        }
+
         // Same-line nested-marker case: a LIST_ITEM whose first non-blank
         // child is a non-empty nested LIST (no preceding PLAIN/PARAGRAPH).
         // Examples: `- - foo`, `1. - 2. foo`. Emit the outer marker without

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.22.2](https://github.com/jolars/panache/compare/panache-parser-v0.22.1...panache-parser-v0.22.2) (2026-07-28)
+
+### Bug Fixes
+- stabilize divs and code blocks in list items ([`3c47658`](https://github.com/jolars/panache/commit/3c476588af1cbdcf1e9f002a5dc904373fbc800e)), closes [#439](https://github.com/jolars/panache/issues/439)
+- **parser:** inline-parse single-column multiline table cells ([`f69d2bb`](https://github.com/jolars/panache/commit/f69d2bbc7847a15f67c1b5322f9d529962fe0521)), closes [#438](https://github.com/jolars/panache/issues/438)
+
 ## [0.22.1](https://github.com/jolars/panache/compare/panache-parser-v0.22.0...panache-parser-v0.22.1) (2026-07-25)
 
 ### Bug Fixes

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/Cargo.toml

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

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/src/parser/block_dispatcher.rs

@@ -135,6 +135,12 @@ pub(crate) struct BlockContext<'a> {
     /// Whether we're currently inside any list
     pub in_list: bool,
 
+    /// Whether the innermost open fenced div wraps the innermost open list (the
+    /// div is outer to the list). When true, a `:::` at the list content column
+    /// is list content rather than the div's closer. See issue #439 and
+    /// `FencedDivCloseParser::detect_prepared`.
+    pub fenced_div_wraps_list: bool,
+
     /// Whether the immediate enclosing container is a list item that has so
     /// far seen only its marker (no content yet). Equivalent to the
     /// `marker_only` flag on `Container::ListItem`. Used by indented code
@@ -2527,7 +2533,27 @@ impl BlockParser for FencedDivCloseParser {
             return None;
         }
 
-        if !is_div_closing_fence(content_for_fenced_div_detection(ctx, lines.first())) {
+        // When the innermost open div *wraps* the current list, a `:::` at or
+        // beyond the list's content column is list content, not this div's
+        // closer: pandoc only closes a div on a fence at the div's own
+        // indentation, so an outer (col-0) div is not closed by an indented
+        // fence buried in a list item — it closes a div opened *inside* the item
+        // (handled by list buffering + re-parse) or is literal text. Without
+        // this guard the outer div steals the inner fence, dropping the nested
+        // div's close and breaking idempotency (issue #439). The guard is scoped
+        // to wrapping divs so a div opened as a list *continuation* block still
+        // closes on a fence at its own (content-column) indentation.
+        let first = lines.first();
+        if ctx.fenced_div_wraps_list
+            && let Some(list_info) = ctx.list_indent_info
+        {
+            let (indent_cols, _) = leading_indent(first);
+            if indent_cols >= list_info.content_col {
+                return None;
+            }
+        }
+
+        if !is_div_closing_fence(content_for_fenced_div_detection(ctx, first)) {
             return None;
         }
 

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/src/parser/blocks/tables.rs

@@ -11,7 +11,7 @@ use crate::parser::utils::attributes::{
 use crate::parser::utils::helpers::{emit_line_tokens, emit_separator_tokens, strip_newline};
 use crate::parser::utils::inline_emission;
 
-use super::container_prefix::StrippedLines;
+use super::container_prefix::{ContainerPrefix, StrippedLines};
 
 /// Read-only indexed view over lines for table detection scans. Two
 /// backings:
@@ -3340,6 +3340,14 @@ fn extract_first_line_cell_contents(line: &str, columns: &[Column]) -> Vec<Strin
     cells
 }
 
+/// Whether the window's container prefix contributes no bytes to continuation
+/// lines (top-level, i.e. not nested in a blockquote or list). Used to gate the
+/// single-column multiline-cell inline join, which reads raw continuation lines
+/// and would otherwise fold `>`/list-marker bytes into cell content.
+fn prefix_is_empty(prefix: &ContainerPrefix) -> bool {
+    prefix.bq_depth() == 0 && prefix.list_content_col() == 0 && prefix.content_indent() == 0
+}
+
 /// Emit a multiline table row with inline parsing (Phase 7.1).
 ///
 /// `indices` are ABSOLUTE line indices into the window's raw buffer; each
@@ -3360,6 +3368,41 @@ fn emit_multiline_table_row(
 
     builder.start_node(kind.into());
 
+    // Single-column, top-level multi-line rows: pandoc joins a cell's physical
+    // lines and parses the result as inline content, so a fenced code block
+    // inside the cell flattens to an inline code span. Emitting continuation
+    // lines as raw TEXT (the general path below) skips that inline pass, leaving
+    // un-normalized markup (```` ```{r} rm(F12) ``` ````) that reparses as a
+    // normalized inline code span on the next format pass — an idempotency break
+    // (issue #438). Feed the joined cell text through the inline emitter,
+    // preserving interior newlines for losslessness. Gated on an empty container
+    // prefix so continuation-line `>`/list markers never leak into cell content;
+    // nested and multi-column rows keep the verbatim path.
+    if columns.len() == 1 && indices.len() > 1 && prefix_is_empty(window.prefix()) {
+        let first = window.strip_at(indices[0]);
+        let (first_trimmed, _) = strip_newline(first);
+        let cell_start = column_offset_to_byte_index(first_trimmed, columns[0].start);
+        if cell_start > 0 {
+            builder.token(SyntaxKind::WHITESPACE.into(), &first_trimmed[..cell_start]);
+        }
+
+        let mut joined = String::from(&first[cell_start..]);
+        for &idx in &indices[1..] {
+            joined.push_str(window.strip_at(idx));
+        }
+
+        // Split the trailing newline off so it sits beside the cell as a sibling
+        // NEWLINE, matching the single-line row shape.
+        let (cell_text, trailing_nl) = strip_newline(&joined);
+        emit_table_cell(builder, cell_text, config);
+        if !trailing_nl.is_empty() {
+            builder.token(SyntaxKind::NEWLINE.into(), trailing_nl);
+        }
+
+        builder.finish_node();
+        return;
+    }
+
     // Emit the first line's container prefix as tokens, then slice cells from
     // the prefix-stripped tail (for CST losslessness, only the first physical
     // line is parsed into cells; continuation lines stay verbatim TEXT).

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/src/parser/blocks/tests/blockquotes.rs

@@ -485,6 +485,7 @@ fn dispatcher_blockquote_detection() {
         has_blank_before_strict: true,
         at_document_start: true,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),
@@ -525,6 +526,7 @@ fn dispatcher_blockquote_requires_blank_before() {
         has_blank_before_strict: false,
         at_document_start: false,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),
@@ -571,6 +573,7 @@ fn dispatcher_blockquote_payload_basic() {
         has_blank_before_strict: true,
         at_document_start: true,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),
@@ -614,6 +617,7 @@ fn dispatcher_blockquote_payload_nested_requires_blank() {
         has_blank_before_strict: false,
         at_document_start: false,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),
@@ -655,6 +659,7 @@ fn dispatcher_blockquote_ignored_inside_blockquote() {
         has_blank_before_strict: false,
         at_document_start: false,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 1,
         config: &ParserOptions::default(),
@@ -692,6 +697,7 @@ fn dispatcher_blockquote_payload_nested_with_blank() {
         has_blank_before_strict: false,
         at_document_start: false,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),
@@ -733,6 +739,7 @@ fn dispatcher_blockquote_payload_nested_after_blank_line() {
         has_blank_before_strict: true,
         at_document_start: false,
         in_fenced_div: false,
+        fenced_div_wraps_list: false,
         myst_directive_closer: None,
         blockquote_depth: 0,
         config: &ParserOptions::default(),

{panache_cli-3.0.1 → panache_cli-3.0.2}/crates/panache-parser/src/parser/core.rs

@@ -2406,6 +2406,7 @@ impl<'a> Parser<'a> {
                 has_blank_before_strict: has_blank_before,
                 at_document_start: self.pos == 0,
                 in_fenced_div: self.in_fenced_div(),
+                fenced_div_wraps_list: self.fenced_div_wraps_innermost_list(),
                 myst_directive_closer: self.innermost_myst_directive_closer(),
                 blockquote_depth: current_bq_depth,
                 config: self.config,
@@ -3569,6 +3570,7 @@ impl<'a> Parser<'a> {
                             || is_blank_line(self.lines[self.pos - 1]),
                         at_document_start: self.pos == 0 && self.current_blockquote_depth() == 0,
                         in_fenced_div: self.in_fenced_div(),
+                        fenced_div_wraps_list: self.fenced_div_wraps_innermost_list(),
                         myst_directive_closer: self.innermost_myst_directive_closer(),
                         blockquote_depth: self.current_blockquote_depth(),
                         config: self.config,
@@ -3826,6 +3828,7 @@ impl<'a> Parser<'a> {
             has_blank_before_strict: false, // filled in later
             at_document_start: false,       // filled in later
             in_fenced_div: self.in_fenced_div(),
+            fenced_div_wraps_list: self.fenced_div_wraps_innermost_list(),
             myst_directive_closer: self.innermost_myst_directive_closer(),
             blockquote_depth: current_bq_depth,
             config: self.config,
@@ -4368,6 +4371,28 @@ impl<'a> Parser<'a> {
             .rposition(|c| matches!(c, Container::FencedDiv { .. }))
     }
 
+    /// True when the innermost open fenced div wraps the innermost open list
+    /// (the div is outer to the list on the container stack). In that case a
+    /// `:::` indented to the list's content column is list content, not the
+    /// div's closer — pandoc only closes a div on a fence at the div's own
+    /// indentation. When instead the innermost div was opened *inside* a list
+    /// item (as a continuation block, so it is inner to the list), a fence at
+    /// the content column does close it. See issue #439.
+    fn fenced_div_wraps_innermost_list(&self) -> bool {
+        let Some(div_idx) = self.fenced_div_container_index() else {
+            return false;
+        };
+        match self
+            .containers
+            .stack
+            .iter()
+            .rposition(|c| matches!(c, Container::List { .. }))
+        {
+            Some(list_idx) => div_idx < list_idx,
+            None => false,
+        }
+    }
+
     fn close_containers_to_fenced_div(&mut self) {
         if let Some(index) = self.fenced_div_container_index() {
             self.close_containers_to(index + 1);

{panache_cli-3.0.1 → panache_cli-3.0.2}/src/config.rs

@@ -598,6 +598,17 @@ fn project_boundary(start_dir: &Path) -> Option<PathBuf> {
     None
 }
 
+/// Resolve a possibly CWD-relative `start_dir` to an absolute path so that
+/// ancestor walks see the real filesystem parents. The empty path (the parent
+/// of a bare filename) means the working directory. Falls back to the path as
+/// given when the working directory is unavailable.
+fn absolutize_start_dir(start_dir: &Path) -> PathBuf {
+    if start_dir.as_os_str().is_empty() {
+        return env::current_dir().unwrap_or_else(|_| start_dir.to_path_buf());
+    }
+    std::path::absolute(start_dir).unwrap_or_else(|_| start_dir.to_path_buf())
+}
+
 fn xdg_config_path() -> Option<PathBuf> {
     if let Ok(xdg) = env::var("XDG_CONFIG_HOME") {
         let p = Path::new(&xdg).join("panache").join("config.toml");
@@ -679,6 +690,13 @@ pub fn load_with_chain(
     input_file: Option<&Path>,
     flavor_override: Option<Flavor>,
 ) -> io::Result<(Config, ConfigSource, Vec<PathBuf>)> {
+    // CLI callers derive `start_dir` from user-supplied targets, so it is
+    // often CWD-relative (`.`, `subdir`, or even empty for a bare filename).
+    // `Path::ancestors()` is purely lexical: a relative walk ends at the
+    // working directory and never reaches its real filesystem parents, so
+    // discovery and the `.git` boundary would miss ancestor configs (#441).
+    let start_dir = absolutize_start_dir(start_dir);
+    let start_dir = start_dir.as_path();
     let boundary = project_boundary(start_dir);
     let (mut cfg, source, extensions, chain) = if let Some(path) = explicit {
         let (cfg, ext, chain) = read_config_with_chain(path).map_err(io::Error::from)?;

{panache_cli-3.0.1 → panache_cli-3.0.2}/src/main.rs

@@ -1522,7 +1522,7 @@ fn main() -> io::Result<()> {
         } => {
             if check {
                 eprintln!(
-                    "Warning: `panache lint --check` is deprecated; linting exits non-zero on \
+                    "Warning: the `--check` flag is deprecated; linting exits non-zero on \
                      violations by default. The flag is now a no-op."
                 );
             }