@nsshunt/stsrunnerframework 1.0.174 → 1.0.176

package/dist/stsrunnerframework.umd.js

@@ -1,19 +1,7 @@
 (function(global2, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@nsshunt/stsutils"), require("@nsshunt/stsobservability")) : typeof define === "function" && define.amd ? define(["exports", "@nsshunt/stsutils", "@nsshunt/stsobservability"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2["@nsshunt/stsrunnerframework"] = {}, global2.stsutils, global2.stsobservability));
-})(this, function(exports2, stsutils, stsobservability) {
-  "use strict";var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-  var _collectorCollectorPort, _runners, _options, _workerId, _archiveDeleteTimeout, _logMessage, _silly, _debug, _info, _warn, _error, _processLoopExecutor, _SetMessagePort, _CreateRunnerEx2RunState, _UpdateRunnerStateById, _CanExecuteNextIterationById, _IsCompletedById, _GetRunnerIterationById, _ResetRunnerIterationById, _IncRunnerIterationById, _GetRunnerInstanceById, _GetRunnerExecutionProfileById, _GetRunnerOptionsById, _SetRunnerOptionsById, _AddRunner, _WorkerInstance_instances, SleepImmediate_fn, _PostMessageToWorkerManagerById, _PostRunnersToWorkerManager, _StartRunner, _StopRunnerByRunnerId, _StopRunner, _TerminateRunner, _SendRunnerCommandResponse, _PauseRunner, _ResumeRunner, _ResetRunner, _ExecuteRunner, _UpdateRunner, _workersEx, _options2, _STSInstrumentController, _telemetryProcessor, _archiveList, _id, _messages, _archiveDeleteTimeout2, _logMessage2, _silly2, _debug2, _info2, _warn2, _error2, _processLoopExecutor2, _SetRunnerIntoWorker, _ProcessTelemetry, _EmitWorkerEvent, _EmitRunnerEvent, _RunnerStateChange, _CreateAsyncRunner, _PostMessageToWorkerUsingDefaultChannel, _StartRunner2, _StopRunner2, _ResetRunner2, _ExecuteRunner2, _TerminateRunner2, _PauseRunner2, _ResumeRunner2, _UpdateRunner2, _StartWorker, _StopWorker, _PauseWorker, _ResumeWorker, _ResetWorker, _ExecuteWorker, _UpdateOptionsWorker, _TerminateWorker, _ProcessWorkerCommands, _ExecuteVariableCommandOnRunners, _STSWorkerManager_instances, GetRunnersResponse_fn, ProcessRunnerResponse_fn, _SyncRunnerData, _SyncWorkerDataFromPayload, _SyncWorkerDataFromWorker, _SyncWorkerDataFromWorkers, _SetupCallbackMessage, _PostMessageToWorkerGetRunners;
+})(this, (function(exports2, stsutils, stsobservability) {
+  "use strict";
   var eIWMessageCommands = /* @__PURE__ */ ((eIWMessageCommands2) => {
     eIWMessageCommands2["InstrumentTelemetry"] = "__STS__InstrumentTelemetry";
     eIWMessageCommands2["MessagePort"] = "__STS__MessagePort";
@@ -1533,785 +1521,735 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
   const chalk = /* @__PURE__ */ getDefaultExportFromCjs(sourceExports);
   chalk.level = 3;
   class WorkerInstance {
-    constructor() {
-      __privateAdd(this, _WorkerInstance_instances);
-      __privateAdd(this, _collectorCollectorPort, null);
-      __privateAdd(this, _runners, {});
-      __privateAdd(this, _options, null);
-      __privateAdd(this, _workerId, null);
-      __privateAdd(this, _archiveDeleteTimeout, 30);
-      __privateAdd(this, _logMessage, (fn, message) => {
-        if (__privateGet(this, _options)) {
-          fn(`pid: [${process.pid}] WorkerInstance: Worker ID: [${__privateGet(this, _workerId)}] Log: [${message}]`);
-        } else {
-          fn(`pid: [${process.pid}] WorkerInstance: Log: [${message}]`);
-        }
-      });
-      __privateAdd(this, _silly, (message) => {
-        if (__privateGet(this, _options) && __privateGet(this, _options).logLevel >= 5) {
-          __privateGet(this, _logMessage).call(this, this.logger.silly, message);
-        }
-      });
-      __privateAdd(this, _debug, (message) => {
-        if (__privateGet(this, _options) && __privateGet(this, _options).logLevel >= 4) {
-          __privateGet(this, _logMessage).call(this, this.logger.debug, message);
-        }
-      });
-      __privateAdd(this, _info, (message) => {
-        if (__privateGet(this, _options) && __privateGet(this, _options).logLevel >= 3) {
-          __privateGet(this, _logMessage).call(this, this.logger.info, message);
-        }
-      });
-      __privateAdd(this, _warn, (message) => {
-        if (__privateGet(this, _options) && __privateGet(this, _options).logLevel >= 2) {
-          __privateGet(this, _logMessage).call(this, this.logger.warn, message);
-        }
-      });
-      __privateAdd(this, _error, (error) => {
-        if (__privateGet(this, _options) && __privateGet(this, _options).logLevel >= 1) {
-          __privateGet(this, _logMessage).call(this, this.logger.error, error);
-        }
-      });
-      __privateAdd(this, _processLoopExecutor, async () => {
-        try {
-          const removeList = [];
-          for (const [, runner] of Object.entries(__privateGet(this, _runners))) {
-            if (runner.archived === false && (runner.runner.state === IRunnerState.completed || runner.runner.state === IRunnerState.error || runner.runner.state === IRunnerState.stopped || runner.runner.state === IRunnerState.terminated)) {
-              removeList.push(runner.runner.id);
-            }
+    #collectorCollectorPort = null;
+    #runners = {};
+    #options = null;
+    #workerId = null;
+    #archiveDeleteTimeout = 30;
+    get logger() {
+      return stsutils.defaultLogger;
+    }
+    #logMessage = (fn, message) => {
+      if (this.#options) {
+        fn(`pid: [${process.pid}] WorkerInstance: Worker ID: [${this.#workerId}] Log: [${message}]`);
+      } else {
+        fn(`pid: [${process.pid}] WorkerInstance: Log: [${message}]`);
+      }
+    };
+    #silly = (message) => {
+      if (this.#options && this.#options.logLevel >= 5) {
+        this.#logMessage(this.logger.silly, message);
+      }
+    };
+    #debug = (message) => {
+      if (this.#options && this.#options.logLevel >= 4) {
+        this.#logMessage(this.logger.debug, message);
+      }
+    };
+    #info = (message) => {
+      if (this.#options && this.#options.logLevel >= 3) {
+        this.#logMessage(this.logger.info, message);
+      }
+    };
+    #warn = (message) => {
+      if (this.#options && this.#options.logLevel >= 2) {
+        this.#logMessage(this.logger.warn, message);
+      }
+    };
+    #error = (error) => {
+      if (this.#options && this.#options.logLevel >= 1) {
+        this.#logMessage(this.logger.error, error);
+      }
+    };
+    #processLoopExecutor = async () => {
+      try {
+        const removeList = [];
+        for (const [, runner] of Object.entries(this.#runners)) {
+          if (runner.archived === false && (runner.runner.state === IRunnerState.completed || runner.runner.state === IRunnerState.error || runner.runner.state === IRunnerState.stopped || runner.runner.state === IRunnerState.terminated)) {
+            removeList.push(runner.runner.id);
           }
-          if (removeList.length > 0) {
-            setTimeout(() => {
-              __privateGet(this, _debug).call(this, chalk.grey(`WorkerInstance:#processLoopExecutor(): Removing runners from collection: [${removeList}]`));
-              for (let i = 0; i < removeList.length; i++) {
-                __privateGet(this, _runners)[removeList[i]].archived = true;
-                if (__privateGet(this, _archiveDeleteTimeout) !== 0) {
-                  if (isNode) {
-                    setTimeout(() => delete __privateGet(this, _runners)[removeList[i]], __privateGet(this, _archiveDeleteTimeout) * 1e3).unref();
-                  } else {
-                    setTimeout(() => delete __privateGet(this, _runners)[removeList[i]], __privateGet(this, _archiveDeleteTimeout) * 1e3);
-                  }
+        }
+        if (removeList.length > 0) {
+          setTimeout(() => {
+            this.#debug(chalk.grey(`WorkerInstance:#processLoopExecutor(): Removing runners from collection: [${removeList}]`));
+            for (let i = 0; i < removeList.length; i++) {
+              this.#runners[removeList[i]].archived = true;
+              if (this.#archiveDeleteTimeout !== 0) {
+                if (isNode) {
+                  setTimeout(() => delete this.#runners[removeList[i]], this.#archiveDeleteTimeout * 1e3).unref();
+                } else {
+                  setTimeout(() => delete this.#runners[removeList[i]], this.#archiveDeleteTimeout * 1e3);
                 }
               }
-              __privateGet(this, _debug).call(this, chalk.grey(`WorkerInstance:#processLoopExecutor(): Remaining Runner Count: [${Object.keys(__privateGet(this, _runners)).length}]`));
-              setTimeout(__privateGet(this, _processLoopExecutor), 1e3);
-            }, 100);
-          } else {
-            setTimeout(__privateGet(this, _processLoopExecutor), 1e3);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#processLoopExecutor(): [${error}]`);
-          setTimeout(__privateGet(this, _processLoopExecutor), 1e3);
-        }
-      });
-      __publicField(this, "GetRandomInt", (max) => {
-        return Math.floor(Math.random() * Math.floor(max));
-      });
-      __publicField(this, "PostTelemetryById", (id) => {
-        __privateGet(this, _PostMessageToWorkerManagerById).call(this, eIWMessageCommands.InstrumentTelemetry, id, false);
-      });
-      __privateAdd(this, _SetMessagePort, (workerMessagePort) => {
-        try {
-          __privateSet(this, _collectorCollectorPort, workerMessagePort.port);
-          if (isNode) {
-            __privateGet(this, _collectorCollectorPort).on("message", (data) => {
-              __privateGet(this, _silly).call(this, `collectorCollectorPort on('message'): ${JSON.stringify(data)}`);
-            });
-          } else {
-            __privateGet(this, _collectorCollectorPort).addEventListener("message", (data) => {
-              __privateGet(this, _silly).call(this, `collectorCollectorPort addEventListener('message'): ${JSON.stringify(data.data)}`);
-            });
-          }
-          const response = {
-            command: eIWMessageCommands.MessagePortResponse,
-            payload: {}
-          };
-          __privateGet(this, _collectorCollectorPort).postMessage(response);
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#SetMessagePort(): [${error}]`);
+            }
+            this.#debug(chalk.grey(`WorkerInstance:#processLoopExecutor(): Remaining Runner Count: [${Object.keys(this.#runners).length}]`));
+            setTimeout(this.#processLoopExecutor, 1e3);
+          }, 100);
+        } else {
+          setTimeout(this.#processLoopExecutor, 1e3);
         }
-      });
-      __publicField(this, "CreateAsyncRunner", async (testRunnerTelemetryPayload) => {
-        return null;
-      });
-      __privateAdd(this, _CreateRunnerEx2RunState, async (runner, runnerInstance) => {
-        try {
-          __privateGet(this, _runners)[runner.id] = {
-            runner,
-            runnerInstance,
-            archived: false
-          };
-          __privateGet(this, _runners)[runner.id].runner.iteration = 0;
-          __privateGet(this, _UpdateRunnerStateById).call(this, "#CreateRunnerEx2RunState", runner.id, IRunnerState.created);
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#CreateRunnerEx2RunState(): [${error}]`);
+      } catch (error) {
+        this.#error(`#processLoopExecutor(): [${error}]`);
+        setTimeout(this.#processLoopExecutor, 1e3);
+      }
+    };
+    constructor() {
+      this.#processLoopExecutor();
+    }
+    GetRandomInt = (max) => {
+      return Math.floor(Math.random() * Math.floor(max));
+    };
+    PostTelemetryById = (id) => {
+      this.#PostMessageToWorkerManagerById(eIWMessageCommands.InstrumentTelemetry, id, false);
+    };
+    get CollectorCollectorPort() {
+      return this.#collectorCollectorPort;
+    }
+    get Options() {
+      return this.#options;
+    }
+    #SetMessagePort = (workerMessagePort) => {
+      try {
+        this.#collectorCollectorPort = workerMessagePort.port;
+        if (isNode) {
+          this.#collectorCollectorPort.on("message", (data) => {
+            this.#silly(`collectorCollectorPort on('message'): ${JSON.stringify(data)}`);
+          });
+        } else {
+          this.#collectorCollectorPort.addEventListener("message", (data) => {
+            this.#silly(`collectorCollectorPort addEventListener('message'): ${JSON.stringify(data.data)}`);
+          });
         }
-      });
-      __privateAdd(this, _UpdateRunnerStateById, (fromContext, id, state) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            const previousState = __privateGet(this, _runners)[id].runner.state;
-            __privateGet(this, _runners)[id].runner.state = state;
-            __privateGet(this, _debug).call(this, `#UpdateRunnerStateById(): Context: [${fromContext}] Previous State: [${previousState}] New State: [${state}]`);
-            __privateGet(this, _PostMessageToWorkerManagerById).call(this, eIWMessageCommands.RunnerStateChange, id, false);
-          } else {
-            __privateGet(this, _warn).call(this, `#UpdateRunnerStateById(): Runner ID: [${id}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#UpdateRunnerStateById(): [${error}]`);
+        const response = {
+          command: eIWMessageCommands.MessagePortResponse,
+          payload: {}
+        };
+        this.#collectorCollectorPort.postMessage(response);
+      } catch (error) {
+        this.#error(`#SetMessagePort(): [${error}]`);
+      }
+    };
+    CreateAsyncRunner = async (testRunnerTelemetryPayload) => {
+      return null;
+    };
+    #CreateRunnerEx2RunState = async (runner, runnerInstance) => {
+      try {
+        this.#runners[runner.id] = {
+          runner,
+          runnerInstance,
+          archived: false
+        };
+        this.#runners[runner.id].runner.iteration = 0;
+        this.#UpdateRunnerStateById("#CreateRunnerEx2RunState", runner.id, IRunnerState.created);
+      } catch (error) {
+        this.#error(`#CreateRunnerEx2RunState(): [${error}]`);
+      }
+    };
+    #UpdateRunnerStateById = (fromContext, id, state) => {
+      try {
+        if (this.#runners[id]) {
+          const previousState = this.#runners[id].runner.state;
+          this.#runners[id].runner.state = state;
+          this.#debug(`#UpdateRunnerStateById(): Context: [${fromContext}] Previous State: [${previousState}] New State: [${state}]`);
+          this.#PostMessageToWorkerManagerById(eIWMessageCommands.RunnerStateChange, id, false);
+        } else {
+          this.#warn(`#UpdateRunnerStateById(): Runner ID: [${id}] not found`);
         }
-      });
-      // If an error occurs or the runner does not exist, treat as cannot execute next iteration
-      __privateAdd(this, _CanExecuteNextIterationById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            const state = __privateGet(this, _runners)[id].runner.state;
-            if (state === IRunnerState.running) {
-              return true;
-            }
-            return false;
-          } else {
-            __privateGet(this, _warn).call(this, `#CanExecuteNextIterationById(): Runner ID: [${id}] not found`);
-            return false;
+      } catch (error) {
+        this.#error(`#UpdateRunnerStateById(): [${error}]`);
+      }
+    };
+    // If an error occurs or the runner does not exist, treat as cannot execute next iteration
+    #CanExecuteNextIterationById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          const state = this.#runners[id].runner.state;
+          if (state === IRunnerState.running) {
+            return true;
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#CanExecuteNextIterationById(): [${error}]`);
+          return false;
+        } else {
+          this.#warn(`#CanExecuteNextIterationById(): Runner ID: [${id}] not found`);
           return false;
         }
-      });
-      // If an error occurs or the runner does not exist, treat as completed.
-      __privateAdd(this, _IsCompletedById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            const state = __privateGet(this, _runners)[id].runner.state;
-            if (state === IRunnerState.error || state === IRunnerState.completed || state === IRunnerState.stopped || state === IRunnerState.terminated) {
-              return true;
-            }
-            return false;
-          } else {
-            __privateGet(this, _warn).call(this, `#IsCompletedById(): Runner ID: [${id}] not found`);
+      } catch (error) {
+        this.#error(`#CanExecuteNextIterationById(): [${error}]`);
+        return false;
+      }
+    };
+    // If an error occurs or the runner does not exist, treat as completed.
+    #IsCompletedById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          const state = this.#runners[id].runner.state;
+          if (state === IRunnerState.error || state === IRunnerState.completed || state === IRunnerState.stopped || state === IRunnerState.terminated) {
             return true;
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#IsCompletedById(): [${error}]`);
+          return false;
+        } else {
+          this.#warn(`#IsCompletedById(): Runner ID: [${id}] not found`);
           return true;
         }
-      });
-      __privateAdd(this, _GetRunnerIterationById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            return __privateGet(this, _runners)[id].runner.iteration;
-          } else {
-            __privateGet(this, _warn).call(this, `#GetRunnerIterationById(): Runner ID: [${id}] not found`);
-            return 0;
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#GetRunnerIterationById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#IsCompletedById(): [${error}]`);
+        return true;
+      }
+    };
+    #GetRunnerIterationById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          return this.#runners[id].runner.iteration;
+        } else {
+          this.#warn(`#GetRunnerIterationById(): Runner ID: [${id}] not found`);
           return 0;
         }
