kreuzberg 4.0.8 → 4.1.1

data/vendor/kreuzberg/src/types/mod.rs

@@ -0,0 +1,281 @@
+//! Core types for document extraction.
+
+// Module declarations
+pub mod djot;
+pub mod extraction;
+pub mod formats;
+pub mod metadata;
+pub mod page;
+pub mod serde_helpers;
+pub mod tables;
+
+// Re-export all types for backward compatibility
+pub use djot::*;
+pub use extraction::*;
+pub use formats::*;
+pub use metadata::*;
+pub use page::*;
+pub use tables::*;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_metadata_serialization_with_format() {
+        let mut metadata = Metadata {
+            format: Some(FormatMetadata::Text(TextMetadata {
+                line_count: 1,
+                word_count: 2,
+                character_count: 13,
+                headers: None,
+                links: None,
+                code_blocks: None,
+            })),
+            ..Default::default()
+        };
+
+        metadata
+            .additional
+            .insert("quality_score".to_string(), serde_json::json!(1.0));
+
+        let json = serde_json::to_value(&metadata).unwrap();
+        println!("Serialized metadata: {}", serde_json::to_string_pretty(&json).unwrap());
+
+        assert!(
+            json.get("format_type").is_some(),
+            "format_type should be present in serialized JSON"
+        );
+        assert_eq!(json.get("format_type").unwrap(), "text");
+
+        assert_eq!(json.get("line_count").unwrap(), 1);
+        assert_eq!(json.get("word_count").unwrap(), 2);
+        assert_eq!(json.get("character_count").unwrap(), 13);
+
+        assert_eq!(json.get("quality_score").unwrap(), 1.0);
+    }
+
+    #[test]
+    fn test_arc_table_serialization_format() {
+        let table = Table {
+            cells: vec![vec!["A".to_string(), "B".to_string()]],
+            markdown: "| A | B |\n|---|---|\n".to_string(),
+            page_number: 1,
+        };
+
+        let json = serde_json::to_value(&table).unwrap();
+
+        assert_eq!(json.get("cells").unwrap()[0][0], "A");
+        assert_eq!(json.get("markdown").unwrap(), "| A | B |\n|---|---|\n");
+        assert_eq!(json.get("page_number").unwrap(), 1);
+    }
+
+    #[test]
+    fn test_arc_table_roundtrip() {
+        let original = Table {
+            cells: vec![
+                vec!["X".to_string(), "Y".to_string()],
+                vec!["1".to_string(), "2".to_string()],
+            ],
+            markdown: "| X | Y |\n|---|---|\n| 1 | 2 |\n".to_string(),
+            page_number: 5,
+        };
+
+        let json = serde_json::to_string(&original).unwrap();
+        let deserialized: Table = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.cells, original.cells);
+        assert_eq!(deserialized.markdown, original.markdown);
+        assert_eq!(deserialized.page_number, original.page_number);
+    }
+
+    #[test]
+    fn test_arc_sharing_preserved_before_serialization() {
+        let shared_table = Arc::new(Table {
+            cells: vec![vec!["shared".to_string()]],
+            markdown: "| shared |".to_string(),
+            page_number: 1,
+        });
+
+        let tables_before = [Arc::clone(&shared_table), Arc::clone(&shared_table)].to_vec();
+        assert_eq!(Arc::strong_count(&tables_before[0]), 3);
+        assert_eq!(Arc::strong_count(&tables_before[1]), 3);
+        assert!(Arc::ptr_eq(&tables_before[0], &tables_before[1]));
+    }
+
+    #[test]
+    fn test_vec_arc_table_serialization_format() {
+        let tables = vec![
+            Table {
+                cells: vec![vec!["A".to_string()]],
+                markdown: "| A |".to_string(),
+                page_number: 1,
+            },
+            Table {
+                cells: vec![vec!["B".to_string()]],
+                markdown: "| B |".to_string(),
+                page_number: 2,
+            },
+        ];
+
+        let json = serde_json::to_string(&tables).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
+
+        assert!(parsed.is_array());
+        assert_eq!(parsed.as_array().unwrap().len(), 2);
+        assert_eq!(parsed[0]["cells"][0][0], "A");
+        assert_eq!(parsed[1]["cells"][0][0], "B");
+    }
+
+    #[test]
+    fn test_page_content_arc_tables_roundtrip() {
+        let page = PageContent {
+            page_number: 3,
+            content: "Page 3 content".to_string(),
+            tables: vec![
+                Arc::new(Table {
+                    cells: vec![vec!["Table1".to_string()]],
+                    markdown: "| Table1 |".to_string(),
+                    page_number: 3,
+                }),
+                Arc::new(Table {
+                    cells: vec![vec!["Table2".to_string()]],
+                    markdown: "| Table2 |".to_string(),
+                    page_number: 3,
+                }),
+            ],
+            images: Vec::new(),
+            hierarchy: None,
+        };
+
+        let json = serde_json::to_string(&page).unwrap();
+        let deserialized: PageContent = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.page_number, 3);
+        assert_eq!(deserialized.content, "Page 3 content");
+        assert_eq!(deserialized.tables.len(), 2);
+        assert_eq!(deserialized.tables[0].cells[0][0], "Table1");
+        assert_eq!(deserialized.tables[1].cells[0][0], "Table2");
+    }
+
+    #[test]
+    fn test_page_content_arc_images_roundtrip() {
+        let image1 = Arc::new(ExtractedImage {
+            data: vec![0xFF, 0xD8, 0xFF],
+            format: "jpeg".to_string(),
+            image_index: 0,
+            page_number: Some(1),
+            width: Some(100),
+            height: Some(200),
+            colorspace: Some("RGB".to_string()),
+            bits_per_component: Some(8),
+            is_mask: false,
+            description: Some("Image 1".to_string()),
+            ocr_result: None,
+        });
+
+        let image2 = Arc::new(ExtractedImage {
+            data: vec![0x89, 0x50, 0x4E],
+            format: "png".to_string(),
+            image_index: 1,
+            page_number: Some(1),
+            width: Some(300),
+            height: Some(400),
+            colorspace: Some("RGBA".to_string()),
+            bits_per_component: Some(8),
+            is_mask: false,
+            description: Some("Image 2".to_string()),
+            ocr_result: None,
+        });
+
+        let page = PageContent {
+            page_number: 1,
+            content: "Page with images".to_string(),
+            tables: Vec::new(),
+            images: vec![image1, image2],
+            hierarchy: None,
+        };
+
+        let json = serde_json::to_string(&page).unwrap();
+        let deserialized: PageContent = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.images.len(), 2);
+        assert_eq!(deserialized.images[0].format, "jpeg");
+        assert_eq!(deserialized.images[0].width, Some(100));
+        assert_eq!(deserialized.images[1].format, "png");
+        assert_eq!(deserialized.images[1].height, Some(400));
+    }
+
+    #[test]
+    fn test_arc_sharing_loss_with_page_content() {
+        let shared_table = Arc::new(Table {
+            cells: vec![vec!["shared across pages".to_string()]],
+            markdown: "| shared across pages |".to_string(),
+            page_number: 0,
+        });
+
+        let page1 = PageContent {
+            page_number: 1,
+            content: "Page 1".to_string(),
+            tables: vec![Arc::clone(&shared_table)],
+            images: Vec::new(),
+            hierarchy: None,
+        };
+
+        let page2 = PageContent {
+            page_number: 2,
+            content: "Page 2".to_string(),
+            tables: vec![Arc::clone(&shared_table)],
+            images: Vec::new(),
+            hierarchy: None,
+        };
+
+        assert!(Arc::ptr_eq(&page1.tables[0], &page2.tables[0]));
+
+        let pages = vec![page1, page2];
+        let json = serde_json::to_string(&pages).unwrap();
+        let deserialized: Vec<PageContent> = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.len(), 2);
+        assert_eq!(deserialized[0].tables[0].cells, deserialized[1].tables[0].cells);
+        assert!(!Arc::ptr_eq(&deserialized[0].tables[0], &deserialized[1].tables[0]));
+    }
+
+    #[test]
+    fn test_empty_page_content_arcs() {
+        let page = PageContent {
+            page_number: 5,
+            content: "No tables or images".to_string(),
+            tables: Vec::new(),
+            images: Vec::new(),
+            hierarchy: None,
+        };
+
+        let json = serde_json::to_string(&page).unwrap();
+        let deserialized: PageContent = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.page_number, 5);
+        assert_eq!(deserialized.tables.len(), 0);
+        assert_eq!(deserialized.images.len(), 0);
+    }
+
+    #[test]
+    fn test_serde_vec_arc_module_behavior() {
+        let table1 = Table {
+            cells: vec![vec!["A".to_string()]],
+            markdown: "| A |".to_string(),
+            page_number: 1,
+        };
+
+        let table2 = Table {
+            cells: vec![vec!["B".to_string()]],
+            markdown: "| B |".to_string(),
+            page_number: 2,
+        };
+
+        let json = serde_json::to_string(&vec![table1, table2]).unwrap();
+        assert!(json.contains("\"A\""));
+        assert!(json.contains("\"B\""));
+    }
+}

