JSON parse + stringify: json_parse / json_stringify via serde_json

Fourth piece of the Python-ergonomics catch-up. Wraps serde_json
(new workspace dep) behind two builtins covering the common Python
json module surface:

  json_parse(text) -> Value
    JSON null -> Value::Null
    JSON bool -> Value::Bool
    JSON number -> HInt (when representable as i64) or HFloat
    JSON string -> Value::String
    JSON array -> Value::Array
    JSON object -> Value::Dict (BTreeMap; keys lexicographically ordered)
    Recursive; throws on parse error.

  json_stringify(value, pretty?=false) -> string
    Inverse mapping. Pretty=1 enables 2-space indented multi-line
    output (matches Python json.dumps(indent=2)).
    Singularity / Function / Circuit values stringify to their
    display form (lossy by design — no clean JSON representation).
    NaN / Inf coerce to JSON null (JSON spec doesn't allow them).

Round-trip invariant: for any pure-data Value (no Function, no
Singularity), json_parse(json_stringify(v)) yields a structurally
equal Value. Numeric exactness is preserved within i64/f64 range.

Helpers added at module scope in interpreter.rs:
  - json_to_value(serde_json::Value) -> Value
  - value_to_json(&Value) -> serde_json::Value

Both pub(crate) so other interpreter sites (e.g. future Python-
JSON bridge work via py_embed) can reuse them.

Tests (examples/tests/test_json.omc — 17 tests, all pass):
  - Parse: int, float, string, bool, null, array (incl. empty, mixed
    types), object, nested object-in-array-in-object
  - Stringify: int, string (with quotes), array (compact), dict
    (alphabetically ordered keys)
  - Round-trip: flat array, deeply nested object with mixed types
  - Pretty-printing: indent=1 produces multi-line output

Cargo.toml: serde_json = \"1.0\" (workspace dep) added to omnimcode-core.

Regression: 8 exception + 10 f-string + 10 regex + 57 substrate +
70 builtins + 18 harmonic libs + 16 heal + 17 new JSON = 206 OMC
tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

Cargo.lock

@@ -0,0 +1,133 @@
+# Tests for json_parse / json_stringify.
+#
+# Round-trip invariants: parse(stringify(v)) == v for any pure-data
+# Value (HInt, HFloat, String, Bool, Null, Array, Dict). Functions
+# and Singularity values stringify to their display form (lossy).
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) {
+    if !cond { test_record_failure(msg); }
+}
+
+# ---- Primitive parsing ----
+
+fn test_parse_int() {
+    h v = json_parse("42");
+    assert_eq(v, 42, "int parses to HInt");
+}
+
+fn test_parse_float() {
+    h v = json_parse("3.14");
+    assert_true(v > 3.1, "float lower bound");
+    assert_true(v < 3.2, "float upper bound");
+}
+
+fn test_parse_string() {
+    h v = json_parse("\"hello\"");
+    assert_eq(v, "hello", "string parses");
+}
+
+fn test_parse_bool() {
+    assert_eq(json_parse("true"), true, "true parses");
+    assert_eq(json_parse("false"), false, "false parses");
+}
+
+fn test_parse_null() {
+    h v = json_parse("null");
+    assert_eq(v, null, "null parses");
+}
+
+# ---- Arrays ----
+
+fn test_parse_array() {
+    h v = json_parse("[1, 2, 3]");
+    assert_eq(arr_len(v), 3, "3-elem array");
+    assert_eq(arr_get(v, 0), 1, "first");
+    assert_eq(arr_get(v, 2), 3, "last");
+}
+
+fn test_parse_empty_array() {
+    h v = json_parse("[]");
+    assert_eq(arr_len(v), 0, "empty array");
+}
+
+fn test_parse_mixed_array() {
+    h v = json_parse("[1, \"two\", 3.5, true, null]");
+    assert_eq(arr_len(v), 5, "5 mixed types");
+    assert_eq(arr_get(v, 0), 1, "int");
+    assert_eq(arr_get(v, 1), "two", "string");
+    assert_eq(arr_get(v, 3), true, "bool");
+}
+
+# ---- Objects (dicts) ----
+
+fn test_parse_object() {
+    h v = json_parse("{\"name\": \"alice\", \"age\": 30}");
+    assert_eq(dict_get(v, "name"), "alice", "name field");
+    assert_eq(dict_get(v, "age"), 30, "age field");
+}
+
+fn test_parse_nested() {
+    h v = json_parse("{\"a\": [1, 2, {\"b\": 3}]}");
+    h a = dict_get(v, "a");
+    assert_eq(arr_len(a), 3, "outer array");
+    h inner = arr_get(a, 2);
+    assert_eq(dict_get(inner, "b"), 3, "nested b");
+}
+
+# ---- Stringify ----
+
+fn test_stringify_int() {
+    assert_eq(json_stringify(42), "42", "int stringifies");
+}
+
+fn test_stringify_string() {
+    assert_eq(json_stringify("hello"), "\"hello\"", "string with quotes");
+}
+
+fn test_stringify_array() {
+    h s = json_stringify([1, 2, 3]);
+    assert_eq(s, "[1,2,3]", "array stringifies (no spaces)");
+}
+
+fn test_stringify_dict() {
+    h d = dict_new();
+    dict_set(d, "x", 1);
+    dict_set(d, "y", 2);
+    # BTreeMap orders alphabetically — output is deterministic.
+    h s = json_stringify(d);
+    assert_eq(s, "{\"x\":1,\"y\":2}", "dict stringifies sorted");
+}
+
+# ---- Round-trip ----
+
+fn test_roundtrip_array() {
+    h v = [10, 20, 30];
+    h back = json_parse(json_stringify(v));
+    assert_eq(arr_len(back), 3, "len preserved");
+    assert_eq(arr_get(back, 1), 20, "values preserved");
+}
+
+fn test_roundtrip_nested() {
+    h d = dict_new();
+    dict_set(d, "users", ["alice", "bob"]);
+    dict_set(d, "count", 2);
+    h s = json_stringify(d);
+    h back = json_parse(s);
+    assert_eq(dict_get(back, "count"), 2, "count round-tripped");
+    h users = dict_get(back, "users");
+    assert_eq(arr_get(users, 1), "bob", "nested array round-tripped");
+}
+
+# ---- Pretty-printing ----
+
+fn test_pretty_print() {
+    h s = json_stringify([1, 2, 3], 1);
+    # Pretty output contains newlines.
+    assert_true(str_contains(s, "\n"), "pretty output has newlines");
+}

