rumdl_lib/rules/

md077_list_continuation_indent.rs

//!
//! Rule MD077: List continuation content indentation
//!
//! See [docs/md077.md](../../docs/md077.md) for full documentation, configuration, and examples.

use std::ops::ControlFlow;

use serde::{Deserialize, Serialize};

use crate::lint_context::{CommonMarkItem, LineInfo, LintContext, NativeListSource};
use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
use crate::utils::list_indent_shift::is_lazy_continuation_source as is_lazy_continuation;

mod md077_config;
use md077_config::MD077Config;

/// How strictly MD077 enforces continuation-line indentation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ContinuationStyle {
    /// Permit any continuation indent in `[0, content_column]` (CommonMark lazy
    /// continuation). Only over-indentation and content that escapes the list
    /// after a blank line are flagged.
    #[default]
    Any,
    /// Require every continuation line to align to the item's content column.
    /// Tight under-indented lazy continuation (which `any` permits) is also
    /// flagged and snapped up to the content column.
    Aligned,
}

/// Rule MD077: List continuation content indentation
///
/// In both tight continuation (no blank line) and loose continuation (after a
/// blank line), content must not be **over-indented** beyond the item's content
/// column. Additionally, in loose continuation content must not be
/// **under-indented** below the content column (W+N rule), or it falls out of the
/// list; tight under-indent is valid CommonMark lazy continuation and is left
/// alone. Content indented to the content column + 4 or more is an indented code
/// block, not continuation, and is not flagged.
///
/// Under the MkDocs flavor, a minimum of 4 spaces per nesting level is enforced
/// to satisfy Python-Markdown: a top-level item needs 4, an item nested in it 8.
///
/// With `style = "aligned"`, tight under-indented continuation is additionally
/// flagged and aligned to the content column (mdformat parity).
#[derive(Clone, Default)]
pub struct MD077ListContinuationIndent {
    config: MD077Config,
}

impl MD077ListContinuationIndent {
    /// Construct the rule with an explicit continuation style. `Default`
    /// (`ContinuationStyle::Any`) preserves the historical behavior.
    pub fn new(style: ContinuationStyle) -> Self {
        Self {
            config: MD077Config { style, indent: None },
        }
    }

    pub fn from_config_struct(config: MD077Config) -> Self {
        Self { config }
    }
}

impl MD077ListContinuationIndent {
    /// Width of a GFM task checkbox prefix including its trailing space:
    /// `[ ] `, `[x] `, or `[X] ` — always exactly 4 bytes.
    const TASK_CHECKBOX_PREFIX_LEN: usize = 4;

    /// Returns true if the item line starts a GFM task list item, i.e. its
    /// content column begins with `[ ] `, `[x] `, or `[X] `. The trailing
    /// space is part of the match — `- [ ]` with no body is an empty list
    /// item, not a task.
    ///
    /// Task items have a second, conventionally-accepted continuation column
    /// at `content_col + 4` (aligned after the checkbox). MD013 reflow
    /// produces this column for wrapped task lines, so MD077 has to accept
    /// it to avoid a fix loop with MD013.
    ///
    /// `content_col` is a byte offset into `line`, not a visual column. The
    /// CommonMark list parser produces byte-offset content columns, and the
    /// checkbox prefix `[ ] ` is pure ASCII, so this byte-level comparison
    /// is correct. Leading indent mixing tabs and spaces is irrelevant here
    /// because `content_col` already points past any leading whitespace.
    fn is_task_list_item(line: &str, content_col: usize) -> bool {
        line.as_bytes()
            .get(content_col..content_col + Self::TASK_CHECKBOX_PREFIX_LEN)
            .is_some_and(|window| matches!(window, b"[ ] " | b"[x] " | b"[X] "))
    }

    /// Whether the list marker written at visual column `marker_column` is an
    /// ordered marker closed by `)`, which Python-Markdown does not read as a
    /// list marker. Tabs advance to the next multiple of four.
    fn is_paren_marker(line: &str, marker_column: usize) -> bool {
        let mut column = 0;
        for (byte, c) in line.char_indices() {
            if column >= marker_column {
                let rest = &line[byte..];
                return rest.trim_start_matches(|c: char| c.is_ascii_digit()).starts_with(')');
            }
            column = if c == '\t' { (column / 4 + 1) * 4 } else { column + 1 };
        }
        false
    }

    /// Whether the text at visual column `content_col` of `line` is a GFM
    /// checkbox. The column is where CommonMark starts the item's content, so
    /// an item whose first content is indented code (five or more columns after
    /// the marker) or an item that starts with a blank line reads no checkbox.
    fn is_task_at_column(line: &str, content_col: usize) -> bool {
        let mut column = 0;
        for (byte, ch) in line.char_indices() {
            if column == content_col {
                return Self::is_task_list_item(line, byte);
            }
            if column > content_col {
                return false;
            }
            column = crate::lint_context::column_after(column, ch);
        }
        false
    }

    /// Whether `text` holds nothing but spaces and tabs, the only whitespace
    /// CommonMark's block structure counts as blank.
    fn is_cm_blank(text: &str) -> bool {
        text.trim_matches([' ', '\t']).is_empty()
    }

    /// Check if a trimmed line is a block-level construct (not list continuation).
    fn is_block_level_construct(trimmed: &str) -> bool {
        // Footnote definition: [^label]:
        if trimmed.starts_with("[^") && trimmed.contains("]:") {
            return true;
        }
        // Abbreviation definition: *[text]:
        if trimmed.starts_with("*[") && trimmed.contains("]:") {
            return true;
        }
        // Reference link definition: [label]: url
        // Must start with [ but not be a regular link, footnote, or abbreviation
        if trimmed.starts_with('[') && !trimmed.starts_with("[^") && trimmed.contains("]: ") {
            return true;
        }
        false
    }

    /// Check if a trimmed line is a fenced code block delimiter (opener or closer).
    fn is_code_fence(trimmed: &str) -> bool {
        let bytes = trimmed.as_bytes();
        if bytes.len() < 3 {
            return false;
        }
        let ch = bytes[0];
        (ch == b'`' || ch == b'~') && bytes[1] == ch && bytes[2] == ch
    }

    /// Whether a line is the delimiter of a fenced code block. Inside an
    /// indented code block, fence-like text is code content.
    fn is_fence_delimiter(ctx: &NativeListSource<'_, '_>, info: &LineInfo, trimmed: &str) -> bool {
        Self::is_code_fence(trimmed) && ctx.fenced_block_overlaps_line(info)
    }

    /// Column of the `>` that opens a blockquote deeper than `depth`, if the
    /// line has one.
    fn deeper_quote_column(ctx: &NativeListSource<'_, '_>, info: &LineInfo, depth: usize) -> Option<usize> {
        if info.blockquote.as_ref()?.nesting_level <= depth {
            return None;
        }
        // The prefix holds only whitespace and `>`, so the (depth + 1)th `>` is
        // the one that opens the deeper quote.
        info.content(ctx.content).match_indices('>').nth(depth).map(|(i, _)| i)
    }

    /// Whether moving a paragraph line from `from` to `to` turns its text into
    /// the start of a block.
    ///
    /// Four or more columns past the content column a line cannot interrupt the
    /// paragraph, so a fence, blockquote marker, setext underline, thematic break,
    /// table row or ATX heading there is paragraph text. Moved closer than that, the same
    /// text opens the block and swallows or splits what follows. Closer in, the
    /// parser already reads such a line as its block, so only this crossing
    /// changes what the line is.
    fn opens_block_when_moved(trimmed: &str, content_col: usize, from: usize, to: usize) -> bool {
        const MAX_BLOCK_INDENT: usize = 3;
        from > content_col + MAX_BLOCK_INDENT
            && to <= content_col + MAX_BLOCK_INDENT
            && (Self::is_code_fence(trimmed)
                || trimmed.starts_with('>')
                || crate::lint_context::is_setext_underline_content(trimmed)
                || crate::lint_context::is_horizontal_rule_content(trimmed)
                || crate::utils::skip_context::is_table_line(trimmed)
                || Self::is_atx_heading_start(trimmed))
    }

    /// CommonMark 4.2: one to six `#` followed by a space, a tab or the end of
    /// the line.
    fn is_atx_heading_start(trimmed: &str) -> bool {
        let hashes = trimmed.bytes().take_while(|&b| b == b'#').count();
        (1..=6).contains(&hashes) && matches!(trimmed.as_bytes().get(hashes), None | Some(b' ' | b'\t'))
    }

    /// Check if a trimmed line starts with a list marker (*, -, +, or ordered).
    /// Used to avoid flagging deeply indented list items that the parser doesn't
    /// recognize as list items (e.g., with indent=8 configured in MD007).
    fn starts_with_list_marker(trimmed: &str) -> bool {
        let bytes = trimmed.as_bytes();
        match bytes.first() {
            Some(b'*' | b'-' | b'+') => bytes.get(1).is_some_and(|&b| b == b' ' || b == b'\t'),
            Some(b'0'..=b'9') => {
                let rest = trimmed.trim_start_matches(|c: char| c.is_ascii_digit());
                rest.starts_with(". ") || rest.starts_with(") ")
            }
            _ => false,
        }
    }

    /// When the line opens a fenced code block, the line number of the block's
    /// last line (its closer, or the last line of an unclosed block). The
    /// block's own byte range decides both, so an adjacent indented code block
    /// on either side is never mistaken for part of it.
    fn fenced_block_last_line(ctx: &NativeListSource<'_, '_>, info: &LineInfo, trimmed: &str) -> Option<usize> {
        if !Self::is_code_fence(trimmed) {
            return None;
        }
        ctx.fenced_block_opened_on_line(info)
            .map(|b| ctx.line_number_at_offset(b.end.saturating_sub(1).max(b.start)))
    }

    /// Build an atomic fix that reindents a fenced code block from its opener
    /// through its matching closer.
    ///
    /// - **Opener and closer** are moved to `required` (the list item's
    ///   content column, which is what MD077 actually flagged).
    /// - **Interior lines** move by the same delta as the fence and are then
    ///   clamped to `required`. Shifting by the delta preserves each line's
    ///   offset from the fence, so the code block's internal structure (JSON
    ///   nesting, indented sub-blocks) survives the move; the clamp
    ///   guarantees fence pairing, since every non-blank line in the block
    ///   ends at column ≥ `required` and the block stays inside the list
    ///   item's scope after the fix.
    ///
    /// Only used for the under-indent direction (`required > opener_actual`);
    /// over-indented fences are intentionally left untouched (see the
    /// over-indent pass in `check`), so there is no down-shift case to handle.
    ///
    /// Why a compound fix rather than three independent fixes? MD077 and
    /// MD031 run in the same iterative fix loop. If we only moved the
    /// delimiters, an intermediate state would have mismatched
    /// opener/closer indentation and MD031 would misread the block as
    /// unpaired, injecting stray blank lines (issue #574).
    ///
    /// Why clamp the shift rather than shift alone? A bare delta shift is
    /// not idempotent: interior starting below the list scope (e.g., col 0
    /// under an opener at col 2 that needs to move to col 3) lands at col 1,
    /// still below the scope, and the next MD077 pass re-flags it and snaps
    /// it to `required`. The clamp reaches that end state in a single pass.
    /// Clamping alone is not enough either: it pins every interior line at
    /// or above `required` to its original column while the fence rises, so
    /// the block's interior indentation shrinks by the delta and one-space
    /// nesting disappears entirely.
    ///
    /// Leading tabs are normalized to spaces: CommonMark expands a tab to
    /// the next column that's a multiple of 4, so simply prepending spaces
    /// before a tab would let the tab snap back and cancel the shift. We
    /// replace the whole leading-whitespace byte range with spaces.
    fn build_compound_fence_fix(
        ctx: &NativeListSource<'_, '_>,
        opener_line: usize,
        closer_line: usize,
        opener_actual: usize,
        required: usize,
    ) -> Option<Fix> {
        if required <= opener_actual {
            return None;
        }
        let opener_info = ctx.line_info(opener_line)?;
        let closer_info = ctx.line_info(closer_line)?;

        let fix_start = opener_info.byte_offset;
        let fix_end = closer_info.byte_offset + closer_info.byte_len;

        let mut replacement = String::new();
        for i in opener_line..=closer_line {
            let info = ctx.line_info(i)?;
            if i > opener_line {
                replacement.push('\n');
            }
            let line = info.content(ctx.content);
            if info.is_blank {
                // Blank lines have no content to shift; preserve verbatim.
                replacement.push_str(line);
            } else {
                let new_visual = if i == opener_line || i == closer_line {
                    required
                } else {
                    (info.visual_indent + (required - opener_actual)).max(required)
                };
                for _ in 0..new_visual {
                    replacement.push(' ');
                }
                replacement.push_str(&line[info.indent..]);
            }
        }

        Some(Fix::new(fix_start..fix_end, replacement))
    }

