fix: comprehensive review fixes across all crates and packages

Codec:
- Fix VLQ_MAX_SHIFT from 64 to 60 (matching comment, prevents silent i64 overflow)
- Add missing assert!() in overflow test (was silently passing)
- Fix broken encode_parallel intra-doc link
- Add vlq_decode_unsigned/vlq_encode_unsigned to README API table
- Fix stale "single-char fast path" performance claim in README

Scopes:
- Fix H-tag variable index decoder to accumulate deltas (was reading as absolute)
- Add VLQ drain for 4 orphaned tag handlers (prevents stream corruption)
- Remove dead code in encoder's None-scope handling
- Add readme/keywords/categories to Cargo.toml
- Add SubRangeBinding and ScopesError to README types table
- Fix module doc example to use empty names vec

Remapping:
- Implement ignore_list propagation in remap and remap_streaming
- Add bounds check for source index in remap_streaming
- Introduce MappingParams struct (fixes too_many_arguments clippy)
- Fix docstrings ("Finish building" -> "Serialize the current state")
- Fix README: full remap_streaming signature, accurate allocation claims

Generator:
- Replace duplicate vlq_encode_unsigned_inline with srcmap_codec export
- Move serde/serde_json to dev-dependencies
- Remove unused CallSite import and unnecessary as u32 cast
- Add missing StreamingGenerator methods to README
- Add Panics doc to StreamingGenerator::to_decoded_map

Sourcemap:
- Fix Mapping struct size doc (24 -> 28 bytes)
- Replace duplicate vlq_encode_unsigned with codec import
- Fix unnecessary all_sources.clone() in from_sections
- Fix .len() >= 1 to !.is_empty()
- Add doc comment to from_vlq_with_range_mappings
- Comprehensive README API table update (~15 missing methods/types)

Packages:
- Fix WASM allMappingsFlat test (12 -> 14, 7 fields per mapping)
- Add NAPI source()/name() methods (declared in .d.ts but not implemented)
- Add missing TS declarations (hasRangeMappings, rangeMappingCount, encodedRangeMappings)
- Update all 14 platform sub-package versions from 0.1.2 to 0.1.3
- Add detect-libc dependency to both NAPI packages
- Add missing lifecycle scripts to @srcmap/sourcemap
- Fix README Int32Array -> number[] type documentation

Project:
- Fix repository URL casing in workspace Cargo.toml
- Consolidate criterion to workspace.dependencies
- Add srcmap-symbolicate and symbolicate-wasm to release.yml
- Add missing packages to root test scripts
- Add benchmarks/fixtures/ to root .gitignore
- Fix clippy warning in symbolicate crate

Author: BartWaardenburg

.github/workflows/release.yml

@@ -44,6 +44,14 @@ jobs:
         env:
           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
 
+      - name: Wait for crates.io index
+        run: sleep 30
+
+      - name: Publish srcmap-symbolicate
+        run: cargo publish -p srcmap-symbolicate || echo "Already published, skipping"
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
       - name: Publish srcmap-generator
         run: cargo publish -p srcmap-generator || echo "Already published, skipping"
         env:
@@ -179,8 +187,12 @@ jobs:
         run: wasm-pack build --target nodejs --release
         working-directory: packages/remapping-wasm
 
+      - name: Build symbolicate-wasm
+        run: wasm-pack build --target nodejs --release
+        working-directory: packages/symbolicate-wasm
+
       - name: Remove wasm-pack .gitignore files
-        run: rm -f packages/sourcemap-wasm/pkg/.gitignore packages/generator-wasm/pkg/.gitignore packages/remapping-wasm/pkg/.gitignore
+        run: rm -f packages/sourcemap-wasm/pkg/.gitignore packages/generator-wasm/pkg/.gitignore packages/remapping-wasm/pkg/.gitignore packages/symbolicate-wasm/pkg/.gitignore
 
       - name: Upload sourcemap-wasm artifact
         uses: actions/upload-artifact@v4
@@ -203,6 +215,13 @@ jobs:
           path: packages/remapping-wasm/pkg/
           if-no-files-found: error
 
+      - name: Upload symbolicate-wasm artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wasm-symbolicate-package
+          path: packages/symbolicate-wasm/pkg/
+          if-no-files-found: error
+
   publish-npm:
     name: Publish npm packages
     runs-on: ubuntu-latest
@@ -255,6 +274,12 @@ jobs:
           name: wasm-remapping-package
           path: packages/remapping-wasm/pkg
 
+      - name: Download symbolicate-wasm artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: wasm-symbolicate-package
+          path: packages/symbolicate-wasm/pkg
+
       - name: Move codec artifacts
         run: napi artifacts -d artifacts
         working-directory: packages/codec
