perf(lib): add heuristics for fast allocation

Author: lalvarezt

src/pipeline/parser.rs

@@ -67,7 +67,11 @@ pub fn parse_template(template: &str) -> Result<(Vec<StringOp>, bool), String> {
         .next()
         .unwrap();
 
-    // Estimate capacity based on template length and complexity
+    // Heuristic: reserve enough space for `|`-separated operations but avoid gross
+    // over-allocation for medium templates.  Count of `|` is cheap (single pass
+    // over the input) and gives an upper bound on the number of operations.
+    let pipe_count = template.as_bytes().iter().filter(|&&b| b == b'|').count();
+
     let estimated_capacity = if template.len() < 50 {
         4 // Simple templates typically have 1-4 operations
     } else if template.len() < 150 {
@@ -76,7 +80,7 @@ pub fn parse_template(template: &str) -> Result<(Vec<StringOp>, bool), String> {
         16 // Complex templates might have 8+ operations
     };
 
-    let mut ops = Vec::with_capacity(estimated_capacity);
+    let mut ops = Vec::with_capacity(std::cmp::min(estimated_capacity, pipe_count + 1));
     let mut debug = false;
 
     for pair in pairs.into_inner() {

src/pipeline/template.rs

@@ -208,6 +208,13 @@ impl MultiTemplate {
     /// let template = Template::parse("{split:,:..|sort|join: - }").unwrap();
     /// ```
     pub fn parse(template: &str) -> Result<Self, String> {
+        // Fast-path: if the input is a *single* template block (no outer-level
+        // literal text) we can skip the multi-template scanner and directly
+        // parse the operation list.
+        if let Some(single) = Self::try_single_block(template)? {
+            return Ok(single);
+        }
+
         let (sections, _) = parser::parse_multi_template(template)?;
         Ok(Self::new(template.to_string(), sections, false))
     }
@@ -252,6 +259,14 @@ impl MultiTemplate {
     /// let template = Template::parse_with_debug("{upper}", Some(true)).unwrap();
     /// ```
     pub fn parse_with_debug(template: &str, debug: Option<bool>) -> Result<Self, String> {
+        // Re-use the single-block shortcut when applicable.
+        if let Some(mut single) = Self::try_single_block(template)? {
+            if let Some(dbg_override) = debug {
+                single.debug = dbg_override;
+            }
+            return Ok(single);
+        }
+
         let (sections, inner_dbg) = parser::parse_multi_template(template)?;
         Ok(Self::new(
             template.to_string(),
@@ -588,6 +603,45 @@ impl MultiTemplate {
             .collect::<Vec<_>>()
             .join(" | ")
     }
+
+    /* -------- helper: detect plain single-block templates ------------- */
+
+    /// Detects and parses templates that consist of exactly one `{ ... }` block
+    /// with no surrounding literal text. Returns `Ok(Some(MultiTemplate))` when
+    /// the fast path can be applied, `Ok(None)` otherwise.
+    fn try_single_block(template: &str) -> Result<Option<Self>, String> {
+        // Must start with '{' and end with '}' to be a candidate.
+        if !(template.starts_with('{') && template.ends_with('}')) {
+            return Ok(None);
+        }
+
+        // Verify that the outer-most braces close at the very end and that the
+        // brace nesting never returns to zero before the last char.
+        let mut depth = 0u32;
+        for ch in template[1..template.len() - 1].chars() {
+            match ch {
+                '{' => depth += 1,
+                '}' => {
+                    if depth == 0 {
+                        // Closed the top-level early → literal content exists.
+                        return Ok(None);
+                    }
+                    depth -= 1;
+                }
+                _ => {}
+            }
+        }
+
+        if depth != 0 {
+            // Unbalanced braces – fall back to full parser for proper error.
+            return Ok(None);
+        }
+
+        // Safe to treat as single template block.
+        let (ops, dbg_flag) = parser::parse_template(template)?;
+        let sections = vec![TemplateSection::Template(ops)];
+        Ok(Some(Self::new(template.to_string(), sections, dbg_flag)))
+    }
 }
 
 /* ---------- trait impls -------------------------------------------------- */