-      });
-      __privateAdd(this, _ResetRunnerIterationById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            __privateGet(this, _runners)[id].runner.iteration = 0;
-            return 0;
-          } else {
-            __privateGet(this, _warn).call(this, `#ResetRunnerIterationById(): Runner ID: [${id}] not found`);
-            return 0;
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#ResetRunnerIterationById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#GetRunnerIterationById(): [${error}]`);
+        return 0;
+      }
+    };
+    #ResetRunnerIterationById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          this.#runners[id].runner.iteration = 0;
           return 0;
-        }
-      });
-      __privateAdd(this, _IncRunnerIterationById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            __privateGet(this, _runners)[id].runner.iteration++;
-            return __privateGet(this, _runners)[id].runner.iteration;
-          } else {
-            __privateGet(this, _warn).call(this, `#IncRunnerIterationById(): Runner ID: [${id}] not found`);
-            return 0;
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#IncRunnerIterationById(): [${error}]`);
+        } else {
+          this.#warn(`#ResetRunnerIterationById(): Runner ID: [${id}] not found`);
           return 0;
         }
-      });
-      __privateAdd(this, _GetRunnerInstanceById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            return __privateGet(this, _runners)[id].runnerInstance;
-          } else {
-            __privateGet(this, _warn).call(this, `#GetRunnerInstanceById(): Runner ID: [${id}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#GetRunnerInstanceById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#ResetRunnerIterationById(): [${error}]`);
+        return 0;
+      }
+    };
+    #IncRunnerIterationById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          this.#runners[id].runner.iteration++;
+          return this.#runners[id].runner.iteration;
+        } else {
+          this.#warn(`#IncRunnerIterationById(): Runner ID: [${id}] not found`);
+          return 0;
         }
-      });
-      __privateAdd(this, _GetRunnerExecutionProfileById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            return __privateGet(this, _runners)[id].runner.options.executionProfile;
-          } else {
-            __privateGet(this, _warn).call(this, `#GetRunnerExecutionProfileById(): Runner ID: [${id}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#GetRunnerExecutionProfileById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#IncRunnerIterationById(): [${error}]`);
+        return 0;
+      }
+    };
+    #GetRunnerInstanceById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          return this.#runners[id].runnerInstance;
+        } else {
+          this.#warn(`#GetRunnerInstanceById(): Runner ID: [${id}] not found`);
         }
-      });
-      __privateAdd(this, _GetRunnerOptionsById, (id) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            return __privateGet(this, _runners)[id].runner.options;
-          } else {
-            __privateGet(this, _warn).call(this, `#GetRunnerOptionsById(): Runner ID: [${id}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#GetRunnerOptionsById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#GetRunnerInstanceById(): [${error}]`);
+      }
+    };
+    #GetRunnerExecutionProfileById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          return this.#runners[id].runner.options.executionProfile;
+        } else {
+          this.#warn(`#GetRunnerExecutionProfileById(): Runner ID: [${id}] not found`);
         }