    /// Walk the continuation lines owned by a single list item, invoking
    /// `per_line` for each *in-scope, non-blank, non-nested, non-skipped*
    /// line with its pre-computed visual column and loose/tight state.
    ///
    /// This is the **single source of truth** for MD077's item-scope
    /// traversal: both the sibling-column pre-pass and the main check loop
    /// route through this method so their termination semantics cannot
    /// drift. The callback sees only lines the rule actually needs to
    /// reason about; it can return `ControlFlow::Break` for early exit.
    ///
    /// Termination conditions (applied before the callback fires):
    /// - Headings and horizontal rules end the item unconditionally.
    /// - After a blank line, content at or below the marker column has
    ///   escaped the item; further lines are not delivered.
    ///
    /// Skipped silently (do not fire the callback):
    /// - Blank lines (toggle `saw_blank`).
    /// - Nested list items (reset `saw_blank`, track their content column).
    /// - Lines inside any still-open nested item's scope: the walk keeps a
    ///   stack of open nested (marker, content) columns, so a continuation
    ///   of a middle nesting level defers to that level's own walk instead
    ///   of being claimed by a shallower ancestor.
    /// - Reference/footnote/abbreviation definitions and similar block
    ///   constructs that aren't list continuation.
    /// - Lines that `should_skip_line` rejects (code-block interior etc.).
    fn walk_item_continuation<F>(ctx: &NativeListSource<'_, '_>, scope: &ItemScope, mut per_line: F)
    where
        F: FnMut(&ContinuationLine<'_>) -> ControlFlow<()>,
    {
        let item_line = scope.item_line;
        let range_end = scope.range_end;
        let marker_col = scope.marker_col;
        let content_col = scope.content_col;
        let mut saw_blank = false;
        // Stack of open nested items as (marker_column, content_column,
        // awaiting_first_content), outermost first. A single scalar is not
        // enough: with 3+ levels a continuation of a middle level sits below the
        // innermost content column but at-or-past its own level's, and must
        // still be skipped here so the owning level's walk evaluates it. The
        // items written on this item's own line start out on the stack.
        let mut nested_stack: Vec<(usize, usize, bool)> = scope
            .same_line
            .iter()
            .map(|item| (item.marker_col, item.content_col, item.is_empty))
            .collect();
        let mut saw_nested = !nested_stack.is_empty();
        // CommonMark 5.2: an item can begin with at most one blank line, so
        // while an item that started empty has no content yet, a blank line or
        // a line left of its content column closes it.
        let mut awaiting_content = scope.starts_empty;
        let item_info = ctx.line_info(item_line);
        let item_quotes = item_info
            .and_then(|i| i.blockquote.as_ref())
            .map_or(0, |q| q.nesting_level);

        for line_num in (item_line + 1)..=range_end {
            let Some(info) = ctx.line_info(line_num) else {
                continue;
            };

            // A `>` left of the content column opens a blockquote outside the
            // item, which ends the item (an empty quote line is not a blank line
            // inside it).
            if Self::deeper_quote_column(ctx, info, item_quotes).is_some_and(|col| col < content_col) {
                break;
            }

            let raw_line = info.content(ctx.content);
            let trimmed = raw_line.trim_start();
            let blank = Self::is_cm_blank(raw_line);

            // An item that started empty and is still waiting for its content.
            if awaiting_content {
                if blank || info.visual_indent < content_col {
                    break;
                }
                awaiting_content = false;
            }
            // The same for the nested items written on the item's line.
            if blank {
                while nested_stack.last().is_some_and(|&(_, _, awaiting)| awaiting) {
                    nested_stack.pop();
                }
            } else {
                while nested_stack
                    .last()
                    .is_some_and(|&(_, content, awaiting)| awaiting && content > info.visual_indent)
                {
                    nested_stack.pop();
                }
                if let Some(top) = nested_stack.last_mut() {
                    top.2 = false;
                }
            }

            if Self::should_skip_line(ctx, info, trimmed) {
                continue;
            }

            if blank {
                saw_blank = true;
                continue;
            }

            // Whitespace that is not CommonMark's is text, which the rule has
            // no indentation to judge.
            if trimmed.is_empty() {
                continue;
            }

            if let Some(ref li) = info.list_item {
                // The items CommonMark opens on this line; the byte columns are
                // the fallback for a line the container pass did not read.
                let fallback = [CommonMarkItem {
                    marker_column: li.marker_column,
                    content_column: li.content_column,
                    is_empty: false,
                }];
                let chain: &[CommonMarkItem] = if li.commonmark_items.is_empty() {
                    &fallback
                } else {
                    &li.commonmark_items
                };
                let first = chain[0];
                // A marker left of the content column cannot nest inside this
                // item: it closes the item and starts a list of its own, which
                // then owns every line below it.
                if first.marker_column > marker_col && first.marker_column < content_col {
                    break;
                }
                if first.marker_column > marker_col {
                    // A sibling-or-shallower marker closes every nested item at
                    // or past its column before this one opens.
                    while nested_stack.last().is_some_and(|&(m, _, _)| m >= first.marker_column) {
                        nested_stack.pop();
                    }
                    for item in chain {
                        nested_stack.push((item.marker_column, item.content_column, item.is_empty));
                    }
                    // Sticky: once a nested child appears, every later line is a
                    // (lazy) continuation of the deeper item, which owns it under
                    // CommonMark. Ancestors must defer so the deepest item claims
                    // and aligns it.
                    saw_nested = true;
                } else {
                    nested_stack.clear();
                }
                saw_blank = false;
                continue;
            }

            // A setext heading's text is the whole paragraph its underline ends,
            // so every one of those lines is a heading rather than a
            // continuation the walk could reindent.
            if info.heading.is_some() || info.is_setext_heading_text || info.is_horizontal_rule {
                break;
            }

            if Self::is_block_level_construct(trimmed) {
                continue;
            }

            let col = info.visual_indent;

            // Straight below a line, left of the content column, and not
            // continuing the paragraph above it: the line opens a block of its
            // own (a fence at the margin) or follows one that closed (text under
            // a closing fence), and either way the item has ended. What follows
            // is top-level content that no indentation of ours should claim;
            // moving it can make it an indented code block, which changes the
            // lines below it too.
            if !saw_blank && col < content_col && !is_lazy_continuation(ctx, line_num - 1) {
                break;
            }

            // A lazy continuation line continues the open paragraph of the
            // innermost nested item without closing it, whatever its indent, so
            // that item keeps owning the lines after it.
            if !nested_stack.is_empty() && is_lazy_continuation(ctx, line_num - 1) {
                continue;
            }

            // Any other line escapes every nested item whose content column it
            // sits below; if any nested item stays open, the line is that item's
            // continuation and its own walk owns the judgement.
            while nested_stack.last().is_some_and(|&(_, c, _)| c > col) {
                nested_stack.pop();
            }
            if !nested_stack.is_empty() {
                continue;
            }

            if saw_blank && col <= marker_col {
                break;
            }

            let line = ContinuationLine {
                line_num,
                info,
                trimmed,
                actual: col,
                saw_blank,
                saw_nested,
            };
            if per_line(&line).is_break() {
                break;
            }
        }
    }

    /// Whether the item's owned continuation range holds a *latent* structural
    /// construct: a list marker or table line the parser has not yet promoted to
    /// its own block, but would once an earlier continuation line is reindented.
    /// Such a promotion re-attributes the following lines to a different block
    /// (different content column) and breaks single-pass idempotency, so the
    /// caller skips the whole item when this returns true.
    ///
    /// A setext underline counts too: as a lazy continuation the parser reads a
    /// `=`/`-` run as paragraph text, but reindenting the prose line above it
    /// into the item turns the pair into a heading.
    ///
    /// Unlike [`Self::walk_item_continuation`], this scans the full owned range and
    /// does NOT stop at a heading or horizontal rule. A heading partway through
    /// the continuation can itself be parse-unstable: an empty backtick run, for
    /// instance, is read as a setext heading, and reindenting an earlier line
    /// dissolves it and promotes a list marker that sits past it. Stopping at the
    /// heading would hide that marker from this check and let the reindent break
    /// idempotency. Lines already parsed as list items are real nested children,
    /// not latent, and are handled by the walk's `saw_nested` logic instead.
    fn item_range_has_latent_structure(ctx: &NativeListSource<'_, '_>, item_line: usize, range_end: usize) -> bool {
        (item_line + 1..=range_end).any(|line_num| {
            ctx.line_info(line_num).is_some_and(|info| {
                if info.is_blank || info.list_item.is_some() {
                    return false;
                }
                let trimmed = info.content(ctx.content).trim_start();
                !Self::should_skip_line(ctx, info, trimmed)
                    && (Self::starts_with_list_marker(trimmed)
                        || crate::utils::skip_context::is_table_line(trimmed)
                        || Self::is_latent_setext_underline(ctx, line_num, trimmed))
            })
        })
    }

    /// Whether reindenting the line above this one would turn the pair into a
    /// setext heading. An underline that is a lazy continuation is paragraph
    /// text, so the parser reports no heading and the walk runs straight past it.
    ///
    /// Only paragraph text can become the heading's text line, so an underline
    /// under an ATX heading, a thematic break or another underline is latent
    /// nothing and must not hold the whole item back. The line above has to pass
    /// both readings: `is_paragraph_context` speaks for the block it sits in,
    /// which is what tells a closing code fence from the prose it looks like,
    /// and the text predicate speaks for the line's own markers, which is what
    /// tells an empty list item from the text it holds none of. A blank line
    /// needs no test of its own: blank means it holds nothing once its markers
    /// are stripped, which is the first thing the text predicate rejects.
    fn is_latent_setext_underline(ctx: &NativeListSource<'_, '_>, line_num: usize, trimmed: &str) -> bool {
        crate::lint_context::is_setext_underline_content(trimmed)
            && ctx.line_info(line_num - 1).is_some_and(|prev| {
                prev.is_paragraph_context() && crate::lint_context::is_paragraph_text_line(prev.content(ctx.content))
            })
    }

    /// Scan an item's owned range and report whether any *other* continuation
    /// line in the item uses the content column or the post-checkbox column.
    ///
    /// Used exclusively for tie-breaking the auto-fix target when an
    /// over-indented line is exactly equidistant from `content_col` and
    /// `task_col`. In that case the author's intent is ambiguous, so we
    /// snap to whichever valid column *they're already using* elsewhere in
    /// the same item. When neither or both columns are in use, the caller
    /// falls back to a canonical default.
    fn sibling_column_usage(ctx: &NativeListSource<'_, '_>, scope: &ItemScope, task_col: usize) -> (bool, bool) {
        let content_col = scope.content_col;
        let mut uses_content = false;
        let mut uses_task = false;

        Self::walk_item_continuation(ctx, scope, |line| {
            if line.actual == content_col {
                uses_content = true;
            }
            if line.actual == task_col {
                uses_task = true;
            }
            if uses_content && uses_task {
                ControlFlow::Break(())
            } else {
                ControlFlow::Continue(())
            }
        });

        (uses_content, uses_task)
    }

    /// Compute the auto-fix target for an over-indented continuation line.
    /// Snaps to the nearer of the two valid columns (content_col / task_col)
    /// for task items, and on an exact tie uses sibling-column context to
    /// pick whichever column the author is already using elsewhere in this
    /// item. Non-task items always snap to `required`.
    fn compute_fix_target(
        actual: usize,
        required: usize,
        task_col: Option<usize>,
        uses_content_col: bool,
        uses_task_col: bool,
    ) -> usize {
        let Some(t) = task_col else { return required };
        match actual.abs_diff(t).cmp(&actual.abs_diff(required)) {
            std::cmp::Ordering::Less => t,
            std::cmp::Ordering::Greater => required,
            std::cmp::Ordering::Equal => match (uses_task_col, uses_content_col) {
                (true, false) => t,
                _ => required,
            },
        }
    }

    /// The opening line of every fenced block, and the other lines inside one.
    fn fence_lines(
        ctx: &NativeListSource<'_, '_>,
        line_count: usize,
    ) -> (std::collections::BTreeSet<usize>, std::collections::BTreeSet<usize>) {
        let last_line = line_count.saturating_sub(1);
        let line_of = |offset: usize| ctx.offset_to_line_col(offset).0.saturating_sub(1).min(last_line);
        let mut openers = std::collections::BTreeSet::new();
        let mut inside = std::collections::BTreeSet::new();
        for block in ctx.code_block_details.iter().filter(|b| b.is_fenced) {
            let first = line_of(block.start);
            let last = line_of(block.end.saturating_sub(1).max(block.start));
            openers.insert(first);
            inside.extend(first + 1..=last);
        }
        (openers, inside)
    }

    /// Per line, whether Python-Markdown reads it as the start of a list item.
    fn parser_marker_lines(ctx: &NativeListSource<'_, '_>) -> Option<Vec<bool>> {
        use crate::utils::python_markdown_lists::{Source, marker_lines};
        let lines: Vec<&str> = ctx.content.split('\n').collect();
        // Admonitions require the native indentation view. Do not build a
        // marker model whose result cannot be used for this document.
        if lines.iter().any(|line| {
            let trimmed = line.trim_start();
            trimmed.starts_with("!!! ") || trimmed.starts_with("??? ") || trimmed.starts_with("???+ ")
        }) {
            return None;
        }
        let (openers, inside) = Self::fence_lines(ctx, lines.len());
        let mut markers = marker_lines(&Source {
            lines: &lines,
            fence_openers: &openers,
            fence_inside: &inside,
        })?;
        // The model knows lists, code and headings only. A line it reads as
        // text counts as text only when the line above is plain prose it can
        // judge; quotes, admonitions, tables, rules and the like are left to
        // the indentation rules.
        for (idx, marker) in markers.iter_mut().enumerate() {
            if !*marker && idx > 0 && !Self::is_plain_prose(lines[idx - 1]) {
                *marker = true;
            }
        }
        Some(markers)
    }

    /// A line the list model reads the same way Python-Markdown does when it
    /// is the line above a possible list marker.
    fn is_plain_prose(line: &str) -> bool {
        let t = line.trim();
        if t.is_empty() {
            return false;
        }
        let first = t.chars().next().unwrap_or(' ');
        if matches!(first, '>' | '#' | ':' | '|' | '<' | '[' | '=' | '-' | '*' | '_' | '+') {
            return false;
        }
        !t.contains('|') && !t.chars().next().is_some_and(|c| c.is_ascii_digit())
    }

    /// Withhold every fix that Python-Markdown would read as a different
    /// document.
    ///
    /// The indentation rules above approximate how Python-Markdown nests list
    /// items. This check does not rely on them: it applies the fixes, parses
    /// the original and the fixed text with a model of Python-Markdown's list
    /// parser, and keeps a fix only if every line stays the same kind of thing
    /// (item marker, paragraph, code) and every paragraph and code block keeps
    /// its lines. A paragraph moving under a different item is the intended
    /// effect and passes; prose becoming code, a marker becoming text, or two
    /// paragraphs merging does not. A region whose result differs keeps its
    /// warnings and loses its fixes.
    fn drop_unsafe_fixes(
        ctx: &NativeListSource<'_, '_>,
        warnings: &mut [LintWarning],
        owners: &std::collections::HashMap<usize, usize>,
    ) {
        use crate::utils::python_markdown_lists::{Source, differing_regions, line_regions};
        use std::collections::BTreeSet;

        // A warning that inline configuration suppresses never reaches the fixer,
        // so only the fixes that survive it are simulated.
        let mut live: Vec<usize> = (0..warnings.len())
            .filter(|&i| warnings[i].fix.is_some() && !ctx.is_rule_disabled("MD077", warnings[i].line))
            .collect();
        if live.is_empty() {
            return;
        }
        // MkDocs removes the front matter before Python-Markdown sees the page.
        let blank_front_matter = |lines: &mut Vec<&str>| {
            for line in lines.iter_mut().take(ctx.front_matter_end_line()) {
                *line = "";
            }
        };
        let mut lines: Vec<&str> = ctx.content.split('\n').collect();
        blank_front_matter(&mut lines);
        let line_of = |offset: usize| {
            ctx.offset_to_line_col(offset)
                .0
                .saturating_sub(1)
                .min(lines.len().saturating_sub(1))
        };
        let (openers, inside) = Self::fence_lines(ctx, lines.len());
        let before = Source {
            lines: &lines,
            fence_openers: &openers,
            fence_inside: &inside,
        };
        let region_of = line_regions(&before);
        let touched = |fix: &Fix| -> BTreeSet<usize> {
            (line_of(fix.range.start)..=line_of(fix.range.end.max(fix.range.start)))
                .map(|l| region_of[l])
                .collect()
        };

        const MAX_ROUNDS: usize = 4;
        for _ in 0..MAX_ROUNDS {
            let mut ranges: Vec<(usize, &Fix)> = live
                .iter()
                .filter_map(|&i| warnings[i].fix.as_ref().map(|f| (i, f)))
                .collect();
            ranges.sort_by_key(|(_, f)| std::cmp::Reverse(f.range.start));
            let mut fixed = ctx.content.to_string();
            let mut floor = usize::MAX;
            let mut overlapping = Vec::new();
            for (i, fix) in ranges {
                if fix.range.end <= floor && fix.range.end <= fixed.len() {
                    fixed.replace_range(fix.range.clone(), &fix.replacement);
                    floor = fix.range.start;
                } else {
                    overlapping.push(i);
                }
            }
            // Fixes that overlap an applied one cannot be applied together
            // with it, so they are withheld rather than simulated away.
            if !overlapping.is_empty() {
                for &i in &overlapping {
                    warnings[i].fix = None;
                }
                live.retain(|i| !overlapping.contains(i));
                if live.is_empty() {
                    return;
                }
                continue;
            }
            let mut after_lines: Vec<&str> = fixed.split('\n').collect();
            blank_front_matter(&mut after_lines);
            let after = Source {
                lines: &after_lines,
                fence_openers: &openers,
                fence_inside: &inside,
            };
            // The line each fixed line is meant to belong to, as a zero-based
            // item marker line.
            let mut owner_of_line: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
            for &i in &live {
                let (Some(fix), Some(&owner)) = (warnings[i].fix.as_ref(), owners.get(&warnings[i].line)) else {
                    continue;
                };
                for l in line_of(fix.range.start)..=line_of(fix.range.end.max(fix.range.start)) {
                    owner_of_line.insert(l, owner.saturating_sub(1));
                }
            }
            let bad = match differing_regions(&before, &after, &owner_of_line) {
                Some(bad) if bad.is_empty() => return,
                Some(bad) => bad,
                None => break,
            };
            let kept: Vec<usize> = live
                .iter()
                .copied()
                .filter(|&i| warnings[i].fix.as_ref().is_some_and(|f| touched(f).is_disjoint(&bad)))
                .collect();
            if kept.len() == live.len() {
                break;
            }
            for &i in live.iter().filter(|i| !kept.contains(i)) {
                warnings[i].fix = None;
            }
            live = kept;
            if live.is_empty() {
                return;
            }
        }
        for i in live {
            warnings[i].fix = None;
        }
    }

    /// Whether Python-Markdown reads the line as an indented code block of the
    /// item: after a blank line, four columns past the item's paragraph column.
    /// Its levels differ from the parser's for an item whose marker sits less
    /// than four columns past its parent's, so the parser's own code-block
    /// classification does not cover every such line, and moving one would turn
    /// code into a paragraph (or the reverse).
    fn is_python_markdown_code(ctx: &NativeListSource<'_, '_>, scope: &ItemScope, line: &ContinuationLine<'_>) -> bool {
        // Only the line right after a blank can open the code block; a deeper
        // line further into a paragraph is that paragraph's continuation.
        (scope.code_column.is_some_and(|column| line.actual >= column)
            && ctx
                .line_info(line.line_num - 1)
                .is_some_and(|prev| Self::is_cm_blank(prev.content(ctx.content))))
            || Self::is_python_markdown_nested_content(scope, line)
    }

    /// Whether Python-Markdown reads the line as content of the deeper item
    /// written most recently above it: a line at that item's paragraph column or
    /// past it, with no line between that fell back below the column and so
    /// closed the item. The parser can leave such a line to the outer item when
    /// the deeper item's content column lies past it (a wide marker, or a marker
    /// sharing its line with another).
    fn is_python_markdown_nested_content(scope: &ItemScope, line: &ContinuationLine<'_>) -> bool {
        let above = scope
            .nested
            .partition_point(|&(item_line, ..)| item_line < line.line_num);
        above
            .checked_sub(1)
            .and_then(|last| scope.nested.get(last))
            .is_some_and(|&(_, column, closed_at)| line.actual >= column && line.line_num < closed_at)
    }

    /// Check if a line should be skipped (inside code, HTML, frontmatter, etc.)
    ///
    /// Code block *content* is skipped, but fence opener/closer lines are not —
    /// their indentation matters for list continuation in MkDocs.
    ///
    /// Footnote-definition lines (the `[^id]:` line and its indented body) are
    /// skipped too: a footnote body that follows a list is its own block, not
    /// list continuation, so its indentation is MD068's concern, not MD077's.
    /// Treating it as continuation produced false over-indent warnings and a
    /// damaging auto-fix that reindented the body and then tripped MD068.
    fn should_skip_line(ctx: &NativeListSource<'_, '_>, info: &LineInfo, trimmed: &str) -> bool {
        if info.in_code_block && !Self::is_fence_delimiter(ctx, info, trimmed) {
            return true;
        }
        let structural = || {
            info.in_front_matter
                || info.in_footnote_definition
                || info.in_html_block
                || info.in_html_comment
                || info.in_mdx_comment
                || info.in_mkdocstrings
                || info.in_esm_block
                || info.in_math_block
                || info.in_admonition
                || info.in_content_tab
                || info.in_pymdown_block
                || info.in_definition_list
                || info.in_mkdocs_html_markdown
                || info.in_kramdown_extension_block
        };
        let protected = || {
            ctx.is_byte_offset_in_code_span(info.byte_offset)
                || ctx.is_in_code_span_byte_with_or_without_math(info.byte_offset)
        };
        // The structural flags settle opaque lines without source-range queries.
        // The alternate reading remains mandatory for every eligible line.

        // A line beginning inside a code span retains its literal whitespace:
        // re-indenting it would change rendered code in either parser reading.
        structural() || protected()
    }

    /// Build the warning for an over-indented continuation line. The fix is a
    /// single-line rewrite of the leading whitespace to `fix_target`.
    ///
    /// The over-indent pass never delivers fenced-code lines here (it skips
    /// anything `in_code_block`), so this builder does not need the compound
    /// fence handling that `build_under_indent_warning` uses: moving an
    /// over-indented fence's delimiters without its body would corrupt the code
    /// content, so over-indented fenced blocks are deliberately left as-is.
    fn build_over_indent_warning(
        ctx: &NativeListSource<'_, '_>,
        line: &ContinuationLine<'_>,
        fix_target: usize,
        message: String,
    ) -> LintWarning {
        let line_content = line.info.content(ctx.content);
        let fix_start = line.info.byte_offset;
        let fix_end = fix_start + line.info.indent;
        LintWarning {
            rule_name: Some("MD077".to_string()),
            line: line.line_num,
            column: 1,
            end_line: line.line_num,
            end_column: line_content.chars().count() + 1,
            message,
            severity: Severity::Warning,
            fix: Some(Fix::new(fix_start..fix_end, " ".repeat(fix_target))),
        }
    }

    /// Build the warning for a loose-mode under-indented continuation line.
    /// When the line is the opener of a fenced code block, emit a compound
    /// fix that reindents opener + interior + closer atomically so MD031
    /// doesn't see a transiently-broken fence pair (see #574).
    ///
    /// Returns the warning plus, when the fix is compound, the closer
    /// line number so the caller can mark it flagged (preventing the
    /// main loop from double-flagging the closer as its own under-indent
    /// case). Keeping the "also flag this line" signal out of band keeps
    /// this function pure — it reads from `ctx` only and returns a
    /// plain value.
    fn build_under_indent_warning(
        ctx: &NativeListSource<'_, '_>,
        line: &ContinuationLine<'_>,
        required: usize,
        message: String,
    ) -> UnderIndentOutcome {
        let line_content = line.info.content(ctx.content);
        let fence_closer = Self::fenced_block_last_line(ctx, line.info, line.trimmed);

        let (fix, warn_end_line, warn_end_column, compound_closer) = if let Some(closer_line) = fence_closer {
            let fix = Self::build_compound_fence_fix(ctx, line.line_num, closer_line, line.actual, required);
            let end_column = ctx
                .line_info(closer_line)
                .map_or(line_content.chars().count() + 1, |ci| {
                    ci.content(ctx.content).chars().count() + 1
                });
            let extra_flag = (closer_line != line.line_num).then_some(closer_line);
            (fix, closer_line, end_column, extra_flag)
        } else {
            let fix_start = line.info.byte_offset;
            let fix_end = fix_start + line.info.indent;
            let fix = Some(Fix::new(fix_start..fix_end, " ".repeat(required)));
            (fix, line.line_num, line_content.chars().count() + 1, None)
        };

        UnderIndentOutcome {
            warning: LintWarning {
                rule_name: Some("MD077".to_string()),
                line: line.line_num,
                column: 1,
                end_line: warn_end_line,
                end_column: warn_end_column,
                message,
                severity: Severity::Warning,
                fix,
            },
            also_flag_line: compound_closer,
        }
    }
}

/// A list item written on the same line as the item that holds it (`- 1. x`),
/// as the columns a continuation has to reach to belong to it.
#[derive(Clone, Copy)]
struct SameLineItem {
    marker_col: usize,
    content_col: usize,
    /// Nothing follows its marker on the line.
    is_empty: bool,
}

/// One list item as MD077 scopes it, in visual columns.
struct ItemScope {
    item_line: usize,
    marker_col: usize,
    content_col: usize,
    /// The post-checkbox column of a GFM task item.
    task_col: Option<usize>,
    /// The indent a continuation line has to reach.
    required: usize,
    /// Only lines without a blank line before them are enforced, because the
    /// required column is one where Python-Markdown reads code after a blank.
    tight_only: bool,
    /// First column at which Python-Markdown reads the item's content as an
    /// indented code block, or `None` outside the strict-indent flavors.
    code_column: Option<usize>,
    /// The items inside this one that Python-Markdown reads as items, as
    /// (line, paragraph column, first line past the item's content), in line order; empty outside the strict-indent
    /// flavors.
    nested: Vec<(usize, usize, usize)>,
    /// The last line the item can own.
    range_end: usize,
    /// Nothing follows the marker on its line, so the item holds at most one
    /// blank line before its content.
    starts_empty: bool,
    /// The items written on this item's line inside it, outermost first.
    same_line: Vec<SameLineItem>,
}

/// A continuation line yielded by `walk_item_continuation`. Bundles the
/// per-line facts both checker branches need so helper functions don't
/// balloon their argument lists.
struct ContinuationLine<'a> {
    line_num: usize,
    info: &'a LineInfo,
    trimmed: &'a str,
    actual: usize,
    saw_blank: bool,
    /// True once a nested child item has appeared earlier in this item's scope.
    /// Subsequent lines are lazy continuation of the deeper item (which owns
    /// them under CommonMark), so an ancestor must not claim them.
    saw_nested: bool,
}

/// Result of `build_under_indent_warning`. Carries both the warning and,
/// when the fix is compound (fence opener → promote-to-required over the
/// whole block), the closer line so the caller can record it as already
/// handled. This keeps the warning builder free of external mutation.
struct UnderIndentOutcome {
    warning: LintWarning,
    also_flag_line: Option<usize>,
}

impl MD077ListContinuationIndent {
    // Keep the native fixer authoritative: its stable descending replacements
    // intentionally retain their existing overlap and line-ending semantics.
    pub(crate) fn apply_native_fixes(content: &str, mut fixes: Vec<Fix>) -> String {
        fixes.sort_by_key(|fix| std::cmp::Reverse(fix.range.start));
        let mut content = content.to_string();
        for fix in fixes {
            if fix.range.start <= content.len() && fix.range.end <= content.len() {
                content.replace_range(fix.range, &fix.replacement);
            }
        }
        content
    }

