Running Next On A Subscription Hangs Indefinitely

I'm attempting to create a distributed task processing system using libp2p that will send a message when work has been done. Other workers are supposed to pick up on this message, and finish processing.

Currently I'm running into an issue,

I have a loop like

for {
	msg, err := subscription.Next(context.Background())
	if err != nil {
		return err
       }
      .........
}

Currently this will hang, and even when one worker sends a message to the topic, none of the other workers currently listening to the topic will receive the message. However, if I do something like this:

for {
go func() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()
	msg, err := finishedSub.Next(ctx)
	if err != nil {
		return
	}
	msg, err := subscription.Next(context.Background())
	if err != nil {
		return err
       }
      .........
}()
}

Then this works, and other workers are able to pick up on the messages. However the one flaw I can detect with this, is that at some point goroutine panics start occurring. Something seems to be off here, and that Next isn't being handled properly or my understanding of the expected functionality of Next is incorrect.

Start by examining the subscription.Next(context.Background()) loop shown in the issue and compare it with the timeout-based workaround. Reproduce the behavior with multiple workers and check whether messages are received without spawning repeated goroutines or causing panics. Done means Next behaves as expected for subscribed workers, or the issue clearly documents the required context and lifecycle handling.