Bundle normalize: preserve YAML scalar style + type inference

NormalizeToJson now parses YAML via the YamlStream representation model so
each scalar's ScalarStyle is visible. Plain scalars get YAML 1.2
core-schema inference (true/false → bool, integer-looking → long,
float-looking → double, "null"/""/"~" → null); single/double-quoted /
literal / folded scalars stay JSON strings.

Fixes a chain of wasm load failures hit on real Tidemark data:
- bool/float/int fields were emitted as JSON strings ("true", "6.1", "1")
  → STJ couldn't deserialize into bool/float/int properties
- After adding inference, quoted strings like `AttachWhenEquals: "0"` got
  re-typed to JSON number 0 → STJ couldn't deserialize into string

Tests: 4 cases in BundleNormalizeToJsonTests covering plain inference,
quoted preservation, multi-dot strings (1.2.3 stays a string), and YAML
null forms. Full suite 723 / 723.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: penspanic

Datra.Tests/BundleNormalizeToJsonTests.cs

@@ -31,13 +31,90 @@ public void NormalizeToJson_ConvertsYamlFiles_AndPreservesJsonFiles()
             Assert.True(normalized.Files["Units.yaml"].TrimStart().StartsWith("["),
                 $"Expected JSON array, got: {normalized.Files["Units.yaml"]}");
             Assert.Contains("\"Id\"", normalized.Files["Units.yaml"]);
+            // Hp should be a JSON number, not a quoted string.
+            Assert.Contains("\"Hp\":10", normalized.Files["Units.yaml"]);
+            Assert.DoesNotContain("\"Hp\":\"10\"", normalized.Files["Units.yaml"]);
             // Original JSON pass-through verbatim.
             Assert.Equal("[{\"Id\":\"x\",\"Price\":1}]", normalized.Files["Item.json"]);
             // YAML path got a format override; JSON path did not.
             Assert.Equal(DataFormat.Json, normalized.FormatOverrides["Units.yaml"]);
             Assert.False(normalized.FormatOverrides.ContainsKey("Item.json"));
         }
 
+        [Fact]
+        public void NormalizeToJson_QuotedScalars_StayAsStrings()
+        {
+            // Quoted YAML scalars must survive as JSON strings even when their content
+            // looks numeric / boolean. Regression: TidemarkParticleParams.AttachWhenEquals
+            // is `string`, and Effects.yaml writes it as `AttachWhenEquals: "0"`.
+            var bundle = new DatraRawBundle
+            {
+                Files =
+                {
+                    ["Sample.yaml"] =
+                        "- Quoted: \"0\"\n" +
+                        "  SingleQuoted: '5'\n" +
+                        "  QuotedBool: \"true\"\n" +
+                        "  Plain: 0\n" +
+                        "  PlainBool: true\n",
+                },
+            };
+
+            var normalized = DatraBundleBuilder.NormalizeToJson(bundle);
+            var s = normalized.Files["Sample.yaml"];
+
+            Assert.Contains("\"Quoted\":\"0\"", s);
+            Assert.Contains("\"SingleQuoted\":\"5\"", s);
+            Assert.Contains("\"QuotedBool\":\"true\"", s);
+            // Plain scalars still infer normally.
+            Assert.Contains("\"Plain\":0", s);
+            Assert.Contains("\"PlainBool\":true", s);
+        }
+
+        [Fact]
+        public void NormalizeToJson_InfersScalarTypes_PerYamlCoreSchema()
+        {
+            // Cover: bool / int / float / negative / null forms / string preservation.
+            var bundle = new DatraRawBundle
+            {
+                Files =
+                {
+                    ["Sample.yaml"] =
+                        "Enabled: true\n" +
+                        "Disabled: False\n" +
+                        "Count: 42\n" +
+                        "Negative: -7\n" +
+                        "Ratio: 3.5\n" +
+                        "Tiny: -0.25\n" +
+                        "Sci: 1.5e3\n" +
+                        "Empty: \n" +
+                        "Null1: null\n" +
+                        "Tilde: ~\n" +
+                        "Name: hero_a\n" +
+                        "VersionLike: 1.2.3\n",
+                },
+            };
+
+            var normalized = DatraBundleBuilder.NormalizeToJson(bundle);
+            var s = normalized.Files["Sample.yaml"];
+
+            Assert.Contains("\"Enabled\":true", s);
+            Assert.Contains("\"Disabled\":false", s);
+            Assert.Contains("\"Count\":42", s);
+            Assert.Contains("\"Negative\":-7", s);
+            Assert.Contains("\"Ratio\":3.5", s);
+            Assert.Contains("\"Tiny\":-0.25", s);
+            Assert.Contains("\"Sci\":1500", s); // 1.5e3 normalized
+            // YAML empty / null / ~ → JSON null
+            Assert.Contains("\"Empty\":null", s);
+            Assert.Contains("\"Null1\":null", s);
+            Assert.Contains("\"Tilde\":null", s);
+            // String-typed values stay quoted.
+            Assert.Contains("\"Name\":\"hero_a\"", s);
+            // Multi-dot scalar must stay a string (not a float).
+            Assert.Contains("\"VersionLike\":\"1.2.3\"", s);
+        }
+
         [Fact]
         public async Task BundledRawDataProvider_DispatchesJsonSerializer_ForNormalizedYamlPath()
         {

Datra/Bundles/DatraBundleBuilder.cs

@@ -1,12 +1,17 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using Datra.Attributes;
 using Datra.Utilities;
+using YamlDotNet.Core;
+using YamlDotNet.RepresentationModel;
 using YamlDotNet.Serialization;
 
 namespace Datra.Bundles
@@ -63,7 +68,6 @@ public static DatraRawBundle NormalizeToJson(DatraRawBundle source)
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (source.Files == null) throw new ArgumentException("Source bundle has no Files.", nameof(source));
 
-            var yamlDeserializer = new DeserializerBuilder().Build();
             var jsonOptions = new JsonSerializerOptions { WriteIndented = false };
 
             var outFiles = new Dictionary<string, string>(source.Files.Count, StringComparer.Ordinal);
@@ -77,12 +81,19 @@ public static DatraRawBundle NormalizeToJson(DatraRawBundle source)
 
                 if (fmt == DataFormat.Yaml)
                 {
-                    // YAML → opaque object graph → JSON via STJ. The runtime serializer
-                    // re-parses this content with its proper [TableData] type info,
-                    // so we only need a structurally faithful conversion here.
+                    // YAML → JSON via the YamlStream representation model so we can
+                    // see each scalar's ScalarStyle: plain scalars are type-inferred
+                    // per the YAML 1.2 core schema, but quoted ones (`"0"`, `'true'`)
+                    // stay as JSON strings — matching the author's intent.
                     using var reader = new StringReader(content);
-                    var graph = yamlDeserializer.Deserialize(reader);
-                    var jsonContent = JsonSerializer.Serialize(graph, jsonOptions);
+                    var yamlStream = new YamlStream();
+                    yamlStream.Load(reader);
+                    JsonNode? node = null;
+                    if (yamlStream.Documents.Count > 0)
+                    {
+                        node = ConvertYamlNodeToJsonNode(yamlStream.Documents[0].RootNode);
+                    }
+                    var jsonContent = node?.ToJsonString(jsonOptions) ?? "null";
                     outFiles[path] = jsonContent;
                     overrides[path] = DataFormat.Json;
                 }
@@ -102,6 +113,92 @@ public static DatraRawBundle NormalizeToJson(DatraRawBundle source)
             return bundle;
         }
 
