anchor.diff:      (fn [env params] ...)))
   ----
   
  +And using the final macro helper (recommended way):
  +
  +[source,clojure]
  +----
  +(pc/defmutation send-message-mutation
  +  {::pc/params #{:message/body}
  +   ::pc/output [:message/id :message/body :message/created-at]}
  +  (fn [env params] ...))
  +----
  +
   === Using `register`
   
  -Once you have your maps ready you can register then using the connect `register` function.
  -
  -[source,clojure]
  -----
  -(def indexes (atom {}))
  -
  -(defmulti resolver-fn pc/resolver-dispatch)
  -(def defresolver (pc/resolver-factory resolver-fn indexes))
  -
  -(defmulti mutation-fn pc/mutation-dispatch)
  -(def defmutation (pc/mutation-factory mutation-fn indexes))
  -
  -(def reg-config {::pc/defresolver defresolver
  -                 ::pc/defmutation defmutation})
  -
  -; register the resolver we created previously
  -(pc/register reg-config some-resolver)
  -
  -; same method works for mutations
  -(pc/register reg-config send-message-mutation)
  -
  -; you can also send collections to register many at once
  -(pc/register reg-config [some-resolver send-message-mutation])
  -
  -; collections will be recursivelly processed, so this is valid too:
  -(pc/register reg-config [some-resolver [send-message-mutation]])
  +Once you have your maps ready you can register then using the connect `register` function to the index.
  +
  +[source,clojure]
  +----
  +(-> {}
  +    ; register the resolver we created previously
  +    (pc/register some-resolver)
  +
  +    ; same method works for mutations
  +    (pc/register send-message-mutation)
  +
  +    ; you can also send collections to register many at once
  +    (pc/register [some-resolver send-message-mutation])
  +
  +    ; collections will be recursivelly processed, so this is valid too:
  +    (pc/register [some-resolver [send-message-mutation]]))
  +
  +; in the end the index will have the information combined of all the resolvers and mutations
   ----
   
   If you are a library author, consider defining each resolver/mutation as its own symbol
  
positive.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.
  This is what makes `Connect` powerful: by leveraging the index containing the attribute relationships you can focus on
  writing just the primary `edges` of the graph, and then all possible paths can be walked automatically. You can read
  more about how this works in the Index page.
  
  In case the path is a dead end (not enough data), `Connect` triggers an error explaining the miss. Let's see that in action:
  
  ```clojure
  (parser {} [:product/brand])
  ; CompilerException clojure.lang.ExceptionInfo: "Insufficient resolver output" {::pp/response-value {...} :key :attribute}
  ```
  
  As you can see, `Connect` will fire an error in case your query asks for something and it's not possible to get there.
  
  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:
  
negative.code: 
  ++++
  <div x-app="interactive-parser" data-parser="connect.batch2" class="loader">
  [{:items [:number-added]}]
  </div>
  <div class="space"></div>
  ++++
  