perf: inline Segment struct, VLQ fast path, and capacity hints

Replace heap-allocated Vec<i64> segments with inline [i64; 5] struct,
add single-char fast path to codec VLQ decoder, and use single-pass
byte counting with per-line capacity hints for decode allocation.

Codec decode: -23% to -54% depending on data shape.
Sourcemap parse: -3% to -5% on large maps.

Author: BartWaardenburg

crates/cli/src/main.rs

@@ -616,10 +616,14 @@ fn cmd_decode(mappings: Option<String>, compact: bool) -> Result<(), CliError> {
 
     reject_control_chars(&input, "mappings input")?;
     let decoded = decode(&input).map_err(|e| CliError::parse(format!("decode error: {e}")))?;
+    let as_vecs: Vec<Vec<Vec<i64>>> = decoded
+        .into_iter()
+        .map(|line| line.into_iter().map(|seg| seg.to_vec()).collect())
+        .collect();
     let json = if compact {
-        serde_json::to_string(&decoded)
+        serde_json::to_string(&as_vecs)
     } else {
-        serde_json::to_string_pretty(&decoded)
+        serde_json::to_string_pretty(&as_vecs)
     }
     .map_err(|e| CliError::parse(format!("JSON serialization error: {e}")))?;
     println!("{json}");
@@ -638,8 +642,16 @@ fn cmd_encode(file: Option<PathBuf>, json: bool) -> Result<(), CliError> {
         }
     };
 
-    let decoded: srcmap_codec::SourceMapMappings =
+    let raw: Vec<Vec<Vec<i64>>> =
         serde_json::from_str(&input).map_err(|e| CliError::parse(format!("invalid JSON: {e}")))?;