data/vendor/kreuzberg/src/types/page.rs

@@ -0,0 +1,182 @@
+//! Page structure types for documents.
+//!
+//! This module defines types for representing paginated document structures.
+
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+// Import serde helper and types from sibling modules
+use super::extraction::ExtractedImage;
+use super::serde_helpers::serde_vec_arc;
+use super::tables::Table;
+
+/// Unified page structure for documents.
+///
+/// Supports different page types (PDF pages, PPTX slides, Excel sheets)
+/// with character offset boundaries for chunk-to-page mapping.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageStructure {
+    /// Total number of pages/slides/sheets
+    pub total_count: usize,
+
+    /// Type of paginated unit
+    pub unit_type: PageUnitType,
+
+    /// Character offset boundaries for each page
+    ///
+    /// Maps character ranges in the extracted content to page numbers.
+    /// Used for chunk page range calculation.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub boundaries: Option<Vec<PageBoundary>>,
+
+    /// Detailed per-page metadata (optional, only when needed)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pages: Option<Vec<PageInfo>>,
+}
+
+/// Type of paginated unit in a document.
+///
+/// Distinguishes between different types of "pages" (PDF pages, presentation slides, spreadsheet sheets).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PageUnitType {
+    /// Standard document pages (PDF, DOCX, images)
+    Page,
+    /// Presentation slides (PPTX, ODP)
+    Slide,
+    /// Spreadsheet sheets (XLSX, ODS)
+    Sheet,
+}
+
+/// Byte offset boundary for a page.
+///
+/// Tracks where a specific page's content starts and ends in the main content string,
+/// enabling mapping from byte positions to page numbers. Offsets are guaranteed to be
+/// at valid UTF-8 character boundaries when using standard String methods (push_str, push, etc.).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageBoundary {
+    /// Byte offset where this page starts in the content string (UTF-8 valid boundary, inclusive)
+    pub byte_start: usize,
+    /// Byte offset where this page ends in the content string (UTF-8 valid boundary, exclusive)
+    pub byte_end: usize,
+    /// Page number (1-indexed)
+    pub page_number: usize,
+}
+
+/// Metadata for individual page/slide/sheet.
+///
+/// Captures per-page information including dimensions, content counts,
+/// and visibility state (for presentations).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageInfo {
+    /// Page number (1-indexed)
+    pub number: usize,
+
+    /// Page title (usually for presentations)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+
+    /// Dimensions in points (PDF) or pixels (images): (width, height)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dimensions: Option<(f64, f64)>,
+
+    /// Number of images on this page
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image_count: Option<usize>,
+
+    /// Number of tables on this page
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub table_count: Option<usize>,
+
+    /// Whether this page is hidden (e.g., in presentations)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hidden: Option<bool>,
+}
+
+/// Content for a single page/slide.
+///
+/// When page extraction is enabled, documents are split into per-page content
+/// with associated tables and images mapped to each page.
+///
+/// # Performance
+///
+/// Uses Arc-wrapped tables and images for memory efficiency:
+/// - `Vec<Arc<Table>>` enables zero-copy sharing of table data
+/// - `Vec<Arc<ExtractedImage>>` enables zero-copy sharing of image data
+/// - Maintains exact JSON compatibility via custom Serialize/Deserialize
+///
+/// This reduces memory overhead for documents with shared tables/images
+/// by avoiding redundant copies during serialization.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageContent {
+    /// Page number (1-indexed)
+    pub page_number: usize,
+
+    /// Text content for this page
+    pub content: String,
+
+    /// Tables found on this page (uses Arc for memory efficiency)
+    ///
+    /// Serializes as Vec<Table> for JSON compatibility while maintaining
+    /// Arc semantics in-memory for zero-copy sharing.
+    #[serde(skip_serializing_if = "Vec::is_empty", default, with = "serde_vec_arc")]
+    pub tables: Vec<Arc<Table>>,
+
+    /// Images found on this page (uses Arc for memory efficiency)
+    ///
+    /// Serializes as Vec<ExtractedImage> for JSON compatibility while maintaining
+    /// Arc semantics in-memory for zero-copy sharing.
+    #[serde(skip_serializing_if = "Vec::is_empty", default, with = "serde_vec_arc")]
+    pub images: Vec<Arc<ExtractedImage>>,
+
+    /// Hierarchy information for the page (when hierarchy extraction is enabled)
+    ///
+    /// Contains text hierarchy levels (H1-H6) extracted from the page content.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hierarchy: Option<PageHierarchy>,
+}
+
+/// Page hierarchy structure containing heading levels and block information.
+///
+/// Used when PDF text hierarchy extraction is enabled. Contains hierarchical
+/// blocks with heading levels (H1-H6) for semantic document structure.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageHierarchy {
+    /// Number of hierarchy blocks on this page
+    pub block_count: usize,
+
+    /// Hierarchical blocks with heading levels
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub blocks: Vec<HierarchicalBlock>,
+}
+
+/// A text block with hierarchy level assignment.
+///
+/// Represents a block of text with semantic heading information extracted from
+/// font size clustering and hierarchical analysis.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HierarchicalBlock {
+    /// The text content of this block
+    pub text: String,
+
+    /// The font size of the text in this block
+    pub font_size: f32,
+
+    /// The hierarchy level of this block (H1-H6 or Body)
+    ///
+    /// Levels correspond to HTML heading tags:
+    /// - "h1": Top-level heading
+    /// - "h2": Secondary heading
+    /// - "h3": Tertiary heading
+    /// - "h4": Quaternary heading
+    /// - "h5": Quinary heading
+    /// - "h6": Senary heading
+    /// - "body": Body text (no heading level)
+    pub level: String,
+
+    /// Bounding box information for the block
+    ///
+    /// Contains coordinates as (left, top, right, bottom) in PDF units.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bbox: Option<(f32, f32, f32, f32)>,
+}

