///|
/// Convert an `UPPER_SNAKE_CASE` or `snake_case` identifier to `PascalCase`.
pub fn to_pascal_case(raw : String) -> String {
  let chars = raw.to_array()
  let sb = StringBuilder()
  let mut cap_next = true
  for i = 0; i < chars.length(); i = i + 1 {
    let c = chars[i]
    if c == '_' || c == '-' || c == ' ' {
      cap_next = true
    } else if cap_next {
      if c >= 'a' && c <= 'z' {
        sb.write_char(Int32::unsafe_to_char(c.to_int() - 32))
      } else {
        sb.write_char(c)
      }
      cap_next = false
    } else if c >= 'A' && c <= 'Z' {
      sb.write_char(Int32::unsafe_to_char(c.to_int() + 32))
    } else {
      sb.write_char(c)
    }
  }
  let res = sb.to_string()
  let res_chars = res.to_array()
  if res_chars.length() > 0 && res_chars[0] >= '0' && res_chars[0] <= '9' {
    "V" + res
  } else if res == "" {
    "Unnamed"
  } else {
    res
  }
}

///|
/// Ensure generated enum or message struct names do not collide with core protocol types
/// or standard library trait/type identifiers (such as `Debug` from MAVLink `DEBUG` #254).
pub fn sanitize_type_name(pascal_name : String) -> String {
  match pascal_name {
    "MavFrame" => "MavCoordFrame"
    "MavHeader" => "MavMsgHeader"
    "MavError" => "MavMsgError"
    "MavSignature" => "MavMsgSignature"
    "MavMessage" => "MavMsgPayload"
    "Debug" => "MavDebug"
    "Eq" => "MavEq"
    "Show" => "MavShow"
    "Compare" => "MavCompare"
    "Hash" => "MavHash"
    "Default" => "MavDefault"
    "Bytes" => "MavBytes"
    "String" => "MavString"
    "Result" => "MavResultType"
    "Option" => "MavOption"
    _ => pascal_name
  }
}

///|
/// Sanitize a MAVLink XML field name so that MoonBit reserved keywords (such as `type`)
/// become valid struct field identifiers.
pub fn sanitize_field_name(name : String) -> String {
  match name {
    "type" => "mav_type"
    "match" => "mav_match"
    "fn" => "mav_fn"
    "let" => "mav_let"
    "struct" => "mav_struct"
    "enum" => "mav_enum"
    "pub" => "mav_pub"
    "priv" => "mav_priv"
    "test" => "mav_test"
    "in" => "mav_in"
    "is" => "mav_is"
    _ => name
  }
}

///|
/// Convert an enum entry name into a clean `PascalCase` variant name by stripping
/// a redundant `ENUM_NAME_` prefix when present.
pub fn enum_entry_variant_name(
  enum_name : String,
  entry_name : String,
) -> String {
  let prefix = enum_name + "_"
  let e_chars = entry_name.to_array()
  let p_chars = prefix.to_array()
  if e_chars.length() > p_chars.length() {
    let mut matches = true
    for i = 0; i < p_chars.length(); i = i + 1 {
      if e_chars[i] != p_chars[i] {
        matches = false
        break
      }
    }
    if matches {
      let rest_sb = StringBuilder()
      for i = p_chars.length(); i < e_chars.length(); i = i + 1 {
        rest_sb.write_char(e_chars[i])
      }
      return to_pascal_case(rest_sb.to_string())
    }
  }
  to_pascal_case(entry_name)
}

///|
/// Map a `MavPrimitiveType` to its MoonBit scalar type name.
pub fn primitive_moonbit_type(prim : MavPrimitiveType) -> String {
  match prim {
    UInt8 | Char => "Byte"
    Int8 | Int16 | Int32 => "Int"
    UInt16 | UInt32 => "UInt"
    UInt64 => "UInt64"
    Int64 => "Int64"
    Float32 => "Float"
    Float64 => "Double"
  }
}

