@MainActor access in closures created in Main Actor functions

When looking into moving from integrating Async-Await with some Combine code, I came into something odd I'm hoping I can get some clarity on.

@MainActor
func configureCancellables() {
    Just(true)
        .receive(on: DispatchQueue.main)
        .sink { [unowned self] in printBool($0) }
        .store(in: &cancellables)
}

@MainActor
func printBool(_ value: Bool) {
    print(value.description)
}

The closure type here is implicitly considered to be (Bool) -> Void rather than @MainActor (Bool) -> Void. Indeed, if I add @MainActor to the closure, it throws the error:
"Converting function value of type '@MainActor (Bool) -> ()' to '(Bool) -> Void' loses global actor 'MainActor'".

My question is how does the closure infer @MainActor access from the function it is being created within? The closure can then be passed around to an API that calls this on any thread, so I'm curious what the rule is and how this is set up.

On a side note, I'm somewhat lucky that this does work, as otherwise there would seem to be no way to perform synchronous actions in the closures where they are actually on the main thread already. This affects cases if you perform a map or other dependent function that relies on on state of self. If this were to change, I'd expect any closures in Combine to become basically unusable in Swift with any API that was not nonisolated, which is a lot of them seeing UIKit etc has been completely annotated with @MainActor.