-      });
-      __privateAdd(this, _SetRunnerOptionsById, (id, options) => {
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            __privateGet(this, _runners)[id].runner.options = { ...options };
-            return __privateGet(this, _runners)[id].runner.options;
-          } else {
-            __privateGet(this, _warn).call(this, `#SetRunnerOptionsById(): Runner ID: [${id}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#SetRunnerOptionsById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#GetRunnerExecutionProfileById(): [${error}]`);
+      }
+    };
+    #GetRunnerOptionsById = (id) => {
+      try {
+        if (this.#runners[id]) {
+          return this.#runners[id].runner.options;
+        } else {
+          this.#warn(`#GetRunnerOptionsById(): Runner ID: [${id}] not found`);
         }
-      });
-      __privateAdd(this, _AddRunner, async (testRunnerTelemetryPayload) => {
-        let result;
-        let returnRunner;
-        try {
-          const { runner } = testRunnerTelemetryPayload;
-          const asyncRunnerInstance = await this.CreateAsyncRunner(testRunnerTelemetryPayload);
-          if (asyncRunnerInstance) {
-            await __privateGet(this, _CreateRunnerEx2RunState).call(this, runner, asyncRunnerInstance);
-          } else {
-            __privateGet(this, _warn).call(this, `#AddRunner(): CreateAsyncRunner not defined.`);
-          }
-          returnRunner = { ...runner };
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#AddRunner(): [${error}]`);
+      } catch (error) {
+        this.#error(`#GetRunnerOptionsById(): [${error}]`);
+      }
+    };
+    #SetRunnerOptionsById = (id, options) => {
+      try {
+        if (this.#runners[id]) {
+          this.#runners[id].runner.options = { ...options };
+          return this.#runners[id].runner.options;
+        } else {
+          this.#warn(`#SetRunnerOptionsById(): Runner ID: [${id}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.AddRunnerResponse, testRunnerTelemetryPayload, result);
-        return returnRunner;
-      });
-      __privateAdd(this, _PostMessageToWorkerManagerById, async (command, runnerId, response) => {
-        try {
-          if (__privateGet(this, _collectorCollectorPort)) {
-            if (__privateGet(this, _runners)[runnerId]) {
-              const message = {
-                command,
-                payload: {
-                  runner: __privateGet(this, _runners)[runnerId].runner
-                }
-              };
-              __privateGet(this, _collectorCollectorPort).postMessage(message);
-              await stsutils.Sleep(0);
-            } else {
-              __privateGet(this, _warn).call(this, `#PostMessageToWorkerManagerById(): Runner: [${runnerId}] not found`);
-            }
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#PostMessageToWorkerManagerById(): [${error}]`);
+      } catch (error) {
+        this.#error(`#SetRunnerOptionsById(): [${error}]`);
+      }
+    };
+    #AddRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      let returnRunner;
+      try {
+        const { runner } = testRunnerTelemetryPayload;
+        const asyncRunnerInstance = await this.CreateAsyncRunner(testRunnerTelemetryPayload);
+        if (asyncRunnerInstance) {
+          await this.#CreateRunnerEx2RunState(runner, asyncRunnerInstance);
+        } else {
+          this.#warn(`#AddRunner(): CreateAsyncRunner not defined.`);
         }
+        returnRunner = { ...runner };
+      } catch (error) {
+        this.#error(`#AddRunner(): [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.AddRunnerResponse, testRunnerTelemetryPayload, result);
+      return returnRunner;
+    };
+    #SleepImmediate() {
+      return new Promise((resolve, reject) => {
+        resolve();
       });
-      __privateAdd(this, _PostRunnersToWorkerManager, async (command, messagePayload) => {
-        try {
-          if (__privateGet(this, _collectorCollectorPort)) {
+    }
+    #PostMessageToWorkerManagerById = async (command, runnerId, response) => {
+      try {
+        if (this.#collectorCollectorPort) {
+          if (this.#runners[runnerId]) {
             const message = {
-              command: eIWMessageCommands.GetRunnersResponse,
+              command,
               payload: {
-                messageId: messagePayload.payload.messageId,
-                workerId: __privateGet(this, _workerId),
-                runners: Object.values(__privateGet(this, _runners)).map((runnerEx) => runnerEx.runner)
+                runner: this.#runners[runnerId].runner
               }
             };
-            __privateGet(this, _collectorCollectorPort).postMessage(message);
+            this.#collectorCollectorPort.postMessage(message);
             await stsutils.Sleep(0);
+          } else {
+            this.#warn(`#PostMessageToWorkerManagerById(): Runner: [${runnerId}] not found`);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#PostRunnersToWorkerManager(): [${error}]`);
         }
-      });
-      __privateAdd(this, _StartRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.created) {
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.StartRunner());
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#StartRunner-1", runnerId, IRunnerState.running);
-              await stsutils.Sleep(0);
-              const startLoop = /* @__PURE__ */ new Date();
-              const ExecuteLoop = async () => {
-                var _a2, _b, _c;
-                try {
-                  let cont = true;
-                  const executionProfile = __privateGet(this, _GetRunnerExecutionProfileById).call(this, runnerId);
-                  if (executionProfile) {
-                    const { iterations, duration, delayBetweenIterations, pauseOnComplete } = executionProfile;
-                    if (iterations > 0) {
-                      cont = __privateGet(this, _GetRunnerIterationById).call(this, runnerId) < iterations;
-                      if (cont === false && pauseOnComplete === true && __privateGet(this, _runners)[runnerId].runner.state === IRunnerState.paused) {
-                        cont = true;
-                      }
-                    } else if (duration > 0) {
-                      cont = ((/* @__PURE__ */ new Date()).getTime() - startLoop.getTime()) / 1e3 < duration;
+      } catch (error) {
+        this.#error(`#PostMessageToWorkerManagerById(): [${error}]`);
+      }
+    };
+    #PostRunnersToWorkerManager = async (command, messagePayload) => {
+      try {
+        if (this.#collectorCollectorPort) {
+          const message = {
+            command: eIWMessageCommands.GetRunnersResponse,
+            payload: {
+              messageId: messagePayload.payload.messageId,
+              workerId: this.#workerId,
+              runners: Object.values(this.#runners).map((runnerEx) => runnerEx.runner)
+            }
+          };
+          this.#collectorCollectorPort.postMessage(message);
+          await stsutils.Sleep(0);
+        }
+      } catch (error) {
+        this.#error(`#PostRunnersToWorkerManager(): [${error}]`);
+      }
+    };
+    #StartRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.created) {
+            result = await this.#GetRunnerInstanceById(runnerId)?.StartRunner();
+            this.#UpdateRunnerStateById("#StartRunner-1", runnerId, IRunnerState.running);
+            await stsutils.Sleep(0);
+            const startLoop = /* @__PURE__ */ new Date();
+            const ExecuteLoop = async () => {
+              try {
+                let cont = true;
+                const executionProfile = this.#GetRunnerExecutionProfileById(runnerId);
+                if (executionProfile) {
+                  const { iterations, duration, delayBetweenIterations, pauseOnComplete } = executionProfile;
+                  if (iterations > 0) {
+                    cont = this.#GetRunnerIterationById(runnerId) < iterations;
+                    if (cont === false && pauseOnComplete === true && this.#runners[runnerId].runner.state === IRunnerState.paused) {
+                      cont = true;
                     }
-                    if (cont) {
-                      if (__privateGet(this, _CanExecuteNextIterationById).call(this, runnerId)) {
-                        await ((_a2 = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a2.ExecuteRunner());
-                        if (!__privateGet(this, _IsCompletedById).call(this, runnerId)) {
-                          __privateGet(this, _IncRunnerIterationById).call(this, runnerId);
-                        }
+                  } else if (duration > 0) {
+                    cont = ((/* @__PURE__ */ new Date()).getTime() - startLoop.getTime()) / 1e3 < duration;
+                  }
+                  if (cont) {
+                    if (this.#CanExecuteNextIterationById(runnerId)) {
+                      await this.#GetRunnerInstanceById(runnerId)?.ExecuteRunner();
+                      if (!this.#IsCompletedById(runnerId)) {
+                        this.#IncRunnerIterationById(runnerId);
                       }
-                      if (__privateGet(this, _CanExecuteNextIterationById).call(this, runnerId)) {
-                        if (delayBetweenIterations > 0) {
-                          await stsutils.Sleep(delayBetweenIterations);
-                        } else {
-                          await __privateMethod(this, _WorkerInstance_instances, SleepImmediate_fn).call(this);
-                        }
-                        ExecuteLoop();
+                    }
+                    if (this.#CanExecuteNextIterationById(runnerId)) {
+                      if (delayBetweenIterations > 0) {
+                        await stsutils.Sleep(delayBetweenIterations);
                       } else {
-                        if (!__privateGet(this, _IsCompletedById).call(this, runnerId)) {
-                          await stsutils.Sleep(50);
-                          ExecuteLoop();
-                        }
+                        await this.#SleepImmediate();
                       }
+                      ExecuteLoop();
                     } else {
-                      if (pauseOnComplete === true) {
-                        await ((_b = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _b.PauseRunner());
-                        __privateGet(this, _UpdateRunnerStateById).call(this, "#StartRunner-2", runnerId, IRunnerState.paused);
+                      if (!this.#IsCompletedById(runnerId)) {
+                        await stsutils.Sleep(50);
                         ExecuteLoop();
-                      } else {
-                        await ((_c = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _c.Completed());
-                        __privateGet(this, _UpdateRunnerStateById).call(this, "#StartRunner-3", runnerId, IRunnerState.completed);
                       }
                     }
                   } else {
-                    __privateGet(this, _warn).call(this, `#StartRunner:ExecuteLoop(): Cannot get execution profile for runner: [${runnerId}]`);
+                    if (pauseOnComplete === true) {
+                      await this.#GetRunnerInstanceById(runnerId)?.PauseRunner();
+                      this.#UpdateRunnerStateById("#StartRunner-2", runnerId, IRunnerState.paused);
+                      ExecuteLoop();
+                    } else {
+                      await this.#GetRunnerInstanceById(runnerId)?.Completed();
+                      this.#UpdateRunnerStateById("#StartRunner-3", runnerId, IRunnerState.completed);
+                    }
                   }
-                } catch (error) {
-                  __privateGet(this, _error).call(this, `#StartRunner:ExecuteLoop(): Error: [${error}]`);
+                } else {
+                  this.#warn(`#StartRunner:ExecuteLoop(): Cannot get execution profile for runner: [${runnerId}]`);
                 }
-              };
-              ExecuteLoop();
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#StartRunner(): Runner: [${runnerId}] not found`);
+              } catch (error) {
+                this.#error(`#StartRunner:ExecuteLoop(): Error: [${error}]`);
+              }
+            };
+            ExecuteLoop();
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#StartRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#StartRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.StartRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _StopRunnerByRunnerId, async (id) => {
-        var _a;
-        let retVal;
-        try {
-          if (__privateGet(this, _runners)[id]) {
-            const { state } = __privateGet(this, _runners)[id].runner;
-            if (state === IRunnerState.paused || state === IRunnerState.running) {
-              retVal = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, id)) == null ? void 0 : _a.StopRunner());
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#StopRunnerByRunnerId", id, IRunnerState.stopped);
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#StopRunnerByRunnerId(): Runner: [${id}] not found`);
+      } catch (error) {
+        this.#error(`#StartRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.StartRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #StopRunnerByRunnerId = async (id) => {
+      let retVal;
+      try {
+        if (this.#runners[id]) {
+          const { state } = this.#runners[id].runner;
+          if (state === IRunnerState.paused || state === IRunnerState.running) {
+            retVal = await this.#GetRunnerInstanceById(id)?.StopRunner();
+            this.#UpdateRunnerStateById("#StopRunnerByRunnerId", id, IRunnerState.stopped);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#StopRunnerByRunnerId(): Error: [${error}]`);
+        } else {
+          this.#warn(`#StopRunnerByRunnerId(): Runner: [${id}] not found`);
         }
-        return retVal;
-      });
-      __privateAdd(this, _StopRunner, async (testRunnerTelemetryPayload) => {
-        let result;
-        try {
-          result = await __privateGet(this, _StopRunnerByRunnerId).call(this, testRunnerTelemetryPayload.runner.id);
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#StopRunner(): Error: [${error}]`);
-        }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.StopRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _TerminateRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.created || state === IRunnerState.paused || state === IRunnerState.running) {
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.TerminateRunner());
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#TerminateRunner", runnerId, IRunnerState.terminated);
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#TerminateRunner(): Runner: [${runnerId}] not found`);
+      } catch (error) {
+        this.#error(`#StopRunnerByRunnerId(): Error: [${error}]`);
+      }
+      return retVal;
+    };
+    #StopRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        result = await this.#StopRunnerByRunnerId(testRunnerTelemetryPayload.runner.id);
+      } catch (error) {
+        this.#error(`#StopRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.StopRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #TerminateRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.created || state === IRunnerState.paused || state === IRunnerState.running) {
+            result = await this.#GetRunnerInstanceById(runnerId)?.TerminateRunner();
+            this.#UpdateRunnerStateById("#TerminateRunner", runnerId, IRunnerState.terminated);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#TerminateRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#TerminateRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.TerminateRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _SendRunnerCommandResponse, (command, testRunnerTelemetryPayload, result) => {
-        try {
-          let runner = void 0;
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            runner = { ...__privateGet(this, _runners)[runnerId].runner };
-          }
-          if (__privateGet(this, _collectorCollectorPort)) {
-            const message = {
-              command,
-              payload: {
-                messageId: testRunnerTelemetryPayload.messageId,
-                runner,
-                executeRunnerActionResult: {
-                  workerManagerId: testRunnerTelemetryPayload.runner.workerManagerId,
-                  workerId: testRunnerTelemetryPayload.runner.workerId,
-                  runnerId: testRunnerTelemetryPayload.runner.id,
-                  result
-                }
+      } catch (error) {
+        this.#error(`#TerminateRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.TerminateRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #SendRunnerCommandResponse = (command, testRunnerTelemetryPayload, result) => {
+      try {
+        let runner = void 0;
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          runner = { ...this.#runners[runnerId].runner };
+        }
+        if (this.#collectorCollectorPort) {
+          const message = {
+            command,
+            payload: {
+              messageId: testRunnerTelemetryPayload.messageId,
+              runner,
+              executeRunnerActionResult: {
+                workerManagerId: testRunnerTelemetryPayload.runner.workerManagerId,
+                workerId: testRunnerTelemetryPayload.runner.workerId,
+                runnerId: testRunnerTelemetryPayload.runner.id,
+                result
               }
-            };
-            __privateGet(this, _collectorCollectorPort).postMessage(message);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#SendRunnerCommandResponse(): [${error}]`);
-        }
-      });
-      __privateAdd(this, _PauseRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.running) {
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.PauseRunner());
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#PauseRunner", runnerId, IRunnerState.paused);
             }
-          } else {
-            __privateGet(this, _warn).call(this, `#PauseRunner(): Runner: [${runnerId}] not found`);
-          }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#PauseRunner(): Error: [${error}]`);
+          };
+          this.#collectorCollectorPort.postMessage(message);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.PauseRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _ResumeRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.paused) {
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.ResumeRunner());
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#ResumeRunner", runnerId, IRunnerState.running);
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#ResumeRunner(): Runner: [${runnerId}] not found`);
+      } catch (error) {
+        this.#error(`#SendRunnerCommandResponse(): [${error}]`);
+      }
+    };
+    #PauseRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.running) {
+            result = await this.#GetRunnerInstanceById(runnerId)?.PauseRunner();
+            this.#UpdateRunnerStateById("#PauseRunner", runnerId, IRunnerState.paused);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#ResumeRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#PauseRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.ResumeRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _ResetRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.paused || state === IRunnerState.running) {
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#ResetRunner", runnerId, IRunnerState.paused);
-              __privateGet(this, _ResetRunnerIterationById).call(this, runnerId);
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.ResetRunner());
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#ResetRunner(): Runner: [${runnerId}] not found`);
+      } catch (error) {
+        this.#error(`#PauseRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.PauseRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #ResumeRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.paused) {
+            result = await this.#GetRunnerInstanceById(runnerId)?.ResumeRunner();
+            this.#UpdateRunnerStateById("#ResumeRunner", runnerId, IRunnerState.running);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#ResetRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#ResumeRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.ResetRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      // Execute a single iteration of this runners work item
-      __privateAdd(this, _ExecuteRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.paused || state === IRunnerState.created) {
-              const currentIteration = __privateGet(this, _GetRunnerIterationById).call(this, runnerId);
-              __privateGet(this, _debug).call(this, `${chalk.magenta(`runner: [${runnerId}]`)} ExecuteRunner(${currentIteration})`);
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.ExecuteRunner());
-              const newIteration = __privateGet(this, _IncRunnerIterationById).call(this, runnerId);
-              __privateGet(this, _debug).call(this, `${chalk.magenta(`  --> runner: [${runnerId}]`)} Next iteration number: [${newIteration}] for next Execute or Resume.`);
-              __privateGet(this, _UpdateRunnerStateById).call(this, "#ExecuteRunner", runnerId, IRunnerState.paused);
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#ExecuteRunner(): Runner: [${runnerId}] not found`);
+      } catch (error) {
+        this.#error(`#ResumeRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.ResumeRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #ResetRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.paused || state === IRunnerState.running) {
+            this.#UpdateRunnerStateById("#ResetRunner", runnerId, IRunnerState.paused);
+            this.#ResetRunnerIterationById(runnerId);
+            result = await this.#GetRunnerInstanceById(runnerId)?.ResetRunner();
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#ExecuteRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#ResetRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.ExecuteRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      __privateAdd(this, _UpdateRunner, async (testRunnerTelemetryPayload) => {
-        var _a;
-        let result;
-        try {
-          const runnerId = testRunnerTelemetryPayload.runner.id;
-          if (__privateGet(this, _runners)[runnerId]) {
-            const { state } = __privateGet(this, _runners)[runnerId].runner;
-            if (state === IRunnerState.paused || state === IRunnerState.created || state === IRunnerState.running) {
-              __privateGet(this, _debug).call(this, chalk.cyan(`before: [${JSON.stringify(__privateGet(this, _GetRunnerOptionsById).call(this, runnerId))}]`));
-              __privateGet(this, _SetRunnerOptionsById).call(this, runnerId, testRunnerTelemetryPayload.runner.options);
-              __privateGet(this, _debug).call(this, chalk.cyan(`after: [${JSON.stringify(__privateGet(this, _GetRunnerOptionsById).call(this, runnerId))}]`));
-              result = await ((_a = __privateGet(this, _GetRunnerInstanceById).call(this, runnerId)) == null ? void 0 : _a.UpdateRunner(testRunnerTelemetryPayload.runner.options));
-            }
-          } else {
-            __privateGet(this, _warn).call(this, `#UpdateRunner(): Runner: [${runnerId}] not found`);
+      } catch (error) {
+        this.#error(`#ResetRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.ResetRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    // Execute a single iteration of this runners work item
+    #ExecuteRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.paused || state === IRunnerState.created) {
+            const currentIteration = this.#GetRunnerIterationById(runnerId);
+            this.#debug(`${chalk.magenta(`runner: [${runnerId}]`)} ExecuteRunner(${currentIteration})`);
+            result = await this.#GetRunnerInstanceById(runnerId)?.ExecuteRunner();
+            const newIteration = this.#IncRunnerIterationById(runnerId);
+            this.#debug(`${chalk.magenta(`  --> runner: [${runnerId}]`)} Next iteration number: [${newIteration}] for next Execute or Resume.`);
+            this.#UpdateRunnerStateById("#ExecuteRunner", runnerId, IRunnerState.paused);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `#UpdateRunner(): Error: [${error}]`);
+        } else {
+          this.#warn(`#ExecuteRunner(): Runner: [${runnerId}] not found`);
         }
-        __privateGet(this, _SendRunnerCommandResponse).call(this, eIWMessageCommands.UpdateRunnerResponse, testRunnerTelemetryPayload, result);
-      });
-      // ProcessMessage = async(data: MessageEvent) => { // Browser version
-      __publicField(this, "ProcessMessage", async (data) => {
-        __privateGet(this, _silly).call(this, `ProcessMessage: data: [${JSON.stringify(data)}]`);
-        try {
-          const payloadMessage = data;
-          switch (payloadMessage.command) {
-            case eIWMessageCommands.MessagePort:
-              __privateGet(this, _silly).call(this, `ProcessMessage::MessagePort`);
-              __privateGet(this, _SetMessagePort).call(this, payloadMessage.payload);
-              __privateSet(this, _options, payloadMessage.payload.options);
-              __privateSet(this, _workerId, payloadMessage.payload.workerId);
-              __privateGet(this, _debug).call(this, `ProcessMessage::#workerId: [${__privateGet(this, _workerId)}]`);
-              __privateGet(this, _debug).call(this, `ProcessMessage::#options: [${JSON.stringify(__privateGet(this, _options))}]`);
-              break;
-            case eIWMessageCommands.AddRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::AddRunner`);
-              __privateGet(this, _AddRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.StartRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::StartRunner`);
-              __privateGet(this, _StartRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.StopRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::StopRunner`);
-              __privateGet(this, _StopRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.TerminateRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::TerminateRunner`);
-              __privateGet(this, _TerminateRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.PauseRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::PauseRunner`);
-              __privateGet(this, _PauseRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.ResumeRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::ResumeRunner`);
-              __privateGet(this, _ResumeRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.ResetRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::ResetRunner`);
-              __privateGet(this, _ResetRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.ExecuteRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::ExecuteRunner`);
-              __privateGet(this, _ExecuteRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.UpdateRunner:
-              __privateGet(this, _silly).call(this, `ProcessMessage::UpdateRunner`);
-              __privateGet(this, _UpdateRunner).call(this, payloadMessage.payload);
-              break;
-            case eIWMessageCommands.GetRunners:
-              __privateGet(this, _silly).call(this, `ProcessMessage::GetRunners`);
-              __privateGet(this, _PostRunnersToWorkerManager).call(this, eIWMessageCommands.GetRunners, payloadMessage);
-              break;
-            default:
-              __privateGet(this, _warn).call(this, `ProcessMessage::default: Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
+      } catch (error) {
+        this.#error(`#ExecuteRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.ExecuteRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    #UpdateRunner = async (testRunnerTelemetryPayload) => {
+      let result;
+      try {
+        const runnerId = testRunnerTelemetryPayload.runner.id;
+        if (this.#runners[runnerId]) {
+          const { state } = this.#runners[runnerId].runner;
+          if (state === IRunnerState.paused || state === IRunnerState.created || state === IRunnerState.running) {
+            this.#debug(chalk.cyan(`before: [${JSON.stringify(this.#GetRunnerOptionsById(runnerId))}]`));
+            this.#SetRunnerOptionsById(runnerId, testRunnerTelemetryPayload.runner.options);
+            this.#debug(chalk.cyan(`after: [${JSON.stringify(this.#GetRunnerOptionsById(runnerId))}]`));
+            result = await this.#GetRunnerInstanceById(runnerId)?.UpdateRunner(testRunnerTelemetryPayload.runner.options);
           }
-        } catch (error) {
-          __privateGet(this, _error).call(this, `ProcessMessage(): Error: [${error}]`);
-          __privateGet(this, _error).call(this, error);
+        } else {
+          this.#warn(`#UpdateRunner(): Runner: [${runnerId}] not found`);
         }
-      });
-      __privateGet(this, _processLoopExecutor).call(this);
-    }
-    get logger() {
-      return stsutils.defaultLogger;
-    }
-    get CollectorCollectorPort() {
-      return __privateGet(this, _collectorCollectorPort);
-    }
-    get Options() {
-      return __privateGet(this, _options);
-    }
+      } catch (error) {
+        this.#error(`#UpdateRunner(): Error: [${error}]`);
+      }
+      this.#SendRunnerCommandResponse(eIWMessageCommands.UpdateRunnerResponse, testRunnerTelemetryPayload, result);
+    };
+    // ProcessMessage = async(data: MessageEvent) => { // Browser version
+    ProcessMessage = async (data) => {
+      this.#silly(`ProcessMessage: data: [${JSON.stringify(data)}]`);
+      try {
+        const payloadMessage = data;
+        switch (payloadMessage.command) {
+          case eIWMessageCommands.MessagePort:
+            this.#silly(`ProcessMessage::MessagePort`);
+            this.#SetMessagePort(payloadMessage.payload);
+            this.#options = payloadMessage.payload.options;
+            this.#workerId = payloadMessage.payload.workerId;
+            this.#debug(`ProcessMessage::#workerId: [${this.#workerId}]`);
+            this.#debug(`ProcessMessage::#options: [${JSON.stringify(this.#options)}]`);
+            break;
+          case eIWMessageCommands.AddRunner:
+            this.#silly(`ProcessMessage::AddRunner`);
+            this.#AddRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.StartRunner:
+            this.#silly(`ProcessMessage::StartRunner`);
+            this.#StartRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.StopRunner:
+            this.#silly(`ProcessMessage::StopRunner`);
+            this.#StopRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.TerminateRunner:
+            this.#silly(`ProcessMessage::TerminateRunner`);
+            this.#TerminateRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.PauseRunner:
+            this.#silly(`ProcessMessage::PauseRunner`);
+            this.#PauseRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.ResumeRunner:
+            this.#silly(`ProcessMessage::ResumeRunner`);
+            this.#ResumeRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.ResetRunner:
+            this.#silly(`ProcessMessage::ResetRunner`);
+            this.#ResetRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.ExecuteRunner:
+            this.#silly(`ProcessMessage::ExecuteRunner`);
+            this.#ExecuteRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.UpdateRunner:
+            this.#silly(`ProcessMessage::UpdateRunner`);
+            this.#UpdateRunner(payloadMessage.payload);
+            break;
+          case eIWMessageCommands.GetRunners:
+            this.#silly(`ProcessMessage::GetRunners`);
+            this.#PostRunnersToWorkerManager(eIWMessageCommands.GetRunners, payloadMessage);
+            break;
+          default:
+            this.#warn(`ProcessMessage::default: Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
+        }
+      } catch (error) {
+        this.#error(`ProcessMessage(): Error: [${error}]`);
+        this.#error(error);
+      }
+    };
   }
-  _collectorCollectorPort = new WeakMap();
-  _runners = new WeakMap();
-  _options = new WeakMap();
-  _workerId = new WeakMap();
-  _archiveDeleteTimeout = new WeakMap();
-  _logMessage = new WeakMap();
-  _silly = new WeakMap();
-  _debug = new WeakMap();
-  _info = new WeakMap();
-  _warn = new WeakMap();
-  _error = new WeakMap();
-  _processLoopExecutor = new WeakMap();
-  _SetMessagePort = new WeakMap();
-  _CreateRunnerEx2RunState = new WeakMap();
-  _UpdateRunnerStateById = new WeakMap();
-  _CanExecuteNextIterationById = new WeakMap();
-  _IsCompletedById = new WeakMap();
-  _GetRunnerIterationById = new WeakMap();
-  _ResetRunnerIterationById = new WeakMap();
-  _IncRunnerIterationById = new WeakMap();
-  _GetRunnerInstanceById = new WeakMap();
-  _GetRunnerExecutionProfileById = new WeakMap();
-  _GetRunnerOptionsById = new WeakMap();
-  _SetRunnerOptionsById = new WeakMap();
-  _AddRunner = new WeakMap();
-  _WorkerInstance_instances = new WeakSet();
-  SleepImmediate_fn = function() {
-    return new Promise((resolve, reject) => {
-      resolve();
-    });
-  };
-  _PostMessageToWorkerManagerById = new WeakMap();
-  _PostRunnersToWorkerManager = new WeakMap();
-  _StartRunner = new WeakMap();
-  _StopRunnerByRunnerId = new WeakMap();
-  _StopRunner = new WeakMap();
-  _TerminateRunner = new WeakMap();
-  _SendRunnerCommandResponse = new WeakMap();
-  _PauseRunner = new WeakMap();
-  _ResumeRunner = new WeakMap();
-  _ResetRunner = new WeakMap();
-  _ExecuteRunner = new WeakMap();
-  _UpdateRunner = new WeakMap();
   class TelemetryProcessor {
-    constructor() {
-      __publicField(this, "ProcessTelemetry", (publishInstrumentController, telemetry) => {
-        let update = false;
-        if (telemetry.message) {
-          telemetry.message.forEach((message) => {
-            publishInstrumentController.LogEx(message);
-          });
-          update = true;
-        }
-        if (telemetry.requestCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.REQUEST_COUNT_GAUGE, {
-            val: telemetry.requestCount
-          });
-          update = true;
-        }
-        if (telemetry.errorCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.ERROR_COUNT_GAUGE, {
-            val: telemetry.errorCount
-          });
-          update = true;
-        }
-        if (telemetry.retryCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.RETRY_COUNT_GAUGE, {
-            val: telemetry.retryCount
-          });
-          update = true;
-        }
-        if (telemetry.authenticationCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_COUNT_GAUGE, {
-            val: telemetry.authenticationCount
-          });
-          update = true;
-        }
-        if (telemetry.authenticationErrorCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
-            val: telemetry.authenticationErrorCount
-          });
-          update = true;
-        }
-        if (telemetry.authenticationRetryCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
-            val: telemetry.authenticationRetryCount
-          });
-          update = true;
-        }
-        if (telemetry.coreCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.CORE_COUNT_GAUGE, {
-            val: telemetry.coreCount
-          });
-          update = true;
-        }
-        if (telemetry.timer) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.TIMER_GAUGE, {
-            val: telemetry.timer
-          });
-          update = true;
-        }
-        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.ACTIVE_REQUEST_GAUGE, {
-          val: telemetry.activeRequestCount
+    ProcessTelemetry = (publishInstrumentController, telemetry) => {
+      let update = false;
+      if (telemetry.message) {
+        telemetry.message.forEach((message) => {
+          publishInstrumentController.LogEx(message);
         });
-        if (telemetry.velocity) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.VELOCITY_GAUGE, {
-            Inc: telemetry.velocity
-          });
-          update = true;
-        }
-        if (telemetry.duration) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.DURATION_GAUGE, {
-            val: telemetry.duration
-          });
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.DURATION_HISTOGRAM_GAUGE, {
-            val: telemetry.duration
-          });
-          update = true;
-        }
-        if (telemetry.latency) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.LATENCY_GAUGE, {
-            val: telemetry.latency
-          });
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.LATENCY_HISTOGRAM_GAUGE, {
-            val: telemetry.latency
-          });
-          update = true;
-        }
-        if (telemetry.childCount) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.CHILD_COUNT, {
-            val: telemetry.childCount
-          });
-          update = true;
-        }
-        if (telemetry.rx) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.NETWORK_RX_GAUGE, {
-            Inc: telemetry.rx
-          });
-          update = true;
-        }
-        if (telemetry.tx) {
-          publishInstrumentController.UpdateInstrument(stsobservability.Gauge.NETWORK_TX_GAUGE, {
-            Inc: telemetry.tx
-          });
-          update = true;
-        }
-        return update;
+        update = true;
+      }
+      if (telemetry.requestCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.REQUEST_COUNT_GAUGE, {
+          val: telemetry.requestCount
+        });
+        update = true;
+      }
+      if (telemetry.errorCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.ERROR_COUNT_GAUGE, {
+          val: telemetry.errorCount
+        });
+        update = true;
+      }
+      if (telemetry.retryCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.RETRY_COUNT_GAUGE, {
+          val: telemetry.retryCount
+        });
+        update = true;
+      }
+      if (telemetry.authenticationCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_COUNT_GAUGE, {
+          val: telemetry.authenticationCount
+        });
+        update = true;
+      }
+      if (telemetry.authenticationErrorCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
+          val: telemetry.authenticationErrorCount
+        });
+        update = true;
+      }
+      if (telemetry.authenticationRetryCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
+          val: telemetry.authenticationRetryCount
+        });
+        update = true;
+      }
+      if (telemetry.coreCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.CORE_COUNT_GAUGE, {
+          val: telemetry.coreCount
+        });
+        update = true;
+      }
+      if (telemetry.timer) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.TIMER_GAUGE, {
+          val: telemetry.timer
+        });
+        update = true;
+      }
+      publishInstrumentController.UpdateInstrument(stsobservability.Gauge.ACTIVE_REQUEST_GAUGE, {
+        val: telemetry.activeRequestCount
       });
