This introduces a few challenges though:

1. clone is a method from the Clone trait, but async classes (= used for processes) can't implement traits. This is because regular methods can't be accessed by anybody but the process itself, and thus implementing traits is kind of pointless. It would also be hard to verify a method is safe to use from the outside

2. If we can't implement traits for async classes, we can't implement Clone; unless we "bless" that implementation (basically by the compiler generating the implementation and ignoring the limitation). Technically this is safe, but it feels weird that clone would literally be the only method you can use from the outside/client side

3. Creating refs to processes, dropping them, and dropping processes themselves needs extra work. Refs would need atomic operations (because they'd modify the same shared value). When dropping a process, it shouldn't be free'd until there are no more references/clients to it

Alternatives involve wrapping the client side in a dedicated type, but then you're lying at the type level (e.g. you'd actually have a Handle[Proc] instead of just a Proc, but type it as Proc in the compiler), and you end up with this weird setup where Proc {} returns a Handle[Proc], while for regular classes it would return Proc