fix(md013): stop exempting a complete link followed by a parenthesized aside

The spaces-in-destination fallback matched any line that starts with a link or
image and ends with one balanced parenthesized group, so a common list entry
such as `- [ripgrep](https://github.com/BurntSushi/ripgrep) (a line-oriented
search tool)` became exempt from the line-length check and `rumdl fmt` stopped
wrapping it.

Two conditions separate a destination from prose. A destination holding a space
does not parse as an inline link at all: the link text degrades to an empty-url
shortcut, which is the state the fallback exists for, while a complete link
carries its own url. And CommonMark forbids whitespace between `]` and `(`, so
a group separated by a space cannot be a destination.

Follow-up to #781.

Author: rvben

src/rules/md013_line_length/helpers.rs

@@ -540,12 +540,15 @@ fn is_link_with_optional_emphasis(ctx: &LintContext, s: &str, s_offset: usize) -
             return true;
         }
 
-        // Fallback for links with spaces in destination (not parsed by pulldown-cmark as a single link)
+        // Fallback for links with spaces in destination (not parsed by pulldown-cmark as a single
+        // link). A destination holding a space leaves the link text parsed as an empty-url
+        // shortcut, and that is what marks the trailing group as the destination rather than
+        // prose following a complete link.
         if let Ok(idx) = ctx.links.binary_search_by_key(&s_start, |l| l.byte_offset) {
             let l = &ctx.links[idx];
-            if l.byte_end < s_end {
+            if l.byte_end < s_end && l.link_type == LinkType::Shortcut && l.url.is_empty() {
                 let remaining = &s[l.byte_end - s_start..];
-                if is_single_parenthesized_group(remaining) {
+                if is_destination_group(remaining) {
                     return true;
                 }
             }
@@ -554,9 +557,9 @@ fn is_link_with_optional_emphasis(ctx: &LintContext, s: &str, s_offset: usize) -
         // Fallback for images with spaces in destination
         if let Ok(idx) = ctx.images.binary_search_by_key(&s_start, |i| i.byte_offset) {
             let i = &ctx.images[idx];
-            if i.byte_end < s_end {
+            if i.byte_end < s_end && i.link_type == LinkType::Shortcut && i.url.is_empty() {
                 let remaining = &s[i.byte_end - s_start..];
-                if is_single_parenthesized_group(remaining) {
+                if is_destination_group(remaining) {
                     return true;
                 }
             }
@@ -647,8 +650,11 @@ fn is_link_with_optional_emphasis(ctx: &LintContext, s: &str, s_offset: usize) -
     false
 }
 
-fn is_single_parenthesized_group(s: &str) -> bool {
-    let s = s.trim();
+/// Whether `s` is the destination of the link text immediately before it: a single balanced
+/// parenthesized group opening on the very next byte. CommonMark forbids whitespace between
+/// `]` and `(`, so only the trailing side is trimmed.
+fn is_destination_group(s: &str) -> bool {
+    let s = s.trim_end();
     if !s.starts_with('(') || !s.ends_with(')') {
         return false;
     }
@@ -1078,6 +1084,40 @@ mod tests {
         assert!(!check_standalone("[link](url) extra text"));
     }
 
+    #[test]
+    fn test_link_followed_by_parenthetical_is_not_standalone() {
+        // A complete link followed by a parenthesized aside is prose, not a destination.
+        // The whole line can be wrapped, so it is not exempt.
+        assert!(!check_standalone(
+            "- [ripgrep](https://github.com/BurntSushi/ripgrep) (a line-oriented search tool)"
+        ));
+        assert!(!check_standalone(
+            "[the docs](https://example.com/d) (updated for 2026, including the new guide)"
+        ));
+        assert!(!check_standalone(
+            "![screenshot](img/s.png) (captured on a retina display with the sidebar hidden)"
+        ));
+        // An unresolved shortcut whose aside is separated by a space: the space rules out a
+        // destination, since CommonMark forbids one between `]` and `(`.
+        assert!(!check_standalone(
+            "[NOTE] (this applies only when the feature flag is enabled)"
+        ));
+        // Attached, so no space rules it out. Here the link parsed with its own destination,
+        // which is what says the trailing group belongs to the prose.
+        assert!(!check_standalone(
+            "[the docs](https://example.com/d)(a parenthetical stuck onto the link)"
+        ));
+
+        // The exemptions the fallback exists for still hold: a destination holding a space
+        // leaves the link text parsed as an empty-url shortcut.
+        assert!(check_standalone(
+            "![Placeholder Screenshot](images/1_<release number>/screenshot-main-window.png)"
+        ));
+        assert!(check_standalone(
+            "* [Front Matter Defaults]({{ '/assets/img/very-long-image-name.png' | relative_url }})"
+        ));
+    }
+
     // --- is_html_only_line tests ---
 
     #[test]

src/rules/md013_line_length/tests.rs

@@ -9678,3 +9678,40 @@ fn test_md013_link_with_nested_code_span_exemption() {
         "Link with nested code and brackets should be exempt"
     );
 }
+
+#[test]
+fn test_md013_link_followed_by_parenthetical_is_not_exempt() {
+    let config = MD013Config {
+        line_length: crate::types::LineLength::from_const(80),
+        stern: true,
+        ignore_link_urls: false,
+        ..Default::default()
+    };
+    let rule = MD013LineLength::from_config_struct(config);
+
+    // A complete link or image followed by a parenthesized aside is prose. The line can be
+    // wrapped, so the standalone exemption must not cover it.
+    let reported = [
+        "- [ripgrep](https://github.com/BurntSushi/ripgrep) (a line-oriented search tool that recursively searches)\n",
+        "[the docs](https://example.com/d) (updated for 2026, including the new configuration guide)\n",
+        "[NOTE] (this applies only when the feature flag is enabled and the server runs in cluster mode)\n",
+        "![screenshot](img/s.png) (captured on a retina display at 2x scaling with the sidebar hidden)\n",
+        "[the docs](https://example.com/d)(a parenthetical stuck right onto the end of the link here)\n",
+    ];
+    for content in reported {
+        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "line should be reported: {content:?}");
+    }
+
+    // A destination that genuinely holds a space still exempts the line.
+    let exempt = [
+        "![Placeholder Screenshot Here](images/1_<release number>/screenshot-main-window.png)\n",
+        "* [Front Matter Defaults]({{ '/assets/img/very-long-image-name.png' | relative_url }})\n",
+    ];
+    for content in exempt {
+        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
+        let result = rule.check(&ctx).unwrap();
+        assert!(result.is_empty(), "line should stay exempt: {content:?}");
+    }
+}