-    }
+      if (telemetry.velocity) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.VELOCITY_GAUGE, {
+          Inc: telemetry.velocity
+        });
+        update = true;
+      }
+      if (telemetry.duration) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.DURATION_GAUGE, {
+          val: telemetry.duration
+        });
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.DURATION_HISTOGRAM_GAUGE, {
+          val: telemetry.duration
+        });
+        update = true;
+      }
+      if (telemetry.latency) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.LATENCY_GAUGE, {
+          val: telemetry.latency
+        });
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.LATENCY_HISTOGRAM_GAUGE, {
+          val: telemetry.latency
+        });
+        update = true;
+      }
+      if (telemetry.childCount) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.CHILD_COUNT, {
+          val: telemetry.childCount
+        });
+        update = true;
+      }
+      if (telemetry.rx) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.NETWORK_RX_GAUGE, {
+          Inc: telemetry.rx
+        });
+        update = true;
+      }
+      if (telemetry.tx) {
+        publishInstrumentController.UpdateInstrument(stsobservability.Gauge.NETWORK_TX_GAUGE, {
+          Inc: telemetry.tx
+        });
+        update = true;
+      }
+      return update;
+    };
   }
   const byteToHex = [];
   for (let i = 0; i < 256; ++i) {
@@ -2333,13 +2271,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
   }
   const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
   const native = { randomUUID };
-  function v4(options, buf, offset) {
-    var _a;
-    if (native.randomUUID && true && !options) {
-      return native.randomUUID();
-    }
+  function _v4(options, buf, offset) {
     options = options || {};
-    const rnds = options.random ?? ((_a = options.rng) == null ? void 0 : _a.call(options)) ?? rng();
+    const rnds = options.random ?? options.rng?.() ?? rng();
     if (rnds.length < 16) {
       throw new Error("Random bytes length must be >= 16");
     }
@@ -2347,6 +2281,12 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
     rnds[8] = rnds[8] & 63 | 128;
     return unsafeStringify(rnds);
   }
+  function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+      return native.randomUUID();
+    }
+    return _v4(options);
+  }
   var lodash_merge = { exports: {} };
   lodash_merge.exports;
   var hasRequiredLodash_merge;
@@ -2373,7 +2313,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
       var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
       var moduleExports = freeModule && freeModule.exports === freeExports;
       var freeProcess = moduleExports && freeGlobal.process;
-      var nodeUtil = function() {
+      var nodeUtil = (function() {
         try {
           var types = freeModule && freeModule.require && freeModule.require("util").types;
           if (types) {
@@ -2382,7 +2322,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
           return freeProcess && freeProcess.binding && freeProcess.binding("util");
         } catch (e) {
         }
-      }();
+      })();
       var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
       function apply(func, thisArg, args) {
         switch (args.length) {
@@ -2421,29 +2361,29 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
       var coreJsData = root["__core-js_shared__"];
       var funcToString = funcProto.toString;
       var hasOwnProperty = objectProto.hasOwnProperty;
-      var maskSrcKey = function() {
+      var maskSrcKey = (function() {
         var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
         return uid ? "Symbol(src)_1." + uid : "";
-      }();
+      })();
       var nativeObjectToString = objectProto.toString;
       var objectCtorString = funcToString.call(Object);
       var reIsNative = RegExp(
         "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
       );
-      var Buffer2 = moduleExports ? root.Buffer : void 0, Symbol2 = root.Symbol, Uint8Array2 = root.Uint8Array;
-      Buffer2 ? Buffer2.allocUnsafe : void 0;
+      var Buffer = moduleExports ? root.Buffer : void 0, Symbol2 = root.Symbol, Uint8Array2 = root.Uint8Array;
+      Buffer ? Buffer.allocUnsafe : void 0;
       var getPrototype = overArg(Object.getPrototypeOf, Object), objectCreate = Object.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
-      var defineProperty = function() {
+      var defineProperty = (function() {
         try {
           var func = getNative(Object, "defineProperty");
           func({}, "", {});
           return func;
         } catch (e) {
         }
-      }();
-      var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0, nativeMax = Math.max, nativeNow = Date.now;
+      })();
+      var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0, nativeMax = Math.max, nativeNow = Date.now;
       var Map2 = getNative(root, "Map"), nativeCreate = getNative(Object, "create");
-      var baseCreate = /* @__PURE__ */ function() {
+      var baseCreate = /* @__PURE__ */ (function() {
         function object() {
         }
         return function(proto) {
@@ -2458,7 +2398,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
           object.prototype = void 0;
           return result;
         };
-      }();
+      })();
       function Hash(entries) {
         var index = -1, length = entries == null ? 0 : entries.length;
         this.clear();
@@ -2965,9 +2905,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
       function eq(value, other) {
         return value === other || value !== value && other !== other;
       }
-      var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+      var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
         return arguments;
-      }()) ? baseIsArguments : function(value) {
+      })()) ? baseIsArguments : function(value) {
         return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
       };
       var isArray = Array.isArray;
