feat: range mappings, streaming composition, and remap_streaming

Implement ECMA-426 Stage 2 range mappings across the full stack:
- Decode/encode `rangeMappings` field with unsigned VLQ
- Range delta lookup in `original_position_for` (cross-line support)
- Range mapping preservation through remap and concat
- Generator APIs: `add_range_mapping`, `add_named_range_mapping`
- StreamingGenerator range mapping support
- WASM/NAPI bindings: hasRangeMappings, rangeMappingCount
- CLI: range mapping display in `info` and `mappings`

Add streaming source map composition:
- `remap_streaming()` using MappingsIter + StreamingGenerator
- Criterion benchmarks (500/10K/60K mappings)
- Updated documentation across all crates and packages

Author: BartWaardenburg

Cargo.lock

@@ -137,6 +137,7 @@ vlq_encode(&mut buf, 42);
 Full [ECMA-426](https://tc39.es/ecma426/) (Source Map v3) compliance:
 
 - All standard fields: `version`, `file`, `sourceRoot`, `sources`, `sourcesContent`, `names`, `mappings`
+- `rangeMappings` for range-based source mapping (ECMA-426 Stage 2 proposal)
 - `ignoreList` for filtering third-party sources
 - Indexed source maps with `sections` — flattened with source/name deduplication
 - Proper `sourceRoot` resolution
@@ -233,7 +234,7 @@ All commands support `--json` for structured output.
 
 ## Internals
 
-- **Flat Mapping struct** — 24 bytes (6 × u32), cache-friendly contiguous layout
+- **Flat Mapping struct** — 28 bytes (6 × u32 + bool), cache-friendly contiguous layout
 - **Inlined VLQ decoder** — single-char fast path for values −15..15 (~85% of real-world VLQ values)
 - **Lazy reverse index** — only built on first `generated_position_for` call
 - **Binary search lookups** — O(log n) for both forward and reverse queries
@@ -247,6 +248,7 @@ cargo test --workspace                # Run all tests
 cargo bench -p srcmap-sourcemap       # Criterion benchmarks
 cargo bench -p srcmap-codec
 cargo bench -p srcmap-generator
+cargo bench -p srcmap-remapping       # remap vs remap_streaming
 ```
 
 <details>

README.md

@@ -40,13 +40,13 @@ The `Mapping` struct gains an `is_range_mapping: bool` field (default `false`).
 
 ### What to implement
 
-- [ ] Decode `rangeMappings` field and set `is_range_mapping` on `Mapping` structs
-- [ ] Encode `rangeMappings` from `Mapping` structs with `is_range_mapping = true`
-- [ ] Update `original_position_for` to apply range delta when the matched mapping is a range mapping
-- [ ] Update `remap()` to preserve and compose range mappings through transform chains
-- [ ] Generator API: `add_range_mapping()` for marking a mapping as a range
-- [ ] WASM/NAPI bindings
-- [ ] CLI: show range mappings in `srcmap info` and `srcmap mappings`
+- [x] Decode `rangeMappings` field and set `is_range_mapping` on `Mapping` structs
+- [x] Encode `rangeMappings` from `Mapping` structs with `is_range_mapping = true`
+- [x] Update `original_position_for` to apply range delta when the matched mapping is a range mapping
+- [x] Update `remap()` to preserve and compose range mappings through transform chains
+- [x] Generator API: `add_range_mapping()` for marking a mapping as a range
+- [x] WASM/NAPI bindings
+- [x] CLI: show range mappings in `srcmap info` and `srcmap mappings`
 
 ---
 
@@ -58,9 +58,11 @@ Rolldown's `collapse_sourcemaps` materializes the entire token stream into `Vec<
 
 ### What to implement
 
-- [ ] `remap()` accepts iterators instead of requiring materialized `Vec`s
+- [x] `MappingsIter`: lazy iterator over VLQ-encoded mappings (decodes one at a time, no `Vec<Mapping>`)
+- [x] `StreamingGenerator`: on-the-fly VLQ encoder that emits mappings in sorted order without collecting
+- [x] `remap_streaming()`: composition pipeline that streams through mappings without intermediate allocation
+- [x] Criterion benchmarks (500 / 10K / 60K mappings) — 15-20% faster than materialized `remap()`
 - [ ] Builder pattern for `SourceMap::new()` that consumes iterators for names/sources/source_contents
-- [ ] Composition pipeline that streams through mappings without intermediate allocation
 - [ ] Benchmark against Rolldown's current `collapse_sourcemaps`
 
 ---

ROADMAP.md

@@ -398,6 +398,7 @@ fn cmd_info(file: &PathBuf, json: bool) -> Result<(), CliError> {
             "sources": sm.sources.len(),
             "names": sm.names.len(),
             "mappings": sm.mapping_count(),
+            "rangeMappings": sm.range_mapping_count(),
             "lines": sm.line_count(),
             "sourcesWithContent": has_content,
             "totalContentSize": content_size,
@@ -416,6 +417,9 @@ fn cmd_info(file: &PathBuf, json: bool) -> Result<(), CliError> {
         println!("Sources:      {}", sm.sources.len());
         println!("Names:        {}", sm.names.len());
         println!("Mappings:     {}", sm.mapping_count());
+        if sm.has_range_mappings() {
+            println!("  Range:      {} range mappings", sm.range_mapping_count());
+        }
         println!("Lines:        {}", sm.line_count());
         println!("File size:    {}", format_size(raw.len()));
 
@@ -702,6 +706,7 @@ fn cmd_mappings(
                     "originalLine": m.original_line,
                     "originalColumn": m.original_column,
                     "name": name,
+                    "isRangeMapping": m.is_range_mapping,
                 })
             })
             .collect();
