♻️ migrate to core json

src-async/BitLoggerAsync_test.mbt

@@ -831,29 +831,29 @@ test "async json helpers export stable structured shapes" {
       flush=AsyncFlushPolicy::Batch,
     ),
   )
-  let config_obj = config_json.as_object().unwrap()
+  let config_obj = config_json.expect_json_object()
   inspect(
-    @json_parser.stringify(config_json),
+    config_json.stringify(),
     content="{\"max_pending\":8,\"max_batch\":3,\"linger_ms\":25,\"overflow\":\"DropOldest\",\"flush\":\"Batch\"}",
   )
   inspect(
-    config_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
+    config_obj.get("max_pending").unwrap().expect_json_number().to_int(),
     content="8",
   )
   inspect(
-    config_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
+    config_obj.get("max_batch").unwrap().expect_json_number().to_int(),
     content="3",
   )
   inspect(
-    config_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
+    config_obj.get("linger_ms").unwrap().expect_json_number().to_int(),
     content="25",
   )
   inspect(
-    config_obj.get("overflow").unwrap().as_string().unwrap(),
+    config_obj.get("overflow").unwrap().expect_json_string(),
     content="DropOldest",
   )
   inspect(
-    config_obj.get("flush").unwrap().as_string().unwrap(),
+    config_obj.get("flush").unwrap().expect_json_string(),
     content="Batch",
   )
 
@@ -874,85 +874,84 @@ test "async json helpers export stable structured shapes" {
       ),
     ),
   )
-  let build_obj = build_json.as_object().unwrap()
-  let logger_obj = build_obj.get("logger").unwrap().as_object().unwrap()
-  let sink_obj = logger_obj.get("sink").unwrap().as_object().unwrap()
+  let build_obj = build_json.expect_json_object()
+  let logger_obj = build_obj.get("logger").unwrap().expect_json_object()
+  let sink_obj = logger_obj.get("sink").unwrap().expect_json_object()
   let formatter_obj = sink_obj
     .get("text_formatter")
     .unwrap()
-    .as_object()
-    .unwrap()
-  let async_obj = build_obj.get("async_config").unwrap().as_object().unwrap()
+    .expect_json_object()
+  let async_obj = build_obj.get("async_config").unwrap().expect_json_object()
 
   inspect(
-    logger_obj.get("min_level").unwrap().as_string().unwrap(),
+    logger_obj.get("min_level").unwrap().expect_json_string(),
     content="WARN",
   )
   inspect(
-    logger_obj.get("target").unwrap().as_string().unwrap(),
+    logger_obj.get("target").unwrap().expect_json_string(),
     content="async.roundtrip",
   )
   inspect(
-    logger_obj.get("timestamp").unwrap().as_bool().unwrap(),
+    logger_obj.get("timestamp").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(logger_obj.get("queue") is None, content="true")
   inspect(
-    sink_obj.get("kind").unwrap().as_string().unwrap(),
+    sink_obj.get("kind").unwrap().expect_json_string(),
     content="text_console",
   )
-  inspect(sink_obj.get("path").unwrap().as_string().unwrap(), content="")
-  inspect(sink_obj.get("append").unwrap().as_bool().unwrap(), content="true")
+  inspect(sink_obj.get("path").unwrap().expect_json_string(), content="")
+  inspect(sink_obj.get("append").unwrap().expect_json_bool(), content="true")
   inspect(
-    sink_obj.get("auto_flush").unwrap().as_bool().unwrap(),
+    sink_obj.get("auto_flush").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("show_timestamp").unwrap().as_bool().unwrap(),
+    formatter_obj.get("show_timestamp").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("separator").unwrap().as_string().unwrap(),
+    formatter_obj.get("separator").unwrap().expect_json_string(),
     content=" ",
   )
   inspect(
-    formatter_obj.get("field_separator").unwrap().as_string().unwrap(),
+    formatter_obj.get("field_separator").unwrap().expect_json_string(),
     content=" ",
   )
   inspect(
-    formatter_obj.get("template").unwrap().as_string().unwrap(),
+    formatter_obj.get("template").unwrap().expect_json_string(),
     content="",
   )
   inspect(
-    formatter_obj.get("color_mode").unwrap().as_string().unwrap(),
+    formatter_obj.get("color_mode").unwrap().expect_json_string(),
     content="never",
   )
   inspect(
-    formatter_obj.get("color_support").unwrap().as_string().unwrap(),
+    formatter_obj.get("color_support").unwrap().expect_json_string(),
     content="truecolor",
   )
   inspect(
-    formatter_obj.get("style_markup").unwrap().as_string().unwrap(),
+    formatter_obj.get("style_markup").unwrap().expect_json_string(),
     content="full",
   )
   inspect(
-    async_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("max_pending").unwrap().expect_json_number().to_int(),
     content="2",
   )
   inspect(
-    async_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("max_batch").unwrap().expect_json_number().to_int(),
     content="5",
   )
   inspect(
-    async_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("linger_ms").unwrap().expect_json_number().to_int(),
     content="40",
   )
   inspect(
-    async_obj.get("overflow").unwrap().as_string().unwrap(),
+    async_obj.get("overflow").unwrap().expect_json_string(),
     content="DropNewest",
   )
   inspect(
-    async_obj.get("flush").unwrap().as_string().unwrap(),
+    async_obj.get("flush").unwrap().expect_json_string(),
     content="Shutdown",
   )
 }
