I arrived to CE3 from Akka world, so I also had a hard time wrapping my head around this one at first :) still do sometimes!

How do you manage long running, independant, but identifiable processes? A process per session on a web server for example, or a process per long running async something or other.

Yes, fibers are indeed the answer. They are lightweight and generally awesome!

why doesn't this already exist - I must be missing something

It is fairly straightforward to make an "actor" using fs2's Channel API.

https://github.com/typelevel/fs2/blob/main/core/shared/src/main/scala/fs2/concurrent/Channel.scala

The send method should be pretty familiar :) to implement the "actor logic", you consume messages A from the stream and do something with them, e.g. fold over some internal "actor state". Then you can run that stream as a Fiber, and voila you have an "actor" :)

I didn't think Fibers were uniquely identifable - do I need to maintain a map of id->fiber myself?

Fibers are ultimately just objects and you can work with them as such, although there are many higher level APIs that are much more friendly.

As for why this pattern is not so popular, I think it just doesn't lend itself well to the FP paradigm :) consider the example of web server, for example. http4s models this concept as a function Request[F] => F[Response[F]] which of course can be run concurrently as a Fiber. The problem with Actors is that they do not fit this pattern very well: sending a message to an actor is a side effect F[Unit] (see the signature of send in Channel), and that actor will itself have to use side-effects to complete handling of the message. So in general it is more difficult to reason about a program whose logic is implemented with side effects (even if they are suspended in an F e.g. IO), rather than a Input => F[Output].

Anyway just my 2 cents, maybe someone smarter can give us both some real insight on the matter