@@ -716,10 +721,10 @@ fn cmd_mappings(
         println!("{}", serde_json::to_string_pretty(&obj).unwrap());
     } else {
         println!(
-            "{:<8} {:<8} {:<30} {:<8} {:<8} name",
-            "gen.ln", "gen.col", "source", "orig.ln", "orig.col"
+            "{:<8} {:<8} {:<30} {:<8} {:<8} {:<6} name",
+            "gen.ln", "gen.col", "source", "orig.ln", "orig.col", "range"
         );
-        println!("{:-<80}", "");
+        println!("{:-<86}", "");
         for m in &filtered {
             let source = if m.source != u32::MAX {
                 sm.source(m.source)
@@ -731,13 +736,15 @@ fn cmd_mappings(
             } else {
                 ""
             };
+            let range_marker = if m.is_range_mapping { "R" } else { "" };
             println!(
-                "{:<8} {:<8} {:<30} {:<8} {:<8} {}",
+                "{:<8} {:<8} {:<30} {:<8} {:<8} {:<6} {}",
                 m.generated_line,
                 m.generated_column,
                 source,
                 m.original_line,
                 m.original_column,
+                range_marker,
                 name
             );
         }

crates/cli/src/main.rs

@@ -54,8 +54,11 @@ let json = gen.to_json();
 | `add_named_mapping(gen_line, gen_col, src, orig_line, orig_col, name)` | Add a mapping with a name |
 | `add_generated_mapping(gen_line, gen_col)` | Add a generated-only mapping (no source) |
 | `maybe_add_mapping(gen_line, gen_col, src, orig_line, orig_col) -> bool` | Add only if different from previous |
+| `add_range_mapping(gen_line, gen_col, src, orig_line, orig_col)` | Add a range mapping (ECMA-426) |
+| `add_named_range_mapping(gen_line, gen_col, src, orig_line, orig_col, name)` | Add a named range mapping |
 | `add_to_ignore_list(source_idx)` | Mark a source as ignored (third-party) |
 | `to_json() -> String` | Serialize to source map v3 JSON |
+| `to_decoded_map() -> SourceMap` | Build a `SourceMap` directly (no JSON roundtrip) |
 | `mapping_count() -> usize` | Number of mappings added |
 
 ### Parallel encoding
@@ -67,10 +70,28 @@ Enable the `parallel` feature for multi-threaded VLQ encoding via [rayon](https:
 srcmap-generator = { version = "0.1", features = ["parallel"] }
 ```
 
+### `StreamingGenerator`
+
+On-the-fly VLQ encoder that emits mappings as they are added, without collecting into a `Vec`. Ideal for composition pipelines where mappings arrive in sorted order.
+
+| Method | Description |
+|--------|-------------|
+| `new(file) -> Self` | Create a new streaming generator |
+| `add_source(path) -> u32` | Register a source file (deduped) |
+| `add_name(name) -> u32` | Register a name (deduped) |
+| `add_mapping(...)` | Add a mapping (encoded immediately) |
+| `add_named_mapping(...)` | Add a mapping with a name |
+| `add_range_mapping(...)` | Add a range mapping (ECMA-426) |
+| `add_named_range_mapping(...)` | Add a named range mapping |
+| `to_json() -> String` | Serialize to source map v3 JSON |
+| `to_decoded_map() -> SourceMap` | Build a `SourceMap` directly |
+
 ## Features
 
 - **Automatic deduplication** of sources and names
 - **`maybe_add_mapping`** skips redundant mappings to reduce output size
+- **Range mappings** (`rangeMappings` field, ECMA-426 Stage 2)
+- **Streaming generation** via `StreamingGenerator` — zero-allocation VLQ encoding
 - **`ignoreList`** support for filtering third-party sources in DevTools
 - **Parallel VLQ encoding** for large maps (opt-in via `parallel` feature)
 - **Hand-rolled JSON serialization** — no serde overhead in output path