@diesalbla identified the issue to here:

The problem is if the background stream (which is derived from the resource-acquiring stream) completes before the foreground stream then it will release the resources.

I am not sure if there is concurrently-like solution, but I was imagining we could do something like:

Stream.resource(background.compile.resource.something).flatMap { _ =>
  foreground ...
}

The precise details are a bit fuzzy :)

@armanbilge If possible, I would like to work on this issue.

Unfortunately, I haven't been able to make any noticable progression with the ticket since I picked it up. This is why I will unassign myself from it.

another incarnation of the problem is broadcastThrough, which also disconnects the underlying stream from the resulting one:

fs2.Stream.bracket { 
    IO.println("making resource").as("TempFile") 
  } { res =>
    IO.println(s"!! releasing resource: $res") 
  }
  .broadcastThrough[IO, Unit](
    (s: fs2.Stream[IO, String]) => s.evalMap(s => IO.sleep(20.millis) *> IO.println(s"1 using $s")),
    (s: fs2.Stream[IO, String]) => s.evalMap(s => IO.sleep(30.millis) *> IO.println(s"2 using $s")),
  )
  .compile
  .drain 
  .unsafeRunSync()

making resource
!! releasing resource: TempFile
1 using TempFile
2 using TempFile