    pub(crate) fn check_native_source(&self, ctx: &NativeListSource<'_, '_>) -> Vec<LintWarning> {
        if ctx.content.is_empty() {
            return Vec::new();
        }

        let strict_indent = ctx.flavor.requires_strict_list_indent();
        let total_lines = ctx.lines.len();
        let mut warnings = Vec::new();
        // The item whose scope produced the warning on each line.
        let mut owners: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
        let mut flagged_lines = std::collections::HashSet::new();

        // Collect all list item lines sorted, with their content_column,
        // marker_column, and — if the item is a GFM task — its post-checkbox
        // column. Precomputing task_col here (instead of re-reading line_info
        // inside the hot inner loop) keeps the per-item cost O(1).
        //
        // We need the owned range to extend past block.end_line because the
        // parser excludes under-indented continuation from the block, and
        // MD077 specifically has to evaluate those escaped lines.
        let mut items: Vec<(usize, CommonMarkItem, Option<usize>)> = Vec::new();
        // The items each list item line opens, to find the ones written on the
        // same line as another.
        let mut chains: Vec<(usize, Vec<CommonMarkItem>)> = Vec::new();
        // The list block each item line belongs to, so that nesting is only read
        // between items of one block.
        let mut block_of_line: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
        for (block_idx, block) in ctx.list_blocks.iter().enumerate() {
            for &item_line in &block.item_lines {
                block_of_line.insert(item_line, block_idx);
                if let Some(info) = ctx.line_info(item_line)
                    && let Some(ref li) = info.list_item
                {
                    // Lists inside blockquotes are out of scope for MD077. Their
                    // content column is measured on the raw line, so it is
                    // meaningless for a lazy continuation sitting outside the
                    // quote: scoping them lets two items with different content
                    // columns each claim such a line and reindent it the other
                    // way on alternating passes.
                    if info.blockquote.is_some() {
                        continue;
                    }
                    // The container pass did not read this line as opening an
                    // item, so its columns are unknown and nothing is judged
                    // against a guess.
                    if li.commonmark_items.is_empty() {
                        continue;
                    }
                    let line = info.content(ctx.content);
                    chains.push((item_line, li.commonmark_items.clone()));
                    for item in &li.commonmark_items {
                        let task_col = Self::is_task_at_column(line, item.content_column)
                            .then_some(item.content_column + Self::TASK_CHECKBOX_PREFIX_LEN);
                        items.push((item_line, *item, task_col));
                    }
                }
            }
        }

        // Every warning below belongs to a collected item or its continuation.
        if items.is_empty() {
            return warnings;
        }

        chains.sort_by_key(|&(line, _)| line);
        chains.dedup_by_key(|&mut (line, _)| line);
        items.sort_unstable_by_key(|&(line, item, _)| (line, item.marker_column));
        items.dedup_by_key(|&mut (line, item, _)| (line, item.marker_column));

        // Precompute each item's owned-range end. The range ends at the line
        // before the next item whose marker column is <= this item's (its next
        // sibling or an ancestor), or the last line if none follows.
        //
        // The direct "scan forward for the next marker_col <= mine" is O(n^2) on
        // a monotonically deepening list, where no later item ever qualifies so
        // every item scans to the end. A monotonic stack (nearest
        // smaller-or-equal marker column to the right) computes all range ends in
        // one linear pass. Walking right-to-left, pop every stacked item whose
        // marker column is strictly greater than the current one (they can never
        // be the sibling/ancestor of anything further left that is <= current),
        // leaving the nearest qualifying item on top.
        let mut range_ends = vec![total_lines; items.len()];
        let mut stack: Vec<usize> = Vec::new();
        for i in (0..items.len()).rev() {
            let marker_col = items[i].1.marker_column;
            while let Some(&top) = stack.last() {
                if items[top].1.marker_column > marker_col {
                    stack.pop();
                } else {
                    break;
                }
            }
            range_ends[i] = stack.last().map_or(total_lines, |&j| items[j].0 - 1);
            stack.push(i);
        }

        // Python-Markdown's nesting level of every item, and whether it reads the
        // item as a list item at all. It reads a line's level as its indent
        // divided by four, so an item that opens its line sits at `marker
        // column / 4`, and each item written after another on the same line
        // (`- - a`) one level deeper than the one before it. A level more than
        // one below its parent's is no item for it, only text of the parent's
        // paragraph, and neither is a marker with nothing after it; the items
        // written directly under either are text too. The parent is the
        // nearest earlier item of the same list block with a marker further left.
        let mut pm_levels: Vec<usize> = Vec::with_capacity(items.len());
        let mut pm_items: Vec<bool> = Vec::with_capacity(items.len());
        let mut shared_line: Vec<bool> = Vec::with_capacity(items.len());
        // Which lines Python-Markdown reads as an item marker: a list never
        // starts in the middle of a paragraph, and an item's text can follow
        // lines of the item above in the same block.
        let parser_markers: Option<Vec<bool>> = strict_indent.then(|| Self::parser_marker_lines(ctx)).flatten();
        // The level of the first item written on each item's line.
        let mut head_levels: Vec<usize> = Vec::with_capacity(items.len());
        let mut open: Vec<usize> = Vec::new();
        for (i, &(item_line, item, _)) in items.iter().enumerate() {
            let block = block_of_line.get(&item_line);
            while open.last().is_some_and(|&top| {
                items[top].1.marker_column >= item.marker_column || block_of_line.get(&items[top].0) != block
            }) {
                open.pop();
            }
            let (level, is_item) = match open.last() {
                Some(&parent) if items[parent].0 == item_line => (pm_levels[parent] + 1, pm_items[parent]),
                Some(&parent) => {
                    let level = item.marker_column / 4;
                    let after_blank = ctx
                        .line_info(item_line - 1)
                        .is_some_and(|prev| Self::is_cm_blank(prev.content(ctx.content)));
                    // Text opens no list for what follows it directly, but a blank
                    // line ends its paragraph, and the marker is then read against
                    // the nearest item above it that is one.
                    let anchor = if pm_items[parent] {
                        Some(Some(parent))
                    } else if after_blank {
                        Some(open.iter().rev().copied().find(|&above| pm_items[above]))
                    } else {
                        None
                    };
                    let is_item = match anchor {
                        None => false,
                        // No item above: a list of its own, whose items sit at
                        // the first level or are code.
                        Some(None) => level <= items[parent].1.marker_column / 4,
                        // An item written on its parent's line holds the text
                        // after it in one paragraph: a deeper marker on the next
                        // line only opens a list after a blank line.
                        Some(Some(above)) if shared_line[above] => {
                            level <= head_levels[above] + 1 || (after_blank && level <= pm_levels[above] + 1)
                        }
                        Some(Some(above)) => level <= items[above].1.marker_column / 4 + 1,
                    };
                    (level, is_item)
                }
                None => (item.marker_column / 4, true),
            };
            // A marker with nothing after it, not even a space, is text there,
            // and so is a `)` ordered marker, which it does not know.
            let raw = ctx.line_info(item_line).map(|info| info.content(ctx.content));
            let bare = item.is_empty && raw.is_some_and(|line| !line.ends_with([' ', '\t']));
            let paren = raw.is_some_and(|line| Self::is_paren_marker(line, item.marker_column));
            let shared = open.last().filter(|&&parent| items[parent].0 == item_line);
            shared_line.push(shared.is_some());
            head_levels.push(shared.map_or(level, |&parent| head_levels[parent]));
            let in_quote = ctx.line_info(item_line).is_some_and(|info| info.blockquote.is_some());
            let read_as_marker = in_quote
                || parser_markers
                    .as_ref()
                    .is_none_or(|markers| markers.get(item_line - 1).copied().unwrap_or(false));
            let is_pm_item = is_item && read_as_marker && !bare && !paren;
            pm_levels.push(level);
            pm_items.push(is_pm_item);
            open.push(i);
        }

        // Precompute which lines can ever reach the per-line continuation
        // callback. `walk_item_continuation` unconditionally skips (regardless of
        // which item owns the line) blank lines, list-item lines, headings,
        // horizontal rules, `should_skip_line` lines, and block-level constructs;
        // only the lines that survive all of those can be flagged. An item whose
        // owned range contains none of them produces no warning, so both passes
        // can skip it without walking the range at all.
        //
        // This keeps a document of purely deeply-nested list items linear: such a
        // document has no continuation prose, so every item skips its walk
        // instead of re-scanning the whole tail (which was O(n^2) in the item
        // count). Documents that do have continuation prose are unaffected - the
        // guard only ever skips items that could not have produced a warning.
        let prose_candidate_lines: Vec<usize> = (1..=total_lines)
            .filter(|&line_num| {
                let Some(info) = ctx.line_info(line_num) else {
                    return false;
                };
                let trimmed = info.content(ctx.content).trim_start();
                !Self::should_skip_line(ctx, info, trimmed)
                    && !info.is_blank
                    && info.list_item.is_none()
                    && info.heading.is_none()
                    && !info.is_setext_heading_text
                    && !info.is_horizontal_rule
                    && !Self::is_block_level_construct(trimmed)
            })
            .collect();
        // True when a continuation candidate falls in `(after_line, range_end]`,
        // i.e. the half-open range `walk_item_continuation` actually visits.
        let range_has_prose_candidate = |after_line: usize, range_end: usize| -> bool {
            let start = prose_candidate_lines.partition_point(|&l| l <= after_line);
            prose_candidate_lines.get(start).is_some_and(|&l| l <= range_end)
        };

        // Precompute each item's required indent and owned line range so both
        // passes below scope identically.
        // The first line past each item that Python-Markdown still reads as the
        // item's own content: the first non-blank line indented less than the
        // item's paragraph column.
        // Evaluated on demand: only the scopes that can produce a warning ask.
        let closes: Vec<std::cell::OnceCell<usize>> = items.iter().map(|_| std::cell::OnceCell::new()).collect();
        let close_of = |idx: usize| -> usize {
            *closes[idx].get_or_init(|| {
                let item_line = items[idx].0;
                let column = 4 * (pm_levels[idx] + 1);
                (item_line + 1..=total_lines)
                    .find(|&line_num| {
                        ctx.line_info(line_num).is_some_and(|info| {
                            info.visual_indent < column && !Self::is_cm_blank(info.content(ctx.content))
                        })
                    })
                    .unwrap_or(total_lines + 1)
            })
        };
        let scoped: Vec<ItemScope> = items
            .iter()
            .enumerate()
            .filter(|&(item_idx, _)| !strict_indent || pm_items[item_idx])
            .map(|(item_idx, &(item_line, item, task_col))| {
                let marker_col = item.marker_column;
                let content_col = item.content_column;
                // A configured indent replaces the content column, but under a
                // flavor that requires strict list indentation it may only raise
                // the 4-space minimum. That minimum is a compatibility floor
                // rather than a style default: below it the renderer stops
                // treating the line as continuation, so honoring a smaller
                // configured value would make `fix` rewrite documents into a
                // form the flavor's renderer no longer reads as part of the item.
                // The minimum is four columns per nesting level: Python-Markdown
                // reads an item's paragraphs at four columns past the item's own
                // level, whatever the marker width.
                let level_column = 4 * (pm_levels[item_idx] + 1);
                let required = match self.config.indent {
                    Some(indent) if strict_indent => (marker_col + indent).max(level_column),
                    Some(indent) => marker_col + indent,
                    None if strict_indent => content_col.max(level_column),
                    None => content_col,
                };
                // No column is both inside the item for the parser and a paragraph
                // for Python-Markdown when the required column is already where
                // it starts reading code, so only the item's tight continuation
                // lines can be enforced: after a blank line the column would
                // turn the paragraph into code.
                let tight_only = strict_indent && required >= level_column + 4;
                // `chains` is sorted by line with one entry per item line.
                let same_line = chains
                    .binary_search_by_key(&item_line, |(line, _)| *line)
                    .ok()
                    .map(|at| &chains[at].1)
                    .map(|chain| {
                        chain
                            .iter()
                            .filter(|inner| inner.marker_column > marker_col)
                            .map(|inner| SameLineItem {
                                marker_col: inner.marker_column,
                                content_col: inner.content_column,
                                is_empty: inner.is_empty,
                            })
                            .collect()
                    })
                    .unwrap_or_default();
                ItemScope {
                    item_line,
                    marker_col,
                    content_col,
                    task_col,
                    required,
                    tight_only,
                    code_column: strict_indent.then_some(level_column + 4),
                    nested: if strict_indent && range_has_prose_candidate(item_line, range_ends[item_idx]) {
                        items[item_idx + 1..]
                            .iter()
                            .enumerate()
                            .take_while(|&(_, &(line, _, _))| line <= range_ends[item_idx])
                            .map(|(offset, &(line, _, _))| (line, item_idx + 1 + offset))
                            .filter(|&(_, other)| pm_items[other])
                            .map(|(line, other)| (line, 4 * (pm_levels[other] + 1), close_of(other)))
                            .collect()
                    } else {
                        Vec::new()
                    },
                    range_end: range_ends[item_idx],
                    starts_empty: item.is_empty,
                    same_line,
                }
            })
            .collect();

        // Pass 1 - under-indented continuation.
        //
        // Loose under-indent (after a blank line) sits below the content column
        // and would escape the list item; it is always flagged. Tight
        // under-indent is valid CommonMark lazy continuation, so it is left
        // alone under `style = "any"`.
        //
        // Under `style = "aligned"`, tight under-indent is additionally flagged
        // and snapped up to the content column. MD077 scopes past the parser's
        // block end (to catch escaped loose content), and the parser absorbs
        // col-0 blockquotes, fences, and tables that sit tight under a list item
        // as lazy continuation. Reindenting those would change the rendered
        // structure, so the tight-aligned branch guards two ways: it skips lines
        // the parser classified in place (code, blockquote - see
        // `confirmed_structure`), and it bails on an item whose continuation
        // holds a construct the parser would re-parse once indentation changes
        // (a latent list marker, table or setext underline - see
        // `has_latent_structure`). Headings and horizontal rules already
        // terminate the walk; reference/footnote/abbreviation definitions are
        // skipped inside it. Erring toward skipping yields false negatives
        // (safe) rather than structural false positives.
        //
        // This pass runs first so that a deeply nested item claims an ambiguous
        // line - one that is under-indented for it yet over-indented for a
        // shallower ancestor - before pass 2 can mis-attribute it to the
        // ancestor as an over-indent and snap it the wrong way.
        let aligned = self.config.style == ContinuationStyle::Aligned;
        for scope in &scoped {
            let (item_line, marker_col, required, range_end) =
                (scope.item_line, scope.marker_col, scope.required, scope.range_end);
            // No continuation candidate in this item's range: it cannot produce a
            // warning, so skip the walk (and the latent-structure scan) entirely.
            if !range_has_prose_candidate(item_line, range_end) {
                continue;
            }
            // "Latent structure": a line in this item's continuation that the
            // parser has NOT yet promoted to a list item or table, but that
            // would be once an earlier continuation line is reindented. Such a
            // promotion re-attributes the following lines to a different block
            // (different content column) and breaks single-pass idempotency, so
            // reindenting anything in the item is unsafe and the whole item is
            // skipped. This is a *prediction* of how the parser would re-parse
            // after a fix, which is why it stays a heuristic (markers, tables and
            // setext underlines are the constructs the parser absorbs as lazy
            // continuation rather than flagging on the line itself; code and
            // blockquotes are classified in place and handled per line below).
            // Well-formed prose continuation matches none, so this only bails
            // on pathological input (a safe false negative). Real nested items
            // never reach the callback (the walk handles them via `saw_nested`).
            let has_latent_structure = aligned && Self::item_range_has_latent_structure(ctx, item_line, range_end);
            // Which setting produced `required` decides what the message may
            // claim. The content column carries a structural consequence (below
            // it the content leaves the item) and the strict-flavor minimum
            // carries a renderer requirement, but a configured indent above
            // both is a house style, so it is reported as one.
            let from_configured_indent = self.config.indent.is_some_and(|indent| marker_col + indent == required);
            Self::walk_item_continuation(ctx, scope, |line| {
                let actual = line.actual;
                if Self::is_python_markdown_code(ctx, scope, line) || (scope.tight_only && line.saw_blank) {
                    return ControlFlow::Continue(());
                }
                let under_indented = actual < required;
                let loose_escape = line.saw_blank && under_indented;
                // Don't reindent a line the parser classified in place as a code
                // block (fenced or indented) or a blockquote: these are read
                // straight from its per-line output, so the rule cannot drift
                // from how rumdl parses the document. Headings and horizontal
                // rules terminate the walk before the callback; latent list
                // markers and tables are handled by `has_latent_structure`.
                let confirmed_structure = line.info.in_code_block || line.info.blockquote.is_some();
                let aligned_tight = aligned
                    && !has_latent_structure
                    && !line.saw_blank
                    && !line.saw_nested
                    && under_indented
                    && !confirmed_structure;
                if (loose_escape || aligned_tight) && flagged_lines.insert(line.line_num) {
                    let message = if line.saw_blank {
                        if from_configured_indent {
                            format!(
                                "Content after blank line in list item needs {required} spaces of \
                                 indentation to match the configured indent (found {actual})",
                            )
                        } else if strict_indent {
                            format!(
                                "Content inside list item needs {required} spaces of indentation \
                                 for MkDocs compatibility (found {actual})",
                            )
                        } else {
                            format!(
                                "Content after blank line in list item needs {required} spaces of \
                                 indentation to remain part of the list (found {actual})",
                            )
                        }
                    } else {
                        format!("Continuation line under-indented (expected {required}, found {actual})")
                    };
                    let outcome = Self::build_under_indent_warning(ctx, line, required, message);
                    if let Some(closer_line) = outcome.also_flag_line {
                        flagged_lines.insert(closer_line);
                    }
                    owners.insert(outcome.warning.line, item_line);
                    warnings.push(outcome.warning);
                }
                ControlFlow::Continue(())
            });
        }

        // Pass 2 - over-indented continuation (tight or loose): prose pushed
        // past the content column is snapped back. Fenced code blocks are
        // skipped here (`!in_code_block`): an over-indented fence is cosmetic
        // (the code still renders), and reindenting only its delimiters - the
        // body is skipped by `should_skip_line` - would alter the literal code
        // content. Indented code blocks (content column + 4 or more) are also
        // `in_code_block`, so a blank line before such a body does not exempt
        // it from being recognized as code rather than over-indented prose.
        for scope in &scoped {
            let (item_line, content_col, task_col, required, range_end) = (
                scope.item_line,
                scope.content_col,
                scope.task_col,
                scope.required,
                scope.range_end,
            );
            // No continuation candidate in this item's range: nothing to flag.
            if !range_has_prose_candidate(item_line, range_end) {
                continue;
            }
            // For task items, gather sibling-column usage once so the auto-fix
            // can tie-break equidistant over-indents toward whichever valid
            // column the author is already using.
            let (uses_content_col, uses_task_col) = match task_col {
                Some(t) => Self::sibling_column_usage(ctx, scope, t),
                None => (false, false),
            };

            Self::walk_item_continuation(ctx, scope, |line| {
                let actual = line.actual;
                if Self::is_python_markdown_code(ctx, scope, line) || (scope.tight_only && line.saw_blank) {
                    return ControlFlow::Continue(());
                }
                if actual <= required {
                    return ControlFlow::Continue(());
                }
                let fix_target = Self::compute_fix_target(actual, required, task_col, uses_content_col, uses_task_col);
                if !line.info.in_code_block
                    && Some(actual) != task_col
                    && !Self::starts_with_list_marker(line.trimmed)
                    && !Self::opens_block_when_moved(line.trimmed, content_col, actual, fix_target)
                    && flagged_lines.insert(line.line_num)
                {
                    let message = match task_col {
                        Some(t) => format!(
                            "Continuation line over-indented \
                             (expected {required} or {t}, found {actual})"
                        ),
                        None => {
                            format!("Continuation line over-indented (expected {required}, found {actual})")
                        }
                    };
                    let warning = Self::build_over_indent_warning(ctx, line, fix_target, message);
                    owners.insert(warning.line, item_line);
                    warnings.push(warning);
                }
                ControlFlow::Continue(())
            });
        }

        // The two passes emit independently, so order by position before
        // returning - callers and tests expect document order.
        warnings.sort_by_key(|w| (w.line, w.column));

        if strict_indent {
            Self::drop_unsafe_fixes(ctx, &mut warnings, &owners);
        }

        warnings
    }
}

impl Rule for MD077ListContinuationIndent {
    fn native_format_policy(&self) -> Option<crate::format_proof::NativeFormatPolicy> {
        (self.config == Default::default()).then_some(crate::format_proof::NativeFormatPolicy::for_rule::<Self>(77))
    }

