codex1: tighten core serialization contract

Author: MatiasHiltunen

core-no-std-plan.md

@@ -121,6 +121,7 @@ Current semantics draft:
   - Comments between `:` and the value normalize to entry-prefix comments.
   - Simple lists and variants stay on one line when they are short and comment-free; multiline containers omit commas in canonical output.
   - On the compact owned `Value` core writer, unit variants may be bare only in root/value position; map-key variants stay explicit with `()`.
+  - On the compact owned `Value` and typed core writers, empty root maps stay explicit as `{}`, while non-empty root maps remain brace-less even when the first key is composite.
   - On the legacy owned `Value` formatter, unit variants collapse to quoted strings.
 - Exact roundtrip guarantees currently documented:
   - Formatter-core canonical output is idempotent on the tested subset of root maps/lists/values, variants, strings, comments, and composite-root-key shapes.
@@ -152,7 +153,7 @@ Tasks:
 - [ ] Keep identifiers, numbers, comments, and unescaped strings borrowed
 - [ ] Represent escaped strings as raw slice plus "needs decode" metadata
 - [ ] Avoid building owned `Value` trees on the critical path unless requested
-- [ ] Add tests that prove borrowed paths work across representative inputs
+- [x] Add tests that prove borrowed paths work across representative inputs
 
 Exit criteria:
 
@@ -455,3 +456,5 @@ Entries:
 - `2026-03-31 | codex1 | WS1/WS8 | Added a short semantics draft to the tracker and tightened the documented exact-roundtrip exclusions: legacy and core keyword map keys canonicalize to strings, legacy unit variants collapse to strings, and fuzz-contract comments now point at tested behavior | next semantics work is to finish the remaining unsupported/tolerated ambiguity list rather than leave it implied`
 - `2026-03-31 | codex1 | WS1/WS8 | Clarified that owned-Value 'exact roundtrip' means Value equality rather than source spelling or numeric storage identity, and marked the value-roundtrip fuzz contract task complete | next semantics work is to review whether any remaining exclusions still need to be promoted from implementation detail to documented non-guarantee`
 - `2026-03-31 | codex2 | WS7/WS9 | Added scripts/run_benchmark_baseline.sh and benchmark-data/README.md with a reproducible local baseline for bench_parse and bench_core_vs_serde at 477118a | next performance slice is release-size tracking or stronger benchmark automation`
+- `2026-03-31 | codex1 | WS1/WS3 | Aligned the compact owned/typed core writers with parser and formatter-core root-map semantics: empty root maps now stay explicit as '{}' and composite first keys no longer force outer braces; added direct regression coverage for both serializers and exact-roundtrip tests for the owned Value path | next semantics work is to review any remaining implementation-tolerated ambiguities that still are not either guaranteed or explicitly excluded`
+- `2026-03-31 | codex1 | WS2 | Added borrowed-slice parser tests in eon_core covering identifiers, numbers, raw escaped strings, and quoted variant heads, so the zero-copy contract is now enforced on representative common tokens | next zero-copy work is the actual allocation audit and deciding whether escaped-string metadata should become more explicit than the current raw-token model`

crates/eon/src/serde/core_serializer.rs

@@ -398,8 +398,10 @@ where
             ));
         }
 
