anchor.diff:  query actually asks for those properties:
   
   ```
  -(defresolver `person-resolver
  +(pc/defresolver person-resolver [{:keys [database] :as env} {:keys [person/id]}]
     {::pc/input #{:person/id}
      ::pc/output [:person/first-name :person/last-name :person/age]}
  -  (fn [{:keys [database] :as env} {:keys [person/id]}]
  -    (let [{:keys [age first-name last-name]} (my-database/get-person database id)]
  -      {:person/age age
  -       :person/first-name first-name
  -       :person/last-name last-name })))
  -
  -(defresolver `person-name-resolver
  +  (let [{:keys [age first-name last-name]} (my-database/get-person database id)]
  +    {:person/age        age
  +     :person/first-name first-name
  +     :person/last-name  last-name}))
  +
  +(pc/defresolver person-name-resolver [_ {:person/keys [first-name last-name]}]
     {::pc/input #{:person/first-name :person/last-name}
      ::pc/output [:person/full-name]}
  -  (fn [_ {:person/keys [first-name last-name]}]
  -    {:person/full-name (str first-name " " last-name)}))
  +  {:person/full-name (str first-name " " last-name)})
   ```
   
   This combination of resolvers can still resolve all of the properties in `[:person/full-name :person/age]` (if
  
positive.code: 
  == Shared resolvers
  
  Since version `2.2` Pathom adds support to describe resolvers as pure maps and `register` those resolvers in
  your system, making possible to write easy to share resolvers in a library format.
  
  === Resolver data format
  
negative.code: 
  When a required attribute is not present in the current entity, `Connect` will look for resolvers that can fetch it,
  analyze their inputs, and recursively walk backwards towards the "known data" in the context.
  When a required attribute is not present in the current entity, `Connect` will calculate the possibole paths
  from the data you have to the data you request, then it can use some euristic to decide which path to take
  and walk this path to reach the data, if there is no possible path connect reader will return `::p/continue` to
  let another reader try to handle that key. You can read more about how this works in the Index page.
  
  Also remember that single-input resolvers can handle ident-based queries.
  Thus, the following ident-join queries already work without having to define anything else:
  