isotropic-cluster 0.4.0 → 0.6.0

package/README.md

@@ -1,9 +1,9 @@
 # isotropic-cluster
 
-[![npm version](https://img.shields.io/npm/v/isotropic-cluster.svg)](https://www.npmjs.com/package/isotropic-cluster)
-[![License](https://img.shields.io/npm/l/isotropic-cluster.svg)](https://github.com/ibi-group/isotropic-cluster/blob/main/LICENSE)
-![](https://img.shields.io/badge/tests-passing-brightgreen.svg)
-![](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)
+[npm version](https://www.npmjs.com/package/isotropic-cluster)
+[License](https://github.com/ibi-group/isotropic-cluster/blob/main/LICENSE)
+
+
 
 A reusable and extendable platform to manage local Node.js process clusters with a clean API for primary/worker communication and lifecycle management.
 
@@ -69,7 +69,7 @@ import _later from 'isotropic-later';
     });
 
     // Later, shutdown the cluster
-    _later_(60000, () => {
+    _later(60000, () => {
         primary.shutDown();
     });
 }
@@ -122,6 +122,7 @@ Node.js clusters consist of a primary process that manages multiple worker proce
 - Handles worker failures and restarts
 
 Workers are separate processes that:
+
 - Handle specific tasks (like serving HTTP requests)
 - Report their status to the primary
 - Perform work assigned by the primary
@@ -205,13 +206,13 @@ import _http from 'node:http';
 
     // Create HTTP server
     const server = _http.createServer((request, response) => {
-        ressponse.writeHead(200);
+        response.writeHead(200);
         response.end(`Hello from worker ${_ClusterWorker.workerId}`);
     });
 
     // Start listening on port 3000
     server.listen(3000, () => {
-        console.log(`Worker ${ClusterWorker.workerId} listening on port 3000`);
+        console.log(`Worker ${_ClusterWorker.workerId} listening on port 3000`);
     });
 
     // Handle shutdown
@@ -304,7 +305,7 @@ import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
 {
     const primary = _ClusterPrimary(),
 
-    // Different types of tasks
+        // Different types of tasks
         tasksByType = {
             compute: [{
                 data: '...',
@@ -326,7 +327,8 @@ import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
             }, {
                 data: '...',
                 id: 'l2'
-            }],
+            }]
+        },
 
         processQueue = queueType => {
             const tasks = tasksByType[queueType];
@@ -354,7 +356,6 @@ import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
                 });
             }
         };
-    };
 
     // Listen for worker readiness
     primary.on('workerReady', () => {
@@ -373,8 +374,10 @@ import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
         if (message.type === 'taskComplete') {
             console.log(`Task ${message.taskId} completed with result:`, message.result);
 
-            // Process next task
-            processQueue();
+            // Process the next task from each queue
+            processQueue('compute');
+            processQueue('io');
+            processQueue('lightweight');
         }
     });
 
@@ -396,7 +399,7 @@ import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
 import _make from 'isotropic-make';
 
 // Extend ClusterPrimary with custom message handler methods
-const _AdvancedPrimary = _make(_ClusterPrimary, {
+const _AdvancedPrimary = _make('AdvancedPrimary', _ClusterPrimary, {
     _eventWorkerMessage_log ({
         data: {
             message,
@@ -470,6 +473,8 @@ const primary = _ClusterPrimary(options);
 ```
 
 Options:
+
+- `restartBackoff`: Controls how dead workers are replaced. By default, replacements are paced by an [isotropic-backoff](https://www.npmjs.com/package/isotropic-backoff) instance with default levels. Pass a backoff configuration object to customize the levels, pass an existing backoff instance to share one, or pass `false` to disable the backoff and replace dead workers immediately and indefinitely.
 - `workerArgs`: Array of arguments to pass to worker processes
 - `workerScript`: Path to worker script (defaults to current script)
 - `workerSilent`: Whether to suppress worker stdout/stderr
@@ -480,22 +485,27 @@ Options:
 
 - **destroy()**: Clean up and destroy the primary instance
 - **fork({ workerCount })**: Start new worker processes. `workerCount` is optional and defaults to `1`.
-- **roundRobin({ tag })**: Select a worker using round-robin distribution. The `tag` is optional. It returns the worker object that has been least recently selected for the given tag.
+- **roundRobin({ tag })**: Select a worker using round-robin distribution. The `tag` is optional. It returns the worker object that has been least recently selected for the given tag, or `undefined` if there are no workers.
 - **send({ message, to })**: Send a message to one or more workers. `to` can be a worker object or a worker id. It can also be an array of either. Returns a promise.
 - **shutDown()**: Gracefully shut down all workers
 
 #### Properties
 
+- **restartBackoff**: The backoff instance pacing worker replacements, or `undefined` when disabled
 - **workerById**: Object mapping worker ids to worker objects
 - **workers**: Array of all active worker objects
 
 #### Events
 
+- **addWorker**: When a ready worker is added to the pool
 - **destroy**: When destroy begins
 - **destroyComplete** When destroy completes
+- **fork**: When `fork()` is called to start one or more workers
 - **initialize**: When initialization begins
 - **initializeComplete**: When initialization completes successfully
 - **initializeError**: When initialization fails
+- **removeWorker**: When a worker is removed from the pool
+- **restartGiveUp**: When the restart backoff is exhausted and no workers remain; the cluster shuts down
 - **shutDown**: When the cluster is shutting down
 - **shutDownComplete**: When all workers have been shut down
 - **workerDisconnect**: When a worker disconnects
@@ -516,11 +526,12 @@ const worker = _ClusterWorker(options);
 ```
 
 Options:
+
 - `initialize`: Whether to automatically initialize (defaults to true)
 
 #### Methods
 
-- **destroy()**: Clean up and destroy the worker instance
+- **destroy({ timeout })**: Clean up and destroy the worker instance. The worker disconnects its IPC channel and, if it has not exited on its own within `timeout` milliseconds (default `6765`), is force-killed.
 - **send({ message })**: Send a message to the primary process
 
 #### Static Properties
@@ -548,7 +559,7 @@ import _make from 'isotropic-make';
 import _mongoose from 'mongoose';
 
 // Custom worker with database connection
-const _DbWorker = _make(_ClusterWorker, {
+const _DbWorker = _make('DbWorker', _ClusterWorker, {
     get db () {
         return this._db;
     },
@@ -595,7 +606,36 @@ const _DbWorker = _make(_ClusterWorker, {
 
 ### Auto-Restart on Worker Failure
 
-The `ClusterPrimary` automatically restarts workers that die unexpectedly. This means workers are automatically replaced if they crash, ensuring application resilience.
+The `ClusterPrimary` automatically restarts workers that die unexpectedly, ensuring application resilience. Replacements are paced by a restart backoff: a worker that crashes repeatedly (for example, one that fails on startup) is replaced immediately once, then with escalating delays. Each worker that reaches the ready state resets the backoff. When the backoff is exhausted and other workers remain, the primary logs an error and continues with the remaining workers; when none remain, it publishes a `restartGiveUp` event and shuts down rather than looping forever.
+
+```javascript
+import _ClusterPrimary from 'isotropic-cluster/lib/cluster-primary.js';
+
+{
+    // Customize the restart pacing: three immediate replacements, then five
+    // escalating delays from 500ms, then give up.
+    const primary = _ClusterPrimary({
+        restartBackoff: {
+            levels: [{
+                count: 3
+            }, {
+                count: 5,
+                delay: 500,
+                factor: 3,
+                maximumDelay: 30000
+            }]
+        }
+    });
+
+    primary.on('restartGiveUp', () => {
+        // The cluster could not keep any worker alive and is shutting down.
+    });
+
+    primary.fork({
+        workerCount: 4
+    });
+}
+```
 
 ### Health Monitoring
 
@@ -669,6 +709,7 @@ import _later from 'isotropic-later';
 
 isotropic-cluster works seamlessly with other modules in the isotropic ecosystem:
 
+- **isotropic-backoff**: Escalating delays for worker replacement
 - **isotropic-error**: Nested error reporting
 - **isotropic-initializable**: Parent-to-child initialization sequence
 - **isotropic-logger**: Structured logging
@@ -681,4 +722,4 @@ Please refer to [CONTRIBUTING.md](https://github.com/ibi-group/isotropic-cluster
 
 ## Issues
 
-If you encounter any issues, please file them at https://github.com/ibi-group/isotropic-cluster/issues
+If you encounter any issues, please file them at [https://github.com/ibi-group/isotropic-cluster/issues](https://github.com/ibi-group/isotropic-cluster/issues)

package/lib/cluster-primary.js

@@ -1,2 +1,541 @@
-import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename))},!0);export default _make(_Initializable,{fork({workerCount:a=1}={}){return this._active?this._publish("fork",{workerCount:a}):this},roundRobin({tag:a=""}={}){let b,c=1/0,d=this._workerTimeByWorkerWeakMapByTag[a];d||(d=new WeakMap,this._workerTimeByWorkerWeakMapByTag[a]=d);for(const e of this._workers){const a=d.get(e);if(a)a<c&&(b=e,c=a);else{b=e;break}}return d.set(b,Date.now()),b},send({message:a,to:b=this._workers}){return Array.isArray(b)||(b=[b]),Promise.all(b.map(b=>new Promise((c,d)=>{const e="number"==typeof b?this._workerById[b]:b;e&&e.send?e.send(a,b=>{b?d(_Error({details:{message:a,workerId:e.id},error:b,message:"Error sending message to worker"})):c()}):d(_Error({details:{message:a,to:b},message:"Invalid message destination"}))})))},shutDown(){return this._publish("shutDown")},get workerById(){return this._workerById},get workers(){return this._workers},_addWorker({worker:a}){return this._publish("addWorker",{worker:a})},_destroy(...a){return this._active?(this._onceAfter("shutDownComplete","_destroy"),void this.shutDown()):void(this._active=void 0,Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.removeListener(a,this._clusterListenerByEventName[a])}),this._clusterListenerByEventName=void 0,this._workerTimeByWorkerWeakMapByTag=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a))},_eventAddWorker({data:{worker:a}}){this._workerById[a.id]=a,this._workers=Object.values(this._workerById)},_eventFork({data:{workerCount:a}}){for(;0<a;)_moduleLogger.info("Starting a new worker"),_cluster.fork(),a-=1},_eventRemoveWorker({data:{worker:a}}){delete this._workerById[a.id],this._workers=Object.values(this._workerById)},_eventShutDown(){return _moduleLogger.info("Shutting down workers"),this._active=!1,_cluster.disconnect(()=>{this._publish("shutDownComplete")}),this},_eventShutDownComplete(){_moduleLogger.info("Worker shut down complete")},_eventWorkerDisconnect({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker disconnected"),this._removeWorker({worker:a})},_eventWorkerError({data:{error:a,worker:b}}){_moduleLogger.fatal({error:_Error({details:{workerId:b.id},error:a,message:"Worker error"}),workerId:b.id},"Worker error"),this._removeWorker({worker:b})},_eventWorkerExit({data:{code:a,signal:b,worker:c}}){c.exitedAfterDisconnect?_moduleLogger.info({code:a,signal:b,workerId:c.id},"Worker exited voluntarily"):a?_moduleLogger.fatal({code:a,signal:b,workerId:c.id},"Worker died unexpectedly"):_moduleLogger.error({code:a,signal:b,workerId:c.id},"Worker died"),this._removeWorker({worker:c}),this._active&&(_moduleLogger.info("Replacing dead worker"),this.fork())},_eventWorkerFork({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Starting new worker"),a.on("error",b=>{this._publish("workerError",{error:_Error({details:{worker:a},error:b,message:"Error in worker"}),worker:a})})},_eventWorkerListening({data:{address:a,worker:b}}){_moduleLogger.info({address:a.address,port:a.port,workerId:b.id},"Worker is listening")},_eventWorkerMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventWorkerMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_eventWorkerOnline({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is now online");const b=c=>{"ready"===c&&(a.removeListener("message",b),this._publish("workerReady",{worker:a}))};a.on("message",b)},_eventWorkerReady({data:{worker:a}}){_moduleLogger.info({workerId:a.id},"Worker is ready to work"),this._addWorker({worker:a})},_init(...a){return this._active=!0,this._clusterListenerByEventName={disconnect:a=>{this._publish("workerDisconnect",{worker:a})},exit:(a,b,c)=>{this._publish("workerExit",{code:b,signal:c,worker:a})},fork:a=>{this._publish("workerFork",{worker:a})},listening:(a,b)=>{this._publish("workerListening",{address:b,worker:a})},message:(a,b,c)=>{this._publish("workerMessage",{handle:c,message:b,worker:a})},online:a=>{this._publish("workerOnline",{worker:a})}},this._workerById=Object.create(null),this._workers=[],this._workerTimeByWorkerWeakMapByTag=Object.create(null),Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(...a){_moduleLogger.info("Initializing primary");const[{workerArgs:b,workerScript:c,workerSilent:d,workerStdio:e}={}]=a;_cluster.setupPrimary({args:"undefined"==typeof b?_process.argv.slice(2):b,exec:"undefined"==typeof c?_process.argv[1]:c,silent:"undefined"!=typeof d&&d,stdio:e}),Object.keys(this._clusterListenerByEventName).forEach(a=>{_cluster.on(a,this._clusterListenerByEventName[a])})},_removeWorker({worker:a}){return a.id in this._workerById&&this._publish("removeWorker",{worker:a}),this}},{_pubsub:{addWorker:{completeFunction:"_eventAddWorker"},fork:{completeFunction:"_eventFork"},removeWorker:{completeFunction:"_eventRemoveWorker"},shutDown:{completeFunction:"_eventShutDown",completeOnce:!0},shutDownComplete:{completeFunction:"_eventShutDownComplete",publishOnce:!0},workerDisconnect:{completeFunction:"_eventWorkerDisconnect"},workerError:{completeFunction:"_eventWorkerError"},workerExit:{completeFunction:"_eventWorkerExit"},workerFork:{completeFunction:"_eventWorkerFork"},workerListening:{completeFunction:"_eventWorkerListening"},workerMessage:{completeFunction:"_eventWorkerMessage"},workerOnline:{completeFunction:"_eventWorkerOnline"},workerReady:{completeFunction:"_eventWorkerReady"}}});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_logger","_make","_path","_process","_moduleLogger","child","module","basename","import","meta","filename","extname","fork","workerCount","_active","_publish","roundRobin","tag","oldestWorker","oldestWorkerTime","workerTimeByWorkerWeakMap","_workerTimeByWorkerWeakMapByTag","WeakMap","worker","_workers","workerTime","get","set","Date","now","send","message","to","Array","isArray","Promise","all","map","resolve","reject","_workerById","error","details","workerId","id","shutDown","workerById","workers","_addWorker","_destroy","args","_onceAfter","Object","keys","_clusterListenerByEventName","forEach","eventName","removeListener","Reflect","apply","prototype","_eventAddWorker","data","values","_eventFork","info","_eventRemoveWorker","_eventShutDown","disconnect","_eventShutDownComplete","_eventWorkerDisconnect","_removeWorker","_eventWorkerError","fatal","_eventWorkerExit","code","signal","exitedAfterDisconnect","_eventWorkerFork","on","_eventWorkerListening","address","port","_eventWorkerMessage","event","type","method","_eventWorkerOnline","listener","_eventWorkerReady","_init","exit","listening","handle","online","create","_initialize","workerArgs","workerScript","workerSilent","workerStdio","setupPrimary","argv","slice","exec","silent","stdio","_pubsub","addWorker","completeFunction","removeWorker","completeOnce","shutDownComplete","publishOnce","workerDisconnect","workerError","workerExit","workerFork","workerListening","workerMessage","workerOnline","workerReady"],"sources":["../js/cluster-primary.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _moduleLogger = _logger.child({\n    module: _path.basename(import.meta.filename, _path.extname(import.meta.filename))\n}, true);\n\nexport default _make(_Initializable, {\n    fork ({\n        workerCount = 1\n    } = {}) {\n        return this._active ?\n            this._publish('fork', {\n                workerCount\n            }) :\n            this;\n    },\n    roundRobin ({\n        tag = ''\n    } = {}) {\n        let oldestWorker,\n            oldestWorkerTime = Infinity,\n            workerTimeByWorkerWeakMap = this._workerTimeByWorkerWeakMapByTag[tag];\n\n        if (!workerTimeByWorkerWeakMap) {\n            workerTimeByWorkerWeakMap = new WeakMap();\n            this._workerTimeByWorkerWeakMapByTag[tag] = workerTimeByWorkerWeakMap;\n        }\n\n        for (const worker of this._workers) {\n            const workerTime = workerTimeByWorkerWeakMap.get(worker);\n\n            if (workerTime) {\n                if (workerTime < oldestWorkerTime) {\n                    oldestWorker = worker;\n                    oldestWorkerTime = workerTime;\n                }\n            } else {\n                oldestWorker = worker;\n                break;\n            }\n        }\n\n        workerTimeByWorkerWeakMap.set(oldestWorker, Date.now());\n        return oldestWorker;\n    },\n    send ({\n        message,\n        to = this._workers\n    }) {\n        if (!Array.isArray(to)) {\n            to = [\n                to\n            ];\n        }\n\n        return Promise.all(to.map(to => new Promise((resolve, reject) => {\n            const worker = typeof to === 'number' ?\n                this._workerById[to] :\n                to;\n\n            if (worker && worker.send) {\n                worker.send(message, error => {\n                    if (error) {\n                        reject(_Error({\n                            details: {\n                                message,\n                                workerId: worker.id\n                            },\n                            error,\n                            message: 'Error sending message to worker'\n                        }));\n                    } else {\n                        resolve();\n                    }\n                });\n            } else {\n                reject(_Error({\n                    details: {\n                        message,\n                        to\n                    },\n                    message: 'Invalid message destination'\n                }));\n            }\n        })));\n    },\n    shutDown () {\n        return this._publish('shutDown');\n    },\n    get workerById () {\n        return this._workerById;\n    },\n    get workers () {\n        return this._workers;\n    },\n    _addWorker ({\n        worker\n    }) {\n        return this._publish('addWorker', {\n            worker\n        });\n    },\n    _destroy (...args) {\n        if (this._active) {\n            this._onceAfter('shutDownComplete', '_destroy');\n            this.shutDown();\n            return;\n        }\n\n        this._active = void null;\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.removeListener(eventName, this._clusterListenerByEventName[eventName]);\n        });\n\n        this._clusterListenerByEventName = void null;\n\n        this._workerTimeByWorkerWeakMapByTag = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _eventAddWorker ({\n        data: {\n            worker\n        }\n    }) {\n        this._workerById[worker.id] = worker;\n        this._workers = Object.values(this._workerById);\n    },\n    _eventFork ({\n        data: {\n            workerCount\n        }\n    }) {\n        while (workerCount > 0) {\n            _moduleLogger.info('Starting a new worker');\n\n            _cluster.fork();\n            workerCount -= 1;\n        }\n    },\n    _eventRemoveWorker ({\n        data: {\n            worker\n        }\n    }) {\n        delete this._workerById[worker.id];\n        this._workers = Object.values(this._workerById);\n    },\n    _eventShutDown () {\n        _moduleLogger.info('Shutting down workers');\n\n        this._active = false;\n\n        _cluster.disconnect(() => {\n            this._publish('shutDownComplete');\n        });\n\n        return this;\n    },\n    _eventShutDownComplete () {\n        _moduleLogger.info('Worker shut down complete');\n    },\n    _eventWorkerDisconnect ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker disconnected');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerError ({\n        data: {\n            error,\n            worker\n        }\n    }) {\n        _moduleLogger.fatal({\n            error: _Error({\n                details: {\n                    workerId: worker.id\n                },\n                error,\n                message: 'Worker error'\n            }),\n            workerId: worker.id\n        }, 'Worker error');\n\n        this._removeWorker({\n            worker\n        });\n    },\n    _eventWorkerExit ({\n        data: {\n            code,\n            signal,\n            worker\n        }\n    }) {\n        if (worker.exitedAfterDisconnect) {\n            _moduleLogger.info({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker exited voluntarily');\n        } else if (code) {\n            _moduleLogger.fatal({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died unexpectedly');\n        } else {\n            _moduleLogger.error({\n                code,\n                signal,\n                workerId: worker.id\n            }, 'Worker died');\n        }\n\n        this._removeWorker({\n            worker\n        });\n\n        if (this._active) {\n            _moduleLogger.info('Replacing dead worker');\n\n            this.fork();\n        }\n    },\n    _eventWorkerFork ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Starting new worker');\n\n        worker.on('error', error => {\n            this._publish('workerError', {\n                error: _Error({\n                    details: {\n                        worker\n                    },\n                    error,\n                    message: 'Error in worker'\n                }),\n                worker\n            });\n        });\n    },\n    _eventWorkerListening ({\n        data: {\n            address,\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            address: address.address,\n            port: address.port,\n            workerId: worker.id\n        }, 'Worker is listening');\n    },\n    _eventWorkerMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventWorkerMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _eventWorkerOnline ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is now online');\n\n        const listener = message => {\n            if (message === 'ready') {\n                worker.removeListener('message', listener);\n\n                this._publish('workerReady', {\n                    worker\n                });\n            }\n        };\n\n        worker.on('message', listener);\n    },\n    _eventWorkerReady ({\n        data: {\n            worker\n        }\n    }) {\n        _moduleLogger.info({\n            workerId: worker.id\n        }, 'Worker is ready to work');\n\n        this._addWorker({\n            worker\n        });\n    },\n    _init (...args) {\n        this._active = true;\n\n        this._clusterListenerByEventName = {\n            disconnect: worker => {\n                this._publish('workerDisconnect', {\n                    worker\n                });\n            },\n            exit: (worker, code, signal) => {\n                this._publish('workerExit', {\n                    code,\n                    signal,\n                    worker\n                });\n            },\n            fork: worker => {\n                this._publish('workerFork', {\n                    worker\n                });\n            },\n            listening: (worker, address) => {\n                this._publish('workerListening', {\n                    address,\n                    worker\n                });\n            },\n            message: (worker, message, handle) => {\n                this._publish('workerMessage', {\n                    handle,\n                    message,\n                    worker\n                });\n            },\n            online: worker => {\n                this._publish('workerOnline', {\n                    worker\n                });\n            }\n        };\n\n        this._workerById = Object.create(null);\n\n        this._workers = [];\n\n        this._workerTimeByWorkerWeakMapByTag = Object.create(null);\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize (...args) {\n        _moduleLogger.info('Initializing primary');\n\n        const [{\n            workerArgs,\n            workerScript,\n            workerSilent,\n            workerStdio\n        } = {}] = args;\n\n        _cluster.setupPrimary({\n            args: typeof workerArgs === 'undefined' ?\n                _process.argv.slice(2) :\n                workerArgs,\n            exec: typeof workerScript === 'undefined' ?\n                _process.argv[1] :\n                workerScript,\n            silent: typeof workerSilent === 'undefined' ?\n                false :\n                workerSilent,\n            stdio: workerStdio\n        });\n\n        Object.keys(this._clusterListenerByEventName).forEach(eventName => {\n            _cluster.on(eventName, this._clusterListenerByEventName[eventName]);\n        });\n    },\n    _removeWorker ({\n        worker\n    }) {\n        if (worker.id in this._workerById) {\n            this._publish('removeWorker', {\n                worker\n            });\n        }\n\n        return this;\n    }\n}, {\n    _pubsub: {\n        addWorker: {\n            completeFunction: '_eventAddWorker'\n        },\n        fork: {\n            completeFunction: '_eventFork'\n        },\n        removeWorker: {\n            completeFunction: '_eventRemoveWorker'\n        },\n        shutDown: {\n            completeFunction: '_eventShutDown',\n            completeOnce: true\n        },\n        shutDownComplete: {\n            completeFunction: '_eventShutDownComplete',\n            publishOnce: true\n        },\n        workerDisconnect: {\n            completeFunction: '_eventWorkerDisconnect'\n        },\n        workerError: {\n            completeFunction: '_eventWorkerError'\n        },\n        workerExit: {\n            completeFunction: '_eventWorkerExit'\n        },\n        workerFork: {\n            completeFunction: '_eventWorkerFork'\n        },\n        workerListening: {\n            completeFunction: '_eventWorkerListening'\n        },\n        workerMessage: {\n            completeFunction: '_eventWorkerMessage'\n        },\n        workerOnline: {\n            completeFunction: '_eventWorkerOnline'\n        },\n        workerReady: {\n            completeFunction: '_eventWorkerReady'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}
+import _Backoff from 'isotropic-backoff';
+import _cluster from 'node:cluster';
+import _Error from 'isotropic-error';
+import _Initializable from 'isotropic-initializable';
+import _logger from 'isotropic-logger';
+import _make from 'isotropic-make';
+import _path from 'node:path';
+import _process from 'node:process';
+
+const _moduleLogger = _logger.child({
+    module: _path.basename(import.meta.filename, _path.extname(import.meta.filename))
+});
+
+export default _make('ClusterPrimary', _Initializable, {
+    fork ({
+        workerCount = 1
+    } = {}) {
+        return this._active ?
+            this._publish('fork', {
+                workerCount
+            }) :
+            this;
+    },
+    get restartBackoff () {
+        return this._restartBackoff;
+    },
+    roundRobin ({
+        tag = ''
+    } = {}) {
+        if (!this._workers.length) {
+            return;
+        }
+
+        let oldestWorker,
+            oldestWorkerTime = Infinity,
+            workerTimeByWorkerWeakMap = this._workerTimeByWorkerWeakMapByTag[tag];
+
+        if (!workerTimeByWorkerWeakMap) {
+            workerTimeByWorkerWeakMap = new WeakMap();
+            this._workerTimeByWorkerWeakMapByTag[tag] = workerTimeByWorkerWeakMap;
+        }
+
+        for (const worker of this._workers) {
+            const workerTime = workerTimeByWorkerWeakMap.get(worker);
+
+            if (workerTime) {
+                if (workerTime < oldestWorkerTime) {
+                    oldestWorker = worker;
+                    oldestWorkerTime = workerTime;
+                }
+            } else {
+                oldestWorker = worker;
+                break;
+            }
+        }
+
+        this._roundRobinCounter += 1;
+
+        workerTimeByWorkerWeakMap.set(oldestWorker, this._roundRobinCounter);
+
+        return oldestWorker;
+    },
+    send ({
+        message,
+        to = this._workers
+    }) {
+        if (!Array.isArray(to)) {
+            to = [
+                to
+            ];
+        }
+
+        return Promise.all(to.map(to => new Promise((resolve, reject) => {
+            const worker = typeof to === 'number' ?
+                this._workerById[to] :
+                to;
+
+            if (worker && worker.send) {
+                worker.send(message, error => {
+                    if (error) {
+                        reject(_Error({
+                            details: {
+                                message,
+                                workerId: worker.id
+                            },
+                            error,
+                            message: 'Error sending message to worker'
+                        }));
+                    } else {
+                        resolve();
+                    }
+                });
+            } else {
+                reject(_Error({
+                    details: {
+                        message,
+                        to
+                    },
+                    message: 'Invalid message destination'
+                }));
+            }
+        })));
+    },
+    shutDown () {
+        return this._publish('shutDown');
+    },
+    get workerById () {
+        return this._workerById;
+    },
+    get workers () {
+        return this._workers;
+    },
+    _addWorker ({
+        worker
+    }) {
+        return this._publish('addWorker', {
+            worker
+        });
+    },
+    _destroy (...args) {
+        if (this._active) {
+            this._onceAfter('shutDownComplete', '_destroy');
+            this.shutDown();
+            return;
+        }
+
+        this._active = void null;
+
+        Object.keys(this._clusterListenerByEventName).forEach(eventName => {
+            _cluster.removeListener(eventName, this._clusterListenerByEventName[eventName]);
+        });
+
+        this._clusterListenerByEventName = void null;
+
+        if (this._ownRestartBackoff) {
+            this._restartBackoff.destroy();
+        }
+
+        this._ownRestartBackoff = void null;
+
+        this._restartAbortController = void null;
+
+        this._restartBackoff = void null;
+
+        this._workerTimeByWorkerWeakMapByTag = void null;
+
+        Reflect.apply(_Initializable.prototype._destroy, this, args);
+    },
+    _eventAddWorker ({
+        data: {
+            worker
+        }
+    }) {
+        this._workerById[worker.id] = worker;
+        this._workers = Object.values(this._workerById);
+    },
+    _eventFork ({
+        data: {
+            workerCount
+        }
+    }) {
+        while (workerCount > 0) {
+            _moduleLogger.info('Starting a new worker');
+
+            _cluster.fork();
+            workerCount -= 1;
+        }
+    },
+    _eventRemoveWorker ({
+        data: {
+            worker
+        }
+    }) {
+        delete this._workerById[worker.id];
+        this._workers = Object.values(this._workerById);
+    },
+    _eventRestartGiveUp () {
+        _moduleLogger.fatal('Worker restart attempts exhausted with no remaining workers; giving up');
+
+        this.shutDown();
+    },
+    _eventShutDown () {
+        _moduleLogger.info('Shutting down workers');
+
+        this._active = false;
+
+        this._restartAbortController?.abort();
+
+        _cluster.disconnect(() => {
+            this._publish('shutDownComplete');
+        });
+
+        return this;
+    },
+    _eventShutDownComplete () {
+        _moduleLogger.info('Worker shut down complete');
+    },
+    _eventWorkerDisconnect ({
+        data: {
+            worker
+        }
+    }) {
+        _moduleLogger.info({
+            workerId: worker.id
+        }, 'Worker disconnected');
+
+        this._removeWorker({
+            worker
+        });
+    },
+    _eventWorkerError ({
+        data: {
+            error,
+            worker
+        }
+    }) {
+        _moduleLogger.fatal({
+            error: _Error({
+                details: {
+                    workerId: worker.id
+                },
+                error,
+                message: 'Worker error'
+            }),
+            workerId: worker.id
+        }, 'Worker error');
+
+        this._removeWorker({
+            worker
+        });
+    },
+    _eventWorkerExit ({
+        data: {
+            code,
+            signal,
+            worker
+        }
+    }) {
+        if (worker.exitedAfterDisconnect) {
+            _moduleLogger.info({
+                code,
+                signal,
+                workerId: worker.id
+            }, 'Worker exited voluntarily');
+        } else if (code) {
+            _moduleLogger.fatal({
+                code,
+                signal,
+                workerId: worker.id
+            }, 'Worker died unexpectedly');
+        } else {
+            _moduleLogger.error({
+                code,
+                signal,
+                workerId: worker.id
+            }, 'Worker died');
+        }
+
+        this._removeWorker({
+            worker
+        });
+
+        if (this._active) {
+            if (this._restartBackoff && !worker.exitedAfterDisconnect) {
+                this._restartWorker();
+            } else {
+                _moduleLogger.info('Replacing dead worker');
+
+                this.fork();
+            }
+        }
+    },
+    _eventWorkerFork ({
+        data: {
+            worker
+        }
+    }) {
+        _moduleLogger.info({
+            workerId: worker.id
+        }, 'Starting new worker');
+
+        worker.on('error', error => {
+            this._publish('workerError', {
+                error: _Error({
+                    details: {
+                        worker
+                    },
+                    error,
+                    message: 'Error in worker'
+                }),
+                worker
+            });
+        });
+    },
+    _eventWorkerListening ({
+        data: {
+            address,
+            worker
+        }
+    }) {
+        _moduleLogger.info({
+            address: address.address,
+            port: address.port,
+            workerId: worker.id
+        }, 'Worker is listening');
+    },
+    _eventWorkerMessage (event) {
+        if (event.data.message && event.data.message.type) {
+            const method = this[`_eventWorkerMessage_${event.data.message.type}`];
+
+            if (typeof method === 'function') {
+                Reflect.apply(method, this, [
+                    event
+                ]);
+            }
+        }
+    },
+    _eventWorkerOnline ({
+        data: {
+            worker
+        }
+    }) {
+        _moduleLogger.info({
+            workerId: worker.id
+        }, 'Worker is now online');
+
+        const listener = message => {
+            if (message === 'ready') {
+                worker.removeListener('message', listener);
+
+                this._publish('workerReady', {
+                    worker
+                });
+            }
+        };
+
+        worker.on('message', listener);
+    },
+    _eventWorkerReady ({
+        data: {
+            worker
+        }
+    }) {
+        _moduleLogger.info({
+            workerId: worker.id
+        }, 'Worker is ready to work');
+
+        this._restartBackoff?.succeeded();
+
+        this._addWorker({
+            worker
+        });
+    },
+    _init (...args) {
+        this._active = true;
+
+        this._clusterListenerByEventName = {
+            disconnect: worker => {
+                this._publish('workerDisconnect', {
+                    worker
+                });
+            },
+            exit: (worker, code, signal) => {
+                this._publish('workerExit', {
+                    code,
+                    signal,
+                    worker
+                });
+            },
+            fork: worker => {
+                this._publish('workerFork', {
+                    worker
+                });
+            },
+            listening: (worker, address) => {
+                this._publish('workerListening', {
+                    address,
+                    worker
+                });
+            },
+            message: (worker, message, handle) => {
+                this._publish('workerMessage', {
+                    handle,
+                    message,
+                    worker
+                });
+            },
+            online: worker => {
+                this._publish('workerOnline', {
+                    worker
+                });
+            }
+        };
+
+        this._workerById = Object.create(null);
+
+        this._workers = [];
+
+        this._roundRobinCounter = 0;
+
+        this._workerTimeByWorkerWeakMapByTag = Object.create(null);
+
+        return Reflect.apply(_Initializable.prototype._init, this, args);
+    },
+    _initialize (...args) {
+        _moduleLogger.info('Initializing primary');
+
+        const [{
+            restartBackoff,
+            workerArgs,
+            workerScript,
+            workerSilent,
+            workerStdio
+        } = {}] = args;
+
+        if (restartBackoff || typeof restartBackoff === 'undefined') {
+            if (typeof restartBackoff?.failed === 'function') {
+                this._restartBackoff = restartBackoff;
+            } else {
+                this._ownRestartBackoff = true;
+                this._restartBackoff = _Backoff(restartBackoff);
+            }
+
+            this._restartAbortController = new AbortController();
+        }
+
+        _cluster.setupPrimary({
+            args: typeof workerArgs === 'undefined' ?
+                _process.argv.slice(2) :
+                workerArgs,
+            exec: typeof workerScript === 'undefined' ?
+                _process.argv[1] :
+                workerScript,
+            silent: typeof workerSilent === 'undefined' ?
+                false :
+                workerSilent,
+            stdio: workerStdio
+        });
+
+        Object.keys(this._clusterListenerByEventName).forEach(eventName => {
+            _cluster.on(eventName, this._clusterListenerByEventName[eventName]);
+        });
+    },
+    _removeWorker ({
+        worker
+    }) {
+        if (worker.id in this._workerById) {
+            this._publish('removeWorker', {
+                worker
+            });
+        }
+
+        return this;
+    },
+    _restartWorker () {
+        this._restartBackoff.failed();
+
+        if (this._restartBackoff.exhausted) {
+            if (this._workers.length) {
+                _moduleLogger.error('Worker restart attempts exhausted; continuing with remaining workers');
+            } else {
+                this._publish('restartGiveUp');
+            }
+
+            return this;
+        }
+
+        const {
+            delay
+        } = this._restartBackoff;
+
+        if (delay) {
+            _moduleLogger.warn({
+                delay
+            }, 'Delaying worker replacement');
+
+            this._restartBackoff.attempt({
+                signal: this._restartAbortController.signal
+            }).then(() => {
+                _moduleLogger.info('Replacing dead worker');
+
+                this.fork();
+            }, () => {
+                // The delayed replacement was canceled during shut down.
+            });
+        } else {
+            _moduleLogger.info('Replacing dead worker');
+
+            this.fork();
+        }
+
+        return this;
+    }
+}, {
+    _pubsub: {
+        addWorker: {
+            completeFunction: '_eventAddWorker'
+        },
+        fork: {
+            completeFunction: '_eventFork'
+        },
+        removeWorker: {
+            completeFunction: '_eventRemoveWorker'
+        },
+        restartGiveUp: {
+            completeFunction: '_eventRestartGiveUp'
+        },
+        shutDown: {
+            completeFunction: '_eventShutDown',
+            completeOnce: true
+        },
+        shutDownComplete: {
+            completeFunction: '_eventShutDownComplete',
+            publishOnce: true
+        },
+        workerDisconnect: {
+            completeFunction: '_eventWorkerDisconnect'
+        },
+        workerError: {
+            completeFunction: '_eventWorkerError'
+        },
+        workerExit: {
+            completeFunction: '_eventWorkerExit'
+        },
+        workerFork: {
+            completeFunction: '_eventWorkerFork'
+        },
+        workerListening: {
+            completeFunction: '_eventWorkerListening'
+        },
+        workerMessage: {
+            completeFunction: '_eventWorkerMessage'
+        },
+        workerOnline: {
+            completeFunction: '_eventWorkerOnline'
+        },
+        workerReady: {
+            completeFunction: '_eventWorkerReady'
+        }
+    }
+});

package/lib/cluster-worker.js

@@ -1,2 +1,117 @@
-import _cluster from"node:cluster";import _Error from"isotropic-error";import _Initializable from"isotropic-initializable";import _later from"isotropic-later";import _logger from"isotropic-logger";import _make from"isotropic-make";import _path from"node:path";import _process from"node:process";const _workerId=_cluster.worker&&_cluster.worker.id,_moduleLogger=_logger.child({module:_path.basename(import.meta.filename,_path.extname(import.meta.filename)),workerId:_workerId});export default _make(_Initializable,{send({message:a}){return new Promise((b,c)=>{_process.send(a,d=>{d?c(_Error({details:{message:a},error:d,message:"Error sending message to primary"})):b()})})},_destroy(...a){Object.keys(this._processEvents).forEach(a=>{_process.removeListener(a,this._processEvents[a])}),this._processEvents=void 0,Reflect.apply(_Initializable.prototype._destroy,this,a)},_destroyComplete({timeout:a=6765}={}){_cluster.worker&&(_cluster.worker.disconnect(),_later(a,()=>{_cluster.worker.kill()}))},_eventPrimaryDisconnect(){_moduleLogger.info("Primary disconnected")},_eventPrimaryMessage(a){if(a.data.message&&a.data.message.type){const b=this[`_eventPrimaryMessage_${a.data.message.type}`];"function"==typeof b&&Reflect.apply(b,this,[a])}},_init(...a){return this._processEvents={disconnect:()=>{this._publish("primaryDisconnect")},message:(a,b)=>{this._publish("primaryMessage",{handle:b,message:a})}},Reflect.apply(_Initializable.prototype._init,this,a)},_initialize(){if(_cluster.isWorker)_moduleLogger.info("Initializing worker"),Object.keys(this._processEvents).forEach(a=>{_process.on(a,this._processEvents[a])});else throw _Error({message:"Cluster worker can not initialize in non-worker process"})},_initializeComplete(){_process.send("ready")}},{get worker(){return _cluster.worker},get workerId(){return _workerId},_pubsub:{primaryDisconnect:{completeFunction:"_eventPrimaryDisconnect"},primaryMessage:{completeFunction:"_eventPrimaryMessage"}}});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cluster","_Error","_Initializable","_later","_logger","_make","_path","_process","_workerId","worker","id","_moduleLogger","child","module","basename","import","meta","filename","extname","workerId","send","message","Promise","resolve","reject","error","details","_destroy","args","Object","keys","_processEvents","forEach","eventName","removeListener","Reflect","apply","prototype","_destroyComplete","timeout","disconnect","kill","_eventPrimaryDisconnect","info","_eventPrimaryMessage","event","data","type","method","_init","_publish","handle","_initialize","isWorker","on","_initializeComplete","_pubsub","primaryDisconnect","completeFunction","primaryMessage"],"sources":["../js/cluster-worker.js"],"sourcesContent":["import _cluster from 'node:cluster';\nimport _Error from 'isotropic-error';\nimport _Initializable from 'isotropic-initializable';\nimport _later from 'isotropic-later';\nimport _logger from 'isotropic-logger';\nimport _make from 'isotropic-make';\nimport _path from 'node:path';\nimport _process from 'node:process';\n\nconst _workerId = _cluster.worker && _cluster.worker.id,\n\n    _moduleLogger = _logger.child({\n        module: _path.basename(import.meta.filename, _path.extname(import.meta.filename)),\n        workerId: _workerId\n    });\n\nexport default _make(_Initializable, {\n    send ({\n        message\n    }) {\n        return new Promise((resolve, reject) => {\n            _process.send(message, error => {\n                if (error) {\n                    reject(_Error({\n                        details: {\n                            message\n                        },\n                        error,\n                        message: 'Error sending message to primary'\n                    }));\n                } else {\n                    resolve();\n                }\n            });\n        });\n    },\n    _destroy (...args) {\n        Object.keys(this._processEvents).forEach(eventName => {\n            _process.removeListener(eventName, this._processEvents[eventName]);\n        });\n\n        this._processEvents = void null;\n\n        Reflect.apply(_Initializable.prototype._destroy, this, args);\n    },\n    _destroyComplete ({\n        timeout = 6765\n    } = {}) {\n        if (_cluster.worker) {\n            _cluster.worker.disconnect();\n\n            _later(timeout, () => {\n                _cluster.worker.kill();\n            });\n        }\n    },\n    _eventPrimaryDisconnect () {\n        _moduleLogger.info('Primary disconnected');\n    },\n    _eventPrimaryMessage (event) {\n        if (event.data.message && event.data.message.type) {\n            const method = this[`_eventPrimaryMessage_${event.data.message.type}`];\n\n            if (typeof method === 'function') {\n                Reflect.apply(method, this, [\n                    event\n                ]);\n            }\n        }\n    },\n    _init (...args) {\n        this._processEvents = {\n            disconnect: () => {\n                this._publish('primaryDisconnect');\n            },\n            message: (message, handle) => {\n                this._publish('primaryMessage', {\n                    handle,\n                    message\n                });\n            }\n        };\n\n        return Reflect.apply(_Initializable.prototype._init, this, args);\n    },\n    _initialize () {\n        if (_cluster.isWorker) {\n            _moduleLogger.info('Initializing worker');\n\n            Object.keys(this._processEvents).forEach(eventName => {\n                _process.on(eventName, this._processEvents[eventName]);\n            });\n        } else {\n            throw _Error({\n                message: 'Cluster worker can not initialize in non-worker process'\n            });\n        }\n    },\n    _initializeComplete () {\n        _process.send('ready');\n    }\n}, {\n    get worker () {\n        return _cluster.worker;\n    },\n    get workerId () {\n        return _workerId;\n    },\n    _pubsub: {\n        primaryDisconnect: {\n            completeFunction: '_eventPrimaryDisconnect'\n        },\n        primaryMessage: {\n            completeFunction: '_eventPrimaryMessage'\n        }\n    }\n});\n"],"mappings":"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","ignoreList":[]}
+import _cluster from 'node:cluster';
+import _Error from 'isotropic-error';
+import _Initializable from 'isotropic-initializable';
+import _later from 'isotropic-later';
+import _logger from 'isotropic-logger';
+import _make from 'isotropic-make';
+import _path from 'node:path';
+import _process from 'node:process';
+
+const _workerId = _cluster.worker && _cluster.worker.id,
+
+    _moduleLogger = _logger.child({
+        module: _path.basename(import.meta.filename, _path.extname(import.meta.filename)),
+        workerId: _workerId
+    });
+
+export default _make('ClusterWorker', _Initializable, {
+    send ({
+        message
+    }) {
+        return new Promise((resolve, reject) => {
+            _process.send(message, error => {
+                if (error) {
+                    reject(_Error({
+                        details: {
+                            message
+                        },
+                        error,
+                        message: 'Error sending message to primary'
+                    }));
+                } else {
+                    resolve();
+                }
+            });
+        });
+    },
+    _destroy (...args) {
+        Object.keys(this._processEvents).forEach(eventName => {
+            _process.removeListener(eventName, this._processEvents[eventName]);
+        });
+
+        this._processEvents = void null;
+
+        Reflect.apply(_Initializable.prototype._destroy, this, args);
+    },
+    _destroyComplete ({
+        timeout = 6765
+    } = {}) {
+        if (_cluster.worker) {
+            _cluster.worker.disconnect();
+
+            _later(timeout, () => {
+                _cluster.worker.kill();
+            }).unref();
+        }
+    },
+    _eventPrimaryDisconnect () {
+        _moduleLogger.info('Primary disconnected');
+    },
+    _eventPrimaryMessage (event) {
+        if (event.data.message && event.data.message.type) {
+            const method = this[`_eventPrimaryMessage_${event.data.message.type}`];
+
+            if (typeof method === 'function') {
+                Reflect.apply(method, this, [
+                    event
+                ]);
+            }
+        }
+    },
+    _init (...args) {
+        this._processEvents = {
+            disconnect: () => {
+                this._publish('primaryDisconnect');
+            },
+            message: (message, handle) => {
+                this._publish('primaryMessage', {
+                    handle,
+                    message
+                });
+            }
+        };
+
+        return Reflect.apply(_Initializable.prototype._init, this, args);
+    },
+    _initialize () {
+        if (_cluster.isWorker) {
+            _moduleLogger.info('Initializing worker');
+
+            Object.keys(this._processEvents).forEach(eventName => {
+                _process.on(eventName, this._processEvents[eventName]);
+            });
+        } else {
+            throw _Error({
+                message: 'Cluster worker can not initialize in non-worker process'
+            });
+        }
+    },
+    _initializeComplete () {
+        _process.send('ready');
+    }
+}, {
+    get worker () {
+        return _cluster.worker;
+    },
+    get workerId () {
+        return _workerId;
+    },
+    _pubsub: {
+        primaryDisconnect: {
+            completeFunction: '_eventPrimaryDisconnect'
+        },
+        primaryMessage: {
+            completeFunction: '_eventPrimaryMessage'
+        }
+    }
+});

package/package.json

@@ -2,42 +2,47 @@
     "author": "Steven Olmsted <steven.olmsted@ibigroup.com>",
     "bugs": "https://github.com/ibi-group/isotropic-cluster/issues",
     "dependencies": {
-        "isotropic-error": "~0.13.1",
-        "isotropic-initializable": "~0.11.0",
-        "isotropic-later": "~0.13.1",
-        "isotropic-logger": "~0.3.1",
-        "isotropic-make": "~0.13.1"
+        "isotropic-backoff": "~0.1.0",
+        "isotropic-error": "~0.14.0",
+        "isotropic-initializable": "~0.13.0",
+        "isotropic-later": "~0.15.0",
+        "isotropic-logger": "~0.5.0",
+        "isotropic-make": "~0.14.0"
     },
     "description": "A reusable and extendable platform to manage local process clusters",
     "devDependencies": {
-        "bunyan-stream-isotropic": "~0.3.1",
-        "eslint": "~9.8.0",
-        "isotropic-dev-dependencies": "~0.3.1"
+        "isotropic-dev-dependencies": "~0.4.0",
+        "isotropic-logger-pretty": "~0.5.0"
     },
     "engines": {
-        "node": "^22.5.1",
-        "npm": "^10.8.2"
+        "node": "^26.5.0",
+        "npm": "^11.17.0"
     },
     "files": [
         "lib"
     ],
     "homepage": "https://github.com/ibi-group/isotropic-cluster",
     "keywords": [
-        "isotropic"
+        "cluster",
+        "fork",
+        "ipc",
+        "isotropic",
+        "primary",
+        "process",
+        "restart",
+        "worker"
     ],
     "license": "BSD-3-Clause",
     "name": "isotropic-cluster",
     "repository": "github:ibi-group/isotropic-cluster",
     "scripts": {
-        "build": "cross-env BABEL_ENV=node-minify babel --config-file ./node_modules/isotropic-dev-dependencies/config/babel.json js -d lib --delete-dir-on-start",
-        "lint": "eslint js test",
-        "postprepare": "node ./node_modules/isotropic-dev-dependencies/lib/install-git-hooks.js",
-        "posttest": "[ -z \"$npm_config_coverage\" ] || c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json check-coverage",
-        "prepare": "npm run build",
-        "prepublishOnly": "npm test --coverage",
+        "lint": "eslint eslint.config.js lib test",
+        "posttest": "c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json check-coverage",
+        "prepare": "node ./node_modules/isotropic-dev-dependencies/lib/install-git-hooks.js",
+        "prepublishOnly": "npm test",
         "pretest": "npm run lint",
-        "test": "cross-env BABEL_ENV=test c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json mocha --import=isotropic-dev-dependencies/lib/register-babel-loader.js"
+        "test": "c8 -c ./node_modules/isotropic-dev-dependencies/config/c8.json node --test"
     },
     "type": "module",
-    "version": "0.4.0"
+    "version": "0.6.0"
 }