-        if self.mode == MapMode::Explicit {
-            self.writer.write_char('}').map_err(fmt_error)?;
+        match self.mode {
+            MapMode::Explicit => self.writer.write_char('}').map_err(fmt_error)?,
+            MapMode::PendingRootMap => self.writer.write_str("{}").map_err(fmt_error)?,
+            MapMode::ImplicitRoot => {}
         }
 
         Ok(())
@@ -435,12 +437,7 @@ where
             MapMode::PendingRootMap => {
                 debug_assert!(self.first);
                 let rendered = serialize_fragment(key, Position::MapKey)?;
-                if rendered.starts_with('{') {
-                    self.writer.write_char('{').map_err(fmt_error)?;
-                    self.mode = MapMode::Explicit;
-                } else {
-                    self.mode = MapMode::ImplicitRoot;
-                }
+                self.mode = MapMode::ImplicitRoot;
                 self.writer.write_str(&rendered).map_err(fmt_error)?;
             }
             MapMode::Explicit | MapMode::ImplicitRoot => {

crates/eon/src/value_to_core.rs

@@ -87,11 +87,7 @@ where
 }
 
 fn root_map_can_be_implicit(map: &Map) -> bool {
-    let Some((first_key, _)) = map.iter().next() else {
-        return true;
-    };
-
-    !matches!(first_key, Value::Map(_))
+    !map.is_empty()
 }
 
 fn write_variant<W>(out: &mut W, variant: &Variant, position: Position) -> fmt::Result

crates/eon/tests/test_core_stringify.rs

@@ -65,3 +65,10 @@ fn test_core_stringify_quotes_non_identifier_unit_variants() {
 
     assert_eq!(value_to_string_with_core(&value), "\"kebab-case\"()");
 }
+
+#[test]
+fn test_core_stringify_keeps_empty_root_maps_explicit() {
+    let value = Value::Map(Map::new());
+
+    assert_eq!(value_to_string_with_core(&value), "{}");
+}

crates/eon/tests/test_core_typed_stringify.rs

@@ -53,3 +53,25 @@ fn test_typed_core_stringify_matches_value_core_for_root_map() {
     assert_eq!(direct, via_value);
     assert_eq!(direct, "alpha: 1, beta: 2");
 }
+
+#[test]
+fn test_typed_core_stringify_matches_value_core_for_composite_root_map_key() {
+    let document = BTreeMap::from([(BTreeMap::from([("nested".to_owned(), 1_u32)]), 2_u32)]);
+
+    let direct = experimental::to_string_with_core(&document).unwrap();
+    let via_value = to_value(&document).unwrap().to_string_with_core();
+
+    assert_eq!(direct, via_value);
+    assert_eq!(direct, "{nested: 1}: 2");
+}
+
+#[test]
+fn test_typed_core_stringify_keeps_empty_root_maps_explicit() {
+    let document = BTreeMap::<String, u32>::new();
+
+    let direct = experimental::to_string_with_core(&document).unwrap();
+    let via_value = to_value(&document).unwrap().to_string_with_core();
+
+    assert_eq!(direct, via_value);
+    assert_eq!(direct, "{}");
+}

crates/eon/tests/test_roundtrip_contract.rs

@@ -1,5 +1,30 @@
 use eon::{Map, Value, Variant, experimental};
 
+#[test]
+fn test_core_value_roundtrip_keeps_empty_root_maps_explicit() {
+    let original = Value::Map(Map::new());
+
+    let serialized = experimental::value_to_string_with_core(&original);
+    assert_eq!(serialized, "{}");
+
+    let parsed = experimental::value_from_str_with_core(&serialized).unwrap();
+    assert_eq!(parsed, original);
+}
+
+#[test]
+fn test_core_value_roundtrip_keeps_composite_root_map_keys_braceless() {
+    let original = Value::Map(Map::from_iter([(
+        Value::Map(Map::from_iter([(Value::from("nested"), Value::from(1))])),
+        Value::from(2),
+    )]));
+
+    let serialized = experimental::value_to_string_with_core(&original);
+    assert_eq!(serialized, "{nested: 1}: 2");
+
+    let parsed = experimental::value_from_str_with_core(&serialized).unwrap();
+    assert_eq!(parsed, original);
+}
+
 #[test]
 fn test_core_value_roundtrip_excludes_keyword_map_keys() {
     let original = Value::Map(Map::from_iter([

crates/eon/tests/test_security_regressions.rs

@@ -211,13 +211,13 @@ fn test_core_typed_stringify_quotes_keyword_variant_names() {
 }
 
 #[test]
-fn test_core_value_stringify_wraps_root_map_when_first_key_is_a_map() {
+fn test_core_value_stringify_keeps_root_map_with_first_map_key_braceless() {
     let key = Value::Map(Map::from_iter([(Value::from("nested"), Value::from(1))]));
     let value = Value::Map(Map::from_iter([(key, Value::from("safe"))]));
 
     let serialized = experimental::value_to_string_with_core(&value);
 
-    assert!(serialized.starts_with("{{"));
+    assert_eq!(serialized, "{nested: 1}: \"safe\"");
     let roundtripped = experimental::value_from_str_with_core(&serialized).unwrap();
     assert_eq!(roundtripped, value);
 }

crates/eon_core/src/parser.rs

@@ -595,10 +595,32 @@ impl<'a> EventSink<'a> for NoopSink {
 
 #[cfg(test)]
 mod tests {
-    use std::string::String;
+    use std::{string::String, vec::Vec};
 
     use super::NoopSink;
-    use crate::{Error, ErrorKind, EventWriter, ParseError, parse, parse_with_limit};
+    use crate::{
+        Error, ErrorKind, Event, EventSink, EventWriter, ParseError, Scalar, Span, SpannedEvent,
+        StringKind, VariantName, parse, parse_with_limit,
+    };
+
+    #[derive(Default)]
+    struct CollectSink<'a> {
+        events: Vec<SpannedEvent<'a>>,
+    }
+
+    impl<'a> EventSink<'a> for CollectSink<'a> {
+        type Error = core::convert::Infallible;
+
+        fn event(&mut self, event: SpannedEvent<'a>) -> core::result::Result<(), Self::Error> {
+            self.events.push(event);
+            Ok(())
+        }
+    }
+
+    fn assert_borrowed_slice(source: &str, span: Span, slice: &str) {
+        assert_eq!(slice, &source[span.start..span.end]);
+        assert_eq!(slice.as_ptr(), source[span.start..].as_ptr());
+    }
 
     #[test]
     fn parse_empty_document_as_implicit_map() {
@@ -670,6 +692,76 @@ mod tests {
         assert_eq!(out, "{nested: true}: answer");
     }
 
+    #[test]
+    fn parser_borrows_identifier_and_number_tokens_from_source() {
+        let source = "mode: EnumValue(42)";
+        let mut sink = CollectSink::default();
+        parse(source, &mut sink).unwrap();
+
+        let (identifier_span, identifier) = sink
+            .events
+            .iter()
+            .find_map(|event| match event.event {
+                Event::Scalar(Scalar::Identifier(identifier)) if identifier == "mode" => {
+                    Some((event.span, identifier))
+                }
+                _ => None,
+            })
+            .unwrap();
+        assert_borrowed_slice(source, identifier_span, identifier);
+
+        let (number_span, number) = sink
+            .events
+            .iter()
+            .find_map(|event| match event.event {
+                Event::Scalar(Scalar::Number(number)) => Some((event.span, number)),
+                _ => None,
+            })
+            .unwrap();
+        assert_eq!(number, "42");
+        assert_borrowed_slice(source, number_span, number);
+    }
+
+    #[test]
+    fn parser_borrows_raw_escaped_string_tokens_from_source() {
+        let source = "label: \"he\\nllo\"";
+        let mut sink = CollectSink::default();
+        parse(source, &mut sink).unwrap();
+
+        let (string_span, raw, kind) = sink
+            .events
+            .iter()
+            .find_map(|event| match event.event {
+                Event::Scalar(Scalar::String(token)) => Some((event.span, token.raw, token.kind)),
+                _ => None,
+            })
+            .unwrap();
+        assert_eq!(kind, StringKind::Basic);
+        assert_eq!(raw, "\"he\\nllo\"");
+        assert_borrowed_slice(source, string_span, raw);
+    }
+
+    #[test]
+    fn parser_borrows_quoted_variant_heads_from_source() {
+        let source = "mode: \"kebab-case\"()";
+        let mut sink = CollectSink::default();
+        parse(source, &mut sink).unwrap();
+
+        let (variant_span, raw, kind) = sink
+            .events
+            .iter()
+            .find_map(|event| match event.event {
+                Event::BeginVariant {
+                    name: VariantName::String(token),
+                } => Some((event.span, token.raw, token.kind)),
+                _ => None,
+            })
+            .unwrap();
+        assert_eq!(kind, StringKind::Basic);
+        assert_eq!(raw, "\"kebab-case\"");
+        assert_borrowed_slice(source, variant_span, raw);
+    }
+
     #[test]
     fn depth_limit_counts_root_containers_once() {
         parse_with_limit("[1]", NoopSink, 1).unwrap();