Locally-defined types can't be inferred as a polymorphic argument in other module

The file below gives the error Type Checker: Foo is not bound as a type in: foo on the last line.

#lang typed/racket

(module m typed/racket
  (define foo
    (let ()
      (define-type Foo (List (U Foo One)))

      (ann (list 1) Foo)))

  (provide foo))

(require 'm)

(: f (∀ (A) (→ (List A) Any)))
(define (f x) 2)

(f foo)

When moving the call to f and its definition inside the module m, the error does not occur.

It seems that for this problem to occur, the type Foo:

• Has to be locally declared (inside a let)
• Has to be recursive (otherwise I guess it gets expanded where used, and its name isn't used anymore)
• Has to be used in a separate module (here it's inferred as the type argument for a polymorphic type)

I hit this problem while writing a macro that defines recursive types, and does so locally so that the macro can be used anywhere and not just at the top-level. Converting to using Rec is not really possible in my case, because there are several mutually recursive types, and their expansion would be very big.

Start by running the typed/racket reproducer in the issue, focusing on the local recursive Foo in module m and the polymorphic (f foo) call. Trace why the exported foo is rejected as the inferred argument type; done when the final call no longer reports Foo as unbound while the in-module call remains valid.