Create a pool of cluster workers.

const poel = require('poel');
(async () => {
  const pool = await poel({
    getPid,
    sayHi,
  });
  for (let i = 0; i < 10; i++) {
    // On an 8 core system, this should print 8 unique pids
    // and then start then start repeating pids.
    console.log(await pool.getPid())
  }
  console.log(await pool.sayHi('World'))
  await pool.$.shutdown();
})();

function getPid() {
  return process.pid;
}

function sayHi(person) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(`Hi ${person}!`), 200);
  });
}

poel takes an object of functions which it then returns as a pool of workers with those same functions. In the example above, it was passed the getId and sayHi functions. The pool object returned also has a getId and sayHi method. Calling any method will cycle through the workers, so in the example above it will print as many unique numbers as there CPU cores on the system. If we called sayHi inside the loop, then the output from the getPid call would never include the pids of the odd numbered workers.

poel uses cluster mode under the hood. The main thing to keep in mind is that you must await (or Promise.resolve()) the call to poel before the main logic of your script. The call to poel will only resolve for the master process, which most of the time is really all you want.
Another thing to watch out for is that value passed into and back out of functions go through JSON.stringify and JSON.parse, so passing regexes and functions won't work. jsan is one solution to pass complex objects around.

The example above takes advantage of function hoisting so as to be able to have the main logic near the top of the file. If the functions were instead declared as
const getPid = () => process.pid then you would need to have that line above the call to poel.

/pōel/ פועל. po as in Edgar Allan Poe, el as in the 12th letter of the alphabet (L).
Poel means worker in Hebrew.