panache-cli 2.60.0__tar.gz → 2.61.0__tar.gz

{panache_cli-2.60.0 → panache_cli-2.61.0}/Cargo.lock

@@ -372,9 +372,9 @@ checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
 
 [[package]]
 name = "defmt"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6e524506490a1953d237cb87b1cfc1e46f88c18f10a22dfe0f507dc6bfc7f7f"
+checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
 dependencies = [
  "bitflags 1.3.2",
  "defmt-macros",
@@ -382,12 +382,11 @@ dependencies = [
 
 [[package]]
 name = "defmt-macros"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0a27770e9c8f719a79d8b638281f4d828f77d8fd61e0bd94451b9b85e576a0b"
+checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
 dependencies = [
  "defmt-parser",
- "proc-macro-error2",
  "proc-macro2",
  "quote",
  "syn",
@@ -931,9 +930,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.46.8"
+version = "0.46.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24fc8535da347b994f6d2fab0a84b74e3b31ad08ebe4204d95f3e755db7af49b"
+checksum = "1d865ca7ca04445fcaa1d751fda3dc43b0113ba2fcddc65d5a0fcb474a7c3bba"
 dependencies = [
  "ahash",
  "bytecount",
@@ -944,18 +943,27 @@ dependencies = [
  "getrandom 0.3.4",
  "idna",
  "itoa",
+ "jsonschema-regex",
  "num-cmp",
  "num-traits",
  "percent-encoding",
  "referencing",
  "regex",
- "regex-syntax",
  "serde",
  "serde_json",
  "unicode-general-category",
  "uuid-simd",
 ]
 
+[[package]]
+name = "jsonschema-regex"
+version = "0.46.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b7fc96cd6677cc81b00607d43477327d719419937ef1c44b3556a40f517d54c"
+dependencies = [
+ "regex-syntax",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -1083,9 +1091,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.6"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "c863e9ab5e7bf9c99ba75e1050f1e4d624ae87ed3532d6238ffbdc7b585dbbe6"
 dependencies = [
  "num-integer",
  "num-traits",
@@ -1182,7 +1190,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "2.60.0"
+version = "2.61.0"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1226,7 +1234,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "insta",
  "log",
@@ -1244,7 +1252,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.20.0"
+version = "0.21.0"
 dependencies = [
  "entities",
  "insta",
@@ -1392,28 +1400,6 @@ dependencies = [
  "yaml_parser",
 ]
 
-[[package]]
-name = "proc-macro-error-attr2"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "proc-macro-error2"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
-dependencies = [
- "proc-macro-error-attr2",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
@@ -1515,9 +1501,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.46.8"
+version = "0.46.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c8dceb372b46fecd006be48ca335468b49ad887a7f0150cabd6098fa4fc500f"
+checksum = "77954d81b2e1c5e8ab889f9f597a92f852ab073255de9e37ee3fb443efd57051"
 dependencies = [
  "ahash",
  "fluent-uri 0.4.1",
@@ -1585,9 +1571,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.2"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 
 [[package]]
 name = "rustix"
@@ -1625,7 +1611,7 @@ dependencies = [
  "parking_lot",
  "portable-atomic",
  "rayon",
- "rustc-hash 2.1.2",
+ "rustc-hash 2.1.3",
  "salsa-macro-rules",
  "salsa-macros",
  "smallvec",

{panache_cli-2.60.0 → panache_cli-2.61.0}/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "2.60.0"
+version = "2.61.0"
 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.18.0" }
-panache-parser = { path = "crates/panache-parser", version = "0.20.0", features = [
+panache-formatter = { path = "crates/panache-formatter", version = "0.19.0" }
+panache-parser = { path = "crates/panache-parser", version = "0.21.0", features = [
     "serde",
     "schema",
 ] }

{panache_cli-2.60.0 → panache_cli-2.61.0}/PKG-INFO

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

{panache_cli-2.60.0 → panache_cli-2.61.0}/build.rs

@@ -80,7 +80,7 @@ fn generate_cli_markdown() -> Result<()> {
     let mut document = String::new();
     document.push_str("---\n");
     document.push_str("title: CLI Reference\n");
-    document.push_str("description: >\n  Comprehensive reference for the Panache CLI, including all commands, options,\nand usage examples.\n");
+    document.push_str("description: >\n  Comprehensive reference for the Panache CLI, including all commands, options,\n  and usage examples.\n");
     document.push_str("---\n\n");
     document.push_str(&markdown);
 

{panache_cli-2.60.0 → panache_cli-2.61.0}/crates/panache-formatter/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.19.0](https://github.com/jolars/panache/compare/panache-formatter-v0.18.0...panache-formatter-v0.19.0) (2026-07-04)
+
+### Features
+- **parser:** flag unbalanced `\left`/`\right` in math ([`73750c9`](https://github.com/jolars/panache/commit/73750c9b854e8899fcd2b7180c21f9b2eb7af892))
+
+### Bug Fixes
+- **formatter:** route non-reflowable math verbatim ([`bd577dc`](https://github.com/jolars/panache/commit/bd577dcd7884428b83ea9034a048863c97368c28))
+
+### Dependencies
+- updated crates/panache-parser to v0.21.0
+
 ## [0.18.0](https://github.com/jolars/panache/compare/panache-formatter-v0.17.0...panache-formatter-v0.18.0) (2026-07-01)
 
 ### Features

{panache_cli-2.60.0 → panache_cli-2.61.0}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.18.0"
+version = "0.19.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.20.0" }
+panache-parser = { path = "../panache-parser", version = "0.21.0" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.16.1"
 serde = { version = "1.0", features = ["derive"], optional = true }

{panache_cli-2.60.0 → panache_cli-2.61.0}/crates/panache-formatter/src/formatter/core.rs

@@ -2680,14 +2680,17 @@ impl Formatter {
                             &self.config,
                             MathContext::EnvironmentBody,
                         );
-                        if opts.enabled {
-                            self.output.push('\n');
-                            self.output.push_str(&math::format_math(&content, &opts));
-                            self.output.push('\n');
-                        } else {
-                            self.output.push_str(&content);
-                            if !content.ends_with('\n') {
+                        match math::format_math(&content, &opts) {
+                            Some(body) => {
                                 self.output.push('\n');
+                                self.output.push_str(&body);
+                                self.output.push('\n');
+                            }
+                            None => {
+                                self.output.push_str(&content);
+                                if !content.ends_with('\n') {
+                                    self.output.push('\n');
+                                }
                             }
                         }
                     }
@@ -2704,16 +2707,19 @@ impl Formatter {
                 // Math content
                 if let Some(content) = math_content {
                     let opts = MathFormatOptions::from_config(&self.config, MathContext::Display);
-                    if opts.enabled {
-                        self.output.push_str(&math::format_math(&content, &opts));
-                        self.output.push('\n');
-                    } else {
-                        let math_indent = self.config.math_indent;
-                        for line in content.trim().lines() {
-                            self.output.push_str(&" ".repeat(math_indent));
-                            self.output.push_str(line.trim_end());
+                    match math::format_math(&content, &opts) {
+                        Some(body) => {
+                            self.output.push_str(&body);
                             self.output.push('\n');
                         }
+                        None => {
+                            let math_indent = self.config.math_indent;
+                            for line in content.trim().lines() {
+                                self.output.push_str(&" ".repeat(math_indent));
+                                self.output.push_str(line.trim_end());
+                                self.output.push('\n');
+                            }
+                        }
                     }
                 }
 

{panache_cli-2.60.0 → panache_cli-2.61.0}/crates/panache-formatter/src/formatter/inline.rs

@@ -530,23 +530,21 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
             // verbatim (byte-identical to before).
             if is_display_math {
                 let opts = MathFormatOptions::from_config(config, MathContext::Display);
-                if opts.enabled {
-                    let clean = InlineMath::cast(node.clone())
-                        .map(|m| m.content())
-                        .unwrap_or_else(|| content.clone());
-                    format!("{}\n{}\n{}", open, math::format_math(&clean, &opts), close)
-                } else {
-                    format!("{}\n{}\n{}", open, content.trim(), close)
+                let clean = InlineMath::cast(node.clone())
+                    .map(|m| m.content())
+                    .unwrap_or_else(|| content.clone());
+                match math::format_math(&clean, &opts) {
+                    Some(body) => format!("{}\n{}\n{}", open, body, close),
+                    None => format!("{}\n{}\n{}", open, content.trim(), close),
                 }
             } else {
                 let opts = MathFormatOptions::from_config(config, MathContext::Inline);
-                if opts.enabled {
-                    let clean = InlineMath::cast(node.clone())
-                        .map(|m| m.content())
-                        .unwrap_or_else(|| content.clone());
-                    format!("{}{}{}", open, math::format_math(&clean, &opts), close)
-                } else {
-                    format!("{}{}{}", open, content, close)
+                let clean = InlineMath::cast(node.clone())
+                    .map(|m| m.content())
+                    .unwrap_or_else(|| content.clone());
+                match math::format_math(&clean, &opts) {
+                    Some(body) => format!("{}{}{}", open, body, close),
+                    None => format!("{}{}{}", open, content, close),
                 }
             }
         }
@@ -589,14 +587,17 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
             if is_environment {
                 let opts = MathFormatOptions::from_config(config, MathContext::EnvironmentBody);
                 result.push_str(open);
-                if opts.enabled {
-                    result.push('\n');
-                    result.push_str(&math::format_math(&content, &opts));
-                    result.push('\n');
-                } else {
-                    result.push_str(&content);
-                    if !content.ends_with('\n') {
+                match math::format_math(&content, &opts) {
+                    Some(body) => {
                         result.push('\n');
+                        result.push_str(&body);
+                        result.push('\n');
+                    }
+                    None => {
+                        result.push_str(&content);
+                        if !content.ends_with('\n') {
+                            result.push('\n');
+                        }
                     }
                 }
                 result.push_str(close);
@@ -611,52 +612,55 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
             result.push('\n');
 
             let opts = MathFormatOptions::from_config(config, MathContext::Display);
-            if opts.enabled {
-                result.push_str(&math::format_math(&content, &opts));
-                result.push('\n');
-            } else {
-                // Process content: drop leading blank (whitespace-only) lines and
-                // trailing whitespace, strip common leading indentation, then
-                // re-indent every line by `math_indent`. Leading whitespace-only
-                // lines must be dropped rather than emitted: a blank line directly
-                // after the opening `$$` reparses as a paragraph break that splits
-                // the display math (pandoc ends `$$…$$` on any blank line), so
-                // emitting one is not lossless across passes. The opening marker's
-                // own trailing whitespace (`$$ `) surfaces here as exactly such a
-                // leading line. Stripping only full blank lines (not leading spaces
-                // of a content line) keeps each real line's indent visible to
-                // `min_indent`, so the re-indent stays idempotent.
-                let mut trimmed_content = content.trim_end();
-                while let Some((first, rest)) = trimmed_content.split_once('\n') {
-                    if first.trim().is_empty() {
-                        trimmed_content = rest;
-                    } else {
-                        break;
-                    }
+            match math::format_math(&content, &opts) {
+                Some(body) => {
+                    result.push_str(&body);
+                    result.push('\n');
                 }
-                if !trimmed_content.is_empty() {
-                    // Find minimum indentation across all non-empty lines
-                    let min_indent = trimmed_content
-                        .lines()
-                        .filter(|line| !line.trim().is_empty())
-                        .map(|line| line.len() - line.trim_start().len())
-                        .min()
-                        .unwrap_or(0);
-
-                    let pad = " ".repeat(config.math_indent);
-                    // Strip common indentation, then re-indent each line.
-                    for line in trimmed_content.lines() {
-                        let stripped = if line.len() >= min_indent {
-                            &line[min_indent..]
+                None => {
+                    // Process content: drop leading blank (whitespace-only) lines and
+                    // trailing whitespace, strip common leading indentation, then
+                    // re-indent every line by `math_indent`. Leading whitespace-only
+                    // lines must be dropped rather than emitted: a blank line directly
+                    // after the opening `$$` reparses as a paragraph break that splits
+                    // the display math (pandoc ends `$$…$$` on any blank line), so
+                    // emitting one is not lossless across passes. The opening marker's
+                    // own trailing whitespace (`$$ `) surfaces here as exactly such a
+                    // leading line. Stripping only full blank lines (not leading spaces
+                    // of a content line) keeps each real line's indent visible to
+                    // `min_indent`, so the re-indent stays idempotent.
+                    let mut trimmed_content = content.trim_end();
+                    while let Some((first, rest)) = trimmed_content.split_once('\n') {
+                        if first.trim().is_empty() {
+                            trimmed_content = rest;
                         } else {
-                            line
-                        };
-                        // Skip padding blank lines to avoid trailing whitespace.
-                        if !stripped.is_empty() {
-                            result.push_str(&pad);
-                            result.push_str(stripped);
+                            break;
+                        }
+                    }
+                    if !trimmed_content.is_empty() {
+                        // Find minimum indentation across all non-empty lines
+                        let min_indent = trimmed_content
+                            .lines()
+                            .filter(|line| !line.trim().is_empty())
+                            .map(|line| line.len() - line.trim_start().len())
+                            .min()
+                            .unwrap_or(0);
+
+                        let pad = " ".repeat(config.math_indent);
+                        // Strip common indentation, then re-indent each line.
+                        for line in trimmed_content.lines() {
+                            let stripped = if line.len() >= min_indent {
+                                &line[min_indent..]
+                            } else {
+                                line
+                            };
+                            // Skip padding blank lines to avoid trailing whitespace.
+                            if !stripped.is_empty() {
+                                result.push_str(&pad);
+                                result.push_str(stripped);
+                            }
+                            result.push('\n');
                         }
-                        result.push('\n');
                     }
                 }
             }

{panache_cli-2.60.0 → panache_cli-2.61.0}/crates/panache-formatter/src/formatter/math.rs

@@ -23,8 +23,8 @@
 //! default) callers emit math verbatim and never reach this module; on, they
 //! route content through [`format_math`].
 
-use panache_parser::parser::math::{MathParseOptions, parse_math_report};
-use panache_parser::syntax::SyntaxNode;
+use panache_parser::parser::math::{MathParseOptions, parse_math_content};
+use panache_parser::syntax::{SyntaxNode, math_diagnostics};
 
 mod linebreak;
 pub mod operators;
@@ -77,35 +77,36 @@ impl MathFormatOptions {
     }
 }
 
-/// Format clean math content (delimiters excluded, both in and out).
+/// Reflow clean math content (delimiters excluded, both in and out).
 ///
-/// Returns the input unchanged — never panicking, never erroring — on any bail
-/// condition: the gate is off, the content has an unescaped lone `$` (a
-/// preservation guard against cross-pass drift), or the structural parse
-/// reports a diagnostic (malformed math is never reflowed). Otherwise it
-/// re-emits the content per `STYLE.md`.
-pub fn format_math(input: &str, opts: &MathFormatOptions) -> String {
+/// Returns `None` — never panicking, never erroring — on any bail condition: the
+/// gate is off, the content has an unescaped lone `$` (a preservation guard
+/// against cross-pass drift), or the structural parse reports a diagnostic
+/// (malformed math is never reflowed). The caller then emits the content through
+/// its own verbatim path, so gate-off and malformed-gate-on stay byte-identical
+/// and no fence-padding normalization is duplicated here. On success it returns
+/// the reflowed content per `STYLE.md`.
+pub fn format_math(input: &str, opts: &MathFormatOptions) -> Option<String> {
     if !opts.enabled {
-        return input.to_string();
+        return None;
     }
     // Lone unescaped `$` inside content confuses delimiter handling downstream;
     // mirror the existing `has_unescaped_single_dollar_in_content` guard.
     if has_unescaped_single_dollar(input) {
-        return input.to_string();
+        return None;
     }
-    let report = parse_math_report(
+    let tree = SyntaxNode::new_root(parse_math_content(
         input,
         MathParseOptions {
             bookdown_equation_labels: opts.bookdown_equation_labels,
         },
-    );
+    ));
     // Malformed math (unclosed/mismatched braces or environments) has an
-    // untrustworthy row/column structure — leave it exactly as written.
-    if !report.diagnostics.is_empty() {
-        return input.to_string();
+    // untrustworthy row/column structure — leave it to the caller's verbatim path.
+    if !math_diagnostics(&tree).is_empty() {
+        return None;
     }
-    let tree = SyntaxNode::new_root(report.green);
-    render::render(&tree, opts)
+    Some(render::render(&tree, opts))
 }
 
 /// String-level twin of `DisplayMath::has_unescaped_single_dollar_in_content`
@@ -151,7 +152,13 @@ mod tests {
     }
 
     fn fmt(input: &str, context: MathContext) -> String {
-        format_math(input, &opts(context))
+        fmt_with(input, &opts(context))
+    }
+
+    /// Reflow with explicit options; unwraps because these cases are well-formed
+    /// (`format_math` only returns `None` for gate-off / lone-`$` / malformed).
+    fn fmt_with(input: &str, o: &MathFormatOptions) -> String {
+        format_math(input, o).expect("expected reflowable math")
     }
 
     /// Every well-formed case must be a fixed point of itself.
@@ -162,13 +169,14 @@ mod tests {
     }
 
     #[test]
-    fn gate_off_is_verbatim() {
+    fn gate_off_returns_none() {
+        // Gate off ⇒ the caller emits verbatim through its own path.
         let off = MathFormatOptions {
             enabled: false,
             ..opts(MathContext::Display)
         };
         let input = "\\begin{aligned}\nx&=1\\\\\ny &= 22\n\\end{aligned}";
-        assert_eq!(format_math(input, &off), input);
+        assert_eq!(format_math(input, &off), None);
     }
 
     #[test]
@@ -185,16 +193,20 @@ mod tests {
     }
 
     #[test]
-    fn malformed_math_is_verbatim() {
-        // Unclosed group → diagnostic → bail.
+    fn malformed_math_bails() {
+        // Unclosed group → diagnostic → bail; the caller emits it verbatim. The
+        // end-to-end verbatim shape (no doubled fence newlines) is covered by the
+        // `math_malformed_delimiter_experimental` golden case.
         let input = "\\frac{1}{2";
-        assert_eq!(fmt(input, MathContext::Inline), input);
+        assert_eq!(format_math(input, &opts(MathContext::Inline)), None);
+        // An unclosed `\left` (a `MATH_DELIMITED` lacking `\right`) also bails.
+        assert_eq!(format_math("\\left( x", &opts(MathContext::Display)), None);
     }
 
     #[test]
-    fn lone_dollar_is_verbatim() {
+    fn lone_dollar_bails() {
         let input = "a $ b";
-        assert_eq!(fmt(input, MathContext::Inline), input);
+        assert_eq!(format_math(input, &opts(MathContext::Inline)), None);
     }
 
     #[test]
@@ -360,10 +372,10 @@ mod tests {
         // First `=` stays; the second starts a continuation aligned under it
         // (equality chain ⇒ relations stack under the first relation).
         let expected = "A = bbbbbbbbbb\n  = cccccccccc";
-        assert_eq!(format_math(input, &narrow), expected);
+        assert_eq!(fmt_with(input, &narrow), expected);
         // Re-feeding the broken (multi-line) form recomputes the same layout.
-        let once = format_math(input, &narrow);
-        assert_eq!(format_math(&once, &narrow), once);
+        let once = fmt_with(input, &narrow);
+        assert_eq!(fmt_with(&once, &narrow), once);
     }
 
     #[test]
@@ -372,7 +384,7 @@ mod tests {
         // to the pre-line-breaking behavior).
         let wide = opts(MathContext::Display); // line_width 80
         assert_eq!(
-            format_math("A = bbbbbbbbbb = cccccccccc", &wide),
+            fmt_with("A = bbbbbbbbbb = cccccccccc", &wide),
             "A = bbbbbbbbbb = cccccccccc"
         );
     }
@@ -387,9 +399,9 @@ mod tests {
         // Relations break first; each over-width segment nests its `+` term one
         // indent level deeper, under the relation's right-hand side.
         let expected = "A = aaaaaaaaaa\n    + bbbbbbbbbb\n  = cccccccccc\n    + dddddddddd";
-        assert_eq!(format_math(input, &narrow), expected);
-        let once = format_math(input, &narrow);
-        assert_eq!(format_math(&once, &narrow), once);
+        assert_eq!(fmt_with(input, &narrow), expected);
+        let once = fmt_with(input, &narrow);
+        assert_eq!(fmt_with(&once, &narrow), once);
     }
 
     #[test]
@@ -399,7 +411,7 @@ mod tests {
         // the rendered math). Regression for the logical-row re-join.
         let wide = opts(MathContext::Display);
         let input = "% leading comment\nx = 1";
-        assert_eq!(format_math(input, &wide), "% leading comment\nx = 1");
+        assert_eq!(fmt_with(input, &wide), "% leading comment\nx = 1");
         assert_idempotent(input, MathContext::Display);
     }
 
@@ -411,14 +423,14 @@ mod tests {
         };
         // A single over-width fraction with no top-level operator stays one line.
         let frac = "\\frac{aaaaaaaa}{bbbbbbbb}";
-        assert_eq!(format_math(frac, &narrow), frac);
+        assert_eq!(fmt_with(frac, &narrow), frac);
         // Relation *and* binary operators buried inside `\left(…\right)` are not
         // depth-0 break points, so this over-width row has no break candidate and
         // stays on one line (the broader binary-breaking scope must still respect
         // delimiter opacity).
         let paren = "\\left( xxxx = yyyy + wwww \\right)";
-        let once = format_math(paren, &narrow);
+        let once = fmt_with(paren, &narrow);
         assert!(!once.contains('\n'), "should not break: {once:?}");
-        assert_eq!(format_math(&once, &narrow), once);
+        assert_eq!(fmt_with(&once, &narrow), once);
     }
 }