switchMap stops working on a Signal#discrete made out of Applicative[Signal]

fs2-core 2.3.0, Scala 2.13.1, Scala.js 0.6.23

Ran into a very weird issue:

• If a signal is made with some Cartesian operator like mapN or product, and
• a .discrete stream of it's values is switchMapped into something, and
• the value returned in switchMap is a non-terminating stream

Then the second inner stream will never be switched from, i.e. function passed to switchMap will be called at most twice.

E.g. the following code:

def run = for {
  sig <- SignallingRef[IO, Int](0)
  _ <- fs2.Stream.awakeEvery[IO](100.millis).as(1).scanMonoid.take(20)
          .evalMap(sig.set)
          .compile.drain.start
          
  test = (Signal.constant[IO, String](">> "), sig).mapN(_ ++ _.toString)
    
  _ <- test.discrete.switchMap { x =>
          fs2.Stream.eval_(IO(println(s"Opening: $x"))) ++
          fs2.Stream.never[IO].onFinalize(IO(println(s"Closing $x")))
        }
        .compile
        .drain
        .start
  } yield ()

run.unsafeRunAsyncAndForget()

Produces the following output:

Opening: >> 0
Closing >> 0
Opening: >> 1

Removing the signal altogether:

def run = fs2.Stream.awakeEvery[IO](100.millis)
  .as(1).scanMonoid.take(20)
  .switchMap { x =>
    fs2.Stream.eval_(IO(println(s"Opening: $x"))) ++
    fs2.Stream.never[IO].onFinalize(IO(println(s"Closing $x")))
  }
  .compile.drain
  .start.void

Or replacing the test signal definition with test = sig.map(">> " + _) produces the following output (expected):

Opening: >> 0
Closing >> 0
Opening: >> 1
...<many similar lines>...
Closing >> 18
Opening: >> 19

Start by running the minimal reproducer against fs2-core 2.3.0, focusing on Signal#discrete, the Applicative[Signal] mapN construction, and switchMap with a non-terminating inner stream. Compare it with the direct signal and map-based variants shown in the issue. Done means updates from the combined signal switch to each new inner stream, with the expected opening and closing output.