@@ -961,103 +960,102 @@ test "async json helpers export stable structured shapes" {
 test "async build config json export materializes parsed omitted defaults" {
   let parsed = parse_async_logger_build_config_text("{}")
   let build_json = async_logger_build_config_to_json(parsed)
-  let build_obj = build_json.as_object().unwrap()
-  let logger_obj = build_obj.get("logger").unwrap().as_object().unwrap()
-  let sink_obj = logger_obj.get("sink").unwrap().as_object().unwrap()
+  let build_obj = build_json.expect_json_object()
+  let logger_obj = build_obj.get("logger").unwrap().expect_json_object()
+  let sink_obj = logger_obj.get("sink").unwrap().expect_json_object()
   let formatter_obj = sink_obj
     .get("text_formatter")
     .unwrap()
-    .as_object()
-    .unwrap()
-  let async_obj = build_obj.get("async_config").unwrap().as_object().unwrap()
+    .expect_json_object()
+  let async_obj = build_obj.get("async_config").unwrap().expect_json_object()
 
   inspect(
-    @json_parser.stringify(build_json),
+    build_json.stringify(),
     content="{\"logger\":{\"min_level\":\"INFO\",\"target\":\"\",\"timestamp\":false,\"sink\":{\"kind\":\"console\",\"path\":\"\",\"append\":true,\"auto_flush\":true,\"text_formatter\":{\"show_timestamp\":true,\"show_level\":true,\"show_target\":true,\"show_fields\":true,\"separator\":\" \",\"field_separator\":\" \",\"template\":\"\",\"color_mode\":\"never\",\"color_support\":\"truecolor\",\"style_markup\":\"full\",\"target_style_markup\":\"disabled\",\"fields_style_markup\":\"disabled\"}}},\"async_config\":{\"max_pending\":0,\"max_batch\":1,\"linger_ms\":0,\"overflow\":\"Blocking\",\"flush\":\"Never\"}}",
   )
   inspect(
-    logger_obj.get("min_level").unwrap().as_string().unwrap(),
+    logger_obj.get("min_level").unwrap().expect_json_string(),
     content="INFO",
   )
-  inspect(logger_obj.get("target").unwrap().as_string().unwrap(), content="")
+  inspect(logger_obj.get("target").unwrap().expect_json_string(), content="")
   inspect(
-    logger_obj.get("timestamp").unwrap().as_bool().unwrap(),
+    logger_obj.get("timestamp").unwrap().expect_json_bool(),
     content="false",
   )
   inspect(logger_obj.get("queue") is None, content="true")
-  inspect(sink_obj.get("kind").unwrap().as_string().unwrap(), content="console")
-  inspect(sink_obj.get("path").unwrap().as_string().unwrap(), content="")
-  inspect(sink_obj.get("append").unwrap().as_bool().unwrap(), content="true")
+  inspect(sink_obj.get("kind").unwrap().expect_json_string(), content="console")
+  inspect(sink_obj.get("path").unwrap().expect_json_string(), content="")
+  inspect(sink_obj.get("append").unwrap().expect_json_bool(), content="true")
   inspect(
-    sink_obj.get("auto_flush").unwrap().as_bool().unwrap(),
+    sink_obj.get("auto_flush").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("show_timestamp").unwrap().as_bool().unwrap(),
+    formatter_obj.get("show_timestamp").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("show_level").unwrap().as_bool().unwrap(),
+    formatter_obj.get("show_level").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("show_target").unwrap().as_bool().unwrap(),
+    formatter_obj.get("show_target").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("show_fields").unwrap().as_bool().unwrap(),
+    formatter_obj.get("show_fields").unwrap().expect_json_bool(),
     content="true",
   )
   inspect(
-    formatter_obj.get("separator").unwrap().as_string().unwrap(),
+    formatter_obj.get("separator").unwrap().expect_json_string(),
     content=" ",
   )
   inspect(
-    formatter_obj.get("field_separator").unwrap().as_string().unwrap(),
+    formatter_obj.get("field_separator").unwrap().expect_json_string(),
     content=" ",
   )
   inspect(
-    formatter_obj.get("template").unwrap().as_string().unwrap(),
+    formatter_obj.get("template").unwrap().expect_json_string(),
     content="",
   )
   inspect(
-    formatter_obj.get("color_mode").unwrap().as_string().unwrap(),
+    formatter_obj.get("color_mode").unwrap().expect_json_string(),
     content="never",
   )
   inspect(
-    formatter_obj.get("color_support").unwrap().as_string().unwrap(),
+    formatter_obj.get("color_support").unwrap().expect_json_string(),
     content="truecolor",
   )
   inspect(
-    formatter_obj.get("style_markup").unwrap().as_string().unwrap(),
+    formatter_obj.get("style_markup").unwrap().expect_json_string(),
     content="full",
   )
   inspect(
-    formatter_obj.get("target_style_markup").unwrap().as_string().unwrap(),
+    formatter_obj.get("target_style_markup").unwrap().expect_json_string(),
     content="disabled",
   )
   inspect(
-    formatter_obj.get("fields_style_markup").unwrap().as_string().unwrap(),
+    formatter_obj.get("fields_style_markup").unwrap().expect_json_string(),
     content="disabled",
   )
   inspect(formatter_obj.get("style_tags") is None, content="true")
   inspect(
-    async_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("max_pending").unwrap().expect_json_number().to_int(),
     content="0",
   )
   inspect(
-    async_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("max_batch").unwrap().expect_json_number().to_int(),
     content="1",
   )
   inspect(
-    async_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
+    async_obj.get("linger_ms").unwrap().expect_json_number().to_int(),
     content="0",
   )
   inspect(
-    async_obj.get("overflow").unwrap().as_string().unwrap(),
+    async_obj.get("overflow").unwrap().expect_json_string(),
     content="Blocking",
   )
-  inspect(async_obj.get("flush").unwrap().as_string().unwrap(), content="Never")
+  inspect(async_obj.get("flush").unwrap().expect_json_string(), content="Never")
 }
 
 ///|
@@ -1068,7 +1066,7 @@ test "async config parsers reject malformed input" {
   })() catch {
     err => err.to_string()
   }