examples/tests/test_json.omc

@@ -15,6 +15,7 @@ path = "src/lib.rs"
 [dependencies]
 regex = "1.10"
 thiserror = "1.0"
+serde_json = "1.0"
 # Embedded CPython — required for the desktop standalone binary
 # (always-on py_import/py_call/etc.), optional for downstream
 # crates that target WASM or no_std where libpython can't link.

omnimcode-core/Cargo.toml

@@ -1915,6 +1915,7 @@ impl Interpreter {
             | "str_split_lines" | "str_count" | "str_is_empty"
             | "str_to_int" | "str_to_float" | "str_capitalize"
             | "re_match" | "re_find" | "re_find_all" | "re_replace" | "re_split"
+            | "json_parse" | "json_stringify"
             // Arrays
             | "arr_new" | "arr_from_range" | "arr_len" | "arr_get" | "arr_set"
             | "arr_push" | "arr_first" | "arr_last" | "arr_slice" | "arr_concat"
@@ -3031,6 +3032,40 @@ impl Interpreter {
             // Defaults to comma separator, no header skip. Pass an explicit
             // separator to handle TSV (sep="\t"), pipe-delim, etc. Pass
             // skip_header=1 to drop the first line.
+            // ---- JSON (via serde_json) -----------------------------
+            "json_parse" => {
+                // json_parse(text) -> Value (dict, array, string, int,
+                // float, bool, or Null). Throws on parse error.
+                if args.is_empty() {
+                    return Err("json_parse requires (text)".to_string());
+                }
+                let text = self.eval_expr(&args[0])?.to_display_string();
+                match serde_json::from_str::<serde_json::Value>(&text) {
+                    Ok(v) => Ok(json_to_value(v)),
+                    Err(e) => Err(format!("json_parse: {}", e)),
+                }
+            }
+            "json_stringify" => {
+                // json_stringify(value) -> string. Pretty-prints if a
+                // second arg is truthy (matches Python json.dumps(indent=2)).
+                if args.is_empty() {
+                    return Err("json_stringify requires (value, pretty?)".to_string());
+                }
+                let v = self.eval_expr(&args[0])?;
+                let jv = value_to_json(&v);
+                let pretty = if args.len() >= 2 {
+                    self.eval_expr(&args[1])?.to_int() != 0
+                } else { false };
+                let s = if pretty {
+                    serde_json::to_string_pretty(&jv)
+                } else {
+                    serde_json::to_string(&jv)
+                };
+                match s {
+                    Ok(out) => Ok(Value::String(out)),
+                    Err(e) => Err(format!("json_stringify: {}", e)),
+                }
+            }
             "csv_parse" => {
                 if args.is_empty() {
                     return Err("csv_parse requires (text, sep?, skip_header?)".to_string());
@@ -7495,6 +7530,63 @@ fn values_equal(a: &Value, b: &Value) -> bool {
 
 // Free function reused by quantize / quantization_ratio / mean_omni_weight.
 // Snap |n| to the nearest Fibonacci attractor, preserving sign.
+/// Convert a `serde_json::Value` into an OMC `Value`. JSON object →
+/// `Value::Dict`, JSON array → `Value::Array`, numbers split into
+/// `HInt` (when representable as i64) vs `HFloat` (everything else).
+pub(crate) fn json_to_value(j: serde_json::Value) -> Value {
+    match j {
+        serde_json::Value::Null => Value::Null,
+        serde_json::Value::Bool(b) => Value::Bool(b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() { Value::HInt(HInt::new(i)) }
+            else if let Some(f) = n.as_f64() { Value::HFloat(f) }
+            else { Value::HInt(HInt::new(0)) }
+        }
+        serde_json::Value::String(s) => Value::String(s),
+        serde_json::Value::Array(arr) => {
+            let items: Vec<Value> = arr.into_iter().map(json_to_value).collect();
+            Value::Array(HArray::from_vec(items))
+        }
+        serde_json::Value::Object(map) => {
+            let mut out = std::collections::BTreeMap::new();
+            for (k, v) in map {
+                out.insert(k, json_to_value(v));
+            }
+            Value::dict_from(out)
+        }
+    }
+}
+
+/// Convert an OMC `Value` back into a `serde_json::Value` for
+/// stringification. Singularity and Function values stringify to
+/// their display form (no clean JSON representation).
+pub(crate) fn value_to_json(v: &Value) -> serde_json::Value {
+    match v {
+        Value::Null => serde_json::Value::Null,
+        Value::Bool(b) => serde_json::Value::Bool(*b),
+        Value::HInt(h) => serde_json::json!(h.value),
+        Value::HFloat(f) => {
+            // NaN / Inf can't be represented in JSON — coerce to null.
+            if f.is_finite() { serde_json::json!(*f) } else { serde_json::Value::Null }
+        }
+        Value::String(s) => serde_json::Value::String(s.clone()),
+        Value::Array(arr) => {
+            let items: Vec<serde_json::Value> = arr.items.borrow().iter()
+                .map(value_to_json).collect();
+            serde_json::Value::Array(items)
+        }
+        Value::Dict(d) => {
+            let mut map = serde_json::Map::new();
+            for (k, vv) in d.borrow().iter() {
+                map.insert(k.clone(), value_to_json(vv));
+            }
+            serde_json::Value::Object(map)
+        }
+        // Singularity / Function / Circuit: fall back to display string.
+        other => serde_json::Value::String(other.to_display_string()),
+    }
+}
+
 pub(crate) fn fold_to_fibonacci_const(n: i64) -> i64 {
     // Substrate-routed via phi_pi_fib::fold_to_nearest_attractor.
     // Was: a 15-element local Fibonacci array + linear scan.
@@ -7855,6 +7947,7 @@ pub(crate) const HEAL_BUILTIN_NAMES: &[&str] = &[
     "str_split_lines", "str_count", "str_is_empty",
     "str_to_int", "str_to_float", "str_capitalize",
     "re_match", "re_find", "re_find_all", "re_replace", "re_split",
+    "json_parse", "json_stringify",
     // Arrays
     "arr_new", "arr_from_range", "arr_len", "arr_get", "arr_set",
     "arr_push", "arr_first", "arr_last", "arr_slice", "arr_concat",