@nsshunt/stsrunnerframework 1.0.174 → 1.0.176

package/dist/stsrunnerframework.mjs

@@ -1,15 +1,3 @@
-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;
 import { defaultLogger, Sleep, ModelDelimeter } from "@nsshunt/stsutils";
 import { Gauge } from "@nsshunt/stsobservability";
 var eIWMessageCommands = /* @__PURE__ */ ((eIWMessageCommands2) => {
@@ -1531,785 +1519,735 @@ var sourceExports = requireSource();
 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 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 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 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 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 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 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 Sleep(delayBetweenIterations);
-                      } else {
-                        await __privateMethod(this, _WorkerInstance_instances, SleepImmediate_fn).call(this);
-                      }
-                      ExecuteLoop();
+                  }
+                  if (this.#CanExecuteNextIterationById(runnerId)) {
+                    if (delayBetweenIterations > 0) {
+                      await Sleep(delayBetweenIterations);
                     } else {
-                      if (!__privateGet(this, _IsCompletedById).call(this, runnerId)) {
-                        await 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 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 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(Gauge.REQUEST_COUNT_GAUGE, {
-          val: telemetry.requestCount
-        });
-        update = true;
-      }
-      if (telemetry.errorCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
-          val: telemetry.errorCount
-        });
-        update = true;
-      }
-      if (telemetry.retryCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
-          val: telemetry.retryCount
-        });
-        update = true;
-      }
-      if (telemetry.authenticationCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
-          val: telemetry.authenticationCount
-        });
-        update = true;
-      }
-      if (telemetry.authenticationErrorCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
-          val: telemetry.authenticationErrorCount
-        });
-        update = true;
-      }
-      if (telemetry.authenticationRetryCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
-          val: telemetry.authenticationRetryCount
-        });
-        update = true;
-      }
-      if (telemetry.coreCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
-          val: telemetry.coreCount
-        });
-        update = true;
-      }
-      if (telemetry.timer) {
-        publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
-          val: telemetry.timer
-        });
-        update = true;
-      }
-      publishInstrumentController.UpdateInstrument(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(Gauge.VELOCITY_GAUGE, {
-          Inc: telemetry.velocity
-        });
-        update = true;
-      }
-      if (telemetry.duration) {
-        publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
-          val: telemetry.duration
-        });
-        publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
-          val: telemetry.duration
-        });
-        update = true;
-      }
-      if (telemetry.latency) {
-        publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
-          val: telemetry.latency
-        });
-        publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
-          val: telemetry.latency
-        });
-        update = true;
-      }
-      if (telemetry.childCount) {
-        publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
-          val: telemetry.childCount
-        });
-        update = true;
-      }
-      if (telemetry.rx) {
-        publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
-          Inc: telemetry.rx
-        });
-        update = true;
-      }
-      if (telemetry.tx) {
-        publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
-          Inc: telemetry.tx
-        });
-        update = true;
-      }
-      return update;
+      update = true;
+    }
+    if (telemetry.requestCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
+        val: telemetry.requestCount
+      });
+      update = true;
+    }
+    if (telemetry.errorCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
+        val: telemetry.errorCount
+      });
+      update = true;
+    }
+    if (telemetry.retryCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
+        val: telemetry.retryCount
+      });
+      update = true;
+    }
+    if (telemetry.authenticationCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
+        val: telemetry.authenticationCount
+      });
+      update = true;
+    }
+    if (telemetry.authenticationErrorCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
+        val: telemetry.authenticationErrorCount
+      });
+      update = true;
+    }
+    if (telemetry.authenticationRetryCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
+        val: telemetry.authenticationRetryCount
+      });
+      update = true;
+    }
+    if (telemetry.coreCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
+        val: telemetry.coreCount
+      });
+      update = true;
+    }
+    if (telemetry.timer) {
+      publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
+        val: telemetry.timer
+      });
+      update = true;
+    }
+    publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+      val: telemetry.activeRequestCount
     });
-  }
+    if (telemetry.velocity) {
+      publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
+        Inc: telemetry.velocity
+      });
+      update = true;
+    }
+    if (telemetry.duration) {
+      publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
+        val: telemetry.duration
+      });
+      publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
+        val: telemetry.duration
+      });
+      update = true;
+    }
+    if (telemetry.latency) {
+      publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
+        val: telemetry.latency
+      });
+      publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
+        val: telemetry.latency
+      });
+      update = true;
+    }
+    if (telemetry.childCount) {
+      publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
+        val: telemetry.childCount
+      });
+      update = true;
+    }
+    if (telemetry.rx) {
+      publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
+        Inc: telemetry.rx
+      });
+      update = true;
+    }
+    if (telemetry.tx) {
+      publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
+        Inc: telemetry.tx
+      });
+      update = true;
+    }
+    return update;
+  };
 }
 const byteToHex = [];
 for (let i = 0; i < 256; ++i) {
@@ -2331,13 +2269,9 @@ function rng() {
 }
 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");
   }
@@ -2345,6 +2279,12 @@ function v4(options, buf, offset) {
   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;
@@ -2371,7 +2311,7 @@ function requireLodash_merge() {
     var freeModule = freeExports && true && module && !module.nodeType && module;
     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) {
@@ -2380,7 +2320,7 @@ function requireLodash_merge() {
         return freeProcess && freeProcess.binding && freeProcess.binding("util");
       } catch (e) {
       }
-    }();
+    })();
     var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
     function apply(func, thisArg, args) {
       switch (args.length) {
@@ -2419,29 +2359,29 @@ function requireLodash_merge() {
     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 getPrototype = overArg(Object.getPrototypeOf, Object), objectCreate = Object.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
-    var defineProperty = function() {
+    var Buffer = moduleExports ? root.Buffer : void 0, Symbol = 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 = Symbol ? Symbol.toStringTag : void 0;
+    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) {
@@ -2456,7 +2396,7 @@ function requireLodash_merge() {
         object.prototype = void 0;
         return result;
       };
-    }();
+    })();
     function Hash(entries) {
       var index = -1, length = entries == null ? 0 : entries.length;
       this.clear();
@@ -2963,9 +2903,9 @@ function requireLodash_merge() {
     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;
@@ -3033,1181 +2973,1124 @@ var lodash_mergeExports = requireLodash_merge();
 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
-              });
-            }
-          }
+      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 () => {
-            __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();
+      }
+      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 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 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}${ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.options.agentId}-${workerEx.options.userAgent}${ModelDelimeter.NID_SEPERATOR}${workerEx.id}${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}${ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.options.agentId}-${workerEx.options.userAgent}${ModelDelimeter.NID_SEPERATOR}${workerEx.id}${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}]`);
+      }
+    });
+  };
+}
 export {
   IRunnerSignalType,
   IRunnerState,