///|
/// Map a `MavFieldType` to its idiomatic MoonBit type annotation.
pub fn field_moonbit_type(ft : MavFieldType) -> String {
  match ft {
    Scalar(prim, _) => primitive_moonbit_type(prim)
    FixedArrayType(Char, _) => "String"
    FixedArrayType(prim, _) =>
      "FixedArray[" + primitive_moonbit_type(prim) + "]"
  }
}

///|
fn default_scalar_expr(prim : MavPrimitiveType) -> String {
  match prim {
    UInt8 | Char => "b'\\x00'"
    Int8 | Int16 | Int32 => "0"
    UInt16 | UInt32 => "0U"
    UInt64 => "0UL"
    Int64 => "0L"
    Float32 => "(0.0 : Float)"
    Float64 => "0.0"
  }
}

///|
fn write_scalar_method(prim : MavPrimitiveType) -> String {
  match prim {
    UInt8 | Char => "write_uint8"
    Int8 => "write_int8"
    UInt16 => "write_uint16"
    Int16 => "write_int16"
    UInt32 => "write_uint32"
    Int32 => "write_int32"
    UInt64 => "write_uint64"
    Int64 => "write_int64"
    Float32 => "write_float"
    Float64 => "write_double"
  }
}

///|
fn read_scalar_method(prim : MavPrimitiveType) -> String {
  match prim {
    UInt8 | Char => "read_uint8"
    Int8 => "read_int8"
    UInt16 => "read_uint16"
    Int16 => "read_int16"
    UInt32 => "read_uint32"
    Int32 => "read_int32"
    UInt64 => "read_uint64"
    Int64 => "read_int64"
    Float32 => "read_float"
    Float64 => "read_double"
  }
}

///|
fn uint_to_dec(v : UInt32) -> String {
  if v == 0U {
    return "0"
  }
  let digits : Array[Char] = []
  let mut cur = v
  while cur > 0U {
    let rem = (cur % 10U).reinterpret_as_int()
    digits.push(Int32::unsafe_to_char('0'.to_int() + rem))
    cur = cur / 10U
  }
  let sb = StringBuilder()
  for i = digits.length() - 1; i >= 0; i = i - 1 {
    sb.write_char(digits[i])
  }
  sb.to_string()
}

///|
fn int_to_dec(v : Int32) -> String {
  if v < 0 {
    "-" + uint_to_dec((-v).reinterpret_as_uint())
  } else {
    uint_to_dec(v.reinterpret_as_uint())
  }
}

///|
fn byte_to_hex_literal(b : Byte) -> String {
  let hex = "0123456789ABCDEF".to_array()
  let u = b.to_int() & 0xFF
  let hi = hex[(u >> 4) & 0x0F]
  let lo = hex[u & 0x0F]
  let sb = StringBuilder()
  sb.write_string("b'\\x")
  sb.write_char(hi)
  sb.write_char(lo)
  sb.write_char('\'')
  sb.to_string()
}

///|
fn single_line_doc(text : String) -> String {
  let chars = text.to_array()
  let sb = StringBuilder()
  let mut prev_space = false
  for i = 0; i < chars.length(); i = i + 1 {
    let c = chars[i]
    if c == '\r' || c == '\n' || c == '\t' || c == ' ' {
      if !prev_space {
        sb.write_char(' ')
        prev_space = true
      }
    } else {
      sb.write_char(c)
      prev_space = false
    }
  }
  trim_string(sb.to_string())
}

