Struct ParseResult 

pub struct ParseResult {
    pub heading_blocks: Vec<HeadingBlock>,
    pub toc: Vec<TocEntry>,
    pub diagnostics: Vec<Diagnostic>,
    pub line_count: usize,
}

The result of parsing a markdown document.

Contains all structured information extracted from the markdown, including heading hierarchy, content blocks, table of contents, and any diagnostic messages generated during parsing.

Usage Patterns

The parse result provides multiple ways to access the document structure:

• Heading Blocks: For content indexing and search
• Table of Contents: For navigation and structure display
• Diagnostics: For quality assurance and debugging
• Line Count: For validation and progress reporting

Examples

Processing heading blocks:

use blz_core::{MarkdownParser, Result};

let mut parser = MarkdownParser::new()?;
let result = parser.parse("# Title\n\nContent\n\n## Subtitle\n\nMore content")?;

for block in &result.heading_blocks {
    println!("Section: {}", block.path.join(" > "));
    println!("  Lines {}-{}", block.start_line, block.end_line);
    println!("  Content: {} chars", block.content.len());
}

Generating navigation from TOC:

use blz_core::{MarkdownParser, TocEntry, Result};

fn generate_nav(entries: &[TocEntry], depth: usize) -> String {
    entries
        .iter()
        .map(|entry| {
            let indent = "  ".repeat(depth);
            let default = "Untitled".to_string();
            let title = entry.heading_path.last().unwrap_or(&default);
            format!("{}* {} ({})\n{}",
                indent,
                title,
                entry.lines,
                generate_nav(&entry.children, depth + 1)
            )
        })
        .collect()
}

let mut parser = MarkdownParser::new()?;
let result = parser.parse("# A\n\nContent A\n\n## A.1\n\nContent A.1\n\n### A.1.1\n\nContent A.1.1\n\n## A.2\n\nContent A.2")?;
let nav = generate_nav(&result.toc, 0);
println!("Navigation:\n{}", nav);

Fields

heading_blocks: Vec<HeadingBlock>

Structured heading blocks extracted from the document.

Each block represents a section of content under a specific heading hierarchy. Blocks are ordered by their appearance in the document and contain both the heading path and all content until the next same-level or higher-level heading.

Content Organization

• Content includes the heading itself and all text below it
• Text continues until the next same-level or higher-level heading
• Nested headings create separate blocks with extended paths
• Documents without headings get a single “Document” block

toc: Vec<TocEntry>

Hierarchical table of contents extracted from headings.

Provides a nested structure that mirrors the heading hierarchy in the document. Each entry contains the full heading path and line range information.

Structure

• Top-level entries correspond to H1 headings
• Child entries represent nested headings (H2, H3, etc.)
• Empty when no headings are present in the document
• Line ranges are 1-based and use “start-end” format

diagnostics: Vec<Diagnostic>

Diagnostic messages generated during parsing.

Contains warnings, errors, and informational messages about issues found during parsing. These help identify quality problems or processing decisions that users should be aware of.

Common Diagnostics

• Missing headings (document has content but no structure)
• Parse tree errors (tree-sitter detected syntax issues)
• Encoding problems (invalid UTF-8 sequences)
• Structure warnings (very deep nesting, empty sections)

line_count: usize

Total number of lines in the source document.

Used for validation, progress reporting, and ensuring line ranges in heading blocks and TOC entries are within bounds. This count includes empty lines and uses the same line numbering as other components (1-based).

Trait Implementations

impl Clone for ParseResult

fn clone(&self) -> ParseResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.