@@ -3035,1181 +2975,1124 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
   const merge = /* @__PURE__ */ getDefaultExportFromCjs(lodash_mergeExports);
   chalk.level = 3;
   class STSWorkerManager {
+    //#agentSession: string = null;
+    #workersEx = {};
+    #options;
+    #STSInstrumentController = null;
+    #telemetryProcessor = null;
+    #archiveList = [];
+    #id;
+    #messages = {};
+    #archiveDeleteTimeout = 30;
     constructor(options) {
-      __privateAdd(this, _STSWorkerManager_instances);
-      //#agentSession: string = null;
-      __privateAdd(this, _workersEx, {});
-      __privateAdd(this, _options2);
-      __privateAdd(this, _STSInstrumentController, null);
-      __privateAdd(this, _telemetryProcessor, null);
-      __privateAdd(this, _archiveList, []);
-      __privateAdd(this, _id);
-      __privateAdd(this, _messages, {});
-      __privateAdd(this, _archiveDeleteTimeout2, 30);
-      __privateAdd(this, _logMessage2, (fn, message) => {
-        fn(`pid: [${process.pid}] STSWorkerManager: ID: [${__privateGet(this, _id)}] Log: [${message}]`);
-      });
-      __privateAdd(this, _silly2, (message) => {
-        if (__privateGet(this, _options2) && __privateGet(this, _options2).logLevel >= 5) {
-          __privateGet(this, _logMessage2).call(this, __privateGet(this, _options2).logger.silly, message);
-        }
-      });
-      __privateAdd(this, _debug2, (message) => {
-        if (__privateGet(this, _options2) && __privateGet(this, _options2).logLevel >= 4) {
-          __privateGet(this, _logMessage2).call(this, __privateGet(this, _options2).logger.debug, message);
-        }
-      });
-      __privateAdd(this, _info2, (message) => {
-        if (__privateGet(this, _options2) && __privateGet(this, _options2).logLevel >= 3) {
-          __privateGet(this, _logMessage2).call(this, __privateGet(this, _options2).logger.info, message);
-        }
-      });
-      __privateAdd(this, _warn2, (message) => {
-        if (__privateGet(this, _options2) && __privateGet(this, _options2).logLevel >= 2) {
-          __privateGet(this, _logMessage2).call(this, __privateGet(this, _options2).logger.warn, message);
+      this.#id = v4();
+      if (options) {
+        this.#options = options;
+      } else {
+        this.#options = {};
+      }
+      if (this.#options.publishInstrumentController) {
+        this.#STSInstrumentController = this.#options.publishInstrumentController;
+        this.#telemetryProcessor = new TelemetryProcessor();
+      }
+      this.#processLoopExecutor();
+    }
+    #logMessage = (fn, message) => {
+      fn(`pid: [${process.pid}] STSWorkerManager: ID: [${this.#id}] Log: [${message}]`);
+    };
+    #silly = (message) => {
+      if (this.#options && this.#options.logLevel >= 5) {
+        this.#logMessage(this.#options.logger.silly, message);
+      }
+    };
+    #debug = (message) => {
+      if (this.#options && this.#options.logLevel >= 4) {
+        this.#logMessage(this.#options.logger.debug, message);
+      }
+    };
+    #info = (message) => {
+      if (this.#options && this.#options.logLevel >= 3) {
+        this.#logMessage(this.#options.logger.info, message);
+      }
+    };
+    #warn = (message) => {
+      if (this.#options && this.#options.logLevel >= 2) {
+        this.#logMessage(this.#options.logger.warn, message);
+      }
+    };
+    #error = (error) => {
+      if (this.#options && this.#options.logLevel >= 1) {
+        this.#logMessage(this.#options.logger.error, error);
+      }
+    };
+    CreateRunnerCopyNoHistory(runnerEx) {
+      try {
+        return {
+          id: runnerEx.id,
+          asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
+          instrumentData: { ...runnerEx.instrumentData },
+          iteration: runnerEx.iteration,
+          options: { ...runnerEx.options },
+          state: runnerEx.state,
+          workerId: runnerEx.workerId,
+          workerManagerId: this.#id
+        };
+      } catch (error) {
+        this.#error(`CreateRunnerCopyNoHistory(): Error: [${error}]`);
+        throw error;
+      }
+    }
+    CreateRunnerCopy(runnerEx) {
+      try {
+        const retVal = this.CreateRunnerCopyNoHistory(runnerEx);
+        if (runnerEx.runnerHistory) {
+          retVal.runnerHistory = [...runnerEx.runnerHistory];
         }
-      });
-      __privateAdd(this, _error2, (error) => {
-        if (__privateGet(this, _options2) && __privateGet(this, _options2).logLevel >= 1) {
-          __privateGet(this, _logMessage2).call(this, __privateGet(this, _options2).logger.error, error);
+        return retVal;
+      } catch (error) {
+        this.#error(`CreateRunnerCopy(): Error: [${error}]`);
+        throw error;
+      }
+    }
+    CreateRunnerCopySmall(runnerEx) {
+      try {
+        const retVal = {
+          id: runnerEx.id,
+          iteration: runnerEx.iteration,
+          state: runnerEx.state
+        };
+        if (runnerEx.options && runnerEx.options.runnerPlan) {
+          retVal.options = {
+            runnerPlan: { ...runnerEx.options.runnerPlan }
+          };
         }
-      });
-      __privateAdd(this, _processLoopExecutor2, async () => {
-        try {
-          const removeList = [];
-          for (const [, workerEx] of Object.entries(__privateGet(this, _workersEx))) {
-            for (const [, runnerEx] of Object.entries(workerEx.runnersEx)) {
-              const runnerState = runnerEx.state;
-              if (runnerEx.archived === false && (runnerState === IRunnerState.completed || runnerState === IRunnerState.error || runnerState === IRunnerState.stopped || runnerState === IRunnerState.terminated)) {
-                removeList.push({
-                  workerId: workerEx.id,
-                  runnerId: runnerEx.id
-                });
-              }
-            }
-          }
-          if (removeList.length > 0) {
-            setTimeout(async () => {
-              __privateGet(this, _debug2).call(this, chalk.grey(`STSWorkerManager:#processLoopExecutor(): Removing runners from collection: [${JSON.stringify(removeList)}]`));
-              for (let i = 0; i < removeList.length; i++) {
-                const workerEx = __privateGet(this, _workersEx)[removeList[i].workerId];
-                if (workerEx) {
-                  const runnerEx = workerEx.runnersEx[removeList[i].runnerId];
-                  if (runnerEx) {
-                    if (runnerEx.publishInstrumentController) {
-                      __privateGet(this, _debug2).call(this, chalk.grey(`Ending publish for runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
-                      runnerEx.publishInstrumentController.EndPublish();
+        return retVal;
+      } catch (error) {
+        this.#error(`CreateRunnerCopy(): Error: [${error}]`);
+        throw error;
+      }
+    }
+    CreateWorkerCopy(workerEx) {
+      try {
+        const { id, options, runnersEx, workerManagerId } = workerEx;
+        const workerCopy = {
+          id,
+          options: { ...options },
+          runners: {},
+          workerManagerId
+        };
+        for (const [, runnerEx] of Object.entries(runnersEx)) {
+          workerCopy.runners[runnerEx.id] = this.CreateRunnerCopy(runnerEx);
+        }
+        return workerCopy;
+      } catch (error) {
+        this.#error(`#CreateWorkerCopy(): Error: [${error}]`);
+        throw error;
+      }
+    }
+    CreateWorkerCopySmall(workerEx, states) {
+      try {
+        const workerCopy = {
+          id: workerEx.id,
+          runners: {}
+        };
+        Object.values(workerEx.runnersEx).filter((runnerEx) => states.length === 0 ? true : states.includes(runnerEx.state)).forEach((runnerEx) => {
+          workerCopy.runners[runnerEx.id] = this.CreateRunnerCopySmall(runnerEx);
+        });
+        return workerCopy;
+      } catch (error) {
+        this.#error(`CreateWorkerCopySmall(): Error: [${error}]`);
+        throw error;
+      }
+    }
+    #processLoopExecutor = async () => {
+      try {
+        const removeList = [];
+        for (const [, workerEx] of Object.entries(this.#workersEx)) {
+          for (const [, runnerEx] of Object.entries(workerEx.runnersEx)) {
+            const runnerState = runnerEx.state;
+            if (runnerEx.archived === false && (runnerState === IRunnerState.completed || runnerState === IRunnerState.error || runnerState === IRunnerState.stopped || runnerState === IRunnerState.terminated)) {
+              removeList.push({
+                workerId: workerEx.id,
+                runnerId: runnerEx.id
+              });
+            }
+          }
+        }
+        if (removeList.length > 0) {
+          setTimeout(async () => {
+            this.#debug(chalk.grey(`STSWorkerManager:#processLoopExecutor(): Removing runners from collection: [${JSON.stringify(removeList)}]`));
+            for (let i = 0; i < removeList.length; i++) {
+              const workerEx = this.#workersEx[removeList[i].workerId];
+              if (workerEx) {
+                const runnerEx = workerEx.runnersEx[removeList[i].runnerId];
+                if (runnerEx) {
+                  if (runnerEx.publishInstrumentController) {
+                    this.#debug(chalk.grey(`Ending publish for runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
+                    runnerEx.publishInstrumentController.EndPublish();
+                  }
+                  if (runnerEx.state !== IRunnerState.terminated) {
+                    this.#debug(chalk.grey(`Archive runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
+                    const runner = this.CreateRunnerCopy(runnerEx);
+                    this.#archiveList.push(runner);
+                    if (this.#archiveList.length > this.#options.maxArchiveListLength) {
+                      this.#archiveList.shift();
                     }
-                    if (runnerEx.state !== IRunnerState.terminated) {
-                      __privateGet(this, _debug2).call(this, chalk.grey(`Archive runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
-                      const runner = this.CreateRunnerCopy(runnerEx);
-                      __privateGet(this, _archiveList).push(runner);
-                      if (__privateGet(this, _archiveList).length > __privateGet(this, _options2).maxArchiveListLength) {
-                        __privateGet(this, _archiveList).shift();
-                      }
+                  } else {
+                    this.#debug(chalk.grey(`Runner has been terminated and will not be archived, runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
+                  }
+                  runnerEx.archived = true;
+                  if (this.#archiveDeleteTimeout !== 0) {
+                    if (isNode) {
+                      setTimeout(() => delete workerEx.runnersEx[removeList[i].runnerId], this.#archiveDeleteTimeout * 1e3).unref();
                     } else {
-                      __privateGet(this, _debug2).call(this, chalk.grey(`Runner has been terminated and will not be archived, runner: [${JSON.stringify(runnerEx.asyncRunnerContext)}]`));
-                    }
-                    runnerEx.archived = true;
-                    if (__privateGet(this, _archiveDeleteTimeout2) !== 0) {
-                      if (isNode) {
-                        setTimeout(() => delete workerEx.runnersEx[removeList[i].runnerId], __privateGet(this, _archiveDeleteTimeout2) * 1e3).unref();
-                      } else {
-                        setTimeout(() => delete workerEx.runnersEx[removeList[i].runnerId], __privateGet(this, _archiveDeleteTimeout2) * 1e3);
-                      }
+                      setTimeout(() => delete workerEx.runnersEx[removeList[i].runnerId], this.#archiveDeleteTimeout * 1e3);
                     }
                   }
                 }
               }
-              for (const [, workerEx] of Object.entries(__privateGet(this, _workersEx))) {
-                __privateGet(this, _debug2).call(this, chalk.grey(`STSWorkerManager:#processLoopExecutor(): Remaining runners from worker: [${workerEx.id}]: [${Object.keys(workerEx.runnersEx).length}]`));
-              }
-              setTimeout(__privateGet(this, _processLoopExecutor2), 1e3);
-            }, 100);
-          } else {
-            setTimeout(__privateGet(this, _processLoopExecutor2), 1e3);
-          }
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `processLoopExecutor(): Error: [${error}]`);
-          throw error;
-        }
-      });
-      __publicField(this, "GetWorkers", async () => {
-        __privateGet(this, _debug2).call(this, `GetWorkers()`);
-        try {
-          await __privateGet(this, _SyncWorkerDataFromWorkers).call(this);
-          const retVal = {};
-          for (const [, workerEx] of Object.entries(__privateGet(this, _workersEx))) {
-            retVal[workerEx.id] = this.CreateWorkerCopy(workerEx);
-          }
-          return retVal;
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `GetWorkers(): Error: [${error}]`);
-          throw error;
-        }
-      });
-      // only include runners that are in the specified states.
-      // Use [] to include all runners irrespective of state.
-      __publicField(this, "GetWorkersSmall", async (states) => {
-        __privateGet(this, _debug2).call(this, `GetWorkersSmall()`);
-        try {
-          await __privateGet(this, _SyncWorkerDataFromWorkers).call(this);
-          const retVal = {};
-          for (const [, workerEx] of Object.entries(__privateGet(this, _workersEx))) {
-            retVal[workerEx.id] = this.CreateWorkerCopySmall(workerEx, states);
-          }
-          return retVal;
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `GetWorkers(): Error: [${error}]`);
-          throw error;
-        }
-      });
-      // Filter by plan and/or tag. Leave blank to not use in filter.
-      __publicField(this, "GetArchiveList", async (runnerSearchFilters) => {
-        __privateGet(this, _debug2).call(this, `GetArchiveList()`);
-        try {
-          return __privateGet(this, _archiveList).filter((runner) => {
-            var _a, _b;
-            return !runnerSearchFilters.plan ? true : ((_b = (_a = runner.options.runnerPlan) == null ? void 0 : _a.plan) == null ? void 0 : _b.localeCompare(runnerSearchFilters.plan)) === 0;
-          }).filter((runner) => {
-            var _a, _b;
-            return !runnerSearchFilters.planInstanceId ? true : ((_b = (_a = runner.options.runnerPlan) == null ? void 0 : _a.planInstanceId) == null ? void 0 : _b.localeCompare(runnerSearchFilters.planInstanceId)) === 0;
-          }).filter((runner) => {
-            var _a;
-            return !runnerSearchFilters.tag ? true : (_a = runner.options.tag) == null ? void 0 : _a.includes(runnerSearchFilters.tag);
-          }).filter((runner) => !runnerSearchFilters.userDataKey ? true : !runner.options.userData ? false : !!runner.options.userData[runnerSearchFilters.userDataKey]);
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `GetArchiveList(): Error: [${error}]`);
-          return [];
+            }
+            for (const [, workerEx] of Object.entries(this.#workersEx)) {
+              this.#debug(chalk.grey(`STSWorkerManager:#processLoopExecutor(): Remaining runners from worker: [${workerEx.id}]: [${Object.keys(workerEx.runnersEx).length}]`));
+            }
+            setTimeout(this.#processLoopExecutor, 1e3);
+          }, 100);
+        } else {
+          setTimeout(this.#processLoopExecutor, 1e3);
         }
-      });
-      __publicField(this, "GetWorker", async (workerId) => {
-        __privateGet(this, _debug2).call(this, `GetWorker()`);
-        try {
-          await __privateGet(this, _SyncWorkerDataFromWorker).call(this, __privateGet(this, _workersEx)[workerId]);
-          return this.CreateWorkerCopy(__privateGet(this, _workersEx)[workerId]);
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `GetWorker(): Error: [${error}]`);
-          throw error;
+      } catch (error) {
+        this.#error(`processLoopExecutor(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    get id() {
+      return this.#id;
+    }
+    GetWorkers = async () => {
+      this.#debug(`GetWorkers()`);
+      try {
+        await this.#SyncWorkerDataFromWorkers();
+        const retVal = {};
+        for (const [, workerEx] of Object.entries(this.#workersEx)) {
+          retVal[workerEx.id] = this.CreateWorkerCopy(workerEx);
         }
-      });
-      __publicField(this, "GetRunner", async (workerId, runnerId) => {
-        __privateGet(this, _debug2).call(this, `GetRunner()`);
-        try {
-          await __privateGet(this, _SyncWorkerDataFromWorker).call(this, __privateGet(this, _workersEx)[workerId]);
-          return this.CreateRunnerCopy(__privateGet(this, _workersEx)[workerId].runnersEx[runnerId]);
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `GetRunner(): Error: [${error}]`);
-          throw error;
+        return retVal;
+      } catch (error) {
+        this.#error(`GetWorkers(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    // only include runners that are in the specified states.
+    // Use [] to include all runners irrespective of state.
+    GetWorkersSmall = async (states) => {
+      this.#debug(`GetWorkersSmall()`);
+      try {
+        await this.#SyncWorkerDataFromWorkers();
+        const retVal = {};
+        for (const [, workerEx] of Object.entries(this.#workersEx)) {
+          retVal[workerEx.id] = this.CreateWorkerCopySmall(workerEx, states);
         }
-      });
-      __publicField(this, "AddWorker", async (workerOptions, useWorkerFactory) => {
-        __privateGet(this, _debug2).call(this, `AddWorker()`);
-        try {
-          let workerFactory;
-          if (useWorkerFactory) {
-            workerFactory = useWorkerFactory;
-          } else {
-            workerFactory = __privateGet(this, _options2).workerFactory;
-          }
-          const {
-            port1,
-            // process message port
-            port2
-            // collector message port
-          } = new MessageChannel();
-          if (!isNode) {
-            port1.start();
-          }
-          const workerId = v4();
-          const stsWorkerEx = {
-            id: workerId,
-            workerManagerId: __privateGet(this, _id),
-            worker: workerFactory.createWorkerThreadWorker(),
-            workerEvents: [],
-            messagePort: port1,
-            options: workerOptions,
-            runnersEx: {},
-            runnersEvents: {},
-            GetRunner: (id) => __privateGet(this, _workersEx)[workerId].runnersEx[id],
-            // Commands to execute on individual runners
-            AddRunner: (runnerOptions) => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
-            StartRunner: (runner) => __privateGet(this, _StartRunner2).call(this, stsWorkerEx, runner),
-            StopRunner: (runner) => __privateGet(this, _StopRunner2).call(this, stsWorkerEx, runner),
-            PauseRunner: (runner) => __privateGet(this, _PauseRunner2).call(this, stsWorkerEx, runner),
-            ResumeRunner: (runner) => __privateGet(this, _ResumeRunner2).call(this, stsWorkerEx, runner),
-            TerminateRunner: (runner) => __privateGet(this, _TerminateRunner2).call(this, stsWorkerEx, runner),
-            ResetRunner: (runner) => __privateGet(this, _ResetRunner2).call(this, stsWorkerEx, runner),
-            ExecuteRunner: (runner) => __privateGet(this, _ExecuteRunner2).call(this, stsWorkerEx, runner),
-            UpdateRunner: (runner, runnerOptions) => __privateGet(this, _UpdateRunner2).call(this, stsWorkerEx, runner, runnerOptions),
-            // Commands to execute on all runners
-            Start: () => __privateGet(this, _StartWorker).call(this, stsWorkerEx),
-            Stop: () => __privateGet(this, _StopWorker).call(this, stsWorkerEx),
-            Pause: () => __privateGet(this, _PauseWorker).call(this, stsWorkerEx),
-            Resume: () => __privateGet(this, _ResumeWorker).call(this, stsWorkerEx),
-            Terminate: () => __privateGet(this, _TerminateWorker).call(this, stsWorkerEx),
-            Reset: () => __privateGet(this, _ResetWorker).call(this, stsWorkerEx),
-            Execute: () => __privateGet(this, _ExecuteWorker).call(this, stsWorkerEx),
-            Update: (runnerOptions) => __privateGet(this, _UpdateOptionsWorker).call(this, stsWorkerEx, runnerOptions),
-            on: (eventName, cb) => {
-              stsWorkerEx.workerEvents.push({
-                eventName,
-                cb
-              });
-              return stsWorkerEx;
-            }
-          };
-          if (__privateGet(this, _STSInstrumentController)) {
-            __privateGet(this, _STSInstrumentController).LogEx(chalk.yellow(`pid: [${process.pid}] Creating new worker: [${stsWorkerEx.id}]`));
-          }
-          __privateGet(this, _debug2).call(this, `AddWorker::workerThreadWorkerOptions: Worker ID: [${stsWorkerEx.id}] Options: [${stsWorkerEx.options}]`);
-          if (stsWorkerEx.options.mocked) {
-            stsWorkerEx.worker.SetPort({
-              command: eIWMessageCommands.MessagePort,
-              payload: {
-                messageId: v4(),
-                port: port2,
-                options: {
-                  ...stsWorkerEx.options
-                },
-                workerId
-              }
+        return retVal;
+      } catch (error) {
+        this.#error(`GetWorkers(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    get WorkersEx() {
+      return this.#workersEx;
+    }
+    // Filter by plan and/or tag. Leave blank to not use in filter.
+    GetArchiveList = async (runnerSearchFilters) => {
+      this.#debug(`GetArchiveList()`);
+      try {
+        return this.#archiveList.filter((runner) => !runnerSearchFilters.plan ? true : runner.options.runnerPlan?.plan?.localeCompare(runnerSearchFilters.plan) === 0).filter((runner) => !runnerSearchFilters.planInstanceId ? true : runner.options.runnerPlan?.planInstanceId?.localeCompare(runnerSearchFilters.planInstanceId) === 0).filter((runner) => !runnerSearchFilters.tag ? true : runner.options.tag?.includes(runnerSearchFilters.tag)).filter((runner) => !runnerSearchFilters.userDataKey ? true : !runner.options.userData ? false : !!runner.options.userData[runnerSearchFilters.userDataKey]);
+      } catch (error) {
+        this.#error(`GetArchiveList(): Error: [${error}]`);
+        return [];
+      }
+    };
+    GetWorker = async (workerId) => {
+      this.#debug(`GetWorker()`);
+      try {
+        await this.#SyncWorkerDataFromWorker(this.#workersEx[workerId]);
+        return this.CreateWorkerCopy(this.#workersEx[workerId]);
+      } catch (error) {
+        this.#error(`GetWorker(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    GetRunner = async (workerId, runnerId) => {
+      this.#debug(`GetRunner()`);
+      try {
+        await this.#SyncWorkerDataFromWorker(this.#workersEx[workerId]);
+        return this.CreateRunnerCopy(this.#workersEx[workerId].runnersEx[runnerId]);
+      } catch (error) {
+        this.#error(`GetRunner(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    AddWorker = async (workerOptions, useWorkerFactory) => {
+      this.#debug(`AddWorker()`);
+      try {
+        let workerFactory;
+        if (useWorkerFactory) {
+          workerFactory = useWorkerFactory;
+        } else {
+          workerFactory = this.#options.workerFactory;
+        }
+        const {
+          port1,
+          // process message port
+          port2
+          // collector message port
+        } = new MessageChannel();
+        if (!isNode) {
+          port1.start();
+        }
+        const workerId = v4();
+        const stsWorkerEx = {
+          id: workerId,
+          workerManagerId: this.#id,
+          worker: workerFactory.createWorkerThreadWorker(),
+          workerEvents: [],
+          messagePort: port1,
+          options: workerOptions,
+          runnersEx: {},
+          runnersEvents: {},
+          GetRunner: (id) => this.#workersEx[workerId].runnersEx[id],
+          // Commands to execute on individual runners
+          AddRunner: (runnerOptions) => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
+          StartRunner: (runner) => this.#StartRunner(stsWorkerEx, runner),
+          StopRunner: (runner) => this.#StopRunner(stsWorkerEx, runner),
+          PauseRunner: (runner) => this.#PauseRunner(stsWorkerEx, runner),
+          ResumeRunner: (runner) => this.#ResumeRunner(stsWorkerEx, runner),
+          TerminateRunner: (runner) => this.#TerminateRunner(stsWorkerEx, runner),
+          ResetRunner: (runner) => this.#ResetRunner(stsWorkerEx, runner),
+          ExecuteRunner: (runner) => this.#ExecuteRunner(stsWorkerEx, runner),
+          UpdateRunner: (runner, runnerOptions) => this.#UpdateRunner(stsWorkerEx, runner, runnerOptions),
+          // Commands to execute on all runners
+          Start: () => this.#StartWorker(stsWorkerEx),
+          Stop: () => this.#StopWorker(stsWorkerEx),
+          Pause: () => this.#PauseWorker(stsWorkerEx),
+          Resume: () => this.#ResumeWorker(stsWorkerEx),
+          Terminate: () => this.#TerminateWorker(stsWorkerEx),
+          Reset: () => this.#ResetWorker(stsWorkerEx),
+          Execute: () => this.#ExecuteWorker(stsWorkerEx),
+          Update: (runnerOptions) => this.#UpdateOptionsWorker(stsWorkerEx, runnerOptions),
+          on: (eventName, cb) => {
+            stsWorkerEx.workerEvents.push({
+              eventName,
+              cb
             });
-          } else {
-            __privateGet(this, _PostMessageToWorkerUsingDefaultChannel).call(this, stsWorkerEx, eIWMessageCommands.MessagePort, {
+            return stsWorkerEx;
+          }
+        };
+        if (this.#STSInstrumentController) {
+          this.#STSInstrumentController.LogEx(chalk.yellow(`pid: [${process.pid}] Creating new worker: [${stsWorkerEx.id}]`));
+        }
+        this.#debug(`AddWorker::workerThreadWorkerOptions: Worker ID: [${stsWorkerEx.id}] Options: [${stsWorkerEx.options}]`);
+        if (stsWorkerEx.options.mocked) {
+          stsWorkerEx.worker.SetPort({
+            command: eIWMessageCommands.MessagePort,
+            payload: {
               messageId: v4(),
               port: port2,
-              //applicationStoreState: stateCopy,
               options: {
                 ...stsWorkerEx.options
               },
               workerId
-            }, port2);
-          }
-          if (!stsWorkerEx.options.mocked) {
-            if (isNode) {
-              stsWorkerEx.worker.on("exit", (code) => {
-                try {
-                  __privateGet(this, _debug2).call(this, chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker exited with code: ${code}`));
-                  __privateGet(this, _EmitWorkerEvent).call(this, "exit", stsWorkerEx);
-                  if (__privateGet(this, _workersEx)[stsWorkerEx.id]) {
-                    delete __privateGet(this, _workersEx)[stsWorkerEx.id];
-                    __privateGet(this, _debug2).call(this, chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker: [${stsWorkerEx.id}] has been removed from the worker collection.`));
-                  }
-                } catch (error) {
-                  __privateGet(this, _error2).call(this, chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(exit): Error: [${error}] Worker: [${stsWorkerEx.id}]`));
-                }
-              });
-              stsWorkerEx.worker.on("error", (error) => {
-                try {
-                  __privateGet(this, _error2).call(this, chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Worker error: ${error}`));
-                  __privateGet(this, _EmitWorkerEvent).call(this, "error", stsWorkerEx);
-                } catch (error2) {
-                  __privateGet(this, _error2).call(this, chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
-                }
-              });
-            } else {
-              stsWorkerEx.worker.onerror = (error) => {
-                try {
-                  __privateGet(this, _error2).call(this, chalk.red("STSWorkerManager:stsWorkerEx.worker.onerror(): Error in worker:", error));
-                  __privateGet(this, _EmitWorkerEvent).call(this, "onerror", stsWorkerEx);
-                  if (__privateGet(this, _workersEx)[stsWorkerEx.id]) {
-                    delete __privateGet(this, _workersEx)[stsWorkerEx.id];
-                    __privateGet(this, _debug2).call(this, chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.onerror(error): Worker: [${stsWorkerEx.id}] has been removed from the worker collection.`));
-                  }
-                } catch (error2) {
-                  __privateGet(this, _error2).call(this, chalk.red(`STSWorkerManager:stsWorkerEx.worker.onerror(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
-                }
-              };
-              stsWorkerEx.worker.onmessageerror = (error) => {
-                try {
-                  __privateGet(this, _error2).call(this, chalk.red("STSWorkerManager:stsWorkerEx.worker.onmessageerror(): Message error in worker:", error));
-                  __privateGet(this, _EmitWorkerEvent).call(this, "onmessageerror", stsWorkerEx);
-                } catch (error2) {
-                  __privateGet(this, _error2).call(this, chalk.red(`STSWorkerManager:stsWorkerEx.worker.onmessageerror(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
-                }
-              };
-            }
-          }
-          const processMessage = (data) => {
-            try {
-              const publishMessagePayload2 = data;
-              switch (publishMessagePayload2.command) {
-                case eIWMessageCommands.MessagePortResponse:
-                  __privateGet(this, _debug2).call(this, `AddWorker:processMessage(): eIWMessageCommands.MessagePortResponse`);
-                  break;
-                case eIWMessageCommands.InstrumentTelemetry:
-                  __privateGet(this, _ProcessTelemetry).call(this, stsWorkerEx, publishMessagePayload2.payload);
-                  break;
-                case eIWMessageCommands.RunnerStateChange:
-                  __privateGet(this, _RunnerStateChange).call(this, stsWorkerEx, publishMessagePayload2.payload);
-                  break;
-                case eIWMessageCommands.GetRunnersResponse:
-                  __privateMethod(this, _STSWorkerManager_instances, GetRunnersResponse_fn).call(this, stsWorkerEx, publishMessagePayload2.payload);
-                  break;
-                case eIWMessageCommands.AddRunnerResponse:
-                case eIWMessageCommands.StartRunnerResponse:
-                case eIWMessageCommands.StopRunnerResponse:
-                case eIWMessageCommands.PauseRunnerResponse:
-                case eIWMessageCommands.ResumeRunnerResponse:
-                case eIWMessageCommands.ExecuteRunnerResponse:
-                case eIWMessageCommands.ResetRunnerResponse:
-                case eIWMessageCommands.UpdateRunnerResponse:
-                case eIWMessageCommands.TerminateRunnerResponse:
-                  __privateMethod(this, _STSWorkerManager_instances, ProcessRunnerResponse_fn).call(this, stsWorkerEx, publishMessagePayload2.payload);
-                  break;
-                default:
-                  __privateGet(this, _warn2).call(this, `processMessage::default: Command Not Found: [${publishMessagePayload2.command}]`);
-              }
-            } catch (error) {
-              __privateGet(this, _error2).call(this, `AddWorker:processMessage(): Error: [${error}]`);
-              throw error;
             }
-          };
-          let publishMessagePayload;
+          });
+        } else {
+          this.#PostMessageToWorkerUsingDefaultChannel(stsWorkerEx, eIWMessageCommands.MessagePort, {
+            messageId: v4(),
+            port: port2,
+            //applicationStoreState: stateCopy,
+            options: {
+              ...stsWorkerEx.options
+            },
+            workerId
+          }, port2);
+        }
+        if (!stsWorkerEx.options.mocked) {
           if (isNode) {
-            stsWorkerEx.messagePort.on("message", (data) => {
-              publishMessagePayload = data;
-              processMessage(publishMessagePayload);
+            stsWorkerEx.worker.on("exit", (code) => {
+              try {
+                this.#debug(chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker exited with code: ${code}`));
+                this.#EmitWorkerEvent("exit", stsWorkerEx);
+                if (this.#workersEx[stsWorkerEx.id]) {
+                  delete this.#workersEx[stsWorkerEx.id];
+                  this.#debug(chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker: [${stsWorkerEx.id}] has been removed from the worker collection.`));
+                }
+              } catch (error) {
+                this.#error(chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(exit): Error: [${error}] Worker: [${stsWorkerEx.id}]`));
+              }
             });
-          } else {
-            stsWorkerEx.messagePort.addEventListener("message", (data) => {
-              publishMessagePayload = data.data;
-              processMessage(publishMessagePayload);
+            stsWorkerEx.worker.on("error", (error) => {
+              try {
+                this.#error(chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Worker error: ${error}`));
+                this.#EmitWorkerEvent("error", stsWorkerEx);
+              } catch (error2) {
+                this.#error(chalk.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
+              }
             });
-          }
-          __privateGet(this, _workersEx)[stsWorkerEx.id] = stsWorkerEx;
-          __privateGet(this, _debug2).call(this, `Added worker: [${stsWorkerEx.id}]`);
-          await stsutils.Sleep(10);
-          const worker = await this.GetWorker(stsWorkerEx.id);
-          if (worker.id.localeCompare(stsWorkerEx.id) === 0) {
-            return stsWorkerEx;
           } else {
-            throw new Error("AddWorker(): Could not get newly created worker.");
-          }
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `AddWorker: Error: [${error}]`);
-          throw error;
-        }
-      });
-      __publicField(this, "AddRunnerToWorker", async (stsWorkerEx, runnerOptions) => {
-        __privateGet(this, _debug2).call(this, `AddRunnerToWorker()`);
-        try {
-          const runnerEx = __privateGet(this, _CreateAsyncRunner).call(this, stsWorkerEx, runnerOptions);
-          stsWorkerEx.runnersEx[runnerEx.id] = runnerEx;
-          const retVal = await __privateGet(this, _SetRunnerIntoWorker).call(this, stsWorkerEx, runnerEx);
-          if (runnerEx.publishInstrumentController) {
-            runnerEx.publishInstrumentController.LogEx(chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}]`));
-          }
-          if (retVal) {
-            __privateGet(this, _debug2).call(this, chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}] result: [${JSON.stringify(retVal)}]`));
+            stsWorkerEx.worker.onerror = (error) => {
+              try {
+                this.#error(chalk.red("STSWorkerManager:stsWorkerEx.worker.onerror(): Error in worker:", error));
+                this.#EmitWorkerEvent("onerror", stsWorkerEx);
+                if (this.#workersEx[stsWorkerEx.id]) {
+                  delete this.#workersEx[stsWorkerEx.id];
+                  this.#debug(chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.onerror(error): Worker: [${stsWorkerEx.id}] has been removed from the worker collection.`));
+                }
+              } catch (error2) {
+                this.#error(chalk.red(`STSWorkerManager:stsWorkerEx.worker.onerror(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
+              }
+            };
+            stsWorkerEx.worker.onmessageerror = (error) => {
+              try {
+                this.#error(chalk.red("STSWorkerManager:stsWorkerEx.worker.onmessageerror(): Message error in worker:", error));
+                this.#EmitWorkerEvent("onmessageerror", stsWorkerEx);
+              } catch (error2) {
+                this.#error(chalk.red(`STSWorkerManager:stsWorkerEx.worker.onmessageerror(error): Error: [${error2}] Worker: [${stsWorkerEx.id}]`));
+              }
+            };
           }
-          return runnerEx;
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `AddRunnerToWorker(): Error: [${error}]`);
-          throw error;
         }
-      });
-      __privateAdd(this, _SetRunnerIntoWorker, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
+        const processMessage = (data) => {
           try {
-            const command = eIWMessageCommands.AddRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
+            const publishMessagePayload2 = data;
+            switch (publishMessagePayload2.command) {
+              case eIWMessageCommands.MessagePortResponse:
+                this.#debug(`AddWorker:processMessage(): eIWMessageCommands.MessagePortResponse`);
+                break;
+              case eIWMessageCommands.InstrumentTelemetry:
+                this.#ProcessTelemetry(stsWorkerEx, publishMessagePayload2.payload);
+                break;
+              case eIWMessageCommands.RunnerStateChange:
+                this.#RunnerStateChange(stsWorkerEx, publishMessagePayload2.payload);
+                break;
+              case eIWMessageCommands.GetRunnersResponse:
+                this.#GetRunnersResponse(stsWorkerEx, publishMessagePayload2.payload);
+                break;
+              case eIWMessageCommands.AddRunnerResponse:
+              case eIWMessageCommands.StartRunnerResponse:
+              case eIWMessageCommands.StopRunnerResponse:
+              case eIWMessageCommands.PauseRunnerResponse:
+              case eIWMessageCommands.ResumeRunnerResponse:
+              case eIWMessageCommands.ExecuteRunnerResponse:
+              case eIWMessageCommands.ResetRunnerResponse:
+              case eIWMessageCommands.UpdateRunnerResponse:
+              case eIWMessageCommands.TerminateRunnerResponse:
+                this.#ProcessRunnerResponse(stsWorkerEx, publishMessagePayload2.payload);
+                break;
+              default:
+                this.#warn(`processMessage::default: Command Not Found: [${publishMessagePayload2.command}]`);
+            }
           } catch (error) {
-            __privateGet(this, _error2).call(this, `#PauseRunner(): Error: [${error}]`);
+            this.#error(`AddWorker:processMessage(): Error: [${error}]`);
             throw error;
           }
-        });
-      });
-      __privateAdd(this, _ProcessTelemetry, (workerEx, payloadContents) => {
-        try {
-          const { runner } = payloadContents;
-          if (workerEx.runnersEx[runner.id]) {
-            const runnerEx = workerEx.runnersEx[runner.id];
-            __privateGet(this, _SyncRunnerData).call(this, runnerEx, runner);
-            if (runnerEx.publishInstrumentController && __privateGet(this, _telemetryProcessor)) {
-              __privateGet(this, _telemetryProcessor).ProcessTelemetry(runnerEx.publishInstrumentController, runnerEx.instrumentData);
-            }
-            __privateGet(this, _EmitRunnerEvent).call(this, "Telemetry", workerEx, runner.id);
-          }
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `ProcessTelemetry(): Error: [${error}]`);
-          throw error;
-        }
-      });
-      __privateAdd(this, _EmitWorkerEvent, (eventName, workerEx) => {
-        try {
-          workerEx.workerEvents.forEach((ev) => {
-            if (ev.eventName.localeCompare(eventName) === 0) {
-              ev.cb(workerEx);
-            }
+        };
+        let publishMessagePayload;
+        if (isNode) {
+          stsWorkerEx.messagePort.on("message", (data) => {
+            publishMessagePayload = data;
+            processMessage(publishMessagePayload);
+          });
+        } else {
+          stsWorkerEx.messagePort.addEventListener("message", (data) => {
+            publishMessagePayload = data.data;
+            processMessage(publishMessagePayload);
           });
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `EmitWorkerEvent(): Error: [${error}]`);
-          throw error;
         }
-      });
-      __privateAdd(this, _EmitRunnerEvent, (eventName, workerEx, runnerId) => {
-        try {
-          if (workerEx.runnersEvents[runnerId]) {
-            const runnersEvents = workerEx.runnersEvents[runnerId];
-            runnersEvents.forEach((ev) => {
-              if (ev.eventName.localeCompare(eventName) === 0) {
-                ev.cb(workerEx.runnersEx[runnerId]);
-              }
-            });
-          }
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `EmitRunnerEvent(): Error: [${error}]`);
-          throw error;
+        this.#workersEx[stsWorkerEx.id] = stsWorkerEx;
+        this.#debug(`Added worker: [${stsWorkerEx.id}]`);
+        await stsutils.Sleep(10);
+        const worker = await this.GetWorker(stsWorkerEx.id);
+        if (worker.id.localeCompare(stsWorkerEx.id) === 0) {
+          return stsWorkerEx;
+        } else {
+          throw new Error("AddWorker(): Could not get newly created worker.");
         }
-      });
-      //@@ make this have an event
-      //@@ make refactor event to own method
-      //@@ check for other events to capture
-      __privateAdd(this, _RunnerStateChange, (workerEx, payloadContents) => {
-        try {
-          const { runner } = payloadContents;
-          if (workerEx.runnersEx[runner.id]) {
-            const runnerEx = workerEx.runnersEx[runner.id];
-            const previousState = runnerEx.state;
-            runnerEx.state = runner.state;
-            if (!runnerEx.runnerHistory) {
-              runnerEx.runnerHistory = [];
-            }
-            runnerEx.runnerHistory.push({
-              eventDate: /* @__PURE__ */ new Date(),
-              runner: { ...runner }
-            });
-            __privateGet(this, _SyncRunnerData).call(this, runnerEx, runner);
-            __privateGet(this, _debug2).call(this, `STSWorkerManager:#RunnerStateChange(): Worker: [${workerEx.id}] Runner: [${runner.id}] Previous State: [${previousState}] State: [${runner.state}]`);
-            __privateGet(this, _EmitRunnerEvent).call(this, "StateChange", workerEx, runner.id);
-          }
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `RunnerStateChange(): Error: [${error}]`);
-          throw error;
+      } catch (error) {
+        this.#error(`AddWorker: Error: [${error}]`);
+        throw error;
+      }
+    };
+    AddRunnerToWorker = async (stsWorkerEx, runnerOptions) => {
+      this.#debug(`AddRunnerToWorker()`);
+      try {
+        const runnerEx = this.#CreateAsyncRunner(stsWorkerEx, runnerOptions);
+        stsWorkerEx.runnersEx[runnerEx.id] = runnerEx;
+        const retVal = await this.#SetRunnerIntoWorker(stsWorkerEx, runnerEx);
+        if (runnerEx.publishInstrumentController) {
+          runnerEx.publishInstrumentController.LogEx(chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}]`));
+        }
+        if (retVal) {
+          this.#debug(chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}] result: [${JSON.stringify(retVal)}]`));
         }
-      });
-      __privateAdd(this, _CreateAsyncRunner, (workerEx, runnerOptions) => {
-        const runnerId = v4();
-        if (__privateGet(this, _STSInstrumentController)) {
-          __privateGet(this, _STSInstrumentController).LogEx(chalk.yellow(`Creating new async runner: [${runnerId}]`));
-        }
-        const asyncRunnerContext = {
-          // [level1]@[level2]^[level3]|[level4]
-          // [hostName]@[agentId]-[userAgent]^[workerId]|[runnerId]
-          nid: `${workerEx.options.hostName}${stsutils.ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.options.agentId}-${workerEx.options.userAgent}${stsutils.ModelDelimeter.NID_SEPERATOR}${workerEx.id}${stsutils.ModelDelimeter.SEPERATOR}${runnerId}`,
-          hostName: workerEx.options.hostName,
-          // level 1 (e.g. host name)
-          agentName: `${workerEx.options.agentId}-${workerEx.options.userAgent}`,
-          // level 2 (e.g. service instance ID or user agent type and tab or instance)
-          threadId: `${workerEx.id}`,
-          // level 3 (web worker)
-          id: runnerId
-          // level 4 // (async runner within a web worker)
-        };
-        const runnerEx = {
-          id: runnerId,
-          workerId: workerEx.id,
-          workerManagerId: __privateGet(this, _id),
-          state: IRunnerState.created,
-          iteration: 0,
-          publishInstrumentController: __privateGet(this, _STSInstrumentController) ? __privateGet(this, _STSInstrumentController).AddPublishInstrumentController(asyncRunnerContext) : void 0,
-          asyncRunnerContext,
-          options: runnerOptions,
-          runnerHistory: [],
-          instrumentData: {
-            requestCount: 0,
-            errorCount: 0,
-            retryCount: 0,
-            authenticationCount: 0,
-            authenticationErrorCount: 0,
-            authenticationRetryCount: 0,
-            velocity: 0,
-            coreCount: 0,
-            timer: 0,
-            duration: 0,
-            latency: 0,
-            activeRequestCount: 0,
-            message: [],
-            childCount: 0,
-            rx: 0,
-            tx: 0
-          },
-          Start: () => __privateGet(this, _StartRunner2).call(this, workerEx, runnerEx),
-          Stop: () => __privateGet(this, _StopRunner2).call(this, workerEx, runnerEx),
-          Pause: () => __privateGet(this, _PauseRunner2).call(this, workerEx, runnerEx),
-          Resume: () => __privateGet(this, _ResumeRunner2).call(this, workerEx, runnerEx),
-          Reset: () => __privateGet(this, _ResetRunner2).call(this, workerEx, runnerEx),
-          Execute: () => __privateGet(this, _ExecuteRunner2).call(this, workerEx, runnerEx),
-          Terminate: () => __privateGet(this, _TerminateRunner2).call(this, workerEx, runnerEx),
-          Update: (runnerOptions2) => __privateGet(this, _UpdateRunner2).call(this, workerEx, runnerEx, runnerOptions2),
-          on: (eventName, cb) => {
-            if (!workerEx.runnersEvents[runnerEx.id]) {
-              workerEx.runnersEvents[runnerEx.id] = [];
-            }
-            workerEx.runnersEvents[runnerEx.id].push({
-              eventName,
-              cb
-            });
-            return runnerEx;
-          },
-          archived: false
-        };
         return runnerEx;
-      });
-      __privateAdd(this, _PostMessageToWorkerUsingDefaultChannel, (workerEx, command, payload, transferObject) => {
+      } catch (error) {
+        this.#error(`AddRunnerToWorker(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #SetRunnerIntoWorker = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          if (transferObject) {
-            __privateGet(this, _debug2).call(this, `#PostMessageToWorker with transfer object`);
-            workerEx.worker.postMessage({ command, payload }, [transferObject]);
-            __privateGet(this, _debug2).call(this, `#PostMessageToWorker with transfer object - done...`);
-          } else {
-            __privateGet(this, _debug2).call(this, `#PostMessageToWorker`);
-            workerEx.worker.postMessage({ command, payload });
-          }
+          const command = eIWMessageCommands.AddRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `PostMessageToWorkerUsingDefaultChannel(): Error: [${error}]`);
+          this.#error(`#PauseRunner(): Error: [${error}]`);
           throw error;
         }
       });
-      __privateAdd(this, _StartRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.StartRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#StartRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _StopRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.StopRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#StopRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _ResetRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.ResetRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#ResetRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _ExecuteRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.ExecuteRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#ExecuteRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _TerminateRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.TerminateRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#PauseRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _PauseRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.PauseRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#PauseRunner(): Error: [${error}]`);
-            throw error;
-          }
-        });
-      });
-      __privateAdd(this, _ResumeRunner2, async (workerEx, runnerEx) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const command = eIWMessageCommands.ResumeRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#ResumeRunner(): Error: [${error}]`);
-            throw error;
+    };
+    #ProcessTelemetry = (workerEx, payloadContents) => {
+      try {
+        const { runner } = payloadContents;
+        if (workerEx.runnersEx[runner.id]) {
+          const runnerEx = workerEx.runnersEx[runner.id];
+          this.#SyncRunnerData(runnerEx, runner);
+          if (runnerEx.publishInstrumentController && this.#telemetryProcessor) {
+            this.#telemetryProcessor.ProcessTelemetry(runnerEx.publishInstrumentController, runnerEx.instrumentData);
           }
-        });
-      });
-      __privateAdd(this, _UpdateRunner2, async (workerEx, runnerEx, runnerOptions) => {
-        return new Promise((resolve, reject) => {
-          try {
-            merge(runnerEx.options, runnerOptions);
-            const command = eIWMessageCommands.UpdateRunner;
-            const messageId = __privateGet(this, _SetupCallbackMessage).call(this, resolve, reject, command);
-            const payload = {
-              messageId,
-              runner: this.CreateRunnerCopyNoHistory(runnerEx)
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#UpdateRunner(): Error: [${error}]`);
-            throw error;
+          this.#EmitRunnerEvent("Telemetry", workerEx, runner.id);
+        }
+      } catch (error) {
+        this.#error(`ProcessTelemetry(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #EmitWorkerEvent = (eventName, workerEx) => {
+      try {
+        workerEx.workerEvents.forEach((ev) => {
+          if (ev.eventName.localeCompare(eventName) === 0) {
+            ev.cb(workerEx);
           }
         });
-      });
-      __privateAdd(this, _StartWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Start());
-        }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _StopWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Stop());
-        }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _PauseWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Pause());
-        }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _ResumeWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Resume());
-        }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _ResetWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Reset());
-        }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _ExecuteWorker, async (workerEx) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Execute());
-        }
-        return Promise.all(promArray);
-      });
-      // IExecutionProfile
-      __privateAdd(this, _UpdateOptionsWorker, async (workerEx, runnerOptions) => {
-        const runners = Object.values(workerEx.runnersEx);
-        const promArray = [];
-        for (let i = 0; i < runners.length; i++) {
-          promArray.push(runners[i].Update(runnerOptions));
+      } catch (error) {
+        this.#error(`EmitWorkerEvent(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #EmitRunnerEvent = (eventName, workerEx, runnerId) => {
+      try {
+        if (workerEx.runnersEvents[runnerId]) {
+          const runnersEvents = workerEx.runnersEvents[runnerId];
+          runnersEvents.forEach((ev) => {
+            if (ev.eventName.localeCompare(eventName) === 0) {
+              ev.cb(workerEx.runnersEx[runnerId]);
+            }
+          });
         }
-        return Promise.all(promArray);
-      });
-      __privateAdd(this, _TerminateWorker, async (workerEx) => {
-        try {
-          const runners = Object.values(workerEx.runnersEx);
-          const promArray = [];
-          for (let i = 0; i < runners.length; i++) {
-            promArray.push(runners[i].Terminate());
+      } catch (error) {
+        this.#error(`EmitRunnerEvent(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    //@@ make this have an event
+    //@@ make refactor event to own method
+    //@@ check for other events to capture
+    #RunnerStateChange = (workerEx, payloadContents) => {
+      try {
+        const { runner } = payloadContents;
+        if (workerEx.runnersEx[runner.id]) {
+          const runnerEx = workerEx.runnersEx[runner.id];
+          const previousState = runnerEx.state;
+          runnerEx.state = runner.state;
+          if (!runnerEx.runnerHistory) {
+            runnerEx.runnerHistory = [];
           }
-          const retVal = Promise.all(promArray);
-          if (workerEx.worker) {
-            setTimeout(() => {
-              workerEx.worker.terminate();
-              __privateGet(this, _debug2).call(this, `Terminated worker: [${workerEx.id}]`);
-              if (__privateGet(this, _workersEx)[workerEx.id]) {
-                delete __privateGet(this, _workersEx)[workerEx.id];
-                __privateGet(this, _debug2).call(this, chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker: [${workerEx.id}] has been removed from the worker collection.`));
-              }
-            }, 500);
+          runnerEx.runnerHistory.push({
+            eventDate: /* @__PURE__ */ new Date(),
+            runner: { ...runner }
+          });
+          this.#SyncRunnerData(runnerEx, runner);
+          this.#debug(`STSWorkerManager:#RunnerStateChange(): Worker: [${workerEx.id}] Runner: [${runner.id}] Previous State: [${previousState}] State: [${runner.state}]`);
+          this.#EmitRunnerEvent("StateChange", workerEx, runner.id);
+        }
+      } catch (error) {
+        this.#error(`RunnerStateChange(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #CreateAsyncRunner = (workerEx, runnerOptions) => {
+      const runnerId = v4();
+      if (this.#STSInstrumentController) {
+        this.#STSInstrumentController.LogEx(chalk.yellow(`Creating new async runner: [${runnerId}]`));
+      }
+      const asyncRunnerContext = {
+        // [level1]@[level2]^[level3]|[level4]
+        // [hostName]@[agentId]-[userAgent]^[workerId]|[runnerId]
+        nid: `${workerEx.options.hostName}${stsutils.ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.options.agentId}-${workerEx.options.userAgent}${stsutils.ModelDelimeter.NID_SEPERATOR}${workerEx.id}${stsutils.ModelDelimeter.SEPERATOR}${runnerId}`,
+        hostName: workerEx.options.hostName,
+        // level 1 (e.g. host name)
+        agentName: `${workerEx.options.agentId}-${workerEx.options.userAgent}`,
+        // level 2 (e.g. service instance ID or user agent type and tab or instance)
+        threadId: `${workerEx.id}`,
+        // level 3 (web worker)
+        id: runnerId
+        // level 4 // (async runner within a web worker)
+      };
+      const runnerEx = {
+        id: runnerId,
+        workerId: workerEx.id,
+        workerManagerId: this.#id,
+        state: IRunnerState.created,
+        iteration: 0,
+        publishInstrumentController: this.#STSInstrumentController ? this.#STSInstrumentController.AddPublishInstrumentController(asyncRunnerContext) : void 0,
+        asyncRunnerContext,
+        options: runnerOptions,
+        runnerHistory: [],
+        instrumentData: {
+          requestCount: 0,
+          errorCount: 0,
+          retryCount: 0,
+          authenticationCount: 0,
+          authenticationErrorCount: 0,
+          authenticationRetryCount: 0,
+          velocity: 0,
+          coreCount: 0,
+          timer: 0,
+          duration: 0,
+          latency: 0,
+          activeRequestCount: 0,
+          message: [],
+          childCount: 0,
+          rx: 0,
+          tx: 0
+        },
+        Start: () => this.#StartRunner(workerEx, runnerEx),
+        Stop: () => this.#StopRunner(workerEx, runnerEx),
+        Pause: () => this.#PauseRunner(workerEx, runnerEx),
+        Resume: () => this.#ResumeRunner(workerEx, runnerEx),
+        Reset: () => this.#ResetRunner(workerEx, runnerEx),
+        Execute: () => this.#ExecuteRunner(workerEx, runnerEx),
+        Terminate: () => this.#TerminateRunner(workerEx, runnerEx),
+        Update: (runnerOptions2) => this.#UpdateRunner(workerEx, runnerEx, runnerOptions2),
+        on: (eventName, cb) => {
+          if (!workerEx.runnersEvents[runnerEx.id]) {
+            workerEx.runnersEvents[runnerEx.id] = [];
           }
-          return retVal;
-        } catch (error) {
-          __privateGet(this, _error2).call(this, `TerminateWorker(): Error: [${error}]`);
-          return [];
+          workerEx.runnersEvents[runnerEx.id].push({
+            eventName,
+            cb
+          });
+          return runnerEx;
+        },
+        archived: false
+      };
+      return runnerEx;
+    };
+    #PostMessageToWorkerUsingDefaultChannel = (workerEx, command, payload, transferObject) => {
+      try {
+        if (transferObject) {
+          this.#debug(`#PostMessageToWorker with transfer object`);
+          workerEx.worker.postMessage({ command, payload }, [transferObject]);
+          this.#debug(`#PostMessageToWorker with transfer object - done...`);
+        } else {
+          this.#debug(`#PostMessageToWorker`);
+          workerEx.worker.postMessage({ command, payload });
         }
-      });
-      __publicField(this, "GetNextAvailableWorker", () => {
-        __privateGet(this, _debug2).call(this, `GetNextAvailableWorker()`);
+      } catch (error) {
+        this.#error(`PostMessageToWorkerUsingDefaultChannel(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #StartRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          let leastRunnerWorker = null;
-          for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
-            if (leastRunnerWorker) {
-              if (Object.keys(stsWorker.runnersEx).length < Object.keys(leastRunnerWorker.runnersEx).length) {
-                leastRunnerWorker = stsWorker;
-              }
-            } else {
-              leastRunnerWorker = stsWorker;
-            }
-          }
-          return leastRunnerWorker;
+          const command = eIWMessageCommands.StartRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `GetNextAvailableWorker(): Error: [${error}]`);
-          return null;
+          this.#error(`#StartRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __publicField(this, "GetBusyWorker", () => {
-        __privateGet(this, _debug2).call(this, `GetBusyWorker()`);
+    };
+    #StopRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          let busyWorker = null;
-          for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
-            if (busyWorker) {
-              if (Object.keys(stsWorker.runnersEx).length > Object.keys(busyWorker.runnersEx).length) {
-                busyWorker = stsWorker;
-              }
-            } else {
-              busyWorker = stsWorker;
-            }
-          }
-          return busyWorker;
+          const command = eIWMessageCommands.StopRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `GetBusyWorker(): Error: [${error}]`);
-          return null;
+          this.#error(`#StopRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __privateAdd(this, _ProcessWorkerCommands, async (workerIds, command, runnerOptions) => {
-        __privateGet(this, _debug2).call(this, `#ProcessWorkerCommands: workerIds: [${workerIds}]  command: [${command}`);
+    };
+    #ResetRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          const promArray = [];
-          const workers = Object.values(this.WorkersEx).filter((workerEx) => workerIds.length === 0 ? true : workerIds.includes(workerEx.id));
-          for (let i = 0; i < workers.length; i++) {
-            if (command === "Update") {
-              promArray.push(workers[i][command](runnerOptions));
-            } else {
-              promArray.push(workers[i][command]());
-            }
-          }
-          const retValResult = await Promise.all(promArray);
-          const returnVal = [];
-          for (let i = 0; i < workers.length; i++) {
-            returnVal.push({
-              workerManagerId: __privateGet(this, _id),
-              workerId: workers[i].id,
-              executeRunnerActionResults: retValResult[i]
-            });
-          }
-          return returnVal;
+          const command = eIWMessageCommands.ResetRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `ProcessWorkerCommands(): command: [${command}] workerIds: [${workerIds}] Error: [${error}]`);
-          return [];
+          this.#error(`#ResetRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __publicField(this, "StartWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Start");
-      });
-      __publicField(this, "StopWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Stop");
-      });
-      __publicField(this, "PauseWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Pause");
-      });
-      __publicField(this, "ResumeWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Resume");
-      });
-      __publicField(this, "ExecuteWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Execute");
-      });
-      __publicField(this, "ResetWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Reset");
-      });
-      __publicField(this, "TerminateWorkers", async (workerIds) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Terminate");
-      });
-      __publicField(this, "UpdateWorkers", async (workerIds, runnerOptions) => {
-        return __privateGet(this, _ProcessWorkerCommands).call(this, workerIds, "Update", runnerOptions);
-      });
-      __privateAdd(this, _ExecuteVariableCommandOnRunners, async (workerId, runnerIds, command, runnerOptions) => {
-        __privateGet(this, _debug2).call(this, `#ExecuteVariableCommandOnRunners: workerId: [${workerId}]  command: [${command}  runnerIds: [${runnerIds}]`);
+    };
+    #ExecuteRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          if (__privateGet(this, _workersEx)[workerId]) {
-            if (runnerIds.length === 0) {
-              if (command === "Update") {
-                return __privateGet(this, _workersEx)[workerId][command](runnerOptions);
-              } else {
-                return __privateGet(this, _workersEx)[workerId][command]();
-              }
-            } else {
-              const promArray = [];
-              const runners = Object.values(__privateGet(this, _workersEx)[workerId].runnersEx).filter((runnerEx) => runnerIds.length === 0 ? true : runnerIds.includes(runnerEx.id));
-              for (let i = 0; i < runners.length; i++) {
-                if (command === "Update") {
-                  promArray.push(runners[i][command](runnerOptions));
-                } else {
-                  promArray.push(runners[i][command]());
-                }
-              }
-              const retValResult = await Promise.all(promArray);
-              const returnVal = [];
-              for (let i = 0; i < runners.length; i++) {
-                returnVal.push({ ...retValResult[i] });
-              }
-              return returnVal;
-            }
-          }
-          return [];
+          const command = eIWMessageCommands.ExecuteRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `#ExecuteVariableCommandRunners(): command: [${command}] workerId: [${workerId}] runnerIds: [${runnerIds}] Error: [${error}]`);
-          return [];
+          this.#error(`#ExecuteRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __publicField(this, "StopRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Stop");
-      });
-      __publicField(this, "StartRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Start");
-      });
-      __publicField(this, "PauseRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Pause");
-      });
-      __publicField(this, "ResumeRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Resume");
-      });
-      __publicField(this, "ExecuteRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Execute");
-      });
-      __publicField(this, "ResetRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Reset");
-      });
-      __publicField(this, "TerminateRunners", async (workerId, runnerIds) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Terminate");
-      });
-      __publicField(this, "UpdateRunners", async (workerId, runnerIds, runnerOptions) => {
-        return __privateGet(this, _ExecuteVariableCommandOnRunners).call(this, workerId, runnerIds, "Update", runnerOptions);
-      });
-      __privateAdd(this, _SyncRunnerData, (runnerEx, runner) => {
+    };
+    #TerminateRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          runnerEx.iteration = runner.iteration;
-          runnerEx.state = runner.state;
-          runnerEx.instrumentData = { ...runner.instrumentData };
+          const command = eIWMessageCommands.TerminateRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `#SyncRunnerData(): Error: [${error}]`);
+          this.#error(`#PauseRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __privateAdd(this, _SyncWorkerDataFromPayload, (payload) => {
+    };
+    #PauseRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          if (__privateGet(this, _workersEx)[payload.workerId]) {
-            const runnersEx = __privateGet(this, _workersEx)[payload.workerId].runnersEx;
-            if (runnersEx) {
-              payload.runners.forEach((runner) => {
-                if (runnersEx[runner.id]) {
-                  __privateGet(this, _SyncRunnerData).call(this, runnersEx[runner.id], runner);
-                }
-              });
-            }
-          }
+          const command = eIWMessageCommands.PauseRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `#SyncWorkerDataFromPayload(): Error: [${error}]`);
+          this.#error(`#PauseRunner(): Error: [${error}]`);
+          throw error;
         }
       });