+        /// <summary>
+        /// Convert a <see cref="YamlNode"/> tree to a <see cref="JsonNode"/> tree.
+        /// Scalar typing follows YAML 1.2 core schema for plain (unquoted) scalars;
+        /// single/double-quoted scalars are always emitted as JSON strings so
+        /// authored quoting (e.g. <c>AttachWhenEquals: "0"</c>) survives round-trip.
+        /// </summary>
+        private static JsonNode? ConvertYamlNodeToJsonNode(YamlNode yaml)
+        {
+            switch (yaml)
+            {
+                case YamlMappingNode map:
+                {
+                    var obj = new JsonObject();
+                    foreach (var entry in map.Children)
+                    {
+                        var key = (entry.Key as YamlScalarNode)?.Value ?? entry.Key.ToString();
+                        obj[key ?? string.Empty] = ConvertYamlNodeToJsonNode(entry.Value);
+                    }
+                    return obj;
+                }
+                case YamlSequenceNode seq:
+                {
+                    var arr = new JsonArray();
+                    foreach (var child in seq.Children) arr.Add(ConvertYamlNodeToJsonNode(child));
+                    return arr;
+                }
+                case YamlScalarNode scalar:
+                    return ConvertYamlScalar(scalar);
+                default:
+                    return null;
+            }
+        }
+
+        private static JsonNode? ConvertYamlScalar(YamlScalarNode scalar)
+        {
+            var s = scalar.Value;
+            // Quoted scalars are always strings (preserves authored intent like `"0"`).
+            if (scalar.Style == ScalarStyle.SingleQuoted ||
+                scalar.Style == ScalarStyle.DoubleQuoted ||
+                scalar.Style == ScalarStyle.Literal ||
+                scalar.Style == ScalarStyle.Folded)
+            {
+                return JsonValue.Create(s ?? string.Empty);
+            }
+            // Plain scalars: apply YAML 1.2 core schema inference.
+            if (s is null) return null;
+            if (s.Length == 0 || s == "~" || s == "null" || s == "Null" || s == "NULL")
+                return null;
+            if (s == "true" || s == "True" || s == "TRUE") return JsonValue.Create(true);
+            if (s == "false" || s == "False" || s == "FALSE") return JsonValue.Create(false);
+            if (LooksLikeInteger(s) && long.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var i))
+                return JsonValue.Create(i);
+            if (LooksLikeFloat(s) && double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var d))
+                return JsonValue.Create(d);
+            return JsonValue.Create(s);
+        }
+
+        private static bool LooksLikeInteger(string s)
+        {
+            if (s.Length == 0) return false;
+            int start = (s[0] == '+' || s[0] == '-') ? 1 : 0;
+            if (start == s.Length) return false;
+            // Reject leading zeros for multi-digit integers (YAML core schema treats
+            // "010" as a string, not an int).
+            if (s.Length - start > 1 && s[start] == '0') return false;
+            for (int i = start; i < s.Length; i++)
+                if (s[i] < '0' || s[i] > '9') return false;
+            return true;
+        }
+
+        private static bool LooksLikeFloat(string s)
+        {
+            if (s.Length == 0) return false;
+            bool seenDigit = false, seenDotOrExp = false;
+            int i = (s[0] == '+' || s[0] == '-') ? 1 : 0;
+            for (; i < s.Length; i++)
+            {
+                var c = s[i];
+                if (c >= '0' && c <= '9') seenDigit = true;
+                else if (c == '.' || c == 'e' || c == 'E') seenDotOrExp = true;
+                else if (c == '+' || c == '-') { /* exponent sign — allow */ }
+                else return false;
+            }
+            return seenDigit && seenDotOrExp;
+        }
+
         public static string ComputeContentHash(IReadOnlyDictionary<string, string> files)
         {
             if (files == null) throw new ArgumentNullException(nameof(files));