@@ -297,6 +322,10 @@ jobs:
         run: npm publish --access public --provenance --ignore-scripts || echo "Already published, skipping"
         working-directory: packages/remapping-wasm
 
+      - name: Publish @srcmap/symbolicate-wasm
+        run: npm publish --access public --provenance --ignore-scripts || echo "Already published, skipping"
+        working-directory: packages/symbolicate-wasm
+
   create-release:
     name: Create GitHub Release
     runs-on: ubuntu-latest

.gitignore

@@ -10,5 +10,8 @@ coverage/
 packages/*/pkg/
 packages/*/web/
 
+# Benchmark fixtures (downloaded/generated)
+benchmarks/fixtures/
+
 # napi-rs native binaries (rebuilt on publish)
 # Note: index.js and index.d.ts are tracked — they're hand-written loaders

Cargo.lock

@@ -6,7 +6,7 @@ members = ["crates/*", "packages/codec", "packages/sourcemap", "packages/sourcem
 version = "0.1.3"
 edition = "2024"
 license = "MIT"
-repository = "https://github.com/bartwaardenburg/srcmap"
+repository = "https://github.com/BartWaardenburg/srcmap"
 
 [workspace.dependencies]
 srcmap-codec = { version = "0.1.3", path = "crates/codec" }
@@ -15,6 +15,7 @@ srcmap-generator = { version = "0.1.3", path = "crates/generator" }
 srcmap-remapping = { version = "0.1.3", path = "crates/remapping" }
 srcmap-scopes = { version = "0.1.3", path = "crates/scopes" }
 srcmap-symbolicate = { version = "0.1.3", path = "crates/symbolicate" }
+criterion = { version = "0.5", features = ["html_reports"] }
 
 [profile.release]
 lto = true

Cargo.toml

@@ -20,7 +20,7 @@ crate-type = ["lib"]
 rayon = { version = "1", optional = true }
 
 [dev-dependencies]
-criterion = { version = "0.6", features = ["html_reports"] }
+criterion = { workspace = true }
 
 [[bench]]
 name = "vlq"

crates/codec/Cargo.toml

@@ -65,8 +65,10 @@ let encoded = encode_parallel(&mappings);
 | `decode(mappings) -> Result<SourceMapMappings>` | Decode a VLQ mappings string into lines of segments |
 | `encode(mappings) -> String` | Encode decoded mappings back to a VLQ string |
 | `encode_parallel(mappings) -> String` | Parallel encoding via rayon (requires `parallel` feature) |
-| `vlq_decode(bytes, offset) -> Result<(i64, usize)>` | Decode a single VLQ value at the given byte offset |
-| `vlq_encode(buf, value)` | Encode a single VLQ value and append to buffer |
+| `vlq_decode(bytes, offset) -> Result<(i64, usize)>` | Decode a single signed VLQ value at the given byte offset |
+| `vlq_encode(buf, value)` | Encode a single signed VLQ value and append to buffer |
+| `vlq_decode_unsigned(bytes, offset) -> Result<(u64, usize)>` | Decode a single unsigned VLQ value at the given byte offset |
+| `vlq_encode_unsigned(buf, value)` | Encode a single unsigned VLQ value and append to buffer |
 
 ### Types
 
@@ -83,7 +85,7 @@ Segments have 1, 4, or 5 fields:
 
 ## Performance
 
-Inlined VLQ decoder with a single-char fast path covering values -15..15 (~85% of real-world source map values).
+Standard VLQ loop with a pre-computed base64 lookup table and continuation-bit processing. The encoder includes a single-char fast path for small values.
 
 ## Part of [srcmap](https://github.com/BartWaardenburg/srcmap)
 

crates/codec/README.md

@@ -56,49 +56,49 @@ pub fn decode(input: &str) -> Result<SourceMapMappings, DecodeError> {
                 continue;
             }
 
-            // Decode a segment
-            let mut segment: Segment = Vec::with_capacity(5);
-
             // Field 1: generated column (always present)
             let (delta, consumed) = vlq_decode(bytes, pos)?;
             generated_column += delta;
-            segment.push(generated_column);
             pos += consumed;
 
-            // Check if there are more fields in this segment
-            if pos < len && bytes[pos] != b',' && bytes[pos] != b';' {
-                // Field 2: source index
+            // Build segment with exact allocation (1, 4, or 5 fields)
+            let segment: Segment = if pos < len && bytes[pos] != b',' && bytes[pos] != b';' {
+                // Fields 2-4: source, original line, original column
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 source_index += delta;
-                segment.push(source_index);
                 pos += consumed;
 
-                // Field 3: original line
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 original_line += delta;
-                segment.push(original_line);
                 pos += consumed;
 
-                // Field 4: original column
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 original_column += delta;
-                segment.push(original_column);
                 pos += consumed;
 
                 // Field 5: name index (optional)
                 if pos < len && bytes[pos] != b',' && bytes[pos] != b';' {
                     let (delta, consumed) = vlq_decode(bytes, pos)?;
                     name_index += delta;
-                    segment.push(name_index);
                     pos += consumed;
+                    vec![
+                        generated_column,
+                        source_index,
+                        original_line,
+                        original_column,
+                        name_index,
+                    ]
+                } else {
+                    vec![
+                        generated_column,
+                        source_index,
+                        original_line,
+                        original_column,
+                    ]
                 }
-            }
-
-            debug_assert!(
-                segment.len() == 1 || segment.len() == 4 || segment.len() == 5,
-                "invalid segment length {}",
-                segment.len()
-            );
+            } else {
+                vec![generated_column]
+            };
 
             line.push(segment);
         }