-      __privateAdd(this, _SyncWorkerDataFromWorker, async (workerEx) => {
+    };
+    #ResumeRunner = async (workerEx, runnerEx) => {
+      return new Promise((resolve, reject) => {
         try {
-          const retVal = await __privateGet(this, _PostMessageToWorkerGetRunners).call(this, workerEx, eIWMessageCommands.GetRunners);
-          __privateGet(this, _SyncWorkerDataFromPayload).call(this, retVal.payload);
-          return retVal;
+          const command = eIWMessageCommands.ResumeRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `#SyncWorkerDataFromWorker(): Error: [${error}]`);
+          this.#error(`#ResumeRunner(): Error: [${error}]`);
           throw error;
         }
       });
-      __privateAdd(this, _SyncWorkerDataFromWorkers, async () => {
+    };
+    #UpdateRunner = async (workerEx, runnerEx, runnerOptions) => {
+      return new Promise((resolve, reject) => {
         try {
-          const retVal = await Promise.all(Object.values(__privateGet(this, _workersEx)).map((workerEx) => __privateGet(this, _PostMessageToWorkerGetRunners).call(this, workerEx, eIWMessageCommands.GetRunners)));
-          retVal.forEach((messagePayload) => {
-            __privateGet(this, _SyncWorkerDataFromPayload).call(this, messagePayload.payload);
-          });
-          return retVal;
+          merge(runnerEx.options, runnerOptions);
+          const command = eIWMessageCommands.UpdateRunner;
+          const messageId = this.#SetupCallbackMessage(resolve, reject, command);
+          const payload = {
+            messageId,
+            runner: this.CreateRunnerCopyNoHistory(runnerEx)
+          };
+          workerEx.messagePort.postMessage({ command, payload });
         } catch (error) {
-          __privateGet(this, _error2).call(this, `#SyncWorkerDataFromWorkers(): Error: [${error}]`);
+          this.#error(`#UpdateRunner(): Error: [${error}]`);
           throw error;
         }
       });
-      __privateAdd(this, _SetupCallbackMessage, (resolve, reject, command) => {
-        const messageId = v4();
-        __privateGet(this, _messages)[messageId] = {
-          timeout: setTimeout(() => {
-            delete __privateGet(this, _messages)[messageId];
-            reject(`STSWorkerManager:#SetupCallbackMessage(): message response timeout for message id: [${messageId}], command: [${command}]`);
-          }, __privateGet(this, _options2).messageTimeout),
-          resolveMessage: (payload) => {
-            resolve(payload);
-          }
-        };
-        return messageId;
-      });
-      __privateAdd(this, _PostMessageToWorkerGetRunners, async (workerEx, command) => {
-        return new Promise((resolve, reject) => {
-          try {
-            const messageId = v4();
-            __privateGet(this, _messages)[messageId] = {
-              timeout: setTimeout(() => {
-                delete __privateGet(this, _messages)[messageId];
-                reject(`STSWorkerManager:#PostMessageToWorkerGetRunners(): message response timeout for message id: [${messageId}], command: [${command}]`);
-              }, __privateGet(this, _options2).messageTimeout),
-              resolveMessage: (payload2) => {
-                resolve(payload2);
-              }
-            };
-            const payload = {
-              messageId
-            };
-            workerEx.messagePort.postMessage({ command, payload });
-          } catch (error) {
-            __privateGet(this, _error2).call(this, `#PostMessageToWorkerGetRunners(): Error: [${error}]`);
-          }
-        });
-      });
-      __privateSet(this, _id, v4());
-      if (options) {
-        __privateSet(this, _options2, options);
-      } else {
-        __privateSet(this, _options2, {});
+    };
+    #StartWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Start());
+      }
+      return Promise.all(promArray);
+    };
+    #StopWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Stop());
       }