-  inspect(invalid_json_error.contains("UnexpectedToken"), content="true")
+  inspect(invalid_json_error != "no error", content="true")
 
   let wrong_type_error = (fn() -> String raise {
     ignore(parse_async_logger_config_text("{\"max_pending\":\"many\"}"))
@@ -1144,7 +1142,7 @@ test "async runtime capability helpers stay consistent" {
   )
   inspect(state.background_worker == worker_supported, content="true")
   inspect(
-    @json_parser.stringify(async_runtime_state_to_json(state)),
+    async_runtime_state_to_json(state).stringify(),
     content=if worker_supported {
       "{\"mode\":\"native_worker\",\"background_worker\":true}"
     } else {
@@ -1225,7 +1223,7 @@ test "async logger state snapshot reflects current counters and runtime" {
     content="Shutdown",
   )
   inspect(
-    @json_parser.stringify(async_logger_state_to_json(state)),
+    async_logger_state_to_json(state).stringify(),
     content=if async_runtime_supports_background_worker() {
       "{\"runtime\":{\"mode\":\"native_worker\",\"background_worker\":true},\"phase\":\"ready\",\"pending_count\":0,\"dropped_count\":0,\"is_closed\":false,\"is_running\":false,\"has_failed\":false,\"backlog_retained\":false,\"can_rerun\":true,\"terminal\":false,\"last_error\":\"\",\"flush_policy\":\"Shutdown\"}"
     } else {

src-async/async_logger_shared.mbt

@@ -48,9 +48,7 @@ pub fn async_runtime_state() -> AsyncRuntimeState {
 }
 
 ///|
-pub fn async_runtime_state_to_json(
-  state : AsyncRuntimeState,
-) -> @json_parser.JsonValue {
+pub fn async_runtime_state_to_json(state : AsyncRuntimeState) -> Json {
   @utils.async_runtime_state_to_json(state)
 }
 
@@ -63,9 +61,7 @@ pub fn stringify_async_runtime_state(
 }
 
 ///|
-pub fn async_logger_state_to_json(
-  state : AsyncLoggerState,
-) -> @json_parser.JsonValue {
+pub fn async_logger_state_to_json(state : AsyncLoggerState) -> Json {
   @utils.async_logger_state_to_json(state)
 }
 
@@ -88,9 +84,7 @@ pub fn parse_async_logger_config_text(
 }
 
 ///|
-pub fn async_logger_config_to_json(
-  config : AsyncLoggerConfig,
-) -> @json_parser.JsonValue {
+pub fn async_logger_config_to_json(config : AsyncLoggerConfig) -> Json {
   @utils.async_logger_config_to_json(config)
 }
 
@@ -115,7 +109,7 @@ pub fn parse_async_logger_build_config_text(
 ///|
 pub fn async_logger_build_config_to_json(
   config : AsyncLoggerBuildConfig,
-) -> @json_parser.JsonValue {
+) -> Json {
   @utils.async_logger_build_config_to_json(config)
 }
 

src-async/json_test_helpers_test.mbt

@@ -0,0 +1,32 @@
+///|
+fn Json::expect_json_object(self : Json) -> Map[String, Json] {
+  match self {
+    Json::Object(value) => value
+    _ => abort("Expected JSON object")
+  }
+}
+
+///|
+fn Json::expect_json_number(self : Json) -> Double {
+  match self {
+    Json::Number(value, ..) => value
+    _ => abort("Expected JSON number")
+  }
+}
+
+///|
+fn Json::expect_json_string(self : Json) -> String {
+  match self {
+    Json::String(value) => value
+    _ => abort("Expected JSON string")
+  }
+}
+
+///|
+fn Json::expect_json_bool(self : Json) -> Bool {
+  match self {
+    Json::True => true
+    Json::False => false
+    _ => abort("Expected JSON bool")
+  }
+}

src-async/moon.pkg

@@ -1,7 +1,7 @@
 import {
   "Nanaloveyuki/BitLogger/src" @bitlogger,
   "Nanaloveyuki/BitLogger/src-async/utils",
-  "maria/json_parser",
+  "moonbitlang/core/json",
   "moonbitlang/async",
   "moonbitlang/async/aqueue",
   "moonbitlang/core/env",

src-async/pkg.generated.mbti

@@ -6,7 +6,6 @@ import {
   "Nanaloveyuki/BitLogger/src/core",
   "Nanaloveyuki/BitLogger/src/runtime",
   "Nanaloveyuki/BitLogger/src/sink_graph",
-  "maria/json_parser",
   "moonbitlang/async/aqueue",
   "moonbitlang/core/ref",
 }
@@ -14,11 +13,11 @@ import {
 // Values
 pub fn[S] async_logger(S, config? : @utils.AsyncLoggerConfig, min_level? : @core.Level, target? : String, flush? : (S) -> Unit raise) -> AsyncLogger[S]
 
-pub fn async_logger_build_config_to_json(@utils.AsyncLoggerBuildConfig) -> @json_parser.JsonValue
+pub fn async_logger_build_config_to_json(@utils.AsyncLoggerBuildConfig) -> Json
 
-pub fn async_logger_config_to_json(@utils.AsyncLoggerConfig) -> @json_parser.JsonValue
+pub fn async_logger_config_to_json(@utils.AsyncLoggerConfig) -> Json
 
-pub fn async_logger_state_to_json(@utils.AsyncLoggerState) -> @json_parser.JsonValue
+pub fn async_logger_state_to_json(@utils.AsyncLoggerState) -> Json
 
 pub fn async_runtime_mode() -> @utils.AsyncRuntimeMode
 
@@ -26,7 +25,7 @@ pub fn async_runtime_mode_label(@utils.AsyncRuntimeMode) -> String
 
 pub fn async_runtime_state() -> @utils.AsyncRuntimeState
 
-pub fn async_runtime_state_to_json(@utils.AsyncRuntimeState) -> @json_parser.JsonValue
+pub fn async_runtime_state_to_json(@utils.AsyncRuntimeState) -> Json
 
 pub fn async_runtime_supports_background_worker() -> Bool
 

src-async/utils/async_models.mbt

@@ -154,12 +154,10 @@ pub fn AsyncLoggerState::new(
 }
 
 ///|
-pub fn async_runtime_state_to_json(
-  state : AsyncRuntimeState,
-) -> @json_parser.JsonValue {
-  @json_parser.JsonValue::Object({
-    "mode": @json_parser.JsonValue::String(async_runtime_mode_label(state.mode)),
-    "background_worker": @json_parser.JsonValue::Bool(state.background_worker),
+pub fn async_runtime_state_to_json(state : AsyncRuntimeState) -> Json {
+  Json::object({
+    "mode": Json::string(async_runtime_mode_label(state.mode)),
+    "background_worker": Json::boolean(state.background_worker),
   })
 }
 
@@ -170,9 +168,9 @@ pub fn stringify_async_runtime_state(
 ) -> String {
   let value = async_runtime_state_to_json(state)
   if pretty {
-    @json_parser.stringify_pretty(value, 2)
+    value.stringify(indent=2)
   } else {
-    @json_parser.stringify(value)
+    value.stringify()
   }
 }
 
@@ -186,37 +184,25 @@ fn async_flush_policy_label(policy : AsyncFlushPolicy) -> String {
 }
 
 ///|
-fn async_logger_state_to_json_value(
-  state : AsyncLoggerState,
-) -> @json_parser.JsonValue {
-  @json_parser.JsonValue::Object({
+fn async_logger_state_to_json_value(state : AsyncLoggerState) -> Json {
+  Json::object({
     "runtime": async_runtime_state_to_json(state.runtime),
-    "phase": @json_parser.JsonValue::String(
-      async_lifecycle_phase_label(state.phase),
-    ),
-    "pending_count": @json_parser.JsonValue::Number(
-      state.pending_count.to_double(),
-    ),
-    "dropped_count": @json_parser.JsonValue::Number(
-      state.dropped_count.to_double(),
-    ),
-    "is_closed": @json_parser.JsonValue::Bool(state.is_closed),
-    "is_running": @json_parser.JsonValue::Bool(state.is_running),
-    "has_failed": @json_parser.JsonValue::Bool(state.has_failed),
-    "backlog_retained": @json_parser.JsonValue::Bool(state.backlog_retained),
-    "can_rerun": @json_parser.JsonValue::Bool(state.can_rerun),
-    "terminal": @json_parser.JsonValue::Bool(state.terminal),
-    "last_error": @json_parser.JsonValue::String(state.last_error),
-    "flush_policy": @json_parser.JsonValue::String(
-      async_flush_policy_label(state.flush_policy),
-    ),
+    "phase": Json::string(async_lifecycle_phase_label(state.phase)),
+    "pending_count": Json::number(state.pending_count.to_double()),
+    "dropped_count": Json::number(state.dropped_count.to_double()),
+    "is_closed": Json::boolean(state.is_closed),
+    "is_running": Json::boolean(state.is_running),
+    "has_failed": Json::boolean(state.has_failed),
+    "backlog_retained": Json::boolean(state.backlog_retained),
+    "can_rerun": Json::boolean(state.can_rerun),
+    "terminal": Json::boolean(state.terminal),
+    "last_error": Json::string(state.last_error),
+    "flush_policy": Json::string(async_flush_policy_label(state.flush_policy)),
   })
 }
 
 ///|
-pub fn async_logger_state_to_json(
-  state : AsyncLoggerState,
-) -> @json_parser.JsonValue {
+pub fn async_logger_state_to_json(state : AsyncLoggerState) -> Json {
   async_logger_state_to_json_value(state)
 }
 
@@ -227,9 +213,9 @@ pub fn stringify_async_logger_state(
 ) -> String {
   let value = async_logger_state_to_json_value(state)
   if pretty {
-    @json_parser.stringify_pretty(value, 2)
+    value.stringify(indent=2)
   } else {
-    @json_parser.stringify(value)
+    value.stringify()
   }
 }
 
@@ -293,53 +279,38 @@ fn parse_async_flush(name : String) -> AsyncFlushPolicy raise {
 pub fn parse_async_logger_config_text(
   input : String,
 ) -> AsyncLoggerConfig raise {
-  let root = @json_parser.parse(input)
-  let obj = match root.as_object() {
-    Some(obj) => obj
-    None => raise Failure::Failure("Expected object for async logger config")
+  let root = @json.parse(input)
+  let obj = match root {
+    Json::Object(obj) => obj
+    _ => raise Failure::Failure("Expected object for async logger config")
   }
   let max_pending = match obj.get("max_pending") {
-    Some(value) =>
-      match value.as_number() {
-        Some(number) => number.to_int()
-        None =>
-          raise Failure::Failure("Expected number at async_config.max_pending")
-      }
+    Some(Json::Number(number, ..)) => number.to_int()
+    Some(_) =>
+      raise Failure::Failure("Expected number at async_config.max_pending")
     None => 0
   }
   let overflow = match obj.get("overflow") {
-    Some(value) =>
-      match value.as_string() {
-        Some(text) => parse_async_overflow(text)
-        None =>
-          raise Failure::Failure("Expected string at async_config.overflow")
-      }
+    Some(Json::String(text)) => parse_async_overflow(text)
+    Some(_) =>
+      raise Failure::Failure("Expected string at async_config.overflow")
     None => AsyncOverflowPolicy::Blocking
   }
   let max_batch = match obj.get("max_batch") {
-    Some(value) =>
-      match value.as_number() {
-        Some(number) => number.to_int()
-        None =>
-          raise Failure::Failure("Expected number at async_config.max_batch")
-      }
+    Some(Json::Number(number, ..)) => number.to_int()
+    Some(_) =>
+      raise Failure::Failure("Expected number at async_config.max_batch")
     None => 1
   }
   let linger_ms = match obj.get("linger_ms") {
-    Some(value) =>
-      match value.as_number() {
-        Some(number) => number.to_int()
-        None =>
-          raise Failure::Failure("Expected number at async_config.linger_ms")
-      }
+    Some(Json::Number(number, ..)) => number.to_int()
+    Some(_) =>
+      raise Failure::Failure("Expected number at async_config.linger_ms")
     None => 0
   }
   let flush = match obj.get("flush") {
-    Some(value) =>
-      match value.as_string() {
-        Some(text) => parse_async_flush(text)
-        None => raise Failure::Failure("Expected string at async_config.flush")
-      }
+    Some(Json::String(text)) => parse_async_flush(text)
+    Some(_) => raise Failure::Failure("Expected string at async_config.flush")
     None => AsyncFlushPolicy::Never
   }
   AsyncLoggerConfig::new(
@@ -352,23 +323,19 @@ pub fn parse_async_logger_config_text(
 }
 
 ///|
-pub fn async_logger_config_to_json(
-  config : AsyncLoggerConfig,
-) -> @json_parser.JsonValue {
-  @json_parser.JsonValue::Object({
-    "max_pending": @json_parser.JsonValue::Number(
-      config.max_pending.to_double(),
-    ),
-    "max_batch": @json_parser.JsonValue::Number(config.max_batch.to_double()),
-    "linger_ms": @json_parser.JsonValue::Number(config.linger_ms.to_double()),
-    "overflow": @json_parser.JsonValue::String(
+pub fn async_logger_config_to_json(config : AsyncLoggerConfig) -> Json {
+  Json::object({
+    "max_pending": Json::number(config.max_pending.to_double()),
+    "max_batch": Json::number(config.max_batch.to_double()),
+    "linger_ms": Json::number(config.linger_ms.to_double()),
+    "overflow": Json::string(
       match config.overflow {
         AsyncOverflowPolicy::Blocking => "Blocking"
         AsyncOverflowPolicy::DropOldest => "DropOldest"
         AsyncOverflowPolicy::DropNewest => "DropNewest"
       },
     ),
-    "flush": @json_parser.JsonValue::String(
+    "flush": Json::string(
       match config.flush {
         AsyncFlushPolicy::Never => "Never"
         AsyncFlushPolicy::Batch => "Batch"
@@ -385,9 +352,9 @@ pub fn stringify_async_logger_config(
 ) -> String {
   let value = async_logger_config_to_json(config)
   if pretty {
-    @json_parser.stringify_pretty(value, 2)
+    value.stringify(indent=2)
   } else {
-    @json_parser.stringify(value)
+    value.stringify()
   }
 }
 
@@ -409,21 +376,20 @@ pub fn AsyncLoggerBuildConfig::new(
 pub fn parse_async_logger_build_config_text(
   input : String,
 ) -> AsyncLoggerBuildConfig raise {
-  let root = @json_parser.parse(input)
-  let obj = match root.as_object() {
-    Some(obj) => obj
-    None =>
+  let root = @json.parse(input)
+  let obj = match root {
+    Json::Object(obj) => obj
+    _ =>
       raise Failure::Failure(
         "Expected object at async logger build config root",
       )
   }
   let logger = match obj.get("logger") {
-    Some(value) =>
-      @bitlogger.parse_logger_config_text(@json_parser.stringify(value))
+    Some(value) => @bitlogger.parse_logger_config_text(value.stringify())
     None => @bitlogger.default_logger_config()
   }
   let async_config = match obj.get("async_config") {
-    Some(value) => parse_async_logger_config_text(@json_parser.stringify(value))
+    Some(value) => parse_async_logger_config_text(value.stringify())
     None => AsyncLoggerConfig::new()
   }
   AsyncLoggerBuildConfig::new(logger~, async_config~)
@@ -432,8 +398,8 @@ pub fn parse_async_logger_build_config_text(
 ///|
 pub fn async_logger_build_config_to_json(
   config : AsyncLoggerBuildConfig,
-) -> @json_parser.JsonValue {
-  @json_parser.JsonValue::Object({
+) -> Json {
+  Json::object({
     "logger": @bitlogger.logger_config_to_json(config.logger),
     "async_config": async_logger_config_to_json(config.async_config),
   })
@@ -446,8 +412,8 @@ pub fn stringify_async_logger_build_config(
 ) -> String {
   let value = async_logger_build_config_to_json(config)
   if pretty {
-    @json_parser.stringify_pretty(value, 2)
+    value.stringify(indent=2)
   } else {
-    @json_parser.stringify(value)
+    value.stringify()
   }
 }

src-async/utils/moon.pkg

@@ -1,4 +1,4 @@
 import {
   "Nanaloveyuki/BitLogger/src" @bitlogger,
-  "maria/json_parser",
+  "moonbitlang/core/json",
 }

src-async/utils/pkg.generated.mbti

@@ -3,19 +3,18 @@ package "Nanaloveyuki/BitLogger/src-async/utils"
 
 import {
   "Nanaloveyuki/BitLogger/src/config_model",
-  "maria/json_parser",
 }
 
 // Values
-pub fn async_logger_build_config_to_json(AsyncLoggerBuildConfig) -> @json_parser.JsonValue
+pub fn async_logger_build_config_to_json(AsyncLoggerBuildConfig) -> Json
 
-pub fn async_logger_config_to_json(AsyncLoggerConfig) -> @json_parser.JsonValue
+pub fn async_logger_config_to_json(AsyncLoggerConfig) -> Json
 
-pub fn async_logger_state_to_json(AsyncLoggerState) -> @json_parser.JsonValue
+pub fn async_logger_state_to_json(AsyncLoggerState) -> Json
 
 pub fn async_runtime_mode_label(AsyncRuntimeMode) -> String
 
-pub fn async_runtime_state_to_json(AsyncRuntimeState) -> @json_parser.JsonValue
+pub fn async_runtime_state_to_json(AsyncRuntimeState) -> Json
 
 pub fn compatibility_async_runtime_mode() -> AsyncRuntimeMode