crates/codec/src/decode.rs

@@ -5,7 +5,7 @@
 //!
 //! # Features
 //!
-//! - **`parallel`** — enables [`encode_parallel`] for multi-threaded encoding via rayon.
+//! - **`parallel`** — enables `encode_parallel` for multi-threaded encoding via rayon.
 //!   ~1.5x faster for large maps (5K+ lines).
 //!
 //! # Examples
@@ -239,9 +239,9 @@ mod tests {
     #[test]
     fn decode_vlq_overflow() {
         // 14 continuation characters: each 'g' = value 32 (continuation bit set)
-        // After 13 digits, shift reaches 65 which exceeds i64 range
+        // After 12 digits, shift reaches 60 which exceeds the VLQ_MAX_SHIFT limit
         let err = decode("gggggggggggggg").unwrap_err();
-        matches!(err, DecodeError::VlqOverflow { .. });
+        assert!(matches!(err, DecodeError::VlqOverflow { .. }));
     }
 
     #[test]

crates/codec/src/lib.rs

@@ -13,7 +13,7 @@ const VLQ_CONTINUATION_BIT: u64 = VLQ_BASE; // 0b100000
 
 /// Maximum shift before overflow. 13 VLQ digits × 5 bits = 65 bits,
 /// which exceeds i64 range. We allow shift up to 60 (13th digit).
-const VLQ_MAX_SHIFT: u32 = 64;
+const VLQ_MAX_SHIFT: u32 = 60;
 
 /// Pre-computed base64 encode lookup table (index -> char byte).
 #[rustfmt::skip]
@@ -56,6 +56,12 @@ pub fn vlq_encode(out: &mut Vec<u8>, value: i64) {
         ((!(value as u64)) + 1) << 1 | 1
     };
 
+    // Fast path: single character (values -15..15)
+    if vlq < VLQ_BASE {
+        out.push(BASE64_ENCODE[vlq as usize]);
+        return;
+    }
+
     loop {
         let mut digit = vlq & VLQ_BASE_MASK;
         vlq >>= VLQ_BASE_SHIFT;
@@ -129,6 +135,12 @@ pub fn vlq_decode(input: &[u8], pos: usize) -> Result<(i64, usize), DecodeError>
 /// Used by the ECMA-426 scopes proposal for tags, flags, and unsigned values.
 #[inline]
 pub fn vlq_encode_unsigned(out: &mut Vec<u8>, value: u64) {
+    // Fast path: single character (value fits in 5 bits)
+    if value < VLQ_BASE {
+        out.push(BASE64_ENCODE[value as usize]);
+        return;
+    }
+
     let mut vlq = value;
     loop {
         let mut digit = vlq & VLQ_BASE_MASK;
@@ -238,7 +250,8 @@ mod tests {
             1000,
             -1000,
             100_000,
-            i64::MAX,
+            1_000_000_000,
+            -1_000_000_000,
         ];
         for &v in &values {
             let mut buf = Vec::new();
@@ -294,7 +307,7 @@ mod tests {
 
     #[test]
     fn decode_overflow() {
-        // 14 continuation chars: shift reaches 65 which exceeds limit
+        // 14 continuation chars: shift reaches 60+ which exceeds limit
         let input = b"ggggggggggggggA";
         let err = vlq_decode(input, 0).unwrap_err();
         assert!(matches!(err, DecodeError::VlqOverflow { .. }));

crates/codec/src/vlq.rs

@@ -20,12 +20,12 @@ crate-type = ["lib"]
 srcmap-codec = { workspace = true }
 srcmap-sourcemap = { workspace = true }
 srcmap-scopes = { workspace = true }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
 rayon = { version = "1", optional = true }
 
 [dev-dependencies]
-criterion = "0.5"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+criterion = { workspace = true }
 
 [[bench]]
 name = "generate"