-      if (__privateGet(this, _options2).publishInstrumentController) {
-        __privateSet(this, _STSInstrumentController, __privateGet(this, _options2).publishInstrumentController);
-        __privateSet(this, _telemetryProcessor, new TelemetryProcessor());
+      return Promise.all(promArray);
+    };
+    #PauseWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Pause());
       }
-      __privateGet(this, _processLoopExecutor2).call(this);
-    }
-    CreateRunnerCopyNoHistory(runnerEx) {
+      return Promise.all(promArray);
+    };
+    #ResumeWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Resume());
+      }
+      return Promise.all(promArray);
+    };
+    #ResetWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Reset());
+      }
+      return Promise.all(promArray);
+    };
+    #ExecuteWorker = async (workerEx) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Execute());
+      }
+      return Promise.all(promArray);
+    };
+    // IExecutionProfile
+    #UpdateOptionsWorker = async (workerEx, runnerOptions) => {
+      const runners = Object.values(workerEx.runnersEx);
+      const promArray = [];
+      for (let i = 0; i < runners.length; i++) {
+        promArray.push(runners[i].Update(runnerOptions));
+      }
+      return Promise.all(promArray);
+    };
+    #TerminateWorker = async (workerEx) => {
       try {
-        return {
-          id: runnerEx.id,
-          asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
-          instrumentData: { ...runnerEx.instrumentData },
-          iteration: runnerEx.iteration,
-          options: { ...runnerEx.options },
-          state: runnerEx.state,
-          workerId: runnerEx.workerId,
-          workerManagerId: __privateGet(this, _id)
-        };
+        const runners = Object.values(workerEx.runnersEx);
+        const promArray = [];
+        for (let i = 0; i < runners.length; i++) {
+          promArray.push(runners[i].Terminate());
+        }
+        const retVal = Promise.all(promArray);
+        if (workerEx.worker) {
+          setTimeout(() => {
+            workerEx.worker.terminate();
+            this.#debug(`Terminated worker: [${workerEx.id}]`);
+            if (this.#workersEx[workerEx.id]) {
+              delete this.#workersEx[workerEx.id];
+              this.#debug(chalk.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker: [${workerEx.id}] has been removed from the worker collection.`));
+            }
+          }, 500);
+        }
+        return retVal;
       } catch (error) {
-        __privateGet(this, _error2).call(this, `CreateRunnerCopyNoHistory(): Error: [${error}]`);
-        throw error;
+        this.#error(`TerminateWorker(): Error: [${error}]`);
+        return [];
       }