///|
/// Generate complete, self-contained MoonBit source code (`.mbt`) for a `DialectSchema`,
/// including strongly typed enums, message structs, wire-reordered payload encoders/decoders,
/// `CRC_EXTRA` lookup table, and top-level `MavMessage` frame router.
pub fn generate_moonbit_code(schema : DialectSchema) -> String {
  let sb = StringBuilder()
  sb.write_string(
    "// ============================================================================\n",
  )
  sb.write_string(
    "// AUTO-GENERATED BY lycvvt/mavlink XML Code Generator — DO NOT EDIT MANUALLY\n",
  )
  sb.write_string(
    "// Dialect version: " +
    int_to_dec(schema.version) +
    ", dialect id: " +
    int_to_dec(schema.dialect) +
    "\n",
  )
  sb.write_string(
    "// ============================================================================\n\n",
  )

  // 1. Enums
  for en in schema.enums {
    if en.entries.length() == 0 {
      continue
    }
    let enum_pascal = sanitize_type_name(to_pascal_case(en.name))
    sb.write_string("///|\n")
    if en.description != "" {
      sb.write_string("/// " + single_line_doc(en.description) + "\n")
    } else {
      sb.write_string("/// MAVLink enum `" + en.name + "`.\n")
    }
    sb.write_string("pub(all) enum " + enum_pascal + " {\n")
    for entry in en.entries {
      let var_name = enum_entry_variant_name(en.name, entry.name)
      sb.write_string("  " + var_name + "\n")
    }
    sb.write_string("} derive(Eq, Debug)\n\n")
    sb.write_string("///|\n")
    sb.write_string(
      "pub extend " + enum_pascal + " with Eq::{not_equal, equal}\n\n",
    )
    sb.write_string("///|\n")
    sb.write_string(
      "pub extend " + enum_pascal + " with @debug.Debug::{to_repr}\n\n",
    )

    // to_uint
    sb.write_string("///|\n")
    sb.write_string(
      "/// Convert `" + enum_pascal + "` to its raw MAVLink numeric value.\n",
    )
    sb.write_string(
      "pub fn " +
      enum_pascal +
      "::to_uint(self : " +
      enum_pascal +
      ") -> UInt {\n",
    )
    sb.write_string("  match self {\n")
    for entry in en.entries {
      let var_name = enum_entry_variant_name(en.name, entry.name)
      sb.write_string(
        "    " + var_name + " => " + uint_to_dec(entry.value) + "U\n",
      )
    }
    sb.write_string("  }\n}\n\n")

    // from_uint
    sb.write_string("///|\n")
    sb.write_string(
      "/// Decode `" + enum_pascal + "` from its raw MAVLink numeric value.\n",
    )
    sb.write_string(
      "pub fn " +
      enum_pascal +
      "::from_uint(v : UInt) -> " +
      enum_pascal +
      "? {\n",
    )
    sb.write_string("  match v {\n")
    let seen_vals : Array[UInt32] = []
    for entry in en.entries {
      let mut dup = false
      for sv in seen_vals {
        if sv == entry.value {
          dup = true
          break
        }
      }
      if !dup {
        seen_vals.push(entry.value)
        let var_name = enum_entry_variant_name(en.name, entry.name)
        sb.write_string(
          "    " + uint_to_dec(entry.value) + "U => Some(" + var_name + ")\n",
        )
      }
    }
    sb.write_string("    _ => None\n  }\n}\n\n")
  }

  // 2. Messages
  for msg in schema.messages {
    let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
    let id_str = uint_to_dec(msg.id)
    let crc_hex = byte_to_hex_literal(msg.crc_extra)
    let crc_dec = int_to_dec(msg.crc_extra.to_int() & 0xFF)

    sb.write_string("///|\n")
    if msg.description != "" {
      sb.write_string("/// " + single_line_doc(msg.description) + "\n")
    }
    sb.write_string(
      "/// - MAVLink Message `" +
      msg.name +
      "` (ID: " +
      id_str +
      ", CRC_EXTRA: " +
      crc_dec +
      ", base_len: " +
      int_to_dec(msg.base_payload_len) +
      "B, max_len: " +
      int_to_dec(msg.max_payload_len) +
      "B)\n",
    )
    sb.write_string("pub(all) struct " + msg_pascal + " {\n")
    for f in msg.fields {
      let fname = sanitize_field_name(f.name)
      let ftype = field_moonbit_type(f.parsed_type)
      sb.write_string("  " + fname + " : " + ftype + "\n")
    }
    sb.write_string("} derive(Eq, Debug)\n\n")
    sb.write_string("///|\n")
    sb.write_string(
      "pub extend " + msg_pascal + " with Eq::{not_equal, equal}\n\n",
    )
    sb.write_string("///|\n")
    sb.write_string(
      "pub extend " + msg_pascal + " with @debug.Debug::{to_repr}\n\n",
    )

    // Metadata helpers
    sb.write_string("///|\n")
    sb.write_string("pub fn " + msg_pascal + "::msg_id() -> UInt {\n")
    sb.write_string("  " + id_str + "U\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("pub fn " + msg_pascal + "::crc_extra() -> Byte {\n")
    sb.write_string("  " + crc_hex + "\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("pub fn " + msg_pascal + "::base_payload_len() -> Int {\n")
    sb.write_string("  " + int_to_dec(msg.base_payload_len) + "\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("pub fn " + msg_pascal + "::max_payload_len() -> Int {\n")
    sb.write_string("  " + int_to_dec(msg.max_payload_len) + "\n}\n\n")

    // encode_payload
    sb.write_string("///|\n")
    sb.write_string(
      "/// Serialize `" +
      msg_pascal +
      "` into wire-ordered little-endian payload bytes.\n",
    )
    sb.write_string(
      "pub fn " +
      msg_pascal +
      "::encode_payload(self : " +
      msg_pascal +
      ", v2~ : Bool = true) -> Bytes {\n",
    )
    sb.write_string(
      "  let writer_ = PayloadWriter::new(capacity=" +
      int_to_dec(msg.max_payload_len) +
      ")\n",
    )

    let mut has_ext = false
    for wf in msg.wire_ordered_fields {
      if wf.is_extension && !has_ext {
        has_ext = true
        sb.write_string("  if v2 {\n")
      }
      let indent = if wf.is_extension { "    " } else { "  " }
      let fname = sanitize_field_name(wf.name)
      match wf.parsed_type {
        Scalar(prim, _) =>
          sb.write_string(
            indent +
            "writer_." +
            write_scalar_method(prim) +
            "(self." +
            fname +
            ")\n",
          )
        FixedArrayType(Char, len) =>
          sb.write_string(
            indent +
            "writer_.write_char_array(self." +
            fname +
            ", " +
            int_to_dec(len) +
            ")\n",
          )
        FixedArrayType(prim, len) => {
          sb.write_string(
            indent +
            "for idx_ = 0; idx_ < " +
            int_to_dec(len) +
            "; idx_ = idx_ + 1 {\n",
          )
          sb.write_string(
            indent +
            "  let elem_ = if idx_ < self." +
            fname +
            ".length() { self." +
            fname +
            "[idx_] } else { " +
            default_scalar_expr(prim) +
            " }\n",
          )
          sb.write_string(
            indent + "  writer_." + write_scalar_method(prim) + "(elem_)\n",
          )
          sb.write_string(indent + "}\n")
        }
      }
    }
    if has_ext {
      sb.write_string("  }\n")
    }
    sb.write_string("  writer_.to_wire_bytes(truncate_zeros=v2)\n}\n\n")

    // decode_payload
    sb.write_string("///|\n")
    sb.write_string(
      "/// Deserialize `" +
      msg_pascal +
      "` from wire-ordered little-endian payload bytes.\n",
    )
    sb.write_string(
      "pub fn " +
      msg_pascal +
      "::decode_payload(payload_ : Bytes, v2~ : Bool = true) -> Result[" +
      msg_pascal +
      ", MavError] {\n",
    )
    sb.write_string(
      "  let reader_ = PayloadReader::new(payload_, zero_extend=v2)\n",
    )
    let mut in_decode_ext = false
    for wf in msg.wire_ordered_fields {
      if wf.is_extension && !in_decode_ext {
        in_decode_ext = true
        sb.write_string("  reader_.zero_extend = true\n")
      }
      let fname = sanitize_field_name(wf.name)
      match wf.parsed_type {
        Scalar(prim, _) => {
          sb.write_string(
            "  let " +
            fname +
            " = match reader_." +
            read_scalar_method(prim) +
            "() {\n",
          )
          sb.write_string("    Ok(v) => v\n    Err(e) => return Err(e)\n  }\n")
        }
        FixedArrayType(Char, len) => {
          sb.write_string(
            "  let " +
            fname +
            " = match reader_.read_char_array(" +
            int_to_dec(len) +
            ") {\n",
          )
          sb.write_string("    Ok(v) => v\n    Err(e) => return Err(e)\n  }\n")
        }
        FixedArrayType(prim, len) => {
          sb.write_string(
            "  let " +
            fname +
            " = FixedArray::make(" +
            int_to_dec(len) +
            ", " +
            default_scalar_expr(prim) +
            ")\n",
          )
          sb.write_string(
            "  for idx_ = 0; idx_ < " +
            int_to_dec(len) +
            "; idx_ = idx_ + 1 {\n",
          )
          sb.write_string(
            "    match reader_." + read_scalar_method(prim) + "() {\n",
          )
          sb.write_string("      Ok(v) => " + fname + "[idx_] = v\n")
          sb.write_string("      Err(e) => return Err(e)\n    }\n  }\n")
        }
      }
    }
    sb.write_string("  Ok({\n")
    for f in msg.fields {
      let fname = sanitize_field_name(f.name)
      sb.write_string("    " + fname + ",\n")
    }
    sb.write_string("  })\n}\n\n")
  }

  // 3. Top-level MavMessage router & CRC_EXTRA table
  if schema.messages.length() > 0 {
    sb.write_string("///|\n")
    sb.write_string(
      "/// Look up the precomputed `CRC_EXTRA` byte for a known MAVLink message ID.\n",
    )
    sb.write_string(
      "pub fn lookup_message_crc_extra(msgid : UInt) -> Byte? {\n",
    )
    sb.write_string("  match msgid {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string(
        "    " +
        uint_to_dec(msg.id) +
        "U => Some(" +
        msg_pascal +
        "::crc_extra())\n",
      )
    }
    sb.write_string("    _ => None\n  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string(
      "/// Look up the official MAVLink message name for a known message ID.\n",
    )
    sb.write_string("pub fn lookup_message_name(msgid : UInt) -> String? {\n")
    sb.write_string("  match msgid {\n")
    for msg in schema.messages {
      sb.write_string(
        "    " + uint_to_dec(msg.id) + "U => Some(\"" + msg.name + "\")\n",
      )
    }
    sb.write_string("    _ => None\n  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("/// Unified top-level MAVLink dialect message sum type.\n")
    sb.write_string("pub(all) enum MavMessage {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string("  Msg" + msg_pascal + "(" + msg_pascal + ")\n")
    }
    sb.write_string("} derive(Eq, Debug)\n\n")
    sb.write_string("///|\n")
    sb.write_string("pub extend MavMessage with Eq::{not_equal, equal}\n\n")
    sb.write_string("///|\n")
    sb.write_string("pub extend MavMessage with @debug.Debug::{to_repr}\n\n")

    sb.write_string("///|\n")
    sb.write_string("/// Return the numeric MAVLink message ID of `self`.\n")
    sb.write_string("pub fn MavMessage::msg_id(self : MavMessage) -> UInt {\n")
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string(
        "    Msg" + msg_pascal + "(_) => " + uint_to_dec(msg.id) + "U\n",
      )
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("/// Return the official MAVLink message name of `self`.\n")
    sb.write_string(
      "pub fn MavMessage::msg_name(self : MavMessage) -> String {\n",
    )
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string("    Msg" + msg_pascal + "(_) => \"" + msg.name + "\"\n")
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("/// Return the `CRC_EXTRA` seed byte of `self`.\n")
    sb.write_string(
      "pub fn MavMessage::crc_extra(self : MavMessage) -> Byte {\n",
    )
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string(
        "    Msg" + msg_pascal + "(_) => " + msg_pascal + "::crc_extra()\n",
      )
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string(
      "/// Return the base (non-extension) payload length in bytes of `self`.\n",
    )
    sb.write_string(
      "pub fn MavMessage::base_payload_len(self : MavMessage) -> Int {\n",
    )
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string(
        "    Msg" +
        msg_pascal +
        "(_) => " +
        msg_pascal +
        "::base_payload_len()\n",
      )
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string(
      "/// Return the maximum (v2 with extensions) payload length in bytes of `self`.\n",
    )
    sb.write_string(
      "pub fn MavMessage::max_payload_len(self : MavMessage) -> Int {\n",
    )
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string(
        "    Msg" +
        msg_pascal +
        "(_) => " +
        msg_pascal +
        "::max_payload_len()\n",
      )
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string("/// Encode `self` into a wire payload.\n")
    sb.write_string(
      "pub fn MavMessage::encode_payload(self : MavMessage, v2~ : Bool = true) -> Bytes {\n",
    )
    sb.write_string("  match self {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string("    Msg" + msg_pascal + "(m) => m.encode_payload(v2~)\n")
    }
    sb.write_string("  }\n}\n\n")

    sb.write_string("///|\n")
    sb.write_string(
      "/// Encode `self` into a complete MAVLink v1 or v2 wire frame.\n",
    )
    sb.write_string(
      "pub fn MavMessage::encode_to_frame(\n  self : MavMessage,\n  seq~ : Byte,\n  sysid~ : Byte,\n  compid~ : Byte,\n  version~ : ProtocolVersion = V2,\n  signing~ : SigningContext? = None,\n) -> Result[(Bytes, MavFrame), MavError] {\n",
    )
    sb.write_string("  let is_v2 = version == V2\n")
    sb.write_string("  let raw_payload = self.encode_payload(v2=is_v2)\n")
    sb.write_string("  let header : MavHeader = {\n")
    sb.write_string("    version,\n")
    sb.write_string("    incompat_flags: b'\\x00',\n")
    sb.write_string("    compat_flags: b'\\x00',\n")
    sb.write_string("    seq,\n")
    sb.write_string("    sysid,\n")
    sb.write_string("    compid,\n")
    sb.write_string("    msgid: self.msg_id(),\n")
    sb.write_string("  }\n")
    sb.write_string(
      "  encode_frame(header, raw_payload, self.crc_extra(), truncate_v2_zeros=is_v2, signing~)\n}\n\n",
    )

    sb.write_string("///|\n")
    sb.write_string("/// Decode a `MavMessage` from a verified `MavFrame`.\n")
    sb.write_string(
      "pub fn MavMessage::decode_from_frame(frame : MavFrame) -> Result[MavMessage, MavError] {\n",
    )
    sb.write_string("  let is_v2 = frame.header.version == V2\n")
    sb.write_string("  match frame.header.msgid {\n")
    for msg in schema.messages {
      let msg_pascal = sanitize_type_name(to_pascal_case(msg.name))
      sb.write_string("    " + uint_to_dec(msg.id) + "U =>\n")
      sb.write_string(
        "      match " +
        msg_pascal +
        "::decode_payload(frame.payload, v2=is_v2) {\n",
      )
      sb.write_string("        Ok(m) => Ok(Msg" + msg_pascal + "(m))\n")
      sb.write_string("        Err(e) => Err(e)\n      }\n")
    }
    sb.write_string("    other => Err(UnknownMessageId(other))\n  }\n}\n")
  }

  sb.to_string()
}

///|
/// Parse an official MAVLink XML string and generate MoonBit source code in one step.
pub fn generate_moonbit_from_xml(
  xml_text : String,
) -> Result[(DialectSchema, String), MavError] {
  match parse_dialect_xml(xml_text) {
    Ok(schema) => Ok((schema, generate_moonbit_code(schema)))
    Err(e) => Err(e)
  }
}

///|
/// Recursively parse a root MAVLink XML dialect and all transitive `` files,
/// then generate complete MoonBit source code for the unified dialect.
pub fn generate_moonbit_from_xml_with_includes(
  root_file_name : String,
  xml_resolver : (String) -> String?,
) -> Result[(DialectSchema, String), MavError] {
  match parse_dialect_xml_with_includes(root_file_name, xml_resolver) {
    Ok(schema) => Ok((schema, generate_moonbit_code(schema)))
    Err(e) => Err(e)
  }
}