¿Corrutina que comprueba regularmente una cola heapify en busca de mensajes para enviar?

Objetivo: Una cola de prioridad con heapify que se verifica regularmente para objetos de mensajes para enviar. Cada vez que se verifica la cola, debe ver si hay algún mensaje. Si es así, debe intentar enviar el mensaje.

En caso de éxito, retire ese mensaje de la cola.

Estoy preocupado por los mensajes perdidos, así que si el mensaje falla, debe permanecer en la cola para ser enviado en la próxima invocación. Y el usuario deberá recibir una alerta (pero yo me encargaré de esa parte).

Lo que tengo hasta ahora:

        import { Heap } from 'heap-js';

    function coroutine(f) {
      var o = f(); // instancia la coroutine
      o.next(); // ejecuta hasta el primer yield
      return function(x) {
        o.next(x);
      };
    }

    socket.messageQueue = new Heap(100);

    var messageBox = coroutine(async function*() {
        while (true) {
            yield;
            if (typeof socket.messageQueue.peek() === 'undefined') {
                continue;
            }

            let message = socket.messageQueue.peek();
            let response = await sendMessage(socket, message);
            if (response.success) {
                socket.messageQueue.pop();
                // el mensaje fue enviado
                // reiniciar las alertas si existen
            } else {
                // alertar al usuario de que el envío del mensaje falló
                // se volverá a intentar en 3 segundos
            }
        }
    });
    socket.messageBox = setInterval(messageBox, 3000);

Y los mensajes se añaden a la cola así:

let priority = // la mayor prioridad + 1
socket.messageQueue.push(message, priority);

El socket es de socket.io. Estoy creando el proceso en un socket del lado del servidor porque lo destruiré cuando el usuario se desconecte. Y la cola es FIFO así que la prioridad simplemente debe establecerse en la última prioridad. Desafortunadamente, no parece que heapify tenga un método incorporado para obtener la mayor prioridad de un heap.

Cualquier sugerencia para hacer esto eficiente y elegante sería apreciada.