Fix WriteJsonScalar for programmatically-created JsonValue numerics

JsonValue.Create(T) preserves the exact CLR type it was created from,
so TryGetValue<T> does a strict type match against it - unlike a
JsonNode.Parse()-produced JsonValue (backed by a flexible JsonElement
that widens across numeric types). WriteJsonScalar only probed bool/
long/double/string, so a value created via JsonValue.Create(3) (int),
JsonValue.Create(3f) (float), or a plain `new JsonObject { ["x"] = 3 }`
assignment matched none of those checks and threw. Verified this
empirically (JsonValue.Create(3)/Create(3.5f)/Create((short)3) each
only satisfy TryGetValue of their own exact type) before fixing.

Now probes every CLR numeric type JsonValue.Create supports (int,
short, sbyte, byte, ushort, uint, ulong alongside the existing long;
float, decimal alongside the existing double) and widens to the
matching Write(long)/Write(double) overload. Added a regression test
building a JsonObject via plain property assignment (not
JsonNode.Parse) to cover this path, since the existing round-trip
test's JsonNode.Parse-backed values didn't exercise it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: shimat

src/OpenCvSharp/Modules/core/FileStorage.cs

@@ -606,8 +606,25 @@ public void Write(string name, JsonNode? value)
     private void WriteJsonScalar(string name, JsonValue value)
     {
         if (value.TryGetValue(out bool b)) { Write(name, b); return; }
+
+        // JsonValue.Create(T) preserves the exact CLR type it was created from - TryGetValue<T>
+        // does a strict type match for it, unlike a JsonNode.Parse()-produced JsonValue (backed by
+        // JsonElement, which freely widens across numeric types). So a value created via e.g.
+        // JsonValue.Create(3) (int) or a plain `new JsonObject { ["x"] = 3 }` assignment fails
+        // TryGetValue<long>/<double> and must be probed by its exact CLR type instead.
         if (value.TryGetValue(out long l)) { Write(name, l); return; }
+        if (value.TryGetValue(out int i)) { Write(name, (long)i); return; }
+        if (value.TryGetValue(out short sh)) { Write(name, (long)sh); return; }
+        if (value.TryGetValue(out sbyte sb)) { Write(name, (long)sb); return; }
+        if (value.TryGetValue(out byte by)) { Write(name, (long)by); return; }
+        if (value.TryGetValue(out ushort us)) { Write(name, (long)us); return; }
+        if (value.TryGetValue(out uint ui)) { Write(name, (long)ui); return; }
+        if (value.TryGetValue(out ulong ul)) { Write(name, unchecked((long)ul)); return; }
+
         if (value.TryGetValue(out double d)) { Write(name, d); return; }
+        if (value.TryGetValue(out float f)) { Write(name, (double)f); return; }
+        if (value.TryGetValue(out decimal dec)) { Write(name, (double)dec); return; }
+
         if (value.TryGetValue(out string? s)) { Write(name, s!); return; }
         throw new NotSupportedException($"Unsupported JsonValue underlying type for key '{name}'.");
     }

test/OpenCvSharp.Tests/core/FileStorageTest.cs

@@ -654,6 +654,46 @@ public void WriteJsonNodeNullThrows()
         Assert.Throws<NotSupportedException>(() => fs.Write("x", (JsonNode?)null));
     }
 
+    [Fact]
+    public void WriteJsonNodeHandlesProgrammaticNumericJsonValueTypes()
+    {
+        // Unlike a JsonNode.Parse()-produced value (backed by a flexible JsonElement),
+        // JsonValue.Create(T) - what a plain `new JsonObject { ["x"] = 3 }` assignment does under
+        // the hood - preserves the exact CLR type it was created from, so this must be covered
+        // independently of the JsonNode.Parse-based round-trip test above.
+        const string fileName = "fs_write_json_node_numeric_types.yml";
+
+        var obj = new JsonObject
+        {
+            ["intValue"] = 3,
+            ["longValue"] = 9_000_000_000L,
+            ["shortValue"] = (short)7,
+            ["byteValue"] = (byte)8,
+            ["floatValue"] = 1.5f,
+            ["doubleValue"] = 2.5,
+            ["boolValue"] = true,
+            ["stringValue"] = "text",
+        };
+
+        using (var fs = new FileStorage(fileName, FileStorage.Modes.Write))
+        {
+            foreach (var (key, value) in obj)
+                fs.Write(key, value);
+        }
+
+        using (var fs = new FileStorage(fileName, FileStorage.Modes.Read))
+        {
+            Assert.Equal(3, fs["intValue"]!.ReadInt());
+            Assert.Equal(9_000_000_000L, fs["longValue"]!.ReadInt64());
+            Assert.Equal(7, fs["shortValue"]!.ReadInt());
+            Assert.Equal(8, fs["byteValue"]!.ReadInt());
+            Assert.Equal(1.5, fs["floatValue"]!.ReadDouble(), 3);
+            Assert.Equal(2.5, fs["doubleValue"]!.ReadDouble(), 3);
+            Assert.True(fs["boolValue"]!.ReadInt() != 0);
+            Assert.Equal("text", fs["stringValue"]!.ReadString());
+        }
+    }
+
     [Fact]
     public void GetPathNavigatesNestedStructure()
     {