Can you provide a example, like this one:

(let [;; a resolver
      a (pco/resolver `a
          {::pco/output [:a]}
          (fn [_ _]
            {:a 42}))
      env (pci/register [a])]
  ;; that is correctly parsed in parser
  (prn (p.eql/process env [:a]))
  ;; but not when I use the definition
  (prn  (a {} {})))

Nope not exactly. Sorry if this is unclear. This works fine: (parser {} [{[:person/id "id"] [:a/name]}]) But somehow if I use the same in here:

(pco/defresolver test  [{:keys [parser] :as env} {:person/keys [id]}]
  {::pco/input  [:person/id]
   ::pco/output [:person/test]}
  {:person/test
   (parser env [{[:person/id id] [:a/name]}])})

I should point out that the test resolver has ::pco/batch? true in the real code.

@U0111PVCS8P by running this code

(let [a (pco/resolver `a
          {::pco/output [:a]}
          (fn [{:keys [parser]} _]
            {:a (nil? parser)}))
      env (pci/register [a])]
  (p.eql/process env [:a]))
=> {:a true}

(pco/defresolver test  [env {:person/keys [id]}]
  {::pco/input  [:person/id]
   ::pco/output [:person/test]}
  {:person/test (p.eql/process env [{[:person/id id] [:a/name]}])})

@U2J4FRT2T Thanks for your answer. Same behavior with p.eql/process, tho. I think parser is something fulcro injects.

in the env map: :parser #function[com.wsscode.pathom3.interface.eql/process]

(pco/defresolver test  [{:keys [parser] :as env} {:person/keys [id]}]
  {::pco/input  [:person/id]
   ::pco/output [:person/test]}
  (try
    (println [:start id])
    (let [return (parser env [{[:person/id id] [:a/name]}])]
      (println [:ok id return])
      {:person/test return})
    (catch Throwable ex 
      (println [:fail id ex])
      (throw ex))))

I think I’m getting more information if I remove the lenient mode injected by fulcro.

I asked in the fulcro channel as it seems more fulcro than pathom related.