fix: ECMA-426 conformance fixes across codec and sourcemap crates

- Reject 2/3-field segments in all decoder paths (codec + 4 sourcemap decoders)
- Reject nested index maps with ParseError::NestedIndexMap
- Validate section ordering (strictly ascending line/column offsets)
- Fix ignoreList: explicit empty [] no longer falls through to x_google_ignoreList
- Fix sourceRoot double-application on roundtrip (strip prefix in to_json)
- Emit scopes field in to_json() output
- Support both x_ and x- prefixed extension keys
- Add 11 conformance tests covering all fixes

Author: BartWaardenburg

ROADMAP.md

@@ -62,14 +62,37 @@ Rolldown's `collapse_sourcemaps` materializes the entire token stream into `Vec<
 - [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()`
+
+Remaining nice-to-haves (low priority):
 - [ ] Builder pattern for `SourceMap::new()` that consumes iterators for names/sources/source_contents
 - [ ] Benchmark against Rolldown's current `collapse_sourcemaps`
 
 ---
 
+## Function Name Mappings
+
+**ECMA-426, standardized** — [bloomberg.github.io/js-blog/post/standardizing-source-maps](https://bloomberg.github.io/js-blog/post/standardizing-source-maps/)
+
+A `"sourcesFunctionMappings"` array parallel to `"sources"`, where each entry is a VLQ-encoded string mapping generated positions to original function names. Previously the `x_com_bloomberg_sourcesFunctionMappings` extension, now standardized in ECMA-426.
+
+This is a simpler alternative to the full scopes proposal for resolving minified function names in stack traces. Tools that don't need full scope/binding information can use this field alone. For tools that support scopes, `FindOriginalFunctionName` from the scopes proposal supersedes this — but both should be supported for interop, since most source maps in the wild won't have scopes data.
+
+### What to implement
+
+- [ ] Parse `sourcesFunctionMappings` field in `srcmap-sourcemap`
+- [ ] Decode per-source function name mappings (VLQ → function name index at position)
+- [ ] `original_function_name_for(source, line, col)` lookup API
+- [ ] Generate `sourcesFunctionMappings` in `srcmap-generator`
+- [ ] Preserve through remapping/concatenation
+- [ ] Use in symbolicate crate as fallback when scopes data is absent
+- [ ] WASM bindings
+- [ ] CLI: show function mappings in `srcmap info`
+
+---
+
 ## Scopes Spec Alignment
 
-**ECMA-426 scopes proposal, actively evolving** — srcmap already has `srcmap-scopes`, but the spec is still changing.
+**ECMA-426 scopes proposal, actively evolving** — srcmap already has `srcmap-scopes`, but the spec is still changing. The scopes proposal is the comprehensive approach to debugging metadata — it supersedes `sourcesFunctionMappings` for function name resolution and adds variable bindings, scope chains, and inlined frame reconstruction.
 
 ### Open issues to track
 
@@ -105,7 +128,7 @@ Rolldown's `collapse_sourcemaps` materializes the entire token stream into `Vec<
 
 ---
 
-## Sources Hash
+## Sources Hash `[Stage 1 — not implementing yet]`
 
 **ECMA-426 proposal, Stage 1** — [tc39/ecma426#208](https://github.com/nicolo-ribaudo/ecma-426/blob/main/proposals/range-mappings.md)
 
@@ -136,7 +159,7 @@ Hash algorithm is implementation-defined (SHA-256 recommended). Format is a pref
 
 ---
 
-## Debug ID Extraction
+## Debug ID Extraction `[Stage 2 — not implementing yet]`
 
 **ECMA-426 proposal, Stage 2** — [tc39/ecma426#207](https://github.com/nicolo-ribaudo/ecma-426/blob/main/proposals/range-mappings.md)
 
@@ -188,7 +211,7 @@ Split the mappings string into chunks and encode VLQ segments in parallel using
 
 ---
 
-## Mappings v2 Encoding
+## Mappings v2 Encoding `[Discussion — not implementing yet]`
 
 **ECMA-426 discussion** — [tc39/ecma426#155](https://github.com/nicolo-ribaudo/ecma-426/blob/main/proposals/range-mappings.md)
 
@@ -223,7 +246,7 @@ This is early-stage and may never land. Worth implementing as an experimental en
 
 ---
 
-## Env Metadata
+## Env Metadata `[Stage 1 — not implementing yet]`
 
 **ECMA-426 proposal, Stage 1** — [tc39/ecma426 proposals/env.md](https://github.com/nicolo-ribaudo/ecma-426/blob/main/proposals/range-mappings.md)
 

crates/codec/src/decode.rs

@@ -71,15 +71,33 @@ pub fn decode(input: &str) -> Result<SourceMapMappings, DecodeError> {
 
             // 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
+                // Field 2: source index
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 source_index += delta;
                 pos += consumed;
 
+                // Reject 2-field segments (only 1, 4, or 5 are valid per ECMA-426)
+                if pos >= len || bytes[pos] == b',' || bytes[pos] == b';' {
+                    return Err(DecodeError::InvalidSegmentLength {
+                        fields: 2,
+                        offset: pos,
+                    });
+                }
+
+                // Field 3: original line
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 original_line += delta;
                 pos += consumed;
 
+                // Reject 3-field segments (only 1, 4, or 5 are valid per ECMA-426)
+                if pos >= len || bytes[pos] == b',' || bytes[pos] == b';' {
+                    return Err(DecodeError::InvalidSegmentLength {
+                        fields: 3,
+                        offset: pos,
+                    });
+                }
+
+                // Field 4: original column
                 let (delta, consumed) = vlq_decode(bytes, pos)?;
                 original_column += delta;
                 pos += consumed;

crates/codec/src/lib.rs

@@ -195,6 +195,8 @@ pub enum DecodeError {
     UnexpectedEof { offset: usize },
     /// A VLQ value exceeded the maximum representable range.
     VlqOverflow { offset: usize },
+    /// A segment has an invalid number of fields (only 1, 4, or 5 are valid per ECMA-426).
+    InvalidSegmentLength { fields: u8, offset: usize },
 }
 
 impl fmt::Display for DecodeError {
@@ -212,6 +214,12 @@ impl fmt::Display for DecodeError {
             Self::VlqOverflow { offset } => {
                 write!(f, "VLQ value overflow at offset {offset}")
             }
+            Self::InvalidSegmentLength { fields, offset } => {
+                write!(
+                    f,
+                    "invalid segment with {fields} fields at offset {offset} (expected 1, 4, or 5)"
+                )
+            }
         }
     }
 }
@@ -373,12 +381,42 @@ mod tests {
     }
 
     #[test]
-    fn decode_truncated_segment() {
-        // "AC" = two VLQ values (0, 1) — starts a 4-field segment but only has 2 values
+    fn decode_truncated_segment_two_fields() {
+        // "AC" = two VLQ values (0, 1) — 2-field segment is invalid per ECMA-426
         let err = decode("AC").unwrap_err();
         assert!(matches!(
             err,
-            DecodeError::UnexpectedEof { .. } | DecodeError::InvalidBase64 { .. }
+            DecodeError::InvalidSegmentLength { fields: 2, .. }
+        ));
+    }
+
+    #[test]
+    fn decode_truncated_segment_three_fields() {
+        // "ACA" = three VLQ values (0, 1, 0) — 3-field segment is invalid per ECMA-426
+        let err = decode("ACA").unwrap_err();
+        assert!(matches!(
+            err,
+            DecodeError::InvalidSegmentLength { fields: 3, .. }
+        ));
+    }
+
+    #[test]
+    fn decode_two_field_segment_followed_by_separator() {
+        // "AC,AAAA" — first segment has 2 fields, invalid
+        let err = decode("AC,AAAA").unwrap_err();
+        assert!(matches!(
+            err,
+            DecodeError::InvalidSegmentLength { fields: 2, .. }
+        ));
+    }
+
+    #[test]
+    fn decode_three_field_segment_followed_by_separator() {
+        // "ACA;AAAA" — first segment has 3 fields, invalid
+        let err = decode("ACA;AAAA").unwrap_err();
+        assert!(matches!(
+            err,
+            DecodeError::InvalidSegmentLength { fields: 3, .. }
         ));
     }
 
@@ -532,6 +570,18 @@ mod tests {
         assert_eq!(err.to_string(), "VLQ value overflow at offset 10");
     }
 
+    #[test]
+    fn decode_error_display_invalid_segment_length() {
+        let err = DecodeError::InvalidSegmentLength {
+            fields: 2,
+            offset: 3,
+        };
+        assert_eq!(
+            err.to_string(),
+            "invalid segment with 2 fields at offset 3 (expected 1, 4, or 5)"
+        );
+    }
+
     // --- Decode edge case: 5-field segment with name ---
 
     #[test]