Async: Configuración de controladores de eventos mediante Async

Tengo problemas para usar async en una de mis pruebas de integración que involucra controladores de eventos. El problema es que el controlador de eventos debe configurarse (con una referencia a una devolución de llamada proporcionada de forma asíncrona) antes de que se emita el evento. Sin embargo, el código del controlador de eventos necesita una devolución de llamada adicional de inmediato.

Aquí hay un ejemplo simplificado que muestra el problema:

async.auto({
  // This needs to run first, but it will finish second
  event: [(next) => {
    emitter.once('awesome', next);
  }],

  // This needs to finish near the end
  checkResults: ['event', (results, next) => {
    assert(results.event.status == 200);
    assert(results.event.msg == 'cool');

    // Do other async stuff...
    somethingAsync(next);
  }],

  // This has to start second, but before the first one finishes
  emit: ['event', (results, next) => {
    event.emit('awesome', {msg: 'cool'}, next);
  }],

  checkEmit: ['emit', (results, next) => {
    // some sort of check that can be async
  },
], done);

event tiene que comenzar primero, pero no terminará hasta que ocurra el emit . emit necesita esperar a que event comience, pero no termine (también conocido como configurar el controlador). Por lo tanto, esto no terminará.

¿Hay alguna forma de hacer esto con la biblioteca asincrónica actual? (de manera limpia)

Aquí hay una solución que me gustaría, asumiendo que esto podría implementarse en async

async.auto({
  listen: [(next, done) => {
    client.on(done);
    return next();
  },

  ...
}, callback);

Podría usar paralelo, ejecutando los emisores y los oyentes (de los cuales puede haber varios en una prueba) como una matriz de tareas. Tomando los resultados y ejecutando las verificaciones como una segunda parte. Sin embargo, técnicamente no se requiere paralelo para iniciar las tareas en orden (aunque es probable que lo haga). Además, el código se vuelve menos plano, especialmente en configuraciones más complicadas.