    fn name(&self) -> &'static str {
        "MD077"
    }

    fn description(&self) -> &'static str {
        "List continuation content indentation"
    }

    fn check(&self, ctx: &LintContext) -> LintResult {
        Ok(self.check_native_source(&ctx.native_list_source()))
    }

    fn fix(&self, ctx: &LintContext) -> Result<String, LintError> {
        let warnings = self.check(ctx)?;
        let warnings =
            crate::utils::fix_utils::filter_warnings_by_inline_config(warnings, ctx.inline_config(), self.name());
        if warnings.is_empty() {
            return Ok(ctx.content.to_string());
        }

        let fixes: Vec<Fix> = warnings.into_iter().filter_map(|w| w.fix).collect();
        Ok(Self::apply_native_fixes(ctx.content, fixes))
    }

    fn fix_with_diagnostics(&self, ctx: &LintContext, warnings: &[LintWarning]) -> Result<String, LintError> {
        let fixes = warnings
            .iter()
            .filter(|warning| crate::utils::fix_utils::warning_is_enabled(warning, ctx.inline_config(), self.name()))
            .filter_map(|warning| warning.fix.clone())
            .collect();
        Ok(Self::apply_native_fixes(ctx.content, fixes))
    }

    fn category(&self) -> RuleCategory {
        RuleCategory::List
    }

    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
        ctx.content.is_empty() || ctx.list_blocks.is_empty()
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    crate::impl_rule_config_methods!(MD077Config);
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::MarkdownFlavor;

    fn check(content: &str) -> Vec<LintWarning> {
        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
        let rule = MD077ListContinuationIndent::default();
        rule.check(&ctx).unwrap()
    }

    fn check_mkdocs(content: &str) -> Vec<LintWarning> {
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        let rule = MD077ListContinuationIndent::default();
        rule.check(&ctx).unwrap()
    }

    fn fix(content: &str) -> String {
        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
        let rule = MD077ListContinuationIndent::default();
        rule.fix(&ctx).unwrap()
    }

    fn fix_mkdocs(content: &str) -> String {
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        let rule = MD077ListContinuationIndent::default();
        rule.fix(&ctx).unwrap()
    }

    #[test]
    fn test_blockquote_line_ends_the_item() {
        // A `>` left of the content column opens a blockquote after the list,
        // so the text below it is a paragraph of its own, not the item's.
        for content in ["1.  item\n>\n  continuation text\n", "- item\n> quote\n\n text\n"] {
            assert!(check(content).is_empty(), "{content:?}: {:?}", check(content));
            assert_eq!(fix(content), content);
        }
        // A quote inside the item keeps the item open.
        let inside = "- item\n\n  > quote\n\n text\n";
        assert_eq!(check(inside).len(), 1);
        assert_eq!(fix(inside), "- item\n\n  > quote\n\n  text\n");
    }

    #[test]
    fn test_fence_after_an_indented_code_block_moves_as_one_block() {
        // The fence opens right below an indented code block, so the whole
        // fenced block, not just its opener, has to move into the item.
        let content = " 2) item\n\n          ```\n   ```\n   code\n   ```\n";
        let fixed = fix(content);
        assert_eq!(fixed, " 2) item\n\n          ```\n    ```\n    code\n    ```\n");
        assert_eq!(fix(&fixed), fixed);
    }

    #[test]
    fn test_marker_left_of_the_content_column_ends_the_item() {
        // `1.` sits left of the bullet's content column, so it starts a list of
        // its own rather than nesting, and the text below continues it.
        let content = "*  a\n 1.  b\n\n  text\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        let message = &warnings[0].message;
        assert!(message.contains("needs 5 spaces"), "{message}");
        let fixed = fix(content);
        assert_eq!(fixed, "*  a\n 1.  b\n\n     text\n");
        assert_eq!(fix(&fixed), fixed);

        // At or left of that list's marker, the text is outside every item.
        let outside = "- a\n 1.  b\n\n text\n";
        assert!(check(outside).is_empty(), "{:?}", check(outside));
    }

    #[test]
    fn test_fence_text_in_indented_code_is_not_a_fence() {
        // Each last line is an indented code block whose text looks like a fence
        // (4 columns past the top level, or past the outer item's content).
        // Moving it would turn literal code into a fenced block.
        for content in [
            "  *  item\n     ```\n     ```\n\n    ```\n",
            "   1. item\n        -  item\n\n          ```\n",
        ] {
            assert!(check(content).is_empty(), "{content:?}: {:?}", check(content));
            assert_eq!(fix(content), content);
        }
    }

    fn aligned_rule() -> MD077ListContinuationIndent {
        MD077ListContinuationIndent::new(ContinuationStyle::Aligned)
    }

    fn check_aligned(content: &str) -> Vec<LintWarning> {
        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
        aligned_rule().check(&ctx).unwrap()
    }

    fn check_aligned_mkdocs(content: &str) -> Vec<LintWarning> {
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        aligned_rule().check(&ctx).unwrap()
    }

    fn fix_aligned(content: &str) -> String {
        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
        aligned_rule().fix(&ctx).unwrap()
    }

    fn fix_aligned_quarto(content: &str) -> String {
        let ctx = LintContext::new(content, MarkdownFlavor::Quarto, None);
        aligned_rule().fix(&ctx).unwrap()
    }

    #[test]
    fn html_block_opened_by_an_inline_level_tag_is_left_alone() {
        // `<math>` names no block-level element, yet alone on its line it opens
        // an HTML block, whose lines are raw HTML rather than continuation.
        let content = "- item\n\n    <math display=\"block\">\n          <mi>x</mi>\n    </math>\n";
        assert!(check(content).is_empty(), "{:?}", check(content));
        assert_eq!(fix(content), content);
    }

    #[test]
    fn html_block_in_an_item_is_left_alone_past_a_broken_tag() {
        // The `>` closing a tag broken across lines is HTML text, so the lines
        // after it stay inside the HTML block rather than becoming continuation.
        let content = "- item\n\n    <table>\n      <td>\n        <a\n          >a</a\n        >\n        text after\n      </td>\n    </table>\n";
        assert!(check(content).is_empty(), "{:?}", check(content));
        assert_eq!(fix(content), content);
    }

    #[test]
    fn lazy_continuation_does_not_close_the_nested_item() {
        // `    lazy` continues `b`'s paragraph below its content column without
        // closing `b`, so `para` at column 8 is `b`'s content, correctly indented.
        // Attributing it to `a` (content column 4) and snapping it there would move
        // the paragraph out of `b`.
        for content in [
            "*   a\n\n    *   b\n    lazy\n\n        para\n",
            "*   a\n\n    *   b\n    lazy\n\n        ```\n        x\n        ```\n\n        para\n",
            "* a\n\n  * b\n  lazy\n  lazy again\n\n    para\n",
        ] {
            assert!(check(content).is_empty(), "{content:?}: {:?}", check(content));
            assert_eq!(fix(content), content);
        }
    }

    #[test]
    fn paragraph_text_that_would_open_a_block_keeps_its_indent() {
        // Four or more columns past the content column these lines cannot
        // interrupt the paragraph, so they are its text. At the content column
        // each would open a block instead: a fence, a blockquote, a setext
        // heading, a thematic break, a table or an ATX heading.
        for construct in [
            "```",
            "```rust",
            "~~~",
            "> q",
            "---",
            "===",
            "***",
            "_ _ _",
            "| x | y |\n      | - | - |",
            "# A",
            "###### A",
            "## A ##",
            "#\tA",
            "#",
        ] {
            let content = format!("- a\n      {construct}\n");
            assert!(check(&content).is_empty(), "{content:?}: {:?}", check(&content));
            assert_eq!(fix(&content), content);
        }
    }

    #[test]
    fn hash_text_that_is_no_atx_heading_is_still_snapped_back() {
        for text in ["#A", "####### A", "#5"] {
            let content = format!("- a\n      {text}\n");
            assert_eq!(check(&content).len(), 1, "{content:?}");
            assert_eq!(fix(&content), format!("- a\n  {text}\n"));
        }
    }

    #[test]
    fn paragraph_text_past_the_threshold_is_still_snapped_back() {
        let content = "- a\n      text\n";
        assert_eq!(check(content).len(), 1);
        assert_eq!(fix(content), "- a\n  text\n");
        // Block-like text is still snapped back when its target column keeps it
        // four or more columns past the content column, where it stays text.
        let rule = MD077ListContinuationIndent::from_config_struct(MD077Config {
            indent: Some(6),
            ..Default::default()
        });
        let content = "- a\n         > q\n";
        let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
        assert_eq!(rule.fix(&ctx).unwrap(), "- a\n      > q\n");
        // Within three columns of the content column the line already is the
        // block, so moving it keeps it the same block.
        let content = "- a\n\n   > q\n";
        assert_eq!(check(content).len(), 1);
        assert_eq!(fix(content), "- a\n\n  > q\n");
    }

    #[test]
    fn over_indent_after_a_lazy_line_is_measured_against_the_nested_item() {
        let content = "* a\n\n  * b\n  lazy\n\n       para\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        assert_eq!(warnings[0].line, 6);
        assert!(
            warnings[0].message.contains("expected 4, found 7"),
            "{}",
            warnings[0].message
        );
        assert_eq!(fix(content), "* a\n\n  * b\n  lazy\n\n    para\n");
    }

    #[test]
    fn aligned_idempotent_with_latent_marker_behind_unstable_heading() {
        // Regression: an empty backtick run (`` ``\n`` ``) is parsed as a setext
        // heading. That heading used to terminate the latent-structure walk
        // before it reached the `- ` marker on the next line, so the marker was
        // not detected as latent. Reindenting the `1. ` continuation then
        // promoted `- ` to a real list item, producing a fresh under-indent
        // violation on the second pass and breaking single-pass idempotency.
        // The latent-structure scan now spans the full owned range, detects the
        // marker, and leaves the (ambiguous) item alone.
        let input = "1. \n``\n``\n- \n``";
        let once = fix_aligned_quarto(input);
        let twice = fix_aligned_quarto(&once);
        assert_eq!(once, twice, "MD077 aligned fix must be idempotent (Quarto)");
    }

    #[test]
    fn latent_underline_needs_paragraph_text_above_it() {
        // Only paragraph text can become a setext heading's text line, so an
        // underline sitting under an ATX heading or a thematic break is latent
        // nothing and must not hold the whole item back.
        for (label, content) in [
            ("ATX heading", "- item\nwrap\n# Heading\n===\n"),
            ("thematic break", "- item\nwrap\n***\n===\n"),
            ("HTML block", "- item\nwrap\n<div>\n===\n"),
        ] {
            assert_eq!(
                check_aligned(content).len(),
                1,
                "{label}: reindenting cannot make a setext heading here, so the under-indent is reportable"
            );
        }

        // A closing code fence is the case only the block flag can answer: its
        // text is indistinguishable from prose, and nothing but the block it
        // sits in says the line cannot be a setext heading's text. The fence at
        // the margin ends the item, so the underline below it is not the item's
        // to move; only the lazy line above the fence is reported.
        let warnings = check_aligned("- item\nwrap\n```\ncode\n```\n===\n");
        assert_eq!(
            warnings.len(),
            1,
            "a closing fence is not paragraph text, so it holds nothing back: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);

        // An empty list item is the case only the line's own markers can answer:
        // it is written inside a paragraph context and holds no text at all, and
        // an underline below it underlines nothing. A lone `-` is not this case
        // (under a paragraph it is itself an underline), so each marker carries
        // the space that opens an item holding nothing.
        for (label, content) in [
            ("empty bullet", "- item\n wrap\n > - \n ===\n"),
            ("empty ordered item", "- item\n wrap\n > 1. \n ===\n"),
            ("empty item in a nested quote", "- item\n wrap\n > > - \n ===\n"),
        ] {
            assert_eq!(
                check_aligned(content).len(),
                1,
                "{label}: an item holding no text cannot become a heading's text line"
            );
        }

        // A blank line above the underline is the same answer for the same
        // reason, and needs no test of its own in the rule: stripped of its
        // markers it holds nothing, which is what the text predicate rejects.
        assert_eq!(
            check_aligned("- item\n wrap\n\n ===\n").len(),
            2,
            "nothing above the underline can become a heading's text line"
        );
        // A quote line left of the content column ends the item instead, so the
        // underline after it is not the item's to align.
        for (label, content) in [
            ("blank line in a quote", "- item\n wrap\n >\n ===\n"),
            ("quoted whitespace", "- item\n wrap\n >   \n ===\n"),
        ] {
            let warnings = check_aligned(content);
            assert_eq!(warnings.len(), 1, "{label}: {warnings:?}");
            assert_eq!(warnings[0].line, 2, "{label}");
        }

        // Paired control: prose above the underline IS latent structure, because
        // reindenting the item would give the underline the content column and
        // turn the pair into a real heading.
        assert!(
            check_aligned("- item\nwrap\ntext\n===\n").is_empty(),
            "prose above the underline is latent structure, so the item is left alone"
        );
    }

    #[test]
    fn aligned_idempotent_with_lazy_continuation_out_of_a_blockquote() {
        // Regression: a lazy continuation that follows a blockquote-nested list
        // item gained one space of indent on every pass, so the formatter never
        // converged.
        let input = "- \n> *\n> a\n``";
        let once = fix_aligned(input);
        let twice = fix_aligned(&once);
        assert_eq!(once, twice, "MD077 aligned fix must be idempotent");
    }

    fn fix_aligned_flavor(content: &str, flavor: MarkdownFlavor) -> String {
        let ctx = LintContext::new(content, flavor, None);
        aligned_rule().fix(&ctx).unwrap()
    }

    #[test]
    fn aligned_text_after_a_margin_fence_is_not_the_items() {
        // A fence at the margin cannot continue the item's paragraph, so it
        // closes the item. The paragraph below it is top level: moving it four
        // columns (the MkDocs requirement) would make it an indented code
        // block, and the second pass would then read the line below it
        // differently.
        for input in [
            "- A\n```\n\n```\n![`]()\n`",
            "- \u{1d400}\n```\n\n```\n*`*\n**`**",
            "- A\n```\nx\n```\ntext\nmore\n",
        ] {
            for flavor in [
                MarkdownFlavor::Standard,
                MarkdownFlavor::MkDocs,
                MarkdownFlavor::Quarto,
                MarkdownFlavor::MDX,
            ] {
                let ctx = LintContext::new(input, flavor, None);
                let warnings = aligned_rule().check(&ctx).unwrap();
                assert!(warnings.is_empty(), "{flavor:?} {input:?}: {warnings:?}");
                assert_eq!(fix_aligned_flavor(input, flavor), input, "{flavor:?} {input:?}");
            }
        }
    }

    #[test]
    fn aligned_text_after_an_in_item_fence_is_not_the_items() {
        // The fence closes inside the item, but the line below it sits left of
        // the content column and no paragraph is open for it to continue.
        let input = "- A\n  ```\n  x\n  ```\ntext\n";
        for flavor in [MarkdownFlavor::Standard, MarkdownFlavor::MkDocs] {
            assert_eq!(fix_aligned_flavor(input, flavor), input, "{flavor:?}");
        }
    }

    #[test]
    fn aligned_still_aligns_the_paragraph_before_a_margin_fence() {
        // Positive control for the two tests above: the lazy lines before the
        // fence are the item's paragraph and are still aligned, in each flavor's
        // own column.
        let input = "- A\nb\nc\n```\nx\n```\ntext\n";
        assert_eq!(
            fix_aligned_flavor(input, MarkdownFlavor::Standard),
            "- A\n  b\n  c\n```\nx\n```\ntext\n"
        );
        assert_eq!(
            fix_aligned_flavor(input, MarkdownFlavor::MkDocs),
            "- A\n    b\n    c\n```\nx\n```\ntext\n"
        );
    }

    #[test]
    fn aligned_one_application_is_a_fixed_point_after_a_margin_fence() {
        for flavor in [MarkdownFlavor::Standard, MarkdownFlavor::MkDocs, MarkdownFlavor::Quarto] {
            for input in [
                "- A\n```\n\n```\n![`]()\n`",
                "- \u{1d400}\n```\n\n```\n*`*\n**`**",
                "- A\nb\n```\n\n```\n![`]()\n`",
            ] {
                let once = fix_aligned_flavor(input, flavor);
                let twice = fix_aligned_flavor(&once, flavor);
                assert_eq!(once, twice, "{flavor:?} {input:?}");
            }
        }
    }

    // ── Tight continuation (no blank line) ─────────────────────────────

    #[test]
    fn tight_lazy_continuation_zero_indent_not_flagged() {
        // Zero-indent lazy continuation is valid CommonMark
        let content = "- Item\ncontinuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn tight_continuation_correct_indent_not_flagged() {
        // Correctly indented tight continuation (aligns with content column)
        let content = "1. Item\n   continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn tight_continuation_over_indented_ordered() {
        // "1. " = 3 chars, but continuation has 4 spaces
        let content = "1. This is a list item with multiple lines.\n    The second line is over-indented.\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 2);
        assert!(warnings[0].message.contains("over-indented"));
    }

    #[test]
    fn tight_continuation_over_indented_unordered() {
        // "- " = 2 chars, but continuation has 3 spaces
        let content = "- Item\n   over-indented\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 2);
    }

    #[test]
    fn tight_continuation_multiple_over_indented_lines() {
        let content = "1. Item\n    line one\n    line two\n    line three\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 3);
    }

    #[test]
    fn tight_continuation_mixed_correct_and_over() {
        let content = "1. Item\n   correct\n    over-indented\n   correct again\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
    }

    #[test]
    fn tight_continuation_nested_over_indented() {
        // L2 "- " at column 2, content_column = 4. Continuation at 5 is over-indented for L2.
        let content = "- L1\n  - L2\n     over-indented continuation of L2\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        // Must report expected=4 (L2's content_col), not expected=2 (L1's)
        assert!(warnings[0].message.contains("expected 4"));
        assert!(warnings[0].message.contains("found 5"));
    }

    #[test]
    fn tight_continuation_nested_correct_indent_not_flagged() {
        // Continuation at 4 spaces is correct for L2 (content_col=4). Must NOT be
        // flagged as over-indented relative to L1 (content_col=2).
        let content = "- L1\n  - L2\n    correctly indented continuation of L2\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn fix_tight_continuation_nested_over_indented() {
        // Fix should reduce to 4 spaces (L2's content_col), not 2 (L1's)
        let content = "- L1\n  - L2\n     over-indented continuation of L2\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- L1\n  - L2\n    over-indented continuation of L2\n");
    }

    #[test]
    fn tight_continuation_under_indented_not_flagged() {
        // 2 spaces instead of 3 for "1. " — under-indented, not over-indented.
        // Valid lazy continuation in CommonMark, so not flagged.
        let content = "1. Item\n  under-indented\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn tight_continuation_tab_over_indented() {
        // A tab expands to 4 visual columns, which exceeds content_col=2 for "- "
        let content = "- Item\n\tover-indented\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
    }

    #[test]
    fn fix_tight_continuation_over_indented_ordered() {
        let content = "1. This is a list item with multiple lines.\n    The second line is over-indented.\n";
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "1. This is a list item with multiple lines.\n   The second line is over-indented.\n"
        );
    }

    #[test]
    fn fix_tight_continuation_over_indented_unordered() {
        let content = "- Item\n   over-indented\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- Item\n  over-indented\n");
    }

    #[test]
    fn fix_tight_continuation_multiple_lines() {
        let content = "1. Item\n    line one\n    line two\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. Item\n   line one\n   line two\n");
    }

    #[test]
    fn tight_continuation_mkdocs_4space_ordered_not_flagged() {
        // MkDocs requires max(3, 4) = 4 spaces for "1. " items.
        // 4-space tight continuation is correct, not over-indented.
        let content = "1. Item\n    continuation\n";
        assert!(check_mkdocs(content).is_empty());
    }

    #[test]
    fn tight_continuation_mkdocs_5space_ordered_flagged() {
        // 5 spaces exceeds the MkDocs required indent of 4
        let content = "1. Item\n     over-indented\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("expected 4"));
        assert!(warnings[0].message.contains("found 5"));
    }

    #[test]
    fn fix_tight_continuation_mkdocs_over_indented() {
        let content = "1. Item\n     over-indented\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. Item\n    over-indented\n");
    }

    #[test]
    fn tight_continuation_deeply_indented_list_markers_not_flagged() {
        // Deeply indented list markers (e.g., indent=8 in MD007) may not be
        // recognized as list items by the parser. MD077 must not flag them.
        let content = "* Level 0\n        * Level 1\n                * Level 2\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn tight_continuation_ordered_marker_not_flagged() {
        // Indented ordered list marker should not be flagged
        let content = "- Parent\n      1. Child item\n";
        assert!(check(content).is_empty());
    }

    // ── Unordered list: correct indent after blank ────────────────────

    #[test]
    fn unordered_correct_indent_no_warning() {
        let content = "- Item\n\n  continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn unordered_partial_indent_warns() {
        // Content with some indent (above marker column) but less than
        // content_column is likely an indentation mistake.
        let content = "- Item\n\n continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        assert!(warnings[0].message.contains("2 spaces"));
        assert!(warnings[0].message.contains("found 1"));
    }

    #[test]
    fn unordered_zero_indent_is_new_paragraph() {
        // Content at 0 indent after a top-level list is a new paragraph, not
        // under-indented continuation.
        let content = "- Item\n\ncontinuation\n";
        assert!(check(content).is_empty());
    }

    // ── Ordered list: CommonMark W+N ──────────────────────────────────

    #[test]
    fn ordered_3space_correct_commonmark() {
        // "1. " is 3 chars, content_column = 3
        let content = "1. Item\n\n   continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn ordered_2space_under_indent_commonmark() {
        let content = "1. Item\n\n  continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("3 spaces"));
        assert!(warnings[0].message.contains("found 2"));
    }

    // ── Multi-digit ordered markers ───────────────────────────────────

    #[test]
    fn multi_digit_marker_correct() {
        // "10. " is 4 chars, content_column = 4
        let content = "10. Item\n\n    continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn multi_digit_marker_under_indent() {
        let content = "10. Item\n\n   continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("4 spaces"));
    }

    // ── MkDocs flavor: 4-space minimum ────────────────────────────────

    #[test]
    fn mkdocs_3space_ordered_warns() {
        // In MkDocs mode, 3-space indent on "1. " is not enough
        let content = "1. Item\n\n   continuation\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("4 spaces"));
        assert!(warnings[0].message.contains("MkDocs"));
    }

    #[test]
    fn mkdocs_4space_ordered_no_warning() {
        let content = "1. Item\n\n    continuation\n";
        assert!(check_mkdocs(content).is_empty());
    }

    #[test]
    fn mkdocs_unordered_2space_ok() {
        // Unordered "- " has content_column = 2; max(2, 4) = 4 in mkdocs
        let content = "- Item\n\n    continuation\n";
        assert!(check_mkdocs(content).is_empty());
    }

    #[test]
    fn mkdocs_unordered_2space_warns() {
        // "- " has content_column 2; MkDocs requires max(2,4) = 4
        let content = "- Item\n\n  continuation\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("4 spaces"));
    }

    // ── Auto-fix ──────────────────────────────────────────────────────

    #[test]
    fn fix_unordered_indent() {
        // Partial indent (above marker column, below content column) gets fixed
        let content = "- Item\n\n continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- Item\n\n  continuation\n");
    }

    #[test]
    fn fix_ordered_indent() {
        let content = "1. Item\n\n continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. Item\n\n   continuation\n");
    }

    #[test]
    fn fix_mkdocs_indent() {
        let content = "1. Item\n\n   continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. Item\n\n    continuation\n");
        assert_eq!(fix_mkdocs(&fixed), fixed);
    }

    // ── MkDocs flavor: the 4-column rule applies per nesting level ────
    //
    // Python-Markdown reads a line's level as indent / 4 (at most one deeper
    // than the open list), so an item at level L holds its paragraphs at
    // 4 * (L + 1). Each document below was rendered with Python-Markdown 3.11
    // and the layout it reads as continuation of the innermost item is
    // asserted clean.

    #[test]
    fn mkdocs_nested_continuation_at_the_level_column_is_clean() {
        for content in [
            // <li>a<ul><li><p>b</p><p>text</p></li></ul></li>
            "- a\n    - b\n\n        text\n",
            // three levels
            "- a\n    - b\n        - c\n\n            text\n",
            // ordered, mixed ordered and bullet in both directions
            "1. a\n    1. b\n\n        text\n",
            "1. a\n    - b\n\n        text\n",
            "- a\n    1. b\n\n        text\n",
            // a sibling after a nested item holds its text at the same column
            "- a\n    - b\n\n    - c\n\n        text\n",
            // the item written on its parent's line is one level deeper
            "- - a\n\n        text\n",
            // and a sibling of that inner item shares its level
            "- - a\n    - b\n\n        text\n",
            // a fenced block at the level column
            "- a\n    - b\n\n        ```\n        code\n        ```\n",
        ] {
            assert!(
                check_mkdocs(content).is_empty(),
                "{content:?}: {:?}",
                check_mkdocs(content)
            );
            assert_eq!(fix_mkdocs(content), content);
        }
    }

    #[test]
    fn mkdocs_nested_continuation_below_the_level_column_moves_to_it() {
        // Text at the CommonMark column of the nested item reads as a paragraph
        // of the parent in Python-Markdown; the item's own column is 8.
        for (content, fixed) in [
            ("- a\n    - b\n\n      text\n", "- a\n    - b\n\n        text\n"),
            (
                "- a\n    - b\n        - c\n\n          text\n",
                "- a\n    - b\n        - c\n\n            text\n",
            ),
            ("1. a\n    1. b\n\n       text\n", "1. a\n    1. b\n\n        text\n"),
            ("- - a\n\n      text\n", "- - a\n\n        text\n"),
        ] {
            let warnings = check_mkdocs(content);
            assert_eq!(warnings.len(), 1, "{content:?}: {warnings:?}");
            assert!(warnings[0].message.contains("MkDocs"), "{}", warnings[0].message);
            assert_eq!(fix_mkdocs(content), fixed);
            assert!(check_mkdocs(fixed).is_empty(), "{fixed:?}");
        }
    }

    #[test]
    fn mkdocs_nested_over_indent_snaps_to_the_level_column() {
        assert_eq!(
            fix_mkdocs("- a\n    - b\n\n         text\n"),
            "- a\n    - b\n\n        text\n"
        );
        let warnings = check_mkdocs("- a\n    - b\n\n         text\n");
        assert_eq!(warnings.len(), 1);
        assert!(
            warnings[0].message.contains("expected 8, found 9"),
            "{}",
            warnings[0].message
        );
    }

    #[test]
    fn mkdocs_text_left_of_the_nested_marker_stays_with_the_parent() {
        // Python-Markdown: a paragraph of `a`. Text at the nested marker's
        // column is not the nested item's to claim.
        let content = "- a\n    - b\n\n    text\n";
        assert!(check_mkdocs(content).is_empty());
        assert_eq!(fix_mkdocs(content), content);
    }

    #[test]
    fn mkdocs_code_at_the_python_markdown_threshold_is_not_reindented() {
        // `b` is a sibling of `a` for Python-Markdown (its marker is under four
        // columns past `a`'s), so text at 8 is an indented code block there.
        let content = "1. a\n   - b\n\n        text\n";
        assert!(check_mkdocs(content).is_empty(), "{:?}", check_mkdocs(content));
        assert_eq!(fix_mkdocs(content), content);
        // The same under a configured indent that raises the requirement above
        // the code column.
        let rule = MD077ListContinuationIndent::from_config_struct(MD077Config {
            indent: Some(6),
            ..Default::default()
        });
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        assert!(rule.check(&ctx).unwrap().is_empty());
        assert_eq!(rule.fix(&ctx).unwrap(), content);
    }

    #[test]
    fn mkdocs_over_indented_paragraph_continuation_is_not_code() {
        // Only the first line after a blank can open Python-Markdown's code
        // block; `text` continues the `para` paragraph (<p>para text</p>).
        let content = "- a\n\n    para\n        text\n";
        assert_eq!(check_mkdocs(content).len(), 1);
        assert_eq!(fix_mkdocs(content), "- a\n\n    para\n    text\n");
        let nested = "- a\n    - b\n\n        para\n            text\n";
        assert_eq!(fix_mkdocs(nested), "- a\n    - b\n\n        para\n        text\n");
    }

    #[test]
    fn mkdocs_item_python_markdown_does_not_read_is_not_judged() {
        // `- b` sits two levels below `123456. a`, which Python-Markdown reads
        // as text of the paragraph, so the line below is a code block whose
        // literal indentation must stay.
        for content in [
            "123456. a\n        - b\n\n          text\n",
            "-    a\n        - b\n\n            text\n",
        ] {
            assert!(
                check_mkdocs(content).is_empty(),
                "{content:?}: {:?}",
                check_mkdocs(content)
            );
            assert_eq!(fix_mkdocs(content), content);
        }
    }

    #[test]
    fn mkdocs_bare_marker_is_not_an_item_for_python_markdown() {
        // A marker with nothing after it is paragraph text, so the lines below
        // are indented code (`<p>-    - b</p><pre><code>  text`) whose literal
        // indentation must stay; the same marker followed by a space is an item.
        for content in [
            "-\n    - b\n\n      text\n",
            "1.\n    - b\n\n      text\n",
            "- a\n    -\n\n      text\n",
            "-\n    -\n\n        text\n",
        ] {
            assert!(
                check_mkdocs(content).is_empty(),
                "{content:?}: {:?}",
                check_mkdocs(content)
            );
            assert_eq!(fix_mkdocs(content), content);
        }
        for content in ["- \n    - b\n\n      text\n", "1. \n    - b\n\n      text\n"] {
            assert_eq!(check_mkdocs(content).len(), 1, "{content:?}");
        }
    }

    #[test]
    fn mkdocs_bare_marker_does_not_unscope_a_later_list() {
        // The list after the heading is a list of its own; the bare marker
        // above it is not its parent.
        let content = "-\n\n# Heading\n\n  - b\n\n     text\n";
        assert_eq!(check_mkdocs(content).len(), 1, "{:?}", check_mkdocs(content));
        assert_eq!(fix_mkdocs(content), "-\n\n# Heading\n\n  - b\n\n    text\n");
    }

    #[test]
    fn mkdocs_paren_marker_is_not_an_item_for_python_markdown() {
        // Python-Markdown renders `1) b` as text of `a`, so text at column 7 is
        // a paragraph of `a` and text at column 8 is its code.
        let paragraph = "- a\n    1) b\n\n       text\n";
        assert!(check_mkdocs(paragraph).is_empty(), "{:?}", check_mkdocs(paragraph));
        let code = "- a\n    1) b\n\n        text\n";
        assert!(check_mkdocs(code).is_empty(), "{:?}", check_mkdocs(code));
    }

    #[test]
    fn mkdocs_item_below_a_same_line_item_needs_the_written_marker_column() {
        // Python-Markdown reads `- b` as text of `- a`: it is two levels past
        // where the outer marker is written. The text at column 10 is a
        // paragraph of that item.
        let content = "1. - a\n        - b\n\n          text\n";
        assert!(check_mkdocs(content).is_empty(), "{:?}", check_mkdocs(content));
    }

    #[test]
    fn mkdocs_list_after_a_blank_line_below_a_text_marker_is_an_item() {
        // `1) a` is a paragraph; after the blank line `  - b` opens a list of its
        // own (<p>1) a</p><ul><li>b</li></ul><p>text</p>), so the three-column
        // text escapes it and needs four. Its owner `- b` is a real item, so the
        // fix re-parents the paragraph under it, as for any item.
        for (content, fixed) in [
            ("1) a\n\n  - b\n\n   text\n", "1) a\n\n  - b\n\n    text\n"),
            ("-\n\n  - b\n\n   text\n", "-\n\n  - b\n\n    text\n"),
        ] {
            assert_eq!(check_mkdocs(content).len(), 1, "{content:?}");
            assert_eq!(fix_mkdocs(content), fixed);
            assert_eq!(fix_mkdocs(fixed), fixed);
        }
        // Without the blank line the marker line continues the paragraph, so
        // nothing below it belongs to an item.
        for content in ["1) a\n  - b\n\n   text\n", "-\n  - b\n\n   text\n"] {
            assert!(check_mkdocs(content).is_empty(), "{content:?}");
        }
    }

    #[test]
    fn mkdocs_marker_under_a_padded_same_line_item_is_text_until_a_blank_line() {
        // Python-Markdown: the inner item holds `- b` as text, whatever padding
        // the outer marker has, so the 10-column text is a paragraph of it.
        for content in [
            "-   - a\n        - b\n\n          text\n",
            "- - a\n        - b\n\n          text\n",
        ] {
            assert!(check_mkdocs(content).is_empty(), "{content:?}");
        }
        // After a blank line the same marker opens a list of its own, whose
        // text sits at 12.
        let content = "-   - a\n\n        - b\n\n            text\n";
        assert!(check_mkdocs(content).is_empty(), "{content:?}");
        assert_eq!(check_mkdocs("-   - a\n\n        - b\n\n          text\n").len(), 1);
    }

    #[test]
    fn mkdocs_markers_under_a_same_line_chain_are_text_until_a_blank_line() {
        // Python-Markdown: `- - b` is text of the innermost `a`, so the 12-column
        // text is its paragraph and must stay.
        let content = "- - - a\n        - - b\n\n            text\n";
        assert!(check_mkdocs(content).is_empty(), "{:?}", check_mkdocs(content));
        // After a blank line the marker is a sibling of the innermost item.
        let content = "- - - a\n\n        - b\n\n            text\n";
        assert!(check_mkdocs(content).is_empty(), "{:?}", check_mkdocs(content));
    }

    #[test]
    fn mkdocs_list_after_an_unsupported_marker_nests_in_the_enclosing_item() {
        // `1) b` is text of `a`; after the blank line `c` opens a list inside `a`
        // (<li><p>a  1) b</p><ul><li><p>c</p><p>text</p></li></ul></li>), so the
        // nine-column text moves to eight.
        let content = "- a\n  1) b\n\n    - c\n\n         text\n";
        assert_eq!(check_mkdocs(content).len(), 1);
        assert_eq!(fix_mkdocs(content), "- a\n  1) b\n\n    - c\n\n        text\n");
        // Two levels below `a` is code, which stays.
        let code = "- a\n    1) b\n\n        - c\n\n            text\n";
        assert!(check_mkdocs(code).is_empty(), "{:?}", check_mkdocs(code));
    }

    #[test]
    fn mkdocs_text_at_a_deeper_item_paragraph_column_is_not_claimed_by_the_outer_item() {
        // Python-Markdown: `text` is a paragraph of `b` (level 1), though the
        // parser leaves it to `a`, whose content column lies below `b`'s. It
        // stays a paragraph of `b`; only `b`'s own content column (9) is asked
        // of it, never the 12 columns of `a`'s level.
        let content = "- - - a\n      1. b\n\n        text\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        assert!(warnings[0].message.contains("needs 9"), "{}", warnings[0].message);
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "- - - a\n      1. b\n\n         text\n");
        assert!(check_mkdocs(&fixed).is_empty());
    }

    #[test]
    fn mkdocs_nested_item_closed_by_a_shallower_line_no_longer_owns_later_text() {
        // Python-Markdown: `para` at four columns closes `b`, so `para` and the
        // over-indented `text` below it are one paragraph of `a`.
        let content = "- a\n    - b\n\n    para\n        text\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1, "{warnings:?}");
        assert_eq!(fix_mkdocs(content), "- a\n    - b\n\n    para\n    text\n");
    }

    /// Documents whose naive fix changes what Python-Markdown makes of a line:
    /// the warning stays, the fix is withheld.
    fn assert_mkdocs_warns_without_fix(content: &str) {
        let warnings = check_mkdocs(content);
        assert!(!warnings.is_empty(), "expected a warning for {content:?}");
        assert!(
            warnings.iter().all(|w| w.fix.is_none()),
            "fix must be withheld for {content:?}: {warnings:?}"
        );
        assert_eq!(fix_mkdocs(content), content);
    }

    #[test]
    fn mkdocs_fix_does_not_turn_prose_after_a_text_marker_into_code() {
        // `1)` is text, so `text` is already a paragraph of the outer item;
        // moving it to the inner item's column would make it indented code.
        assert_mkdocs_warns_without_fix("- - a\n\n    1) b\n\n    text\n");
        // Control: with no text line between, the same move only re-parents.
        assert_eq!(fix_mkdocs("- - a\n\n    text\n"), "- - a\n\n        text\n");
    }

    #[test]
    fn mkdocs_item_after_the_continuation_lines_of_the_item_above_is_an_item() {
        // Python-Markdown splits the block at `- b`, so `text` (two columns in)
        // falls out of that item and needs four; the owner `- b` is a real item,
        // so the paragraph is re-parented under it.
        assert_eq!(
            fix_mkdocs("- a\n  continuation\n- b\n\n  text\n"),
            "- a\n  continuation\n- b\n\n    text\n"
        );
        // Control: a marker line under plain paragraph text starts no list.
        assert_eq!(check_mkdocs("para\n- b\n\n  text\n").len(), 0);
        // A heading above is not paragraph text: the list
        // after it is a list.
        assert_eq!(check_mkdocs("# Heading\n- a\n\n  text\n").len(), 1);
    }

    #[test]
    fn mkdocs_fix_is_withheld_when_it_would_change_how_later_lines_read() {
        // Moving `a` one column makes the item own the indented line after it,
        // which turns that code line into a nested list item.
        assert_mkdocs_warns_without_fix("10. word two\n\n     1.\n\n   a\n\n      - word two\n");
        assert_mkdocs_warns_without_fix(" - - word two\n\n    a\n          text\n\n           para\n");
    }

    #[test]
    fn mkdocs_fix_is_withheld_when_it_would_change_code_text_or_a_quote() {
        // Moving `text` lets the item own the code block after it, which
        // loses four columns of the code's own indentation.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      text\n\n            code\n");
        // The quote after `text` would become part of its paragraph.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      text\n    > quote\n");
    }

    #[test]
    fn mkdocs_fix_is_withheld_around_a_single_hyphen_underline_and_a_split_code_span() {
        // A lone `-` under `text` underlines it into a heading.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      text\n    - \n");
        // The code span's second line keeps its own indentation, so moving only
        // the lines around it changes the span's text.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      para\n         `one\n      two`\n");
        // Backtick runs of different lengths on one line can nest, so the span
        // that continues onto the next line cannot be told apart.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      `a `` b` c ``x\n      d`` e `f `` g`\n");
        // Control: a span that closes on its own line moves with the paragraph.
        assert_eq!(
            fix_mkdocs("- a\n    - b\n\n      para `one`\n"),
            "- a\n    - b\n\n        para `one`\n"
        );
    }

    #[test]
    fn mkdocs_fix_is_withheld_when_it_would_change_list_kind_or_tab_expansion() {
        // At eight columns `text` ends the nested list differently: the ordered
        // list below it would be absorbed into the bullet list and lose its numbers.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      text\n\n    1. ordered\n");
        // A tab after the text expands to the next multiple of four columns, so
        // re-indenting the fence changes the spaces the tab stands for.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      ```\n      a\tb\n      ```\n");
    }

    #[test]
    fn mkdocs_fix_is_withheld_for_a_quote_after_an_earlier_quote_and_for_exotic_space() {
        // The quote at the top of the document does not make the quote below the
        // list safe to move text across: at eight columns it joins `text`.
        assert_mkdocs_warns_without_fix("> intro\n\n- a\n    - b\n\n      text\n    > quote\n");
        // A code block holding only a no-break space is a block for
        // Python-Markdown; moving `text` would absorb it.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n      text\n\n        \u{a0}\n");
    }

    #[test]
    fn mkdocs_fix_is_withheld_below_a_whitespace_only_first_line() {
        // The first line keeps its spaces, so `- - a` is text of a paragraph
        // and `text` below it is code that a move would indent further.
        assert_mkdocs_warns_without_fix("   \n- - a\n\n    text\n");
        // Control: a whitespace-only line later in the document is blank.
        assert_eq!(
            fix_mkdocs("para\n\n   \n- - a\n\n    text\n"),
            "para\n\n   \n- - a\n\n        text\n"
        );
    }

    #[test]
    fn mkdocs_fix_ignores_front_matter_and_is_withheld_around_abbreviation_definitions() {
        // The front matter is removed before Python-Markdown reads the page, so
        // its delimiters do not make the list below it unmodeled.
        assert_eq!(
            fix_mkdocs("---\ntitle: Example\n---\n\n- a\n\n  text\n"),
            "---\ntitle: Example\n---\n\n- a\n\n    text\n"
        );
        // An abbreviation definition swallows the line below it, so moving that
        // line turns it into code.
        assert_mkdocs_warns_without_fix("- a\n    - b\n\n    *[X]: abbreviation\n      ## H\n");
    }

    #[test]
    fn mkdocs_fix_is_judged_on_the_fixes_inline_configuration_leaves() {
        // `one` is exempt, so only `two` would move, and that turns it into code.
        let content = "- a\n    - b\n\n      one <!-- rumdl-disable-line MD077 -->\n\n      two\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, content);
    }

    #[test]
    fn mkdocs_fix_does_not_pull_a_fence_outside_the_list_into_it() {
        // The two-column fence sits after the list; moving it under its item is
        // the documented re-parenting, and the interior moves with it.
        assert_eq!(
            fix_mkdocs("- a\n\n  ```\n  code\n  ```\n"),
            "- a\n\n    ```\n    code\n    ```\n"
        );
        // Inside the list the fence and its interior move together.
        assert_eq!(
            fix_mkdocs("- a\n    - b\n\n      ```\n      code\n      ```\n"),
            "- a\n    - b\n\n        ```\n        code\n        ```\n"
        );
    }

    #[test]
    fn mkdocs_fix_is_withheld_around_constructs_the_model_does_not_read() {
        // Each fix would change how Python-Markdown reads a later line: a
        // reference definition is dropped from the text, a thematic break ends
        // the paragraph before indented code, and an indented fence is plain
        // text to it, so the list marker inside is a list.
        for content in [
            "- a\n    - b\n\n      more\n        [id]: url\n",
            "- a\n    - b\n\n      ---\n          - c\n",
            "- a\n    - b\n\n      ```\n\n        - c\n      ```\n",
            "- a\n    - b\n\n     text\n      ===\n",
            "- a\n    - b\n\n      text\n  <!-- x -->\n            code\n",
            "- a\n    - b\n\n      ```\n        ***\n      ```\n",
        ] {
            assert_eq!(fix_mkdocs(content), content, "{content:?}");
        }
    }

    #[test]
    fn mkdocs_fix_is_withheld_for_a_fence_whose_lines_do_not_share_a_column() {
        // Python-Markdown reads the indented fence as a paragraph and keeps
        // each line's leading spaces inside the inline code span.
        let content = "- a\n    - b\n\n      ```\n        code\n      code\n```\n";
        assert_eq!(fix_mkdocs(content), content);
        assert!(check_mkdocs(content).iter().all(|w| w.fix.is_none()));
    }

    #[test]
    fn mkdocs_warnings_never_carry_overlapping_fixes() {
        // The caller applies every fix it is given by its original offsets, so
        // two fixes over the same bytes would duplicate text.
        let content = "- a\n    - b\n\n     ```\n       ```\n         ```\n";
        let mut ranges: Vec<_> = check_mkdocs(content)
            .iter()
            .filter_map(|w| w.fix.as_ref().map(|f| f.range.clone()))
            .collect();
        ranges.sort_by_key(|r| r.start);
        for pair in ranges.windows(2) {
            assert!(pair[0].end <= pair[1].start, "{ranges:?}");
        }
    }

    #[test]
    fn mkdocs_fence_on_the_items_own_line_keeps_the_item() {
        // Python-Markdown reads the marker line as an item whose text is
        // inline code, so the five-column paragraph below still needs four.
        let content = "- ```\n  code\n  ```\n\n     text\n";
        assert_eq!(check_mkdocs(content).len(), 1, "{:?}", check_mkdocs(content));
    }

    #[test]
    fn mkdocs_wide_marker_still_enforces_tight_continuation() {
        // The column a loose paragraph would need is where code starts, but a
        // tight continuation line has no such constraint.
        assert_eq!(
            fix_mkdocs("123456. a\n         continuation\n"),
            "123456. a\n        continuation\n"
        );
    }

    #[test]
    fn mkdocs_paren_marker_after_a_tab_is_found_by_column() {
        // The tab puts `x)` at column 4; byte offsets would read `x)` as `)`.
        let content = "- a\n\t- x) b\n\n         text\n";
        assert_eq!(check_mkdocs(content).len(), 1, "{:?}", check_mkdocs(content));
    }

    #[test]
    fn mkdocs_configured_indent_cannot_go_below_the_level_column() {
        let rule = MD077ListContinuationIndent::from_config_struct(MD077Config {
            indent: Some(2),
            ..Default::default()
        });
        let content = "- a\n    - b\n\n      text\n";
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        assert_eq!(rule.fix(&ctx).unwrap(), "- a\n    - b\n\n        text\n");
        let clean = "- a\n    - b\n\n        text\n";
        let ctx = LintContext::new(clean, MarkdownFlavor::MkDocs, None);
        assert!(rule.check(&ctx).unwrap().is_empty());
    }

    #[test]
    fn standard_flavor_keeps_the_content_column_for_nested_items() {
        // Control: the per-level rule is Python-Markdown's only.
        let content = "- a\n    - b\n\n      text\n";
        assert!(check(content).is_empty());
        assert_eq!(fix("- a\n    - b\n\n        text\n"), "- a\n    - b\n\n      text\n");
    }

    // ── Nested lists: only flag continuation, not sub-items ───────────

    #[test]
    fn nested_list_items_not_flagged() {
        let content = "- Parent\n\n  - Child\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn nested_list_zero_indent_is_new_paragraph() {
        // Content at 0 indent ends the list, not continuation
        let content = "- Parent\n  - Child\n\ncontinuation of parent\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn nested_list_partial_indent_flagged() {
        // Content with partial indent (above parent marker, below content col)
        let content = "- Parent\n  - Child\n\n continuation of parent\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("2 spaces"));
    }

    // ── Code blocks inside items ─────────────────────────────────────

    #[test]
    fn code_block_correctly_indented_no_warning() {
        // Fence lines and content all at correct indent for "- " (content_column = 2)
        let content = "- Item\n\n  ```\n  code\n  ```\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn code_fence_under_indented_warns() {
        // Fence opener has 1-space indent, but "- " needs 2.
        // Only the opener is flagged — its compound fix also covers the
        // interior content and the matching closer (see issue #574).
        let content = "- Item\n\n ```\n code\n ```\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
    }

    #[test]
    fn code_fence_under_indented_ordered_mkdocs() {
        // Ordered list in MkDocs: "1. " needs max(3, 4) = 4 spaces
        // Fence at 3 spaces is correct for CommonMark but wrong for MkDocs
        let content = "1. Item\n\n   ```toml\n   key = \"value\"\n   ```\n";
        assert!(check(content).is_empty()); // Standard mode: 3 is fine
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1); // MkDocs: opener's compound fix covers the whole block
        assert_eq!(warnings[0].line, 3);
        assert!(warnings[0].message.contains("4 spaces"));
        assert!(warnings[0].message.contains("MkDocs"));
    }

    #[test]
    fn code_fence_tilde_under_indented() {
        let content = "- Item\n\n ~~~\n code\n ~~~\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1); // Tilde fences: single compound-fix warning on opener
        assert_eq!(warnings[0].line, 3);
    }

    // ── Multiple blank lines ──────────────────────────────────────────

    #[test]
    fn multiple_blank_lines_zero_indent_is_new_paragraph() {
        // Even with multiple blanks, 0-indent content is a new paragraph
        let content = "- Item\n\n\ncontinuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn multiple_blank_lines_partial_indent_flags() {
        let content = "- Item\n\n\n continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
    }

    // ── Empty items: no continuation to check ─────────────────────────

    #[test]
    fn empty_item_no_warning() {
        let content = "- \n- Second\n";
        assert!(check(content).is_empty());
    }

    // ── Multiple items, only some under-indented ──────────────────────

    #[test]
    fn multiple_items_mixed_indent() {
        let content = "1. First\n\n   correct continuation\n\n2. Second\n\n  wrong continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 7);
    }

    // ── Task list items ───────────────────────────────────────────────

    #[test]
    fn task_list_correct_indent() {
        // "- [ ] " = content_column is typically at col 6
        let content = "- [ ] Task\n\n      continuation\n";
        assert!(check(content).is_empty());
    }

    // ── Frontmatter skipped ───────────────────────────────────────────

    #[test]
    fn frontmatter_not_flagged() {
        let content = "---\ntitle: test\n---\n\n- Item\n\n  continuation\n";
        assert!(check(content).is_empty());
    }

    // ── Fix produces valid output with multiple fixes ─────────────────

    #[test]
    fn fix_multiple_items() {
        let content = "1. First\n\n wrong1\n\n2. Second\n\n wrong2\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. First\n\n   wrong1\n\n2. Second\n\n   wrong2\n");
    }

    #[test]
    fn fix_multiline_loose_continuation_all_lines() {
        let content = "1. Item\n\n  line one\n  line two\n  line three\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. Item\n\n   line one\n   line two\n   line three\n");
    }

    #[test]
    fn multi_line_setext_heading_after_a_list_is_not_a_continuation() {
        // A setext heading's text is the whole paragraph its underline ends, so
        // every line of that paragraph is heading text. Reindenting the first of
        // them would move the heading, not a continuation line.
        let content = "1. Item\n\n  First line\n  second line\n  ===\n";
        let warnings = check(content);
        assert!(
            warnings.is_empty(),
            "the text lines of a setext heading are not continuation candidates. Got: {warnings:?}"
        );
        assert_eq!(fix(content), content);
    }

    // ── No false positive when content is after sibling item ──────────

    #[test]
    fn sibling_item_boundary_respected() {
        // The "continuation" after a blank belongs to "- Second", not "- First"
        let content = "- First\n- Second\n\n  continuation\n";
        assert!(check(content).is_empty());
    }

    // ── Blockquote-nested lists ────────────────────────────────────────

    #[test]
    fn blockquote_list_correct_indent_no_warning() {
        // Lists inside blockquotes: visual_indent includes the blockquote
        // prefix, so comparisons work on raw line columns.
        let content = "> - Item\n>\n>   continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn blockquote_list_under_indent_no_false_positive() {
        // Under-indented continuation inside a blockquote: visual_indent
        // starts at 0 (the `>` char) which is <= marker_col, so the scan
        // breaks and no warning is emitted. This is a known false negative
        // (not a false positive), which is the safer default.
        let content = "> - Item\n>\n> continuation\n";
        assert!(check(content).is_empty());
    }

    // ── Deep nesting (3+ levels) ──────────────────────────────────────

    #[test]
    fn deep_nesting_correct_indent() {
        let content = "- L1\n  - L2\n    - L3\n\n      continuation of L3\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn deep_nesting_under_indent() {
        // L3 starts at column 4 with "- " marker, content_column = 6
        // Continuation with 5 spaces is under-indented for L3.
        let content = "- L1\n  - L2\n    - L3\n\n     continuation of L3\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("6 spaces"));
        assert!(warnings[0].message.contains("found 5"));
    }

    #[test]
    fn deep_nesting_middle_level_continuation_bullets() {
        // A loose continuation of the MIDDLE level (L2, content_column = 4)
        // after a deeper L3 list is valid; the L1 walk must not claim it as
        // its own over-indented continuation (issue #739).
        let content = "- L1\n  - L2\n    - L3\n\n    continuation of L2\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn deep_nesting_middle_level_continuation_ordered() {
        // Issue #739 repro: ordered lists, continuation of the level-2 item
        // (content_column = 6) after a level-3 bullet list.
        let content = "1. Level 1 item.\n1. Level 1 item:\n   1. Level 2 item.\n   1. Level 2 item.\n   1. Level 2 item:\n      - Level 3 item.\n      - Level 3 item.\n\n      Level 2 list continuation.\n1. Level 1 item.\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn deep_nesting_outermost_continuation() {
        // A loose continuation of the OUTERMOST level (L1, content_column = 2)
        // past two open nested levels escapes both and stays valid.
        let content = "- L1\n  - L2\n    - L3\n\n  continuation of L1\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn deep_nesting_between_levels_still_flagged() {
        // Col 3 sits strictly between L1's content column (2) and L2's (4):
        // the deepest applicable item (L2) claims it as loose under-indent.
        let content = "- L1\n  - L2\n    - L3\n\n   continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("4 spaces"));
        assert!(warnings[0].message.contains("found 3"));
    }

    #[test]
    fn deep_nesting_beyond_deepest_still_flagged() {
        // Col 7 exceeds even L3's content column (6): over-indent for L3.
        let content = "- L1\n  - L2\n    - L3\n\n       continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("over-indented"));
        assert!(warnings[0].message.contains("expected 6, found 7"));
    }

    #[test]
    fn four_levels_middle_continuation() {
        // Continuation of L2 (content_column = 4) after open L3 and L4 lists:
        // the walk must pop two deeper levels and still defer to L2.
        let content = "- L1\n  - L2\n    - L3\n      - L4\n\n    continuation of L2\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn nested_sibling_closes_deeper_level() {
        // L2b closes L2a's deeper L3 list; a continuation at L2b's content
        // column belongs to L2b and stays valid.
        let content = "- L1\n  - L2a\n    - L3\n  - L2b\n\n    continuation of L2b\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn deep_nesting_middle_level_continuation_fix_preserved() {
        // The valid middle-level continuation must survive fix() unchanged.
        let content = "- L1\n  - L2\n    - L3\n\n    continuation of L2\n";
        assert_eq!(fix(content), content);
    }

    // ── Tab indentation ───────────────────────────────────────────────

    #[test]
    fn loose_tab_continuation_over_indented() {
        // A tab expands to 4 visual columns, exceeding content_column = 2 for
        // "- ". Loose over-indent is flagged just like the tight tab case
        // (`tight_continuation_tab_over_indented`), and the fix normalizes the
        // tab down to the content-column indent.
        let content = "- Item\n\n\tcontinuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        assert_eq!(fix(content), "- Item\n\n  continuation\n");
    }

    // ── Multiple continuation paragraphs ──────────────────────────────

    #[test]
    fn multiple_continuations_correct() {
        let content = "- Item\n\n  para 1\n\n  para 2\n\n  para 3\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn multiple_continuations_second_under_indent() {
        // First continuation is correct, second is under-indented
        let content = "- Item\n\n  para 1\n\n continuation 2\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 5);
    }

    // ── Ordered list with `)` marker style ────────────────────────────

    #[test]
    fn ordered_paren_marker_correct() {
        // "1) " is 3 chars, content_column = 3
        let content = "1) Item\n\n   continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn ordered_paren_marker_under_indent() {
        let content = "1) Item\n\n  continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("3 spaces"));
    }

    // ── Star and plus markers ─────────────────────────────────────────

    #[test]
    fn star_marker_correct() {
        let content = "* Item\n\n  continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn star_marker_under_indent() {
        let content = "* Item\n\n continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
    }

    #[test]
    fn plus_marker_correct() {
        let content = "+ Item\n\n  continuation\n";
        assert!(check(content).is_empty());
    }

    // ── Heading breaks scan ───────────────────────────────────────────

    #[test]
    fn heading_after_list_no_warning() {
        let content = "- Item\n\n# Heading\n";
        assert!(check(content).is_empty());
    }

    // ── Horizontal rule breaks scan ───────────────────────────────────

    #[test]
    fn hr_after_list_no_warning() {
        let content = "- Item\n\n---\n";
        assert!(check(content).is_empty());
    }

    // ── Reference link definitions skip ───────────────────────────────

    #[test]
    fn reference_link_def_not_flagged() {
        let content = "- Item\n\n [link]: https://example.com\n";
        assert!(check(content).is_empty());
    }

    // ── Footnote definitions skip ─────────────────────────────────────

    #[test]
    fn footnote_def_not_flagged() {
        let content = "- Item\n\n [^1]: footnote text\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn footnote_multiline_body_after_list_not_flagged() {
        // A footnote definition whose indented body follows a list must not be
        // read as over-indented list continuation. The 4-space body lines
        // belong to the footnote, not to `- This is a list.` (content col 2).
        let content = "# A list followed by a footnote\n\n\
                       Here is a paragraph.[^fn]\n\n\
                       - This is a list.\n\n\
                       [^fn]:\n\
                       \x20\x20\x20\x20Here is a footnote that spans multiple lines.\n\
                       \x20\x20\x20\x20It should thus be indented by at least four spaces.\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn fix_footnote_multiline_body_after_list_is_noop() {
        // The false positive also produced a damaging auto-fix: reindenting the
        // footnote body from 4 spaces to 2 broke the footnote (then tripped
        // MD068). The fix must leave the footnote untouched.
        let content = "# A list followed by a footnote\n\n\
                       Here is a paragraph.[^fn]\n\n\
                       - This is a list.\n\n\
                       [^fn]:\n\
                       \x20\x20\x20\x20Here is a footnote that spans multiple lines.\n\
                       \x20\x20\x20\x20It should thus be indented by at least four spaces.\n";
        assert_eq!(fix(content), content);
    }

    #[test]
    fn footnote_body_indented_past_list_content_col_not_flagged() {
        // Footnote body indented well past the list's content column (here a
        // single-space list marker would put content col at 2, body at 4) is
        // footnote content, not over-indented continuation.
        let content = "- Item\n\n[^fn]:\n    Body line one.\n    Body line two.\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn list_inside_footnote_body_continuation_not_flagged() {
        // Accepted trade-off: a list living *inside* a footnote body is skipped
        // wholesale, so MD077 does not police its continuation indentation.
        // Consistent with MD007, which also skips footnote-internal content.
        let content = "Text.[^fn]\n\n[^fn]:\n\
                       \x20\x20\x20\x20- nested item\n\
                       \x20\x20\x20\x20\x20\x20\x20over-indented continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn footnote_multiline_body_after_list_not_flagged_mkdocs() {
        // Same protection under the MkDocs flavor. The body sits at 6 spaces,
        // past MkDocs's required indent of 4 for `- `, so without skipping
        // footnote content it would be flagged as over-indented continuation.
        let content = "Here is a paragraph.[^fn]\n\n\
                       - This is a list.\n\n\
                       [^fn]:\n\
                       \x20\x20\x20\x20\x20\x20Footnote body that spans\n\
                       \x20\x20\x20\x20\x20\x20multiple indented lines.\n";
        assert!(check_mkdocs(content).is_empty());
    }

    // ── Fix preserves correct content ─────────────────────────────────

    #[test]
    fn fix_deep_nesting() {
        let content = "- L1\n  - L2\n    - L3\n\n     under-indented\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- L1\n  - L2\n    - L3\n\n      under-indented\n");
    }

    #[test]
    fn fix_mkdocs_unordered() {
        // MkDocs: "- " has content_column 2, but MkDocs requires max(2,4) = 4
        let content = "- Item\n\n  continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "- Item\n\n    continuation\n");
        assert_eq!(fix_mkdocs(&fixed), fixed);
    }

    #[test]
    fn fix_code_fence_indent() {
        // Fence opener, interior, and closer all shift by the same delta so
        // the parser keeps pairing the fences and MD031 doesn't misfire.
        let content = "- Item\n\n ```\n code\n ```\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- Item\n\n  ```\n  code\n  ```\n");
    }

    #[test]
    fn fix_mkdocs_code_fence_indent() {
        // MkDocs ordered list: fence at 3 spaces needs 4; interior shifts too
        let content = "1. Item\n\n   ```toml\n   key = \"val\"\n   ```\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. Item\n\n    ```toml\n    key = \"val\"\n    ```\n");
        assert_eq!(fix_mkdocs(&fixed), fixed);
    }

    // ── Empty document / whitespace-only ──────────────────────────────

    #[test]
    fn empty_document_no_warning() {
        assert!(check("").is_empty());
    }

    #[test]
    fn whitespace_only_no_warning() {
        assert!(check("   \n\n  \n").is_empty());
    }

    // ── No list at all ────────────────────────────────────────────────

    #[test]
    fn no_list_no_warning() {
        let content = "# Heading\n\nSome paragraph.\n\nAnother paragraph.\n";
        assert!(check(content).is_empty());
    }

    // ── Multi-line continuation (additional coverage) ──────────────

    #[test]
    fn multiline_continuation_all_lines_flagged() {
        let content = "1. This is a list item.\n\n  This is continuation text and\n  it has multiple lines.\n  This is yet another line.\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 3);
        assert_eq!(warnings[0].line, 3);
        assert_eq!(warnings[1].line, 4);
        assert_eq!(warnings[2].line, 5);
    }

    #[test]
    fn multiline_continuation_with_frontmatter_fix() {
        let content = "---\ntitle: Heading\n---\n\nSome introductory text:\n\n1. This is a list item.\n\n  This is list continuation text and\n  it has multiple lines that aren't indented properly.\n  This is yet another line that isn't indented properly.\n1. This is a list item.\n\n  This is list continuation text and\n  it has multiple lines that aren't indented properly.\n  This is yet another line that isn't indented properly.\n";
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "---\ntitle: Heading\n---\n\nSome introductory text:\n\n1. This is a list item.\n\n   This is list continuation text and\n   it has multiple lines that aren't indented properly.\n   This is yet another line that isn't indented properly.\n1. This is a list item.\n\n   This is list continuation text and\n   it has multiple lines that aren't indented properly.\n   This is yet another line that isn't indented properly.\n"
        );
    }

    #[test]
    fn multiline_continuation_correct_indent_no_warning() {
        let content = "1. Item\n\n   line one\n   line two\n   line three\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn multiline_continuation_mixed_indent() {
        let content = "1. Item\n\n   correct\n  wrong\n   correct\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 4);
    }

    #[test]
    fn multiline_continuation_unordered() {
        let content = "- Item\n\n continuation 1\n continuation 2\n continuation 3\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 3);
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "- Item\n\n  continuation 1\n  continuation 2\n  continuation 3\n"
        );
    }

    #[test]
    fn multiline_continuation_two_items_fix() {
        let content = "1. First\n\n  cont a\n  cont b\n\n2. Second\n\n  cont c\n  cont d\n";
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "1. First\n\n   cont a\n   cont b\n\n2. Second\n\n   cont c\n   cont d\n"
        );
    }

    #[test]
    fn fence_fix_does_not_break_pairing_for_md031() {
        // Regression for issue #574: previously MD077 only reindented the
        // fence delimiter lines while leaving the code block's interior at
        // the old indent. Between iterations of the fix loop the parser
        // saw an opener-closer mismatch, and MD031 then injected stray
        // blank lines at the fence boundaries. MD077's compound fix must
        // now rewrite the whole block atomically so the fences stay paired.
        let content = "#### title\n\nabc\n\n\
                       1. ab\n\n\
                       \x20\x20`aabbccdd`\n\n\
                       2. cd\n\n\
                       \x20\x20`bbcc dd ee`\n\n\
                       \x20\x20```\n\
                       \x20\x20abcd\n\
                       \x20\x20ef gh\n\
                       \x20\x20```\n\n\
                       \x20\x20uu\n\n\
                       \x20\x20```\n\
                       \x20\x20cdef\n\
                       \x20\x20gh ij\n\
                       \x20\x20```\n";
        let expected = "#### title\n\nabc\n\n\
                        1. ab\n\n\
                        \x20\x20\x20`aabbccdd`\n\n\
                        2. cd\n\n\
                        \x20\x20\x20`bbcc dd ee`\n\n\
                        \x20\x20\x20```\n\
                        \x20\x20\x20abcd\n\
                        \x20\x20\x20ef gh\n\
                        \x20\x20\x20```\n\n\
                        \x20\x20\x20uu\n\n\
                        \x20\x20\x20```\n\
                        \x20\x20\x20cdef\n\
                        \x20\x20\x20gh ij\n\
                        \x20\x20\x20```\n";
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn multiline_continuation_separated_by_blank() {
        let content = "1. Item\n\n  para1 line1\n  para1 line2\n\n  para2 line1\n  para2 line2\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 4);
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "1. Item\n\n   para1 line1\n   para1 line2\n\n   para2 line1\n   para2 line2\n"
        );
    }

    #[test]
    fn tab_indented_fence_is_normalized_to_spaces() {
        // Leading tabs expand to the next multiple-of-4 column under
        // CommonMark, so simply prepending spaces before a tab would
        // silently no-op (the tab snaps back to column 4). The compound
        // fence fix must replace the leading whitespace with a fresh
        // (visual_indent + delta) run of spaces. The fence (visual col 4)
        // belongs to the outer item, short of the nested `100. ` item's
        // content column 7, and must end up at 7 spaces after the fix.
        let content = "- a\n\n  100. ab\n\n\t```\n\tabcd\n\t```\n";
        let expected = "- a\n\n  100. ab\n\n       ```\n       abcd\n       ```\n";
        assert_eq!(fix(content), expected);
        // At the top level the same lines are an indented code block holding
        // fence-like text, which is not continuation of the item.
        let code = "100. ab\n\n\t```\n\tabcd\n\t```\n";
        assert_eq!(fix(code), code);
    }

    // ── Loose continuation (after a blank line): over-indent ──────────
    //
    // Over-indentation is a mistake in both tight and loose continuation:
    // the body looks aligned but isn't. A blank line between the marker and
    // the body must not exempt it. The only over-indent that is intentional
    // after a blank line is an indented code block (content column + 4 or
    // more), which the parser marks `in_code_block` and the rule skips.

    #[test]
    fn loose_continuation_over_indented_flagged() {
        // "* " content column is 2; 3 spaces after a blank is over-indented
        // (the code-block threshold is content_col + 4 = 6).
        let content = "* Item\n\n   over-indented\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        assert!(warnings[0].message.contains("over-indented"));
        assert!(warnings[0].message.contains("expected 2"));
        assert!(warnings[0].message.contains("found 3"));
    }

    #[test]
    fn loose_continuation_over_indented_multiline_mixed() {
        // Over, correct, over — only the two over-indented lines are flagged.
        let content = "* Item\n\n   over one\n  correct\n   over two\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 2);
        assert_eq!(warnings[0].line, 3);
        assert_eq!(warnings[1].line, 5);
    }

    #[test]
    fn fix_loose_continuation_over_indented() {
        let content = "* Item\n\n   over one\n  correct\n   over two\n";
        let fixed = fix(content);
        assert_eq!(fixed, "* Item\n\n  over one\n  correct\n  over two\n");
    }

    #[test]
    fn fix_tight_and_loose_items_normalized_identically() {
        // The reported document: a tight item and a loose item with the same
        // over-indented body must both normalize to the content column.
        let content = "---\ntitle: Heading\n---\n\nSome introductory text:\n\n\
                       * This is a list item.\n   This is list continuation text and\n  it has multiple lines that aren't indented properly.\n   This is yet another line that isn't indented properly.\n\n\
                       * This is a list item.\n\n   This is list continuation text and\n  it has multiple lines that aren't indented properly.\n   This is yet another line that isn't indented properly.\n";
        let expected = "---\ntitle: Heading\n---\n\nSome introductory text:\n\n\
                        * This is a list item.\n  This is list continuation text and\n  it has multiple lines that aren't indented properly.\n  This is yet another line that isn't indented properly.\n\n\
                        * This is a list item.\n\n  This is list continuation text and\n  it has multiple lines that aren't indented properly.\n  This is yet another line that isn't indented properly.\n";
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn multi_paragraph_item_loose_paragraph_over_indented() {
        // A tight first paragraph and a loose second paragraph (after an
        // internal blank line) are both over-indented; both must be flagged.
        let content = "* Item.\n   tight over\n\n   loose over\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 2);
        assert_eq!(warnings[0].line, 2);
        assert_eq!(warnings[1].line, 4);
    }

    #[test]
    fn loose_indented_code_block_not_flagged() {
        // content_col = 2; a loose line at content_col + 4 (6 spaces) is a
        // CommonMark indented code block, not over-indented prose. The over-
        // indent check must never reach it (it is `in_code_block` and skipped).
        let content = "- Item\n\n      code line\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn mkdocs_loose_over_indented_flagged() {
        // MkDocs requires max(3, 4) = 4 for "1. ". A loose line at 5 spaces is
        // over-indented (code-block threshold is content_col + 4 = 7).
        let content = "1. Item\n\n     over\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        assert!(warnings[0].message.contains("over-indented"));
        assert!(warnings[0].message.contains("expected 4"));
        assert!(warnings[0].message.contains("found 5"));
    }

    #[test]
    fn task_list_loose_over_indented_flagged() {
        // "- [ ] " content_col = 2, task_col = 6. A loose line at 4 spaces is
        // neither valid column and below the code-block threshold (6); flagged.
        let content = "- [ ] Task\n\n    over\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
    }

    #[test]
    fn loose_over_indent_boundary_below_code_block_threshold_flagged() {
        // content_col = 2; 5 spaces (= content_col + 3) is the deepest loose
        // over-indent that is still prose. content_col + 4 (6 spaces) would be
        // an indented code block - see `loose_indented_code_block_not_flagged`.
        // This pins the boundary so a shift in the parser's threshold is caught.
        let content = "- Item\n\n     over\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 3);
        assert!(warnings[0].message.contains("expected 2"));
        assert!(warnings[0].message.contains("found 5"));
    }

    #[test]
    fn loose_over_indent_does_not_steal_nested_under_indent() {
        // Inner content_col = 4, marker_col = 2. A loose continuation at column
        // 3 is under-indented for Inner yet over-indented for Outer (content_col
        // 2). The under-indent pass must claim it for Inner (snap *up* to 4,
        // preserving the apparent nesting), never letting the over-indent pass
        // mis-attribute it to Outer and snap it *down* to 2. This is the exact
        // ambiguity the two-pass ordering exists to resolve.
        let content = "- Outer\n  - Inner\n\n   continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 4);
        assert!(warnings[0].message.contains("4 spaces"));
        assert!(warnings[0].message.contains("found 3"));
        assert_eq!(fix(content), "- Outer\n  - Inner\n\n    continuation\n");
    }

    #[test]
    fn loose_over_indent_attributes_to_deepest_enclosing_item() {
        // Inner content_col = 4. A loose continuation at column 5 over-indents
        // Inner (the deepest item it sits within), so it is flagged against
        // Inner's column 4 - not Outer's column 2 - and snapped to 4.
        let content = "- Outer\n  - Inner\n\n     continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 4);
        assert!(warnings[0].message.contains("expected 4"));
        assert!(warnings[0].message.contains("found 5"));
        assert_eq!(fix(content), "- Outer\n  - Inner\n\n    continuation\n");
    }

    // ── Over-indented fenced code blocks are left untouched ───────────
    //
    // An over-indented fence is cosmetic: the code still renders inside the
    // list item. Reindenting only its delimiters (the body is skipped as code)
    // would change the literal code content, so the over-indent pass skips
    // anything `in_code_block`. The under-indent path still fixes fences, where
    // moving the block up is required to keep it inside the item.

    #[test]
    fn loose_over_indented_fence_not_flagged() {
        let content = "- Item\n\n   ```\n   code\n   ```\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn tight_over_indented_fence_not_flagged() {
        let content = "- Item\n   ```\n   code\n   ```\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn over_indented_tilde_fence_not_flagged() {
        let content = "- Item\n\n   ~~~\n   code\n   ~~~\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn fence_like_code_content_inside_fenced_block_not_flagged() {
        // A ``` line that is the *body* of a ~~~ block must not be treated as
        // over-indented continuation; rewriting it would corrupt code content.
        let content = "- Item\n\n  ~~~\n   ```\n  ~~~\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn unterminated_over_indented_fence_not_flagged() {
        // No closing fence: the last code line must not be mistaken for a
        // closer and snapped to the content column.
        let content = "- Item\n\n   ```\n   code1\n     code2deeper\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    // ── GFM task list items: post-checkbox continuation column ───────
    //
    // MD013's reflow indents wrapped task-list lines at `content_col + 4`
    // (the column after the checkbox). MD077 must accept that column for
    // both tight and loose continuation, for every marker flavour, so the
    // two rules don't fight over well-formed task items (issue #579).

    #[test]
    fn task_list_tight_continuation_post_checkbox_reproducer_579() {
        // Exact reproducer from the bug report: content wraps to the
        // post-checkbox column (6) with no blank line.
        let content = "- [ ] Lorem ipsum dolor sit amet, consectetur adipiscing\n      tempor incididunt ut labore.\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_dash_unchecked() {
        let content = "- [ ] Task\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_dash_checked_lower() {
        let content = "- [x] Task\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_dash_checked_upper() {
        let content = "- [X] Task\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_star_marker() {
        let content = "* [ ] Task\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_plus_marker() {
        let content = "+ [ ] Task\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_content_column_still_valid() {
        // Column 2 is the CommonMark-canonical indent for "- " and remains
        // valid for task items too.
        let content = "- [ ] Task\n  continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_between_columns_still_flagged() {
        // Column 4 matches neither content_col (2) nor post-checkbox (6).
        // A genuine indentation mistake — must remain flagged.
        let content = "- [ ] Task\n    continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        // Task items advertise both valid columns to the user.
        assert!(warnings[0].message.contains("expected 2 or 6"));
        assert!(warnings[0].message.contains("found 4"));
    }

    #[test]
    fn task_list_tight_continuation_overshoot_still_flagged() {
        // Column 7 overshoots the post-checkbox column. Genuine mistake.
        let content = "- [ ] Task\n       continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("expected 2 or 6"));
        assert!(warnings[0].message.contains("found 7"));
    }

    // ── Task-list fix output: snap to nearer valid column ────────────

    #[test]
    fn fix_task_list_overshoot_snaps_to_task_col() {
        // Col 7 is 1 away from post-checkbox (6), 5 away from content (2).
        // Snap to 6 — the author's intent was almost certainly the
        // post-checkbox alignment, not the content column.
        let content = "- [ ] Task\n       continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n      continuation\n");
    }

    #[test]
    fn fix_task_list_col_5_snaps_to_task_col() {
        // Col 5 is 1 away from post-checkbox (6), 3 away from content (2).
        let content = "- [ ] Task\n     continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n      continuation\n");
    }

    #[test]
    fn fix_task_list_col_3_snaps_to_content_col() {
        // Col 3 is 1 away from content (2), 3 away from post-checkbox (6).
        let content = "- [ ] Task\n   continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n  continuation\n");
    }

    #[test]
    fn fix_task_list_col_4_ties_to_content_col() {
        // Col 4 is equidistant (±2) from both columns. Tie breaks to the
        // CommonMark-canonical content column — that's the default indent
        // MD077 would produce for a non-task item, so prefer it when the
        // author's intent is ambiguous.
        let content = "- [ ] Task\n    continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n  continuation\n");
    }

    #[test]
    fn fix_task_list_ordered_overshoot_snaps_to_task_col() {
        // "1. [ ] " → content_col = 3, post-checkbox = 7.
        // Col 8 is nearer to 7.
        let content = "1. [ ] Task\n        continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. [ ] Task\n       continuation\n");
    }

    #[test]
    fn fix_task_list_ordered_under_overshoot_snaps_to_content_col() {
        // "1. [ ] " → content_col = 3, post-checkbox = 7.
        // Col 4 is nearer to 3.
        let content = "1. [ ] Task\n    continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. [ ] Task\n   continuation\n");
    }

    #[test]
    fn task_list_tight_continuation_ordered_single_digit() {
        // "1. [ ] " → content_col = 3, post-checkbox = 7
        let content = "1. [ ] Task\n       continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_ordered_multi_digit() {
        // "10. [ ] " → content_col = 4, post-checkbox = 8
        let content = "10. [ ] Task\n        continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_tight_continuation_nested_dash() {
        // Nested "  - [ ] " at marker_col=2 → content_col=4, post-checkbox=8
        let content = "- Parent\n  - [ ] Nested task\n        continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_loose_continuation_post_checkbox_column_not_flagged() {
        // Loose continuation (blank line) at col 6 is also valid. This
        // already passed before the fix, but pin the intent: the 6-space
        // indent is accepted because it's the task-alignment column, not
        // because the under-indent check happens to let it through.
        let content = "- [ ] Task\n\n      continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_empty_body_is_not_a_task() {
        // "- [ ]" with nothing after is an empty regular list item, not a
        // task. Column 4 continuation has no task alignment to justify it
        // and must still be flagged as over-indented. (Col 6 would turn
        // the continuation into an indented code block inside the item,
        // which is a different code path.)
        let content = "- [ ]\n    continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("found 4"));
    }

    #[test]
    fn task_list_malformed_checkbox_is_not_a_task() {
        // `[~] ` is not a GFM checkbox; only `[ ] `, `[x] `, `[X] ` count.
        let content = "- [~] Not a task\n      continuation\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
    }

    // ── MkDocs flavor × task checkbox ─────────────────────────────────
    //
    // MkDocs strict-indent and task alignment interact: required_min is
    // max(content_col, 4), and post-checkbox is content_col + 4. Both are
    // independently valid; values between them are flagged.

    #[test]
    fn task_list_mkdocs_unordered_required_min_valid() {
        // "- [ ]" MkDocs: required_min = max(2, 4) = 4, post-checkbox = 6.
        let content = "- [ ] Task\n    continuation\n";
        assert!(check_mkdocs(content).is_empty());
    }

    #[test]
    fn task_list_mkdocs_unordered_post_checkbox_valid() {
        let content = "- [ ] Task\n      continuation\n";
        assert!(check_mkdocs(content).is_empty());
    }

    #[test]
    fn task_list_mkdocs_unordered_between_flagged() {
        // Column 5 is between required_min=4 and post-checkbox=6.
        let content = "- [ ] Task\n     continuation\n";
        let warnings = check_mkdocs(content);
        assert_eq!(warnings.len(), 1);
    }

    #[test]
    fn task_list_mkdocs_ordered_both_columns_valid() {
        // "1. [ ]" MkDocs: required_min = max(3, 4) = 4, post-checkbox = 7.
        let at_4 = "1. [ ] Task\n    continuation\n";
        assert!(check_mkdocs(at_4).is_empty());
        let at_7 = "1. [ ] Task\n       continuation\n";
        assert!(check_mkdocs(at_7).is_empty());
    }

    #[test]
    fn task_list_mkdocs_ordered_between_flagged() {
        // Column 5 and 6 are between required_min=4 and post-checkbox=7.
        let at_5 = "1. [ ] Task\n     continuation\n";
        assert_eq!(check_mkdocs(at_5).len(), 1);
        let at_6 = "1. [ ] Task\n      continuation\n";
        assert_eq!(check_mkdocs(at_6).len(), 1);
    }

    // ── Context-aware tie-break ──────────────────────────────────────
    //
    // When a flagged line is exactly equidistant from `content_col` and
    // `task_col`, the author's intent is ambiguous. Before picking a
    // canonical default, look at whether other continuation lines in the
    // same item already use one of the valid columns — if so, snap to the
    // column they're using so the fix preserves the author's visible
    // convention.

    #[test]
    fn fix_task_list_tie_sibling_at_task_col_snaps_to_task_col() {
        // Col 4 is equidistant from content_col (2) and task_col (6).
        // A valid sibling at col 6 proves the author is aligning under the
        // checkbox, so the tie resolves to col 6.
        let content = "- [ ] Task\n      aligned continuation\n    tied continuation\n";
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "- [ ] Task\n      aligned continuation\n      tied continuation\n"
        );
    }

    #[test]
    fn fix_task_list_tie_sibling_at_content_col_snaps_to_content_col() {
        // Valid sibling at col 2 proves the author is aligning to the
        // content column, so the col-4 tie resolves to col 2.
        let content = "- [ ] Task\n  aligned continuation\n    tied continuation\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n  aligned continuation\n  tied continuation\n");
    }

    #[test]
    fn fix_task_list_tie_both_siblings_snaps_to_content_col() {
        // When siblings exist at both valid columns, the author's pattern
        // is self-contradictory. Fall back to the CommonMark-canonical
        // content column.
        let content = "- [ ] Task\n  at content col\n      at task col\n    tied continuation\n";
        let fixed = fix(content);
        assert_eq!(
            fixed,
            "- [ ] Task\n  at content col\n      at task col\n  tied continuation\n"
        );
    }

    #[test]
    fn fix_task_list_tie_sees_task_col_through_tight_lazy_continuation() {
        // CommonMark allows tight lazy continuation at col ≤ marker_col
        // (zero-indent continuation) inside a list item. The pre-pass
        // must MIRROR the main check loop's termination semantics: in
        // tight mode (no preceding blank) col ≤ marker_col is NOT a
        // termination signal — the lazy line still belongs to the item.
        //
        // This test pins that mirroring: a `lazy` line at col 0 is
        // followed by a legitimate task-col sibling at col 6, then a
        // tied col-4 line. If the pre-pass terminated eagerly at the
        // lazy line, the task-col sibling would be missed and the tied
        // line would fall back to content column. With correct
        // mirroring, the task-col sibling is seen and the tie resolves
        // to col 6.
        let content = concat!("- [ ] Task\n", "lazy\n", "      aligned at task col\n", "    tied\n",);
        let fixed = fix(content);
        assert!(
            fixed.contains("\n      tied\n"),
            "tied line should snap to col 6 (task col) because a task-col \
             sibling is visible past the tight lazy-continuation line; got:\n{fixed}"
        );
    }

    // ── Tab-indented task continuation ───────────────────────────────
    //
    // Leading tabs expand to the next column that's a multiple of 4 under
    // CommonMark. The fix replaces the leading whitespace bytes wholesale,
    // turning tabs into space-indented output.

    #[test]
    fn task_list_tab_indented_continuation_flagged() {
        // Two tabs → visual col 8, which overshoots both valid columns
        // for `- [ ] ` (content_col=2, task_col=6).
        let content = "- [ ] Task\n\t\twrap\n";
        let warnings = check(content);
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("expected 2 or 6"));
        assert!(warnings[0].message.contains("found 8"));
    }

    #[test]
    fn fix_task_list_tab_indented_snaps_to_task_col() {
        // abs_diff(8, 6) = 2 < abs_diff(8, 2) = 6 → snap to task_col (6).
        let content = "- [ ] Task\n\t\twrap\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n      wrap\n");
    }

    #[test]
    fn fix_task_list_single_tab_equidistant_snaps_to_content_col() {
        // One tab → visual col 4, equidistant from content_col (2) and
        // task_col (6). No siblings → tie-break to content_col.
        let content = "- [ ] Task\n\twrap\n";
        let fixed = fix(content);
        assert_eq!(fixed, "- [ ] Task\n  wrap\n");
    }

    // ── Blockquote × task-list ───────────────────────────────────────
    //
    // Blockquote-nested lists are a known limitation on MD077: the list
    // parser doesn't always expose them with the same column semantics as
    // top-level lists, and the rule prefers a false-negative default to
    // avoid spurious warnings inside blockquotes (see
    // `blockquote_list_under_indent_no_false_positive`). These tests pin
    // the current behavior so any future change is intentional.

    #[test]
    fn task_list_blockquote_post_checkbox_not_flagged() {
        // Post-checkbox alignment inside a blockquote — accepted as valid.
        let content = "> - [ ] Task\n>       continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_blockquote_between_cols_documented_limitation() {
        // Col-4-equivalent inside a blockquote is silently accepted — a
        // known MD077 limitation on blockquote-nested lists, not a task-
        // list-specific choice. Pinning the current behavior.
        let content = "> - [ ] Task\n>     continuation\n";
        assert!(check(content).is_empty());
    }

    #[test]
    fn task_list_blockquote_overshoot_documented_limitation() {
        // Overshoot inside a blockquote — same known limitation.
        let content = "> - [ ] Task\n>        continuation\n";
        assert!(check(content).is_empty());
    }

    // ── MkDocs × task × fix output ───────────────────────────────────
    //
    // MkDocs strict-indent raises `required` to max(content_col, 4) while
    // task_col stays at content_col + 4. The snap logic operates on the
    // raised required, not on the underlying content_col.

    #[test]
    fn fix_task_list_mkdocs_unordered_overshoot_snaps_to_task_col() {
        // `- [ ]` MkDocs: required=4, task_col=6. Col 7 → abs_diff(7,6)=1
        // < abs_diff(7,4)=3. Snap to task_col.
        let content = "- [ ] Task\n       continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "- [ ] Task\n      continuation\n");
    }

    #[test]
    fn fix_task_list_mkdocs_unordered_tie_snaps_to_required() {
        // `- [ ]` MkDocs: required=4, task_col=6. Col 5 → abs_diff(5,6)=1
        // == abs_diff(5,4)=1. Tie with no siblings → required (4).
        let content = "- [ ] Task\n     continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "- [ ] Task\n    continuation\n");
    }

    #[test]
    fn fix_task_list_mkdocs_ordered_overshoot_snaps_to_task_col() {
        // `1. [ ]` MkDocs: required=4, task_col=7. Col 8 → abs_diff(8,7)=1
        // < abs_diff(8,4)=4. Snap to task_col.
        let content = "1. [ ] Task\n        continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. [ ] Task\n       continuation\n");
    }

    #[test]
    fn fix_task_list_mkdocs_ordered_near_required_snaps_to_required() {
        // `1. [ ]` MkDocs: required=4, task_col=7. Col 5 → abs_diff(5,7)=2
        // > abs_diff(5,4)=1. Snap to required (4). `1. [ ] Task\n     wrap`
        // has actual=5 which is over `required=4` so it's flagged in
        // strict mode, while in standard mode it falls under the lazy-
        // continuation window and isn't flagged at all.
        let content = "1. [ ] Task\n     continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. [ ] Task\n    continuation\n");
    }

    #[test]
    fn fix_task_list_mkdocs_ordered_between_cols_snaps_to_task_col() {
        // `1. [ ]` MkDocs: required=4, task_col=7. Col 6 → abs_diff(6,7)=1
        // < abs_diff(6,4)=2. Snap to task_col (7).
        let content = "1. [ ] Task\n      continuation\n";
        let fixed = fix_mkdocs(content);
        assert_eq!(fixed, "1. [ ] Task\n       continuation\n");
    }

    // ── Fix idempotency (property test) ──────────────────────────────
    //
    // A fix pass on already-fixed content must produce the same content
    // — otherwise MD077 would oscillate on repeated invocations. This is
    // the core property that issue #579 was about (MD077 vs. MD013 fix
    // loop), and the integration test covers the MD013 interaction. The
    // property tests below pin the *internal* idempotency of MD077's own
    // fix, so any future change that introduces oscillation fails fast.

    fn assert_idempotent(content: &str) {
        let once = fix(content);
        let twice = fix(&once);
        assert_eq!(once, twice, "MD077 fix was not idempotent on input: {content:?}");
    }

    fn assert_idempotent_mkdocs(content: &str) {
        let once = fix_mkdocs(content);
        let twice = fix_mkdocs(&once);
        assert_eq!(
            once, twice,
            "MD077 (MkDocs) fix was not idempotent on input: {content:?}"
        );
    }

    #[test]
    fn idempotent_task_list_between_cols() {
        assert_idempotent("- [ ] Task\n    continuation\n");
    }

    #[test]
    fn idempotent_task_list_overshoot() {
        assert_idempotent("- [ ] Task\n       continuation\n");
    }

    #[test]
    fn idempotent_task_list_under_post_checkbox() {
        assert_idempotent("- [ ] Task\n   continuation\n");
    }

    #[test]
    fn idempotent_task_list_near_post_checkbox() {
        assert_idempotent("- [ ] Task\n     continuation\n");
    }

    #[test]
    fn idempotent_task_list_tab_overshoot() {
        assert_idempotent("- [ ] Task\n\t\twrap\n");
    }

    #[test]
    fn idempotent_task_list_single_tab() {
        assert_idempotent("- [ ] Task\n\twrap\n");
    }

    #[test]
    fn idempotent_task_list_ordered_overshoot() {
        assert_idempotent("1. [ ] Task\n        continuation\n");
    }

    #[test]
    fn idempotent_task_list_ordered_under() {
        assert_idempotent("1. [ ] Task\n    continuation\n");
    }

    #[test]
    fn idempotent_task_list_tie_with_sibling_at_task_col() {
        assert_idempotent("- [ ] Task\n      aligned\n    tied\n");
    }

    #[test]
    fn idempotent_task_list_tie_with_sibling_at_content_col() {
        assert_idempotent("- [ ] Task\n  aligned\n    tied\n");
    }

    #[test]
    fn idempotent_task_list_mkdocs_unordered_overshoot() {
        assert_idempotent_mkdocs("- [ ] Task\n       continuation\n");
    }

    #[test]
    fn idempotent_task_list_mkdocs_unordered_tie() {
        assert_idempotent_mkdocs("- [ ] Task\n     continuation\n");
    }

    #[test]
    fn idempotent_task_list_mkdocs_ordered_overshoot() {
        assert_idempotent_mkdocs("1. [ ] Task\n        continuation\n");
    }

    #[test]
    fn idempotent_task_list_mkdocs_ordered_between() {
        assert_idempotent_mkdocs("1. [ ] Task\n      continuation\n");
    }

    #[test]
    fn idempotent_task_list_reproducer_579() {
        // The exact reproducer from issue #579 already has correct indent
        // (col 6 = post-checkbox), so idempotency is trivially true. Pin
        // it anyway as a smoke test against future regressions.
        assert_idempotent(
            "- [ ] Lorem ipsum dolor sit amet, consectetur adipiscing\n      tempor incididunt ut labore.\n",
        );
    }

    #[test]
    fn idempotent_non_task_list_still_holds() {
        // Non-task items never enter the task_col code path; sanity-check
        // that idempotency is preserved for them too.
        assert_idempotent("1. Item\n    over-indented\n");
        assert_idempotent("- Item\n\n continuation\n");
    }

    // ── Non-task idempotency: loose-mode under-indent ────────────────
    //
    // When a blank line precedes the continuation (loose mode),
    // under-indented content is flagged and fixed up to the content
    // column. Idempotency pins that one pass of the fix is sufficient.

    #[test]
    fn idempotent_non_task_loose_under_indent_ordered() {
        // 1. Item → content col 3; "  x" is 2 spaces, under content col.
        assert_idempotent("1. Item\n\n  continuation\n");
    }

    #[test]
    fn idempotent_non_task_loose_under_indent_multi_digit() {
        // 10. Item → content col 4; single-space continuation needs 4.
        assert_idempotent("10. Item\n\n continuation\n");
    }

    #[test]
    fn idempotent_non_task_tight_over_indent_ordered() {
        // Tight-mode over-indent: 5 spaces where content col is 3.
        assert_idempotent("1. Item\n     over-indented\n");
    }

    // ── Non-task idempotency: fenced code block compound fix ─────────
    //
    // A fence opener that needs re-indenting is repaired by the
    // compound-fence fix which shifts opener + interior + closer
    // together. Idempotency pins that the compound fix settles in one
    // pass and does not oscillate between runs.

    #[test]
    fn idempotent_non_task_fence_ordered_loose() {
        // 1. Item → content col 3; fence at col 2 needs to shift to 3.
        assert_idempotent("1. Item\n\n  ```rust\n  let x = 1;\n  ```\n");
    }

    #[test]
    fn idempotent_non_task_fence_tilde_under_indent() {
        // Tilde fences use the same compound-fix path as backtick fences.
        // Interior below the list scope (col 0 here, required col 3) must
        // be promoted up in the same pass as the fence delimiters —
        // otherwise a second pass would flag the interior individually
        // and defeat idempotency.
        assert_idempotent("1. Item\n\n  ~~~\nplain text\n  ~~~\n");
    }

    #[test]
    fn idempotent_non_task_fence_interior_above_required() {
        // Interior already above the required column must not be pushed
        // further up by the compound fix — authored interior indentation
        // is preserved when it doesn't threaten fence pairing.
        assert_idempotent("1. Item\n\n  ```\n    deeply indented code\n  ```\n");
    }

    #[test]
    fn fence_fix_promotes_interior_below_scope_in_single_pass() {
        // Concrete behavioral check, not just idempotency:
        // interior at col 0 with opener at col 2, required 3, must land
        // at col 3 (same as opener) so fence pairing is preserved.
        let content = "1. Item\n\n  ```\ncode\n  ```\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. Item\n\n   ```\n   code\n   ```\n");
    }

    #[test]
    fn fence_fix_preserves_interior_offset_from_the_fence() {
        // Opener at col 2 → col 3 (required). Interior at col 4 sits two
        // columns inside the fence and must still sit two columns inside it
        // afterwards, at col 5: leaving it at col 4 would silently flatten
        // one level of the code block's own indentation.
        let content = "1. Item\n\n  ```\n    code\n  ```\n";
        let fixed = fix(content);
        assert_eq!(fixed, "1. Item\n\n   ```\n     code\n   ```\n");
    }

    // ── Non-task idempotency: MkDocs strict-indent ───────────────────
    //
    // Under MkDocs flavor, continuation requires max(content_col, 4),
    // which can force a fix even when CommonMark would accept the
    // content. Pin idempotency for the non-task path there too.

    #[test]
    fn idempotent_non_task_mkdocs_ordered_at_3_spaces() {
        // CommonMark-valid (3 spaces) but MkDocs demands 4 → fix runs.
        assert_idempotent_mkdocs("1. Item\n\n   continuation\n");
    }

    #[test]
    fn idempotent_non_task_mkdocs_unordered_at_2_spaces() {
        // "- Item" → content col 2, but MkDocs raises the floor to 4.
        assert_idempotent_mkdocs("- Item\n\n  continuation\n");
    }

    #[test]
    fn idempotent_non_task_mkdocs_fence_compound() {
        // MkDocs non-task fence: opener/interior/closer shift together.
        assert_idempotent_mkdocs("1. Item\n\n   ```toml\n   k = 1\n   ```\n");
    }

    // ── style = "aligned" ──────────────────────────────────────────────

    #[test]
    fn aligned_tight_zero_indent_continuation_flagged() {
        // The core #682 case: a tight 0-indent lazy continuation is valid
        // CommonMark (and accepted by `any`), but `aligned` requires it to sit
        // at the content column.
        let content = "- this is a long line\nthat continues on a second line\n";
        let warnings = check_aligned(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].line, 2);
        assert_eq!(
            fix_aligned(content),
            "- this is a long line\n  that continues on a second line\n"
        );
    }

    #[test]
    fn aligned_full_issue_example_made_consistent() {
        // The full #682 example: every continuation line is snapped to the
        // content column, producing the consistent result the reporter wants.
        let content = "- this is a long line\n\
                       that continues on a second line\n\
                       - this is another long line\n\
                       \x20\x20that continues on the next line\n\
                       - yet again a long line\n\
                       and still inconsistently spaced\n\
                       \x20\x20and even worse\n";
        let expected = "- this is a long line\n\
                        \x20\x20that continues on a second line\n\
                        - this is another long line\n\
                        \x20\x20that continues on the next line\n\
                        - yet again a long line\n\
                        \x20\x20and still inconsistently spaced\n\
                        \x20\x20and even worse\n";
        assert_eq!(fix_aligned(content), expected);
        // And the fix is a fixpoint.
        assert_eq!(fix_aligned(expected), expected);
    }

    #[test]
    fn aligned_already_aligned_not_flagged() {
        let content = "- item\n  continuation at content column\n";
        assert!(check_aligned(content).is_empty());
    }

    #[test]
    fn aligned_tight_partial_indent_flagged() {
        // 1 space under "- " (content col 2): tight partial under-indent.
        let content = "- item\n continuation\n";
        let warnings = check_aligned(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(fix_aligned(content), "- item\n  continuation\n");
    }

    #[test]
    fn aligned_post_blank_zero_indent_still_new_paragraph() {
        // After a blank line, 0-indent content is a NEW paragraph that has left
        // the list - aligned mode must not reindent it back into the item.
        let content = "- item\n\nnew paragraph\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    // ── aligned: structural blocks must NOT be pulled into the list ────

    #[test]
    fn aligned_top_level_blockquote_after_list_untouched() {
        // A blockquote tight after a list item is a list-breaking separator,
        // not continuation. `in_list_block` is false for it, so aligned mode
        // must leave it alone (no reindent into the item).
        let content = "- item\n> quote\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    #[test]
    fn aligned_top_level_fence_after_list_untouched() {
        let content = "- item\n```\ncode\n```\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    #[test]
    fn aligned_top_level_table_after_list_untouched() {
        let content = "- item\n| a | b |\n|---|---|\n| 1 | 2 |\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    // ── aligned: nested lists ──────────────────────────────────────────

    #[test]
    fn aligned_nested_tight_lazy_continuation_aligns_to_inner() {
        // A tight lazy continuation after a nested item is, per CommonMark,
        // continuation of the innermost open item, so it aligns to the inner
        // item's content column (4), not the outer's (2). The outer item must
        // defer to the inner one.
        let content = "- Outer\n  - Inner\ncontinuation\n";
        let warnings = check_aligned(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(fix_aligned(content), "- Outer\n  - Inner\n    continuation\n");
    }

    #[test]
    fn aligned_nested_continuation_already_aligned_not_flagged() {
        let content = "- L1\n  - L2\n    cont of L2 at 4\n";
        assert!(check_aligned(content).is_empty());
    }

    #[test]
    fn aligned_nested_idempotent() {
        let content = "- Outer\n  - Inner\ncontinuation\n";
        let once = fix_aligned(content);
        assert_eq!(fix_aligned(&once), once);
    }

    #[test]
    fn aligned_three_level_nesting_aligns_to_innermost() {
        // The saw_nested cascade defers through every level, so the tight lazy
        // line aligns to L3's content column (6), the innermost open item.
        let content = "- L1\n  - L2\n    - L3\ncont\n";
        assert_eq!(fix_aligned(content), "- L1\n  - L2\n    - L3\n      cont\n");
    }

    #[test]
    fn aligned_continuation_after_sibling_owned_by_last_item() {
        // Tight lazy continuation after the second sibling belongs to that
        // sibling (no nesting), so it aligns to its content column (2).
        let content = "- a\n- b\nlazy\n";
        assert_eq!(fix_aligned(content), "- a\n- b\n  lazy\n");
    }

    #[test]
    fn aligned_multi_digit_ordered_marker_aligns_to_content_column() {
        let content = "10. Item\nwrap\n";
        assert_eq!(fix_aligned(content), "10. Item\n    wrap\n");
    }

    #[test]
    fn aligned_latent_setext_underline_is_left_alone() {
        // The underline is a lazy continuation, so the whole item renders as one
        // paragraph and no heading exists. Reindenting `Text` into the item would
        // promote the pair to a setext heading, changing the rendered structure,
        // so the item is skipped.
        let content = "- item\nText\n===\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    #[test]
    fn aligned_reindents_prose_that_only_looks_like_an_underline() {
        // Positive control for the guard above: `= = =` has internal spaces, so
        // it is not an underline and cannot be promoted. The item is reindented.
        let content = "- item\nText\n= = =\n";
        assert_eq!(fix_aligned(content), "- item\n  Text\n  = = =\n");
    }

    #[test]
    fn aligned_latent_marker_in_continuation_is_idempotent() {
        // Regression (fuzzer-found): a list-marker-looking line ("2. ") that the
        // parser absorbs as lazy continuation can be promoted to a real list
        // item once an earlier continuation line is reindented, re-attributing
        // later lines and breaking single-pass idempotency. Such items are not
        // reindented at all.
        let content = "# \n- \n``\n2. \n![]()";
        let once = fix_aligned(content);
        assert_eq!(fix_aligned(&once), once, "fix must be idempotent in one pass");
        assert_eq!(once, content, "item with a latent marker is left untouched");
    }

    #[test]
    fn aligned_latent_table_in_continuation_is_idempotent() {
        // Regression (fuzzer-found): a table-looking line that the parser
        // absorbs as lazy continuation (so it is NOT yet `in_table_block`) can
        // be promoted to a real table once an earlier line is reindented. Like
        // a latent marker, this re-parses the block, so the item is left alone.
        let content = "- \n![`]()\n|  | ` |\n| --- | --- |";
        let once = fix_aligned(content);
        assert_eq!(fix_aligned(&once), once, "fix must be idempotent in one pass");
        assert_eq!(once, content, "item with a latent table is left untouched");
    }

    #[test]
    fn aligned_blockquote_nested_list_not_touched() {
        // Lists inside blockquotes are a documented MD077 limitation (the scan
        // breaks at the blockquote prefix). Aligned inherits that conservative
        // no-false-positive behavior.
        let content = "> - item\n> wrap\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    // ── aligned: GFM task list items ───────────────────────────────────

    #[test]
    fn aligned_task_post_checkbox_column_accepted() {
        // Continuation aligned to the post-checkbox column (content_col + 4 = 6)
        // stays valid so aligned mode doesn't fight MD013 reflow.
        let content = "- [ ] Task\n      wrap\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    #[test]
    fn aligned_task_under_indent_snaps_to_content_column() {
        let content = "- [ ] Task\nwrap\n";
        let warnings = check_aligned(content);
        assert_eq!(warnings.len(), 1);
        assert_eq!(fix_aligned(content), "- [ ] Task\n  wrap\n");
    }

    // ── aligned: MkDocs flavor ─────────────────────────────────────────

    #[test]
    fn aligned_mkdocs_tight_under_indent_snaps_to_four() {
        // MkDocs raises the required indent to max(content_col, 4) = 4 for "- ".
        let content = "- item\nwrap\n";
        let warnings = check_aligned_mkdocs(content);
        assert_eq!(warnings.len(), 1);
        let ctx = LintContext::new(content, MarkdownFlavor::MkDocs, None);
        assert_eq!(aligned_rule().fix(&ctx).unwrap(), "- item\n    wrap\n");
    }

    // ── any (default) regression: tight lazy continuation untouched ────

    #[test]
    fn any_default_does_not_flag_tight_lazy_continuation() {
        // The default style must preserve CommonMark lazy continuation.
        let content = "- item\nwrapped at zero indent\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn from_config_aligned_enables_tight_flagging() {
        // End-to-end: `[MD077] style = "aligned"` wires through from_config.
        let mut config = crate::config::Config::default();
        let mut rule_config = crate::config::RuleConfig::default();
        rule_config
            .values
            .insert("style".to_string(), toml::Value::String("aligned".to_string()));
        config.rules.insert("MD077".to_string(), rule_config);

        let rule = MD077ListContinuationIndent::from_config(&config);
        let ctx = LintContext::new("- item\nwrap\n", MarkdownFlavor::Standard, None);
        assert_eq!(rule.check(&ctx).unwrap().len(), 1);
    }

    #[test]
    fn from_config_default_is_any() {
        // No config -> default `any` -> tight lazy continuation untouched.
        let config = crate::config::Config::default();
        let rule = MD077ListContinuationIndent::from_config(&config);
        let ctx = LintContext::new("- item\nwrap\n", MarkdownFlavor::Standard, None);
        assert!(rule.check(&ctx).unwrap().is_empty());
    }

    #[test]
    fn from_config_indent_sets_fixed_requirement() {
        // End-to-end: `[MD077] indent = 4` wires through from_config and
        // requires continuation content to sit 4 spaces past the marker.
        let mut config = crate::config::Config::default();
        let mut rule_config = crate::config::RuleConfig::default();
        rule_config.values.insert("indent".to_string(), toml::Value::Integer(4));
        config.rules.insert("MD077".to_string(), rule_config);

        let rule = MD077ListContinuationIndent::from_config(&config);

        // "- item\n    wrap\n" -> continuation at 4 spaces: accepted.
        let ok_ctx = LintContext::new("- item\n    wrap\n", MarkdownFlavor::Standard, None);
        assert!(rule.check(&ok_ctx).unwrap().is_empty());
        assert_eq!(rule.fix(&ok_ctx).unwrap(), "- item\n    wrap\n");

        // "- item\n\n  wrap\n" -> continuation at 2 spaces after a blank line:
        // flagged as under-indented (would escape the list item).
        let bad_ctx = LintContext::new("- item\n\n  wrap\n", MarkdownFlavor::Standard, None);
        let warnings = rule.check(&bad_ctx).unwrap();
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].message.contains("needs 4 spaces"));
    }

    #[test]
    fn from_config_indent_applies_per_nested_marker() {
        // With a fixed indent, each item's requirement is its own marker
        // column plus the configured indent (nested item marker at 2 -> 6).
        let mut config = crate::config::Config::default();
        let mut rule_config = crate::config::RuleConfig::default();
        rule_config.values.insert("indent".to_string(), toml::Value::Integer(4));
        config.rules.insert("MD077".to_string(), rule_config);

        let rule = MD077ListContinuationIndent::from_config(&config);
        let ctx = LintContext::new("- a\n  - b\n      wrap\n", MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        assert!(
            warnings.is_empty(),
            "continuation at 6 spaces should pass: {warnings:?}"
        );
    }

    /// A rule configured through the real `[MD077]` config path.
    fn rule_with(settings: &[(&str, toml::Value)]) -> Box<dyn Rule> {
        let mut config = crate::config::Config::default();
        let mut rule_config = crate::config::RuleConfig::default();
        for (key, value) in settings {
            rule_config.values.insert((*key).to_string(), value.clone());
        }
        config.rules.insert("MD077".to_string(), rule_config);
        MD077ListContinuationIndent::from_config(&config)
    }

    #[test]
    fn configured_indent_cannot_lower_the_strict_flavor_minimum() {
        // The MkDocs 4-space minimum is what the renderer needs to read a line
        // as part of the item, so `indent = 2` may not pull it down to 2 - that
        // would have `fix` rewrite a rendering document into a broken one.
        let rule = rule_with(&[("indent", toml::Value::Integer(2))]);

        let two = LintContext::new("- item\n\n  wrap\n", MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&two).unwrap();
        assert_eq!(warnings.len(), 1, "2 spaces is below the MkDocs minimum: {warnings:?}");
        assert!(
            warnings[0].message.contains("needs 4 spaces") && warnings[0].message.contains("MkDocs"),
            "the requirement comes from MkDocs, so the message must say so: {}",
            warnings[0].message
        );
        assert_eq!(rule.fix(&two).unwrap(), "- item\n\n    wrap\n");

        // Control: a document already at the minimum is left alone.
        let four = LintContext::new("- item\n\n    wrap\n", MarkdownFlavor::MkDocs, None);
        assert!(rule.check(&four).unwrap().is_empty());

        // Control: the clamp is scoped to the strict flavor. Under the standard
        // flavor the same setting means exactly what it says, and 4 is then an
        // over-indent to be snapped back to 2.
        let standard = LintContext::new("- item\n\n    wrap\n", MarkdownFlavor::Standard, None);
        assert_eq!(rule.check(&standard).unwrap().len(), 1);
        assert_eq!(rule.fix(&standard).unwrap(), "- item\n\n  wrap\n");
    }

    #[test]
    fn configured_indent_can_raise_the_strict_flavor_minimum() {
        // The clamp is a floor, not a fixed value: above 4 the configured indent
        // still governs under the MkDocs flavor.
        let rule = rule_with(&[("indent", toml::Value::Integer(6))]);
        let ctx = LintContext::new("- item\n\n    wrap\n", MarkdownFlavor::MkDocs, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(warnings.len(), 1);
        assert!(
            warnings[0].message.contains("needs 6 spaces"),
            "configured 6 must win over the 4-space floor: {}",
            warnings[0].message
        );
        assert_eq!(rule.fix(&ctx).unwrap(), "- item\n\n      wrap\n");
    }

    #[test]
    fn configured_indent_message_does_not_claim_a_structural_consequence() {
        // Two spaces under a `- ` marker keeps the content in the list item, so
        // a message blaming list membership would be false. The requirement is
        // the configured one and the message has to say which.
        let rule = rule_with(&[("indent", toml::Value::Integer(4))]);
        let ctx = LintContext::new("- item\n\n  wrap\n", MarkdownFlavor::Standard, None);
        let warnings = rule.check(&ctx).unwrap();
        assert_eq!(warnings.len(), 1);
        assert!(
            warnings[0].message.contains("match the configured indent"),
            "expected the configured-indent wording, got: {}",
            warnings[0].message
        );
        assert!(
            !warnings[0].message.contains("remain part of the list"),
            "the content does remain part of the list here: {}",
            warnings[0].message
        );

        // Control: the default rule reports the same document as clean, which is
        // what makes the structural claim wrong above.
        assert!(check("- item\n\n  wrap\n").is_empty());

        // Control: content that really would escape the item still gets the
        // structural message, so the wording was narrowed and not replaced.
        let escaping = check("- item\n\n wrap\n");
        assert_eq!(escaping.len(), 1);
        assert!(
            escaping[0].message.contains("remain part of the list"),
            "unconfigured under-indent keeps its structural message, got: {}",
            escaping[0].message
        );
    }

    #[test]
    fn configured_indent_leaves_tight_lazy_continuation_to_style() {
        // `indent` sets what the requirement is; `style` decides which lines are
        // measured against it. A tight continuation is CommonMark lazy
        // continuation, so `any` accepts it however the requirement was derived.
        let any = rule_with(&[("indent", toml::Value::Integer(4))]);
        let ctx = LintContext::new("- item\n  wrap\n", MarkdownFlavor::Standard, None);
        assert!(
            any.check(&ctx).unwrap().is_empty(),
            "style = any accepts tight lazy continuation"
        );

        let aligned = rule_with(&[
            ("indent", toml::Value::Integer(4)),
            ("style", toml::Value::String("aligned".to_string())),
        ]);
        let warnings = aligned.check(&ctx).unwrap();
        assert_eq!(warnings.len(), 1, "style = aligned raises it: {warnings:?}");
        assert!(warnings[0].message.contains("expected 4"));
        assert_eq!(aligned.fix(&ctx).unwrap(), "- item\n    wrap\n");
    }

    #[test]
    fn aligned_tight_underindented_fence_inside_item_left_alone() {
        // A fenced block is a structural construct; aligned mode does not
        // reindent it (the `in_code_block` guard), so a tight under-indented
        // fence is a no-op rather than a risky delimiter-only rewrite.
        let content = "- item\n ```\n code\n ```\n";
        assert!(check_aligned(content).is_empty());
        assert_eq!(fix_aligned(content), content);
    }

    #[test]
    fn aligned_task_under_indent_fix_is_idempotent() {
        let content = "- [ ] Task\nwrap\n";
        let once = fix_aligned(content);
        assert_eq!(fix_aligned(&once), once);
    }

    #[test]
    fn aligned_partial_indent_fix_is_idempotent() {
        let content = "- item\n continuation\n";
        let once = fix_aligned(content);
        assert_eq!(fix_aligned(&once), once);
    }

    #[test]
    fn fence_shift_preserves_one_space_of_interior_nesting() {
        // Reindenting the fence moves the whole block: an interior line keeps
        // its offset from the opener, so one space of JSON nesting survives.
        let content = "1. Configure:\n\n  ```json\n  {\n   \"a\": 1\n  }\n  ```\n";
        let expected = "1. Configure:\n\n   ```json\n   {\n    \"a\": 1\n   }\n   ```\n";
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn fence_shift_preserves_every_interior_nesting_level() {
        let content = "1. Configure:\n\n  ```json\n  {\n    \"a\": {\n      \"b\": 1\n    }\n  }\n  ```\n";
        let expected = "1. Configure:\n\n   ```json\n   {\n     \"a\": {\n       \"b\": 1\n     }\n   }\n   ```\n";
        assert_eq!(fix(content), expected);
    }

    #[test]
    fn fence_shift_lifts_interior_below_the_list_scope_all_the_way() {
        // The case the promote-up rule was written for: an interior line
        // starting below the item's content column must land at that column,
        // not one space above where it began.
        let content = "1. Configure:\n\n  ```json\n{\n  ```\n";
        let expected = "1. Configure:\n\n   ```json\n   {\n   ```\n";
        assert_eq!(fix(content), expected);
        assert_eq!(fix(expected), expected, "and the result is stable");
    }

    #[test]
    fn fence_shift_is_idempotent() {
        for content in [
            "1. Configure:\n\n  ```json\n  {\n   \"a\": 1\n  }\n  ```\n",
            "1. Configure:\n\n  ```json\n{\n    deep\n  }\n  ```\n",
            "- item\n\n ```\n  nested\n ```\n",
        ] {
            let once = fix(content);
            assert_eq!(fix(&once), once, "MD077 fence fix must be idempotent: {content:?}");
        }
    }

    #[test]
    fn fence_already_at_the_content_column_is_left_alone() {
        let content = "1. Configure:\n\n   ```json\n   {\n    \"a\": 1\n   }\n   ```\n";
        assert!(check(content).is_empty());
        assert_eq!(fix(content), content);
    }

    #[test]
    fn over_indented_fence_keeps_its_interior_untouched() {
        // The over-indent direction deliberately leaves fenced blocks alone.
        let content = "1. Configure:\n\n       ```json\n       {\n        \"a\": 1\n       }\n       ```\n";
        assert_eq!(fix(content), content);
    }

    /// Documents MD077 has nothing to say about, with the same result under both
    /// styles: every continuation sits where CommonMark puts the item's content.
    fn assert_untouched(content: &str) {
        assert!(check(content).is_empty(), "{content:?}: {:?}", check(content));
        assert_eq!(fix(content), content, "{content:?}");
        assert!(
            check_aligned(content).is_empty(),
            "{content:?}: {:?}",
            check_aligned(content)
        );
        assert_eq!(fix_aligned(content), content, "{content:?} (aligned)");
    }

    #[test]
    fn mkdocs_aligned_fix_settles_when_a_number_follows_re_indented_prose() {
        // `29.` continues the paragraph; indenting the line above it must not
        // turn it into a list item on the second pass.
        let content = "# \n`?`\n<span>x</span>\n- X\n![t](u)\n29. y\n*z*";
        let once = fix_aligned_flavor(content, MarkdownFlavor::MkDocs);
        assert_eq!(
            fix_aligned_flavor(&once, MarkdownFlavor::MkDocs),
            once,
            "{content:?} -> {once:?}"
        );
    }

    /// An exact re-indent that settles: fixing the result changes nothing.
    fn assert_fixed(content: &str, expected: &str) {
        assert_eq!(fix(content), expected, "{content:?}");
        assert_eq!(fix(expected), expected, "{content:?} is not idempotent");
    }

    #[test]
    fn bare_marker_content_sits_one_column_past_the_marker() {
        for content in [
            "-\n  a\n",
            "+\n  a\n",
            "*\n  a\n  b\n",
            "1.\n   a\n",
            "10.\n    a\n",
            "1)\n   a\n",
            "- x\n\n  -\n    a\n",
            "-\n  foo\n-\n  ```\n  bar\n  ```\n-\n      baz\n",
            "-\n  a\n\n  b\n",
        ] {
            assert_untouched(content);
        }
    }

    #[test]
    fn bare_marker_item_followed_by_a_fence_keeps_the_text_after_it() {
        // The fence is the first content, so the blank line after it no longer
        // ends the item, and `after` belongs to it.
        assert_untouched("-\n  ```\n  x\n  ```\n\n  after\n");
        assert_untouched("1.\n   ```\n   x\n   ```\n\n   after\n");
    }

    #[test]
    fn bare_marker_over_indent_still_snaps_back() {
        assert_fixed("-\n    a\n", "-\n  a\n");
        assert_fixed("1.\n     a\n", "1.\n   a\n");
        // Four columns past the content column is indented code.
        assert_untouched("-\n      a\n");
    }

    #[test]
    fn bare_marker_item_holds_at_most_one_blank_line_before_its_content() {
        // The item is empty, so whatever follows is outside it and is not
        // pulled in.
        for content in ["-\n\n  a\n", "-\n\n a\n", "1.\n\n   a\n", "-\n a\n"] {
            assert_untouched(content);
        }
        // Once the item has content, a blank line no longer closes it.
        assert_fixed("-\n  a\n\n b\n", "-\n  a\n\n  b\n");
    }

    #[test]
    fn tab_after_the_marker_is_measured_in_columns() {
        assert_untouched("-\tx\n\n\ty\n");
        assert_untouched("1.\tx\n\n\ty\n");
        assert_untouched("-\tx\n\n    y\n");
        assert_fixed("-\tx\n\n  y\n", "-\tx\n\n    y\n");
        assert_fixed("-\tx\n\n\t y\n", "-\tx\n\n    y\n");
    }

    #[test]
    fn indented_code_first_puts_the_content_one_column_past_the_marker() {
        assert_untouched("-     t\n\n  y\n");
        assert_untouched("-     t\n\n      y\n");
        assert_untouched("1.     t\n\n   y\n");
        assert_fixed("-     t\n\n y\n", "-     t\n\n  y\n");
        assert_fixed("1.     t\n\n  y\n", "1.     t\n\n   y\n");
    }

    #[test]
    fn checkbox_text_in_indented_code_is_not_a_task() {
        // `[ ] task` is the code, so there is no post-checkbox column.
        assert_fixed("-     [ ] task\n\n     y\n", "-     [ ] task\n\n  y\n");
    }

    #[test]
    fn items_written_on_one_line_each_own_their_continuation() {
        for content in [
            "- 1. x\n\n     y\n",
            "1. -\n     f\n",
            "- 1. ```\n     ```\n     b\n",
            "- - a\n    ---\n",
            "- - a\n\n    b\n",
            "- 1. x\n\n  y\n",
        ] {
            assert_untouched(content);
        }
        assert_fixed("- 1. x\n\n      y\n", "- 1. x\n\n     y\n");
    }

    #[test]
    fn items_written_on_one_line_keep_their_task_columns() {
        for content in ["- - [ ] task\n        wrap\n", "- - [ ] task\n    wrap\n"] {
            assert_untouched(content);
        }
        assert_untouched("- [ ] t\n\n      w\n");
    }

    #[test]
    fn an_empty_inner_item_closes_at_the_blank_line() {
        // The inner item has no content, so `a` belongs to the outer one.
        assert_fixed("- -\n\n    a\n", "- -\n\n  a\n");
        // Once the inner item has content, a blank line keeps it open.
        assert_untouched("- -\n    a\n\n    b\n");
    }

    #[test]
    fn text_that_commonmark_does_not_treat_as_a_marker_or_blank_is_content() {
        // Only the outer item opens, so `y` is judged against column 2.
        assert_fixed(
            "- \u{661}\u{662}\u{663}\u{664}. x\n\n   y\n",
            "- \u{661}\u{662}\u{663}\u{664}. x\n\n  y\n",
        );
        assert_untouched("-  \u{a0}\n   a\n\n   y\n");
        assert_untouched("- -\n    \u{a0}\n\n    b\n");
    }

    #[test]
    fn intended_reindents_still_happen() {
        assert_fixed("- e\n\n t\n", "- e\n\n  t\n");
        assert_fixed("1. a\n\n  b\n", "1. a\n\n   b\n");
        assert_fixed("- a\n\n    b\n", "- a\n\n  b\n");
        assert_eq!(fix_aligned("- a\n b\n"), "- a\n  b\n");
        assert_eq!(check("- e\n\n t\n").len(), 1);
    }

    #[test]
    fn whitespace_at_the_start_of_a_line_inside_a_code_span_is_kept() {
        assert_untouched("- > para\n  `a\n  \tb`\n");
        assert_untouched("- x\n\n  `a\n      b`\n");
        // A span closed on the previous line does not shield the next line.
        assert_fixed("- x\n\n  `a`\n     b\n", "- x\n\n  `a`\n  b\n");
    }
}