data/vendor/kreuzberg/src/types/serde_helpers.rs

@@ -0,0 +1,132 @@
+//! Custom serde serialization helpers for Arc<T> and Vec<Arc<T>>.
+
+/// Module providing transparent serde support for Arc<T>.
+///
+/// Allows Arc-wrapped types to serialize/deserialize as if unwrapped,
+/// maintaining exact JSON format while preserving memory efficiency benefits.
+///
+/// # Arc Sharing Semantics
+///
+/// **Important**: Arc sharing semantics are **NOT** preserved across serialization.
+/// When deserializing, each Arc is independently created with `Arc::new()`.
+/// This means that if two Arcs referenced the same data before serialization,
+/// they will be separate Arcs after deserialization.
+///
+/// Example:
+/// ```ignore
+/// let shared = Arc::new(Table { /* ... */ });
+/// let tables = vec![Arc::clone(&shared), Arc::clone(&shared)];
+/// // Both in-memory Arcs point to the same Table
+///
+/// let json = serde_json::to_string(&tables)?;
+/// let deserialized: Vec<Arc<Table>> = serde_json::from_str(&json)?;
+/// // deserialized[0] and deserialized[1] are now independent Arcs,
+/// // even though they contain identical data
+/// ```
+///
+/// This design choice maintains:
+/// - Exact JSON format compatibility (no sharing metadata in JSON)
+/// - Predictable deserialization behavior
+/// - Zero additional serialization overhead
+///
+/// If in-memory sharing is required, callers must implement custom sharing logic
+/// or use a different data structure (like a HashMap of deduplicated values).
+#[allow(dead_code)]
+pub mod serde_arc {
+    use serde::{Deserialize, Deserializer, Serializer};
+    use std::sync::Arc;
+
+    /// Serialize an Arc<T> by serializing the inner value directly.
+    ///
+    /// This makes Arc<T> serialize identically to T, maintaining API compatibility.
+    /// The outer Arc wrapper is transparent during serialization.
+    pub fn serialize<S, T>(arc_value: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+        T: serde::Serialize,
+    {
+        (**arc_value).serialize(serializer)
+    }
+
+    /// Deserialize a T and wrap it in Arc.
+    ///
+    /// This makes Arc<T> deserialize from the same format as T.
+    /// Each Arc is independently created during deserialization;
+    /// Arc sharing from before serialization is NOT preserved.
+    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Arc<T>, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: Deserialize<'de>,
+    {
+        T::deserialize(deserializer).map(Arc::new)
+    }
+}
+
+/// Module for serializing Vec<Arc<T>> with transparent Arc handling.
+///
+/// Serializes a Vec<Arc<T>> as Vec<T> for compatibility, while preserving
+/// Arc semantics for memory efficiency.
+///
+/// # Arc Sharing Semantics
+///
+/// **Important**: Arc sharing semantics are **NOT** preserved across serialization.
+/// When deserializing, each element's Arc is independently created with `Arc::new()`.
+/// This is important for `PageContent` where tables/images may be shared across pages.
+///
+/// Example with shared tables:
+/// ```ignore
+/// let shared_table = Arc::new(Table { /* ... */ });
+/// let page_contents = vec![
+///     PageContent { tables: vec![Arc::clone(&shared_table)], ... },
+///     PageContent { tables: vec![Arc::clone(&shared_table)], ... },
+/// ];
+/// // In-memory: both pages' tables point to the same Arc
+///
+/// let json = serde_json::to_string(&page_contents)?;
+/// let deserialized = serde_json::from_str::<Vec<PageContent>>(&json)?;
+/// // After deserialization: each page has independent Arc instances,
+/// // even though the table data is identical
+/// ```
+///
+/// Design rationale:
+/// - JSON has no mechanism to represent shared references
+/// - Preserving sharing would require complex metadata and deduplication
+/// - Current approach is simple, predictable, and maintains compatibility
+/// - In-memory sharing (via Arc) is an implementation detail for the Rust side
+///
+/// If in-memory sharing is required after deserialization, implement custom
+/// deduplication logic using hashing or content comparison.
+pub mod serde_vec_arc {
+    use serde::{Deserialize, Deserializer, Serializer};
+    use std::sync::Arc;
+
+    /// Serialize Vec<Arc<T>> by serializing each T directly.
+    ///
+    /// Each element is unwrapped from its Arc and serialized independently.
+    /// No sharing metadata is included in the serialized output.
+    pub fn serialize<S, T>(vec: &[Arc<T>], serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+        T: serde::Serialize,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(vec.len()))?;
+        for arc_item in vec {
+            seq.serialize_element(&**arc_item)?;
+        }
+        seq.end()
+    }
+
+    /// Deserialize Vec<T> and wrap each element in Arc.
+    ///
+    /// Each element is independently wrapped in a new Arc.
+    /// Sharing relationships from before serialization are lost.
+    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Vec<Arc<T>>, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: Deserialize<'de>,
+    {
+        let vec: Vec<T> = Deserialize::deserialize(deserializer)?;
+        Ok(vec.into_iter().map(Arc::new).collect())
+    }
+}