-    }
-    CreateRunnerCopy(runnerEx) {
+    };
+    GetNextAvailableWorker = () => {
+      this.#debug(`GetNextAvailableWorker()`);
       try {
-        const retVal = this.CreateRunnerCopyNoHistory(runnerEx);
-        if (runnerEx.runnerHistory) {
-          retVal.runnerHistory = [...runnerEx.runnerHistory];
+        let leastRunnerWorker = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+          if (leastRunnerWorker) {
+            if (Object.keys(stsWorker.runnersEx).length < Object.keys(leastRunnerWorker.runnersEx).length) {
+              leastRunnerWorker = stsWorker;
+            }
+          } else {
+            leastRunnerWorker = stsWorker;
+          }
         }
-        return retVal;
+        return leastRunnerWorker;
       } catch (error) {
-        __privateGet(this, _error2).call(this, `CreateRunnerCopy(): Error: [${error}]`);
-        throw error;
+        this.#error(`GetNextAvailableWorker(): Error: [${error}]`);
+        return null;
       }
-    }
-    CreateRunnerCopySmall(runnerEx) {
+    };
+    GetBusyWorker = () => {
+      this.#debug(`GetBusyWorker()`);
       try {
-        const retVal = {
-          id: runnerEx.id,
-          iteration: runnerEx.iteration,
-          state: runnerEx.state
-        };
-        if (runnerEx.options && runnerEx.options.runnerPlan) {
-          retVal.options = {
-            runnerPlan: { ...runnerEx.options.runnerPlan }
-          };
+        let busyWorker = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+          if (busyWorker) {
+            if (Object.keys(stsWorker.runnersEx).length > Object.keys(busyWorker.runnersEx).length) {
+              busyWorker = stsWorker;
+            }
+          } else {
+            busyWorker = stsWorker;
+          }
         }
-        return retVal;
+        return busyWorker;
       } catch (error) {
-        __privateGet(this, _error2).call(this, `CreateRunnerCopy(): Error: [${error}]`);
-        throw error;
+        this.#error(`GetBusyWorker(): Error: [${error}]`);
+        return null;
       }
+    };
+    get Options() {
+      return this.#options;
     }
-    CreateWorkerCopy(workerEx) {
+    set Options(options) {
+      this.#options = options;
+    }
+    #ProcessWorkerCommands = async (workerIds, command, runnerOptions) => {
+      this.#debug(`#ProcessWorkerCommands: workerIds: [${workerIds}]  command: [${command}`);
       try {
-        const { id, options, runnersEx, workerManagerId } = workerEx;
-        const workerCopy = {
-          id,
-          options: { ...options },
-          runners: {},
-          workerManagerId
-        };
-        for (const [, runnerEx] of Object.entries(runnersEx)) {
-          workerCopy.runners[runnerEx.id] = this.CreateRunnerCopy(runnerEx);
+        const promArray = [];
+        const workers = Object.values(this.WorkersEx).filter((workerEx) => workerIds.length === 0 ? true : workerIds.includes(workerEx.id));
+        for (let i = 0; i < workers.length; i++) {
+          if (command === "Update") {
+            promArray.push(workers[i][command](runnerOptions));
+          } else {
+            promArray.push(workers[i][command]());
+          }
         }
-        return workerCopy;
+        const retValResult = await Promise.all(promArray);
+        const returnVal = [];
+        for (let i = 0; i < workers.length; i++) {
+          returnVal.push({
+            workerManagerId: this.#id,
+            workerId: workers[i].id,
+            executeRunnerActionResults: retValResult[i]
+          });
+        }
+        return returnVal;
       } catch (error) {
-        __privateGet(this, _error2).call(this, `#CreateWorkerCopy(): Error: [${error}]`);
-        throw error;
+        this.#error(`ProcessWorkerCommands(): command: [${command}] workerIds: [${workerIds}] Error: [${error}]`);
+        return [];
       }
-    }
-    CreateWorkerCopySmall(workerEx, states) {
+    };
+    StartWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Start");
+    };
+    StopWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Stop");
+    };
+    PauseWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Pause");
+    };
+    ResumeWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Resume");
+    };
+    ExecuteWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Execute");
+    };
+    ResetWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Reset");
+    };
+    TerminateWorkers = async (workerIds) => {
+      return this.#ProcessWorkerCommands(workerIds, "Terminate");
+    };
+    UpdateWorkers = async (workerIds, runnerOptions) => {
+      return this.#ProcessWorkerCommands(workerIds, "Update", runnerOptions);
+    };
+    #ExecuteVariableCommandOnRunners = async (workerId, runnerIds, command, runnerOptions) => {
+      this.#debug(`#ExecuteVariableCommandOnRunners: workerId: [${workerId}]  command: [${command}  runnerIds: [${runnerIds}]`);
       try {
-        const workerCopy = {
-          id: workerEx.id,
-          runners: {}
-        };
-        Object.values(workerEx.runnersEx).filter((runnerEx) => states.length === 0 ? true : states.includes(runnerEx.state)).forEach((runnerEx) => {
-          workerCopy.runners[runnerEx.id] = this.CreateRunnerCopySmall(runnerEx);
-        });
-        return workerCopy;
+        if (this.#workersEx[workerId]) {
+          if (runnerIds.length === 0) {
+            if (command === "Update") {
+              return this.#workersEx[workerId][command](runnerOptions);
+            } else {
+              return this.#workersEx[workerId][command]();
+            }
+          } else {
+            const promArray = [];
+            const runners = Object.values(this.#workersEx[workerId].runnersEx).filter((runnerEx) => runnerIds.length === 0 ? true : runnerIds.includes(runnerEx.id));
+            for (let i = 0; i < runners.length; i++) {
+              if (command === "Update") {
+                promArray.push(runners[i][command](runnerOptions));
+              } else {
+                promArray.push(runners[i][command]());
+              }
+            }
+            const retValResult = await Promise.all(promArray);
+            const returnVal = [];
+            for (let i = 0; i < runners.length; i++) {
+              returnVal.push({ ...retValResult[i] });
+            }
+            return returnVal;
+          }
+        }
+        return [];
       } catch (error) {
-        __privateGet(this, _error2).call(this, `CreateWorkerCopySmall(): Error: [${error}]`);
-        throw error;
+        this.#error(`#ExecuteVariableCommandRunners(): command: [${command}] workerId: [${workerId}] runnerIds: [${runnerIds}] Error: [${error}]`);
+        return [];
+      }
+    };
+    StopRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Stop");
+    };
+    StartRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Start");
+    };
+    PauseRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Pause");
+    };
+    ResumeRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Resume");
+    };
+    ExecuteRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Execute");
+    };
+    ResetRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Reset");
+    };
+    TerminateRunners = async (workerId, runnerIds) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Terminate");
+    };
+    UpdateRunners = async (workerId, runnerIds, runnerOptions) => {
+      return this.#ExecuteVariableCommandOnRunners(workerId, runnerIds, "Update", runnerOptions);
+    };
+    #GetRunnersResponse(stsWorkerEx, payload) {
+      try {
+        const messageId = payload.messageId;
+        if (this.#messages[messageId]) {
+          const messageRecord = this.#messages[messageId];
+          clearTimeout(messageRecord.timeout);
+          const returnPayload = {
+            command: eIWMessageCommands.GetRunners,
+            payload: {
+              messageId,
+              workerId: stsWorkerEx.id,
+              runners: payload.runners
+            }
+          };
+          delete this.#messages[messageId];
+          messageRecord.resolveMessage(returnPayload);
+        }
+      } catch (error) {
+        this.#error(`#GetRunnersResponse(): Error: [${error}]`);
       }
     }
-    get id() {
-      return __privateGet(this, _id);
-    }
-    get WorkersEx() {
-      return __privateGet(this, _workersEx);
-    }
-    get Options() {
-      return __privateGet(this, _options2);
-    }
-    set Options(options) {
-      __privateSet(this, _options2, options);
-    }
-  }
-  _workersEx = new WeakMap();
-  _options2 = new WeakMap();
-  _STSInstrumentController = new WeakMap();
-  _telemetryProcessor = new WeakMap();
-  _archiveList = new WeakMap();
-  _id = new WeakMap();
-  _messages = new WeakMap();
-  _archiveDeleteTimeout2 = new WeakMap();
-  _logMessage2 = new WeakMap();
-  _silly2 = new WeakMap();
-  _debug2 = new WeakMap();
-  _info2 = new WeakMap();
-  _warn2 = new WeakMap();
-  _error2 = new WeakMap();
-  _processLoopExecutor2 = new WeakMap();
-  _SetRunnerIntoWorker = new WeakMap();
-  _ProcessTelemetry = new WeakMap();
-  _EmitWorkerEvent = new WeakMap();
-  _EmitRunnerEvent = new WeakMap();
-  _RunnerStateChange = new WeakMap();
-  _CreateAsyncRunner = new WeakMap();
-  _PostMessageToWorkerUsingDefaultChannel = new WeakMap();
-  _StartRunner2 = new WeakMap();
-  _StopRunner2 = new WeakMap();
-  _ResetRunner2 = new WeakMap();
-  _ExecuteRunner2 = new WeakMap();
-  _TerminateRunner2 = new WeakMap();
-  _PauseRunner2 = new WeakMap();
-  _ResumeRunner2 = new WeakMap();
-  _UpdateRunner2 = new WeakMap();
-  _StartWorker = new WeakMap();
-  _StopWorker = new WeakMap();
-  _PauseWorker = new WeakMap();
-  _ResumeWorker = new WeakMap();
-  _ResetWorker = new WeakMap();
-  _ExecuteWorker = new WeakMap();
-  _UpdateOptionsWorker = new WeakMap();
-  _TerminateWorker = new WeakMap();
-  _ProcessWorkerCommands = new WeakMap();
-  _ExecuteVariableCommandOnRunners = new WeakMap();
-  _STSWorkerManager_instances = new WeakSet();
-  GetRunnersResponse_fn = function(stsWorkerEx, payload) {
-    try {
-      const messageId = payload.messageId;
-      if (__privateGet(this, _messages)[messageId]) {
-        const messageRecord = __privateGet(this, _messages)[messageId];
-        clearTimeout(messageRecord.timeout);
-        const returnPayload = {
-          command: eIWMessageCommands.GetRunners,
-          payload: {
-            messageId,
-            workerId: stsWorkerEx.id,
-            runners: payload.runners
+    #ProcessRunnerResponse(stsWorkerEx, payload) {
+      try {
+        const messageId = payload.messageId;
+        if (this.#messages[messageId]) {
+          const messageRecord = this.#messages[messageId];
+          clearTimeout(messageRecord.timeout);
+          const retPayload = { ...payload.executeRunnerActionResult };
+          delete this.#messages[messageId];
+          if (this.#workersEx[payload.runner.workerId]) {
+            const runnersEx = this.#workersEx[payload.runner.workerId].runnersEx;
+            if (runnersEx && runnersEx[payload.runner.id]) {
+              this.#SyncRunnerData(runnersEx[payload.runner.id], payload.runner);
+            }
           }
-        };
-        delete __privateGet(this, _messages)[messageId];
-        messageRecord.resolveMessage(returnPayload);
+          messageRecord.resolveMessage(retPayload);
+        }
+      } catch (error) {
+        this.#error(`#ProcessRunnerResponse(): Error: [${error}]`);
       }
-    } catch (error) {
-      __privateGet(this, _error2).call(this, `#GetRunnersResponse(): Error: [${error}]`);
     }
-  };
-  ProcessRunnerResponse_fn = function(stsWorkerEx, payload) {
-    try {
-      const messageId = payload.messageId;
-      if (__privateGet(this, _messages)[messageId]) {
-        const messageRecord = __privateGet(this, _messages)[messageId];
-        clearTimeout(messageRecord.timeout);
-        const retPayload = { ...payload.executeRunnerActionResult };
-        delete __privateGet(this, _messages)[messageId];
-        if (__privateGet(this, _workersEx)[payload.runner.workerId]) {
-          const runnersEx = __privateGet(this, _workersEx)[payload.runner.workerId].runnersEx;
-          if (runnersEx && runnersEx[payload.runner.id]) {
-            __privateGet(this, _SyncRunnerData).call(this, runnersEx[payload.runner.id], payload.runner);
+    #SyncRunnerData = (runnerEx, runner) => {
+      try {
+        runnerEx.iteration = runner.iteration;
+        runnerEx.state = runner.state;
+        runnerEx.instrumentData = { ...runner.instrumentData };
+      } catch (error) {
+        this.#error(`#SyncRunnerData(): Error: [${error}]`);
+      }
+    };
+    #SyncWorkerDataFromPayload = (payload) => {
+      try {
+        if (this.#workersEx[payload.workerId]) {
+          const runnersEx = this.#workersEx[payload.workerId].runnersEx;
+          if (runnersEx) {
+            payload.runners.forEach((runner) => {
+              if (runnersEx[runner.id]) {
+                this.#SyncRunnerData(runnersEx[runner.id], runner);
+              }
+            });
           }
         }
-        messageRecord.resolveMessage(retPayload);
+      } catch (error) {
+        this.#error(`#SyncWorkerDataFromPayload(): Error: [${error}]`);
       }
-    } catch (error) {
-      __privateGet(this, _error2).call(this, `#ProcessRunnerResponse(): Error: [${error}]`);
-    }
-  };
-  _SyncRunnerData = new WeakMap();
-  _SyncWorkerDataFromPayload = new WeakMap();
-  _SyncWorkerDataFromWorker = new WeakMap();
-  _SyncWorkerDataFromWorkers = new WeakMap();
-  _SetupCallbackMessage = new WeakMap();
-  _PostMessageToWorkerGetRunners = new WeakMap();
+    };
+    #SyncWorkerDataFromWorker = async (workerEx) => {
+      try {
+        const retVal = await this.#PostMessageToWorkerGetRunners(workerEx, eIWMessageCommands.GetRunners);
+        this.#SyncWorkerDataFromPayload(retVal.payload);
+        return retVal;
+      } catch (error) {
+        this.#error(`#SyncWorkerDataFromWorker(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #SyncWorkerDataFromWorkers = async () => {
+      try {
+        const retVal = await Promise.all(Object.values(this.#workersEx).map((workerEx) => this.#PostMessageToWorkerGetRunners(workerEx, eIWMessageCommands.GetRunners)));
+        retVal.forEach((messagePayload) => {
+          this.#SyncWorkerDataFromPayload(messagePayload.payload);
+        });
+        return retVal;
+      } catch (error) {
+        this.#error(`#SyncWorkerDataFromWorkers(): Error: [${error}]`);
+        throw error;
+      }
+    };
+    #SetupCallbackMessage = (resolve, reject, command) => {
+      const messageId = v4();
+      this.#messages[messageId] = {
+        timeout: setTimeout(() => {
+          delete this.#messages[messageId];
+          reject(`STSWorkerManager:#SetupCallbackMessage(): message response timeout for message id: [${messageId}], command: [${command}]`);
+        }, this.#options.messageTimeout),
+        resolveMessage: (payload) => {
+          resolve(payload);
+        }
+      };
+      return messageId;
+    };
+    #PostMessageToWorkerGetRunners = async (workerEx, command) => {
+      return new Promise((resolve, reject) => {
+        try {
+          const messageId = v4();
+          this.#messages[messageId] = {
+            timeout: setTimeout(() => {
+              delete this.#messages[messageId];
+              reject(`STSWorkerManager:#PostMessageToWorkerGetRunners(): message response timeout for message id: [${messageId}], command: [${command}]`);
+            }, this.#options.messageTimeout),
+            resolveMessage: (payload2) => {
+              resolve(payload2);
+            }
+          };
+          const payload = {
+            messageId
+          };
+          workerEx.messagePort.postMessage({ command, payload });
+        } catch (error) {
+          this.#error(`#PostMessageToWorkerGetRunners(): Error: [${error}]`);
+        }
+      });
+    };
+  }
   exports2.IRunnerSignalType = IRunnerSignalType;
   exports2.IRunnerState = IRunnerState;
   exports2.IWorkerState = IWorkerState;
@@ -4218,5 +4101,5 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
   exports2.WorkerInstance = WorkerInstance;
   exports2.eIWMessageCommands = eIWMessageCommands;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-});
+}));
 //# sourceMappingURL=stsrunnerframework.umd.js.map