+    let decoded: srcmap_codec::SourceMapMappings = raw
+        .into_iter()
+        .map(|line| {
+            line.into_iter()
+                .map(srcmap_codec::Segment::from)
+                .collect()
+        })
+        .collect();
     let encoded = encode(&decoded);
 
     if json {

crates/codec/benches/vlq.rs

@@ -1,7 +1,7 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 #[cfg(feature = "parallel")]
 use srcmap_codec::encode_parallel;
-use srcmap_codec::{decode, encode};
+use srcmap_codec::{Segment, decode, encode};
 use std::hint::black_box;
 
 /// Synthetic all-zero mappings (best case: single-char VLQ values).
@@ -50,9 +50,9 @@ fn make_realistic_mappings() -> String {
             // ~20% of segments have names
             if seg % 5 == 0 {
                 name += 1;
-                line.push(vec![gen_col, src, src_line, src_col, name]);
+                line.push(Segment::five(gen_col, src, src_line, src_col, name));
             } else {
-                line.push(vec![gen_col, src, src_line, src_col]);
+                line.push(Segment::four(gen_col, src, src_line, src_col));
             }
         }
 
@@ -106,9 +106,9 @@ fn make_large_realistic_mappings() -> srcmap_codec::SourceMapMappings {
 
             if seg % 5 == 0 {
                 name += 1;
-                line.push(vec![gen_col, src, src_line, src_col, name]);
+                line.push(Segment::five(gen_col, src, src_line, src_col, name));
             } else {
-                line.push(vec![gen_col, src, src_line, src_col]);
+                line.push(Segment::four(gen_col, src, src_line, src_col));
             }
         }
         mappings.push(line);
@@ -166,9 +166,9 @@ fn bench_encode(c: &mut Criterion) {
                     src_col = src_col.max(0);
                     if seg % 5 == 0 {
                         name += 1;
-                        line.push(vec![gen_col, src, src_line, src_col, name]);
+                        line.push(Segment::five(gen_col, src, src_line, src_col, name));
                     } else {
-                        line.push(vec![gen_col, src, src_line, src_col]);
+                        line.push(Segment::four(gen_col, src, src_line, src_col));
                     }
                 }
                 mappings.push(line);

crates/codec/src/decode.rs

@@ -1,6 +1,7 @@
 use crate::vlq::vlq_decode;
 use crate::{DecodeError, Line, Segment, SourceMapMappings};
 
+
 /// Decode a VLQ-encoded source map mappings string into structured data.
 ///
 /// The mappings string uses `;` to separate lines and `,` to separate
@@ -24,8 +25,16 @@ pub fn decode(input: &str) -> Result<SourceMapMappings, DecodeError> {
     let bytes = input.as_bytes();
     let len = bytes.len();
 
-    // Pre-count lines for capacity hint
-    let line_count = bytes.iter().filter(|&&b| b == b';').count() + 1;
+    // Pre-count lines and segments in a single pass for capacity hints
+    let mut semicolons = 0usize;
+    let mut commas = 0usize;
+    for &b in bytes {
+        semicolons += (b == b';') as usize;
+        commas += (b == b',') as usize;
+    }
+    let line_count = semicolons + 1;
+    let approx_segments = commas + line_count;
+    let avg_segments_per_line = approx_segments / line_count;
     let mut mappings: SourceMapMappings = Vec::with_capacity(line_count);
 
     // Cumulative state across the entire mappings string
@@ -39,7 +48,7 @@ pub fn decode(input: &str) -> Result<SourceMapMappings, DecodeError> {
     loop {
         // Generated column resets per line
         let mut generated_column: i64 = 0;
-        let mut line: Line = Vec::new();
+        let mut line: Line = Vec::with_capacity(avg_segments_per_line);
         let mut saw_semicolon = false;
 
         while pos < len {
@@ -81,23 +90,23 @@ pub fn decode(input: &str) -> Result<SourceMapMappings, DecodeError> {
                     let (delta, consumed) = vlq_decode(bytes, pos)?;
                     name_index += delta;
                     pos += consumed;
-                    vec![
+                    Segment::five(
                         generated_column,
                         source_index,
                         original_line,
                         original_column,
                         name_index,
-                    ]
+                    )
                 } else {
-                    vec![
+                    Segment::four(
                         generated_column,
                         source_index,
                         original_line,
                         original_column,
-                    ]
+                    )
                 }
             } else {
-                vec![generated_column]
+                Segment::one(generated_column)
             };
 
             line.push(segment);

crates/codec/src/lib.rs

@@ -47,13 +47,111 @@ pub use vlq::{vlq_decode, vlq_decode_unsigned, vlq_encode, vlq_encode_unsigned};
 
 use std::fmt;
 
-/// A single source map segment.
+/// A single source map segment stored inline (no heap allocation).
 ///
 /// Segments have 1, 4, or 5 fields:
 /// - 1 field:  `[generated_column]`
 /// - 4 fields: `[generated_column, source_index, original_line, original_column]`
 /// - 5 fields: `[generated_column, source_index, original_line, original_column, name_index]`
-pub type Segment = Vec<i64>;
+///
+/// Implements `Deref<Target=[i64]>` so indexing, `len()`, `is_empty()`, and
+/// iteration work identically to `Vec<i64>`.
+#[derive(Debug, Clone, Copy)]
+pub struct Segment {
+    data: [i64; 5],
+    len: u8,
+}
+
+impl Segment {
+    /// Create a 1-field segment (generated column only).
+    #[inline]
+    pub fn one(a: i64) -> Self {
+        Self {
+            data: [a, 0, 0, 0, 0],
+            len: 1,
+        }
+    }
+
+    /// Create a 4-field segment (with source info, no name).
+    #[inline]
+    pub fn four(a: i64, b: i64, c: i64, d: i64) -> Self {
+        Self {
+            data: [a, b, c, d, 0],
+            len: 4,
+        }
+    }
+
+    /// Create a 5-field segment (with source info and name).
+    #[inline]
+    pub fn five(a: i64, b: i64, c: i64, d: i64, e: i64) -> Self {
+        Self {
+            data: [a, b, c, d, e],
+            len: 5,
+        }
+    }
+
+    /// Convert to a `Vec<i64>` (for interop with APIs that expect `Vec`).
+    pub fn to_vec(&self) -> Vec<i64> {
+        self.data[..self.len as usize].to_vec()
+    }
+}
+
+impl std::ops::Deref for Segment {
+    type Target = [i64];
+
+    #[inline]
+    fn deref(&self) -> &[i64] {
+        &self.data[..self.len as usize]
+    }
+}
+
+impl<'a> IntoIterator for &'a Segment {
+    type Item = &'a i64;
+    type IntoIter = std::slice::Iter<'a, i64>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.data[..self.len as usize].iter()
+    }
+}
+
+impl PartialEq for Segment {
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+
+impl Eq for Segment {}
+
+impl PartialEq<Vec<i64>> for Segment {
+    fn eq(&self, other: &Vec<i64>) -> bool {
+        **self == **other
+    }
+}
+
+impl PartialEq<Segment> for Vec<i64> {
+    fn eq(&self, other: &Segment) -> bool {
+        **self == **other
+    }
+}
+
+impl From<Vec<i64>> for Segment {
+    fn from(v: Vec<i64>) -> Self {
+        let mut data = [0i64; 5];
+        let len = v.len().min(5);
+        data[..len].copy_from_slice(&v[..len]);
+        Self { data, len: len as u8 }
+    }
+}
+
+impl From<&[i64]> for Segment {
+    fn from(s: &[i64]) -> Self {
+        let mut data = [0i64; 5];
+        let len = s.len().min(5);
+        data[..len].copy_from_slice(&s[..len]);
+        Self { data, len: len as u8 }
+    }
+}
 
 /// A source map line is a list of segments.
 pub type Line = Vec<Segment>;
@@ -124,15 +222,15 @@ mod tests {
 
     #[test]
     fn roundtrip_large_values() {
-        let mappings = vec![vec![vec![1000_i64, 50, 999, 500, 100]]];
+        let mappings = vec![vec![Segment::five(1000, 50, 999, 500, 100)]];
         let encoded = encode(&mappings);
         let decoded = decode(&encoded).unwrap();
         assert_eq!(decoded, mappings);
     }
 
     #[test]
     fn roundtrip_negative_deltas() {
-        let mappings = vec![vec![vec![10_i64, 0, 10, 10], vec![20, 0, 5, 5]]];
+        let mappings = vec![vec![Segment::four(10, 0, 10, 10), Segment::four(20, 0, 5, 5)]];
         let encoded = encode(&mappings);
         let decoded = decode(&encoded).unwrap();
         assert_eq!(decoded, mappings);
@@ -259,20 +357,22 @@ mod tests {
     #[test]
     fn encode_empty_segments_no_dangling_comma() {
         // Empty segments should be skipped without producing dangling commas
-        let mappings = vec![vec![vec![], vec![0, 0, 0, 0], vec![], vec![2, 0, 0, 1]]];
+        let empty = Segment::from(&[] as &[i64]);
+        let mappings = vec![vec![empty, Segment::four(0, 0, 0, 0), empty, Segment::four(2, 0, 0, 1)]];
         let encoded = encode(&mappings);
         assert!(
             !encoded.contains(",,"),
             "should not contain dangling commas"
         );
         // Should encode as if empty segments don't exist
-        let expected = encode(&vec![vec![vec![0, 0, 0, 0], vec![2, 0, 0, 1]]]);
+        let expected = encode(&vec![vec![Segment::four(0, 0, 0, 0), Segment::four(2, 0, 0, 1)]]);
         assert_eq!(encoded, expected);
     }
 
     #[test]
     fn encode_all_empty_segments() {
-        let mappings = vec![vec![vec![], vec![], vec![]]];
+        let empty = Segment::from(&[] as &[i64]);
+        let mappings = vec![vec![empty, empty, empty]];
         let encoded = encode(&mappings);
         assert_eq!(encoded, "");
     }
@@ -288,13 +388,13 @@ mod tests {
             for line in 0..lines {
                 let mut line_segments = Vec::with_capacity(segments_per_line);
                 for seg in 0..segments_per_line {
-                    line_segments.push(vec![
+                    line_segments.push(Segment::five(
                         (seg * 10) as i64, // generated column
                         (seg % 5) as i64,  // source index
                         line as i64,       // original line
                         (seg * 5) as i64,  // original column
                         (seg % 3) as i64,  // name index
-                    ]);
+                    ));
                 }
                 mappings.push(line_segments);
             }
@@ -328,25 +428,22 @@ mod tests {
                 let mut line_segments = Vec::new();
                 for seg in 0..8 {
                     if seg % 4 == 0 {
-                        // 1-field segment (generated-only)
-                        line_segments.push(vec![(seg * 10) as i64]);
+                        line_segments.push(Segment::one((seg * 10) as i64));
                     } else if seg % 4 == 3 {
-                        // 5-field segment (with name)
-                        line_segments.push(vec![
+                        line_segments.push(Segment::five(
                             (seg * 10) as i64,
                             (seg % 3) as i64,
                             line as i64,
                             (seg * 5) as i64,
                             (seg % 2) as i64,
-                        ]);
+                        ));
                     } else {
-                        // 4-field segment
-                        line_segments.push(vec![
+                        line_segments.push(Segment::four(
                             (seg * 10) as i64,
                             (seg % 3) as i64,
                             line as i64,
                             (seg * 5) as i64,
-                        ]);
+                        ));
                     }
                 }
                 mappings.push(line_segments);
@@ -411,7 +508,7 @@ mod tests {
 
     #[test]
     fn encode_single_segment_one_field() {
-        let mappings = vec![vec![vec![5_i64]]];
+        let mappings = vec![vec![Segment::one(5)]];
         let encoded = encode(&mappings);
         let decoded = decode(&encoded).unwrap();
         assert_eq!(decoded, mappings);