data/vendor/kreuzberg/src/types/tables.rs

@@ -0,0 +1,39 @@
+//! Table-related types for document extraction.
+
+use serde::{Deserialize, Serialize};
+
+/// Extracted table structure.
+///
+/// Represents a table detected and extracted from a document (PDF, image, etc.).
+/// Tables are converted to both structured cell data and Markdown format.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Table {
+    /// Table cells as a 2D vector (rows × columns)
+    pub cells: Vec<Vec<String>>,
+    /// Markdown representation of the table
+    pub markdown: String,
+    /// Page number where the table was found (1-indexed)
+    pub page_number: usize,
+}
+
+/// Individual table cell with content and optional styling.
+///
+/// Future extension point for rich table support with cell-level metadata.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TableCell {
+    /// Cell content as text
+    pub content: String,
+    /// Row span (number of rows this cell spans)
+    #[serde(default = "default_span")]
+    pub row_span: usize,
+    /// Column span (number of columns this cell spans)
+    #[serde(default = "default_span")]
+    pub col_span: usize,
+    /// Whether this is a header cell
+    #[serde(default)]
+    pub is_header: bool,
+}
+
+fn default_span() -> usize {
+    1
+}

data/vendor/kreuzberg/src/utils/quality/heuristics.rs

@@ -0,0 +1,58 @@
+//! Quality heuristics and text analysis
+//!
+//! This module provides heuristic checks for text quality, including
+//! structure analysis and line-level checks.
+
+use super::patterns::*;
+
+// ============================================================================
+// Structure Thresholds
+// ============================================================================
+
+const MIN_SENTENCE_WORDS: f64 = 10.0;
+const MAX_SENTENCE_WORDS: f64 = 30.0;
+const MIN_PARAGRAPH_WORDS: f64 = 50.0;
+const MAX_PARAGRAPH_WORDS: f64 = 300.0;
+
+// ============================================================================
+// Structure Analysis
+// ============================================================================
+
+/// Calculate bonus based on text structure quality
+#[inline]
+pub(crate) fn calculate_structure_bonus(text: &str) -> f64 {
+    if text.is_empty() {
+        return 0.0;
+    }
+
+    let sentence_count = SENTENCE_DETECT.find_iter(text).count() as f64;
+    let paragraph_count = text.matches("\n\n").count() as f64 + 1.0;
+    let words = text.split_whitespace().count() as f64;
+
+    if words == 0.0 {
+        return 0.0;
+    }
+
+    let avg_words_per_sentence = words / sentence_count.max(1.0);
+    let avg_words_per_paragraph = words / paragraph_count.max(1.0);
+
+    let mut structure_score: f64 = 0.0;
+
+    if (MIN_SENTENCE_WORDS..=MAX_SENTENCE_WORDS).contains(&avg_words_per_sentence) {
+        structure_score += 0.3;
+    }
+
+    if (MIN_PARAGRAPH_WORDS..=MAX_PARAGRAPH_WORDS).contains(&avg_words_per_paragraph) {
+        structure_score += 0.3;
+    }
+
+    if paragraph_count > 1.0 {
+        structure_score += 0.2;
+    }
+
+    if PUNCTUATION_DETECT.is_match(text) {
+        structure_score += 0.2;
+    }
+
+    structure_score.min(1.0)
+}