Is MySQL 8.x's Explain JSON Format Working Properly?

Question

I've been trying to read MySQL 8.0.30 execution plans and I haven't been able to make heads or tails of it.

The testing query (see db<>fiddle ) in question is:

select *
from (
  select t.a from t join u on u.b = t.a and u.b >= 50
) x
left join (
  select v.c from v join w on w.d = v.c and v.c <= 500
) y on y.c <= x.a

First, I got the the "Tree Format" of it and it makes sense to me:

-> Left hashwhich join (no condition), extra conditions: (v.c <= t.a) (cost=8.06 rows=40)
    -> Inner hash join (t.a = u.b) (cost=1.30 rows=1)
        -> Table scan on t (cost=0.26 rows=3)
        -> Hash
            -> Filter: (u.b >= 50) (cost=0.65 rows=1)
                -> Table scan on u (cost=0.65 rows=4)
    -> Hash
        -> Filter: ((v.c <= 500) and (w.d = v.c)) (cost=3.81 rows=30)
            -> Inner hash join (no condition) (cost=3.81 rows=30)
                -> Table scan on w (cost=0.13 rows=6)
                -> Hash
                    -> Table scan on v (cost=0.56 rows=5)

Then, I got the "JSON Format" for the same query:

{
  "query_block": {
    "select_id": 1,
    "cost_info": {
      "query_cost": "6.47"
    },
    "nested_loop": [
      {
        "table": {
          "table_name": "u",
          "access_type": "ALL",
          "rows_examined_per_scan": 4,
          "rows_produced_per_join": 1,
          "filtered": "33.33",
          "cost_info": {
            "read_cost": "0.52",
            "eval_cost": "0.13",
            "prefix_cost": "0.65",
            "data_read_per_join": "10"
          },
          "used_columns": [
            "b"
          ],
          "attached_condition": "(`fiddle`.`u`.`b` >= 50)"
        }
      },
      {
        "table": {
          "table_name": "t",
          "access_type": "ALL",
          "rows_examined_per_scan": 3,
          "rows_produced_per_join": 1,
          "filtered": "33.33",
          "using_join_buffer": "hash join",
          "cost_info": {
            "read_cost": "0.25",
            "eval_cost": "0.13",
            "prefix_cost": "1.30",
            "data_read_per_join": "10"
          },
          "used_columns": [
            "a"
          ],
          "attached_condition": "(`fiddle`.`t`.`a` = `fiddle`.`u`.`b`)"
        }
      },
      {
        "table": {
          "table_name": "v",
          "access_type": "ALL",
          "rows_examined_per_scan": 5,
          "rows_produced_per_join": 6,
          "filtered": "100.00",
          "using_join_buffer": "hash join",
          "cost_info": {
            "read_cost": "0.25",
            "eval_cost": "0.67",
            "prefix_cost": "2.22",
            "data_read_per_join": "53"
          },
          "used_columns": [
            "c"
          ],
          "attached_condition": "<if>(is_not_null_compl(v..w), ((`fiddle`.`v`.`c` <= `fiddle`.`t`.`a`) and (`fiddle`.`v`.`c` <= 500)), true)"
        }
      },
      {
        "table": {
          "table_name": "w",
          "access_type": "ALL",
          "rows_examined_per_scan": 6,
          "rows_produced_per_join": 39,
          "filtered": "100.00",
          "using_join_buffer": "hash join",
          "cost_info": {
            "read_cost": "0.25",
            "eval_cost": "4.00",
            "prefix_cost": "6.47",
            "data_read_per_join": "319"
          },
          "used_columns": [
            "d"
          ],
          "attached_condition": "<if>(is_not_null_compl(v..w), (`fiddle`.`w`.`d` = `fiddle`.`v`.`c`), true)"
        }
      }
    ]
  }
}

Even though it's the same query, the plans look structurally different. In the first one I can see operators linked in a tree form, while in the JSON format they all look flattened at the same level -- inside a single "nested_loop" operator.

The first format (tree) clearly shows two execution branches , while the second format (JSON) shows a single flat execution sequence .

In short, who's telling the truth and who's lying?