@nsshunt/stsrunnerframework 1.0.58 → 1.0.60

package/dist/stsrunnerframework.mjs

@@ -9,7 +9,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value2) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value2);
 var __privateSet = (obj, member, value2, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value2) : member.set(obj, value2), value2);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _collectorCollectorPort, _runners, _options3, _workerId, _debug, _SetMessagePort, _AddRunner, _WorkerInstance_instances, SleepImmediate_fn, _StartRunner, _StopAllRunners, _StopRunner, _TerminateRunner, _PauseRunner, _ResumeRunner, _ResetRunner, _ExecuteRunner, _UpdateOptions, _workersEx, _options4, _STSInstrumentController, _telemetryProcessor, _debug2, _STSWorkerManager_instances, CreateRunnerCopy_fn, _SetRunnerIntoWorker, _ProcessTelemetry, _ProcessCompleted, _CreateAsyncRunner, _PostMessageToWorker, _StartRunner2, _ResetRunner2, _ExecuteRunner2, _StopRunner2, _TerminateRunner2, _PauseRunner2, _ResumeRunner2, _BroadcastCommandToAllRunners, _PauseWorker, _ResumeWorker, _StopWorker, _StartWorker, _ResetWorker, _ExecuteWorker, _BroadcastUpdateCommandToAllRunners, _UpdateOptionsWorker, _TerminateWorker, _UpdateOptions2, _options5, _rest01Client, _accessToken2, _agentManager, _authUtilsNode, _GetAccessToken;
+var _collectorCollectorPort, _runners, _options3, _workerId, _debug, _SetMessagePort, _CreateRunnerEx2RunState, _UpdateRunnerStateById, _GetAllRunners, _CanExecuteNextIterationById, _GetRunnerIterationById, _ResetRunnerIterationById, _IncRunnerIterationById, _GetRunnerInstanceById, _GetRunnerExecutionProfileById, _GetRunnerOptionsById, _SetRunnerOptionsById, _AddRunner, _WorkerInstance_instances, SleepImmediate_fn, _PostMessageToWorkerManagerById, _StartRunner, _StopRunnerByRunnerById, _StopAllRunners, _StopRunner, _TerminateRunner, _PauseRunner, _ResumeRunner, _ResetRunner, _ExecuteRunner, _UpdateOptions, _workersEx, _options4, _STSInstrumentController, _telemetryProcessor, _debug2, _STSWorkerManager_instances, CreateRunnerCopy_fn, _SetRunnerIntoWorker, _ProcessTelemetry, _RunnerStateChange, _ProcessCompleted, _CreateAsyncRunner, _PostMessageToWorkerUsingDefaultChannel, _PostMessageToWorker, _StartRunner2, _ResetRunner2, _ExecuteRunner2, _StopRunner2, _TerminateRunner2, _PauseRunner2, _ResumeRunner2, _BroadcastCommandToAllRunners, _PauseWorker, _ResumeWorker, _StopWorker, _StartWorker, _ResetWorker, _ExecuteWorker, _BroadcastUpdateCommandToAllRunners, _UpdateOptionsWorker, _TerminateWorker, _UpdateOptions2, _options5, _rest01Client, _accessToken2, _agentManager, _authUtilsNode, _GetAccessToken;
 import { Sleep, ModelDelimeter, STSAxiosConfig, GetErrorPayload, AgentManager, defaultLogger } from "@nsshunt/stsutils";
 import { Gauge } from "@nsshunt/stsobservability";
 import { accessSync, constants as constants$2, readFileSync } from "node:fs";
@@ -43,20 +43,36 @@ var eIWMessageCommands = /* @__PURE__ */ ((eIWMessageCommands2) => {
   eIWMessageCommands2["Completed"] = "__STS__Completed";
   eIWMessageCommands2["UpdateOptions"] = "__STS__UpdateOptions";
   eIWMessageCommands2["TerminateRunner"] = "__STS__TerminateRunner";
+  eIWMessageCommands2["RunnerStateChange"] = "__STS__RunnerStateChange";
   return eIWMessageCommands2;
 })(eIWMessageCommands || {});
 var IRunnerState = /* @__PURE__ */ ((IRunnerState2) => {
-  IRunnerState2["created"] = "created";
-  IRunnerState2["running"] = "running";
+  IRunnerState2["starting"] = "starting";
+  IRunnerState2["started"] = "started";
+  IRunnerState2["stopping"] = "stopping";
   IRunnerState2["stopped"] = "stopped";
+  IRunnerState2["terminating"] = "terminating";
+  IRunnerState2["terminated"] = "terminated";
+  IRunnerState2["resuming"] = "resuming";
+  IRunnerState2["resumed"] = "resumed";
+  IRunnerState2["pausing"] = "pausing";
   IRunnerState2["paused"] = "paused";
+  IRunnerState2["executing"] = "executing";
+  IRunnerState2["executed"] = "executed";
+  IRunnerState2["resetting"] = "resetting";
+  IRunnerState2["reset"] = "reset";
   IRunnerState2["error"] = "error";
+  IRunnerState2["completed"] = "completed";
+  IRunnerState2["created"] = "created";
+  IRunnerState2["running"] = "running";
   return IRunnerState2;
 })(IRunnerState || {});
 var IWorkerState = /* @__PURE__ */ ((IWorkerState2) => {
   IWorkerState2["starting"] = "starting";
   IWorkerState2["started"] = "started";
   IWorkerState2["stopped"] = "stopped";
+  IWorkerState2["paused"] = "paused";
+  IWorkerState2["error"] = "error";
   return IWorkerState2;
 })(IWorkerState || {});
 const PublishMessageCommandsTestRunner = {
@@ -1571,27 +1587,19 @@ class WorkerInstance {
       __privateGet(this, _debug).call(this, `StartWork`);
       return;
     });
-    __publicField(this, "PostTelemetry", (runner) => {
-      if (__privateGet(this, _collectorCollectorPort)) {
-        const message2 = {
-          command: eIWMessageCommands.InstrumentTelemetry,
-          payload: {
-            runner
-          }
-        };
-        __privateGet(this, _collectorCollectorPort).postMessage(message2);
-      }
+    __publicField(this, "PostTelemetryById", (id) => {
+      __privateGet(this, _PostMessageToWorkerManagerById).call(this, eIWMessageCommands.InstrumentTelemetry, id);
     });
     __privateAdd(this, _SetMessagePort, (workerMessagePort) => {
       __privateGet(this, _debug).call(this, `SetMessagePort`);
       __privateSet(this, _collectorCollectorPort, workerMessagePort.port);
       if (isNode$1) {
         __privateGet(this, _collectorCollectorPort).on("message", (data) => {
-          __privateGet(this, _debug).call(this, `collectorCollectorPort onmessage: ${data.data}`);
+          __privateGet(this, _debug).call(this, `collectorCollectorPort onmessage: ${JSON.stringify(data)}`);
         });
       } else {
         __privateGet(this, _collectorCollectorPort).onmessage = function(data) {
-          console.log(`collectorCollectorPort onmessage: ${data.data}`);
+          console.log(`collectorCollectorPort onmessage: ${JSON.stringify(data.data)}`);
         };
       }
       const response = {
@@ -1603,122 +1611,180 @@ class WorkerInstance {
     __publicField(this, "CreateAsyncRunner", (testRunnerTelemetryPayload) => {
       return null;
     });
+    __privateAdd(this, _CreateRunnerEx2RunState, (runner, runnerInstance) => {
+      __privateGet(this, _runners)[runner.id] = {
+        runner,
+        runnerInstance
+      };
+      __privateGet(this, _runners)[runner.id].runner.state = IRunnerState.created;
+      __privateGet(this, _runners)[runner.id].runner.iteration = 0;
+    });
+    __privateAdd(this, _UpdateRunnerStateById, (id, state) => {
+      __privateGet(this, _runners)[id].runner.state = state;
+      __privateGet(this, _PostMessageToWorkerManagerById).call(this, eIWMessageCommands.RunnerStateChange, id);
+    });
+    __privateAdd(this, _GetAllRunners, () => {
+      return __privateGet(this, _runners);
+    });
+    __privateAdd(this, _CanExecuteNextIterationById, (id) => {
+      const state = __privateGet(this, _runners)[id].runner.state;
+      if (state === IRunnerState.running || state === IRunnerState.executed || state === IRunnerState.resumed || state === IRunnerState.reset || state === IRunnerState.started) {
+        return true;
+      }
+      return false;
+    });
+    __privateAdd(this, _GetRunnerIterationById, (id) => {
+      return __privateGet(this, _runners)[id].runner.iteration;
+    });
+    __privateAdd(this, _ResetRunnerIterationById, (id) => {
+      __privateGet(this, _runners)[id].runner.iteration = 0;
+      return 0;
+    });
+    __privateAdd(this, _IncRunnerIterationById, (id) => {
+      __privateGet(this, _runners)[id].runner.iteration++;
+      return __privateGet(this, _runners)[id].runner.iteration;
+    });
+    __privateAdd(this, _GetRunnerInstanceById, (id) => {
+      return __privateGet(this, _runners)[id].runnerInstance;
+    });
+    __privateAdd(this, _GetRunnerExecutionProfileById, (id) => {
+      return __privateGet(this, _runners)[id].runner.options.executionProfile;
+    });
+    __privateAdd(this, _GetRunnerOptionsById, (id) => {
+      return __privateGet(this, _runners)[id].runner.options;
+    });
+    __privateAdd(this, _SetRunnerOptionsById, (id, options) => {
+      __privateGet(this, _runners)[id].runner.options = { ...options };
+      return __privateGet(this, _runners)[id].runner.options;
+    });
     __privateAdd(this, _AddRunner, (testRunnerTelemetryPayload) => {
       __privateGet(this, _debug).call(this, `AddRunner`);
       const { runner } = testRunnerTelemetryPayload;
       const asyncRunnerInstance = this.CreateAsyncRunner(testRunnerTelemetryPayload);
       if (asyncRunnerInstance) {
-        __privateGet(this, _runners)[runner.id] = {
-          runnerInstance: asyncRunnerInstance,
-          runner: testRunnerTelemetryPayload.runner,
-          iteration: 0,
-          terminate: false,
-          paused: false
-        };
+        __privateGet(this, _CreateRunnerEx2RunState).call(this, runner, asyncRunnerInstance);
       }
       return runner;
     });
+    __privateAdd(this, _PostMessageToWorkerManagerById, (command, id) => {
+      if (__privateGet(this, _collectorCollectorPort)) {
+        const message2 = {
+          command,
+          payload: {
+            runner: __privateGet(this, _runners)[id].runner
+          }
+        };
+        __privateGet(this, _collectorCollectorPort).postMessage(message2);
+      }
+    });
     __privateAdd(this, _StartRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} StartRunner`);
-      __privateGet(this, _runners)[runner.id].terminate = false;
-      __privateGet(this, _runners)[runner.id].paused = false;
-      await __privateGet(this, _runners)[runner.id].runnerInstance.StartRunner();
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} StartRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.starting);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).StartRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.started);
       const ExecuteLoop = async () => {
-        if (__privateGet(this, _runners)[runner.id].iteration < __privateGet(this, _runners)[runner.id].runner.options.executionProfile.iterations) {
-          if (!__privateGet(this, _runners)[runner.id].paused) {
-            await __privateGet(this, _runners)[runner.id].runnerInstance.Execute(__privateGet(this, _runners)[runner.id].iteration);
-            __privateGet(this, _runners)[runner.id].iteration++;
+        if (__privateGet(this, _GetRunnerIterationById).call(this, runnerId) < __privateGet(this, _GetRunnerExecutionProfileById).call(this, runnerId).iterations) {
+          if (__privateGet(this, _CanExecuteNextIterationById).call(this, runnerId)) {
+            await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).Execute(__privateGet(this, _GetRunnerIterationById).call(this, runnerId));
+            __privateGet(this, _IncRunnerIterationById).call(this, runnerId);
           }
-          if (!__privateGet(this, _runners)[runner.id].terminate) {
-            if (!__privateGet(this, _runners)[runner.id].paused) {
-              if (__privateGet(this, _runners)[runner.id].runner.options.executionProfile.delayBetweenIterations > 0) {
-                await Sleep(__privateGet(this, _runners)[runner.id].runner.options.executionProfile.delayBetweenIterations);
-              } else {
-                await __privateMethod(this, _WorkerInstance_instances, SleepImmediate_fn).call(this);
-              }
-              ExecuteLoop();
+          if (__privateGet(this, _CanExecuteNextIterationById).call(this, runnerId)) {
+            if (__privateGet(this, _GetRunnerExecutionProfileById).call(this, runnerId).delayBetweenIterations > 0) {
+              await Sleep(__privateGet(this, _GetRunnerExecutionProfileById).call(this, runnerId).delayBetweenIterations);
             } else {
-              await Sleep(50);
-              ExecuteLoop();
+              await __privateMethod(this, _WorkerInstance_instances, SleepImmediate_fn).call(this);
             }
+            ExecuteLoop();
+          } else {
+            await Sleep(50);
+            ExecuteLoop();
           }
         } else {
-          await __privateGet(this, _runners)[runner.id].runnerInstance.Completed();
-          if (__privateGet(this, _collectorCollectorPort)) {
-            const message2 = {
-              command: eIWMessageCommands.Completed,
-              payload: {
-                runner
-              }
-            };
-            __privateGet(this, _collectorCollectorPort).postMessage(message2);
-          }
+          await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).Completed();
+          __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.completed);
+          __privateGet(this, _PostMessageToWorkerManagerById).call(this, eIWMessageCommands.Completed, runnerId);
         }
       };
       ExecuteLoop();
     });
+    __privateAdd(this, _StopRunnerByRunnerById, async (id) => {
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${id}]`)} StopRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, id, IRunnerState.stopping);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, id).StopRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, id, IRunnerState.stopped);
+      await Sleep(0);
+    });
     __privateAdd(this, _StopAllRunners, async (testRunnerTelemetryPayload) => {
       __privateGet(this, _debug).call(this, `StopAllRunners`);
-      for (const [, runner] of Object.entries(__privateGet(this, _runners))) {
-        __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.runner.id}]`)} StopAllRunners`);
-        runner.terminate = true;
-        await runner.runnerInstance.StopRunner();
+      const promArray = [];
+      for (const [, runner] of Object.entries(__privateGet(this, _GetAllRunners))) {
+        promArray.push(__privateGet(this, _StopRunnerByRunnerById).call(this, runner.id));
       }
+      await Promise.all(promArray);
       await Sleep(0);
     });
     __privateAdd(this, _StopRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} StopRunner`);
-      __privateGet(this, _runners)[runner.id].terminate = true;
-      await __privateGet(this, _runners)[runner.id].runnerInstance.StopRunner();
-      await Sleep(0);
+      await __privateGet(this, _StopRunnerByRunnerById).call(this, testRunnerTelemetryPayload.runner.id);
     });
     __privateAdd(this, _TerminateRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} TerminateRunner`);
-      __privateGet(this, _runners)[runner.id].terminate = true;
-      const retVal = await __privateGet(this, _runners)[runner.id].runnerInstance.TerminateRunner();
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} TerminateRunner Result = [${retVal}]`);
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} TerminateRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.terminating);
+      await Sleep(0);
+      const retVal = await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).TerminateRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.terminated);
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} TerminateRunner Result = [${retVal}]`);
       await Sleep(0);
     });
     __privateAdd(this, _PauseRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} PauseRunner`);
-      __privateGet(this, _runners)[runner.id].paused = true;
-      await __privateGet(this, _runners)[runner.id].runnerInstance.PauseRunner();
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} PauseRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.pausing);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).PauseRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.paused);
       await Sleep(0);
     });
     __privateAdd(this, _ResumeRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} ResumeRunner`);
-      __privateGet(this, _runners)[runner.id].paused = false;
-      await __privateGet(this, _runners)[runner.id].runnerInstance.ResumeRunner();
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} ResumeRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.resuming);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).ResumeRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.resumed);
       await Sleep(0);
     });
     __privateAdd(this, _ResetRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} ResetRunner`);
-      __privateGet(this, _runners)[runner.id].terminate = true;
-      __privateGet(this, _runners)[runner.id].iteration = 0;
-      await __privateGet(this, _runners)[runner.id].runnerInstance.ResetRunner();
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} ResetRunner`);
+      __privateGet(this, _ResetRunnerIterationById).call(this, runnerId);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.resetting);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).ResetRunner();
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.reset);
       await Sleep(0);
     });
     // Execute a single iteration of this runners work item
     __privateAdd(this, _ExecuteRunner, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} ExecuteRunner`);
-      await __privateGet(this, _runners)[runner.id].runnerInstance.Execute(__privateGet(this, _runners)[runner.id].iteration);
-      __privateGet(this, _runners)[runner.id].iteration++;
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} ExecuteRunner`);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.executing);
+      await Sleep(0);
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).Execute(__privateGet(this, _GetRunnerIterationById).call(this, runnerId));
+      __privateGet(this, _IncRunnerIterationById).call(this, runnerId);
+      __privateGet(this, _UpdateRunnerStateById).call(this, runnerId, IRunnerState.executed);
       await Sleep(0);
     });
     __privateAdd(this, _UpdateOptions, async (testRunnerTelemetryPayload) => {
-      const { runner } = testRunnerTelemetryPayload;
-      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runner.id}]`)} UpdateOptions`);
-      console.log(chalk$1.cyan(`before: [${JSON.stringify(__privateGet(this, _runners)[runner.id].runner.options)}]`));
-      __privateGet(this, _runners)[runner.id].runner.options = { ...runner.options };
-      console.log(chalk$1.cyan(`after: [${JSON.stringify(__privateGet(this, _runners)[runner.id].runner.options)}]`));
-      await __privateGet(this, _runners)[runner.id].runnerInstance.UpdateOptions();
+      const runnerId = testRunnerTelemetryPayload.runner.id;
+      __privateGet(this, _debug).call(this, `${chalk$1.magenta(`runner: [${runnerId}]`)} UpdateOptions`);
+      console.log(chalk$1.cyan(`before: [${JSON.stringify(__privateGet(this, _GetRunnerOptionsById).call(this, runnerId))}]`));
+      __privateGet(this, _SetRunnerOptionsById).call(this, runnerId, testRunnerTelemetryPayload.runner.options);
+      console.log(chalk$1.cyan(`after: [${JSON.stringify(__privateGet(this, _GetRunnerOptionsById).call(this, runnerId))}]`));
+      await __privateGet(this, _GetRunnerInstanceById).call(this, runnerId).UpdateOptions();
       await Sleep(0);
     });
     // ProcessMessage = async(data: MessageEvent) => { // Browser version
@@ -1797,6 +1863,17 @@ _options3 = new WeakMap();
 _workerId = new WeakMap();
 _debug = new WeakMap();
 _SetMessagePort = new WeakMap();
+_CreateRunnerEx2RunState = new WeakMap();
+_UpdateRunnerStateById = new WeakMap();
+_GetAllRunners = new WeakMap();
+_CanExecuteNextIterationById = 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() {
@@ -1804,7 +1881,9 @@ SleepImmediate_fn = function() {
     resolve();
   });
 };
+_PostMessageToWorkerManagerById = new WeakMap();
 _StartRunner = new WeakMap();
+_StopRunnerByRunnerById = new WeakMap();
 _StopAllRunners = new WeakMap();
 _StopRunner = new WeakMap();
 _TerminateRunner = new WeakMap();
@@ -1974,10 +2053,17 @@ class STSWorkerManager {
       } else {
         workerFactory = __privateGet(this, _options4).workerFactory;
       }
+      const {
+        port1,
+        // process message port
+        port2
+        // collector message port
+      } = new MessageChannel();
       const workerId = v4$1();
       const stsWorkerEx = {
         id: workerId,
         worker: workerFactory.createWorkerThreadWorker(),
+        messagePort: port1,
         state: IWorkerState.starting,
         workerThreadWorkerOptions: workerFactory.workerThreadWorkerOptions,
         runnersEx: {},
@@ -2005,36 +2091,44 @@ class STSWorkerManager {
       };
       __privateGet(this, _STSInstrumentController).LogEx(chalk$1.yellow(`pid: [${process.pid}] Creating new worker: [${stsWorkerEx.id}]`));
       __privateGet(this, _debug2).call(this, `Adding worker: [${stsWorkerEx.id}]`);
-      const {
-        port1,
-        // process message port
-        port2
-        // collector message port
-      } = new MessageChannel();
-      const workerPort = port1;
       __privateGet(this, _debug2).call(this, `AddWorker::workerThreadWorkerOptions: [${stsWorkerEx.workerThreadWorkerOptions.id}]`);
-      __privateGet(this, _PostMessageToWorker).call(this, stsWorkerEx, eIWMessageCommands.MessagePort, {
-        port: port2,
-        //applicationStoreState: stateCopy,
-        options: {
-          ...stsWorkerEx.workerThreadWorkerOptions
-        },
-        workerId
-      }, port2);
-      if (isNode$1) {
-        stsWorkerEx.worker.on("exit", (code) => {
-          console.log(chalk$1.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker exited with code: ${code}`));
-        });
-        stsWorkerEx.worker.on("error", (error) => {
-          console.error(chalk$1.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Worker error: ${error}`));
+      if (stsWorkerEx.workerThreadWorkerOptions.mocked) {
+        stsWorkerEx.worker.SetPort({
+          command: eIWMessageCommands.MessagePort,
+          payload: {
+            port: port2,
+            options: {
+              ...stsWorkerEx.workerThreadWorkerOptions
+            },
+            workerId
+          }
         });
       } else {
-        stsWorkerEx.worker.onerror = (error) => {
-          console.error(chalk$1.red("STSWorkerManager:stsWorkerEx.worker.onerror(): Error in worker:", error));
-        };
-        stsWorkerEx.worker.onmessageerror = (error) => {
-          console.error(chalk$1.red("STSWorkerManager:stsWorkerEx.worker.onmessageerror(): Message error in worker:", error));
-        };
+        __privateGet(this, _PostMessageToWorkerUsingDefaultChannel).call(this, stsWorkerEx, eIWMessageCommands.MessagePort, {
+          port: port2,
+          //applicationStoreState: stateCopy,
+          options: {
+            ...stsWorkerEx.workerThreadWorkerOptions
+          },
+          workerId
+        }, port2);
+      }
+      if (!stsWorkerEx.workerThreadWorkerOptions.mocked) {
+        if (isNode$1) {
+          stsWorkerEx.worker.on("exit", (code) => {
+            console.log(chalk$1.magenta(`STSWorkerManager:stsWorkerEx.worker.on(exit): Worker exited with code: ${code}`));
+          });
+          stsWorkerEx.worker.on("error", (error) => {
+            console.error(chalk$1.red(`STSWorkerManager:stsWorkerEx.worker.on(error): Worker error: ${error}`));
+          });
+        } else {
+          stsWorkerEx.worker.onerror = (error) => {
+            console.error(chalk$1.red("STSWorkerManager:stsWorkerEx.worker.onerror(): Error in worker:", error));
+          };
+          stsWorkerEx.worker.onmessageerror = (error) => {
+            console.error(chalk$1.red("STSWorkerManager:stsWorkerEx.worker.onmessageerror(): Message error in worker:", error));
+          };
+        }
       }
       const processMessage = (data) => {
         const publishMessagePayload2 = data;
@@ -2048,18 +2142,21 @@ class STSWorkerManager {
           case eIWMessageCommands.Completed:
             __privateGet(this, _ProcessCompleted).call(this, stsWorkerEx, publishMessagePayload2.payload);
             break;
+          case eIWMessageCommands.RunnerStateChange:
+            __privateGet(this, _RunnerStateChange).call(this, stsWorkerEx, publishMessagePayload2.payload);
+            break;
           default:
             __privateGet(this, _debug2).call(this, `AddWorker::default`);
         }
       };
       let publishMessagePayload;
       if (isNode$1) {
-        workerPort.on("message", (data) => {
+        stsWorkerEx.messagePort.on("message", (data) => {
           publishMessagePayload = data;
           processMessage(publishMessagePayload);
         });
       } else {
-        workerPort.onmessage = async (data) => {
+        stsWorkerEx.messagePort.onmessage = async (data) => {
           publishMessagePayload = data.data;
           processMessage(publishMessagePayload);
         };
@@ -2102,6 +2199,13 @@ class STSWorkerManager {
         }
       }
     });
+    __privateAdd(this, _RunnerStateChange, (workerEx, payloadContents) => {
+      const { runner } = payloadContents;
+      if (workerEx.runnersEx[runner.id]) {
+        const runnerEx = workerEx.runnersEx[runner.id];
+        runnerEx.state = runner.state;
+      }
+    });
     __privateAdd(this, _ProcessCompleted, (workerEx, payloadContents) => {
       const { runner } = payloadContents;
       if (workerEx.runnersEvents[runner.id]) {
@@ -2125,6 +2229,8 @@ class STSWorkerManager {
       };
       const runnerEx = {
         id: runnerOptions.id,
+        state: IRunnerState.created,
+        iteration: 0,
         publishInstrumentController: __privateGet(this, _STSInstrumentController).AddPublishInstrumentController(asyncRunnerContext),
         asyncRunnerContext,
         options: runnerOptions,
@@ -2167,7 +2273,7 @@ class STSWorkerManager {
       };
       return runnerEx;
     });
-    __privateAdd(this, _PostMessageToWorker, (workerEx, command, payload, transferObject) => {
+    __privateAdd(this, _PostMessageToWorkerUsingDefaultChannel, (workerEx, command, payload, transferObject) => {
       if (transferObject) {
         __privateGet(this, _debug2).call(this, `#PostMessageToWorker with transfer object`);
         workerEx.worker.postMessage({ command, payload }, [transferObject]);
@@ -2177,28 +2283,36 @@ class STSWorkerManager {
         workerEx.worker.postMessage({ command, payload });
       }
     });
+    __privateAdd(this, _PostMessageToWorker, (workerEx, command, payload) => {
+      __privateGet(this, _debug2).call(this, `#PostMessageToWorker`);
+      workerEx.messagePort.postMessage({ command, payload });
+    });
     __privateAdd(this, _StartRunner2, async (workerEx, runnerEx) => {
       __privateGet(this, _PostMessageToWorker).call(this, workerEx, eIWMessageCommands.StartRunner, {
         runner: __privateMethod(this, _STSWorkerManager_instances, CreateRunnerCopy_fn).call(this, runnerEx)
       });
+      runnerEx.state = IRunnerState.running;
       return true;
     });
     __privateAdd(this, _ResetRunner2, async (workerEx, runnerEx) => {
       __privateGet(this, _PostMessageToWorker).call(this, workerEx, eIWMessageCommands.ResetRunner, {
         runner: __privateMethod(this, _STSWorkerManager_instances, CreateRunnerCopy_fn).call(this, runnerEx)
       });
+      runnerEx.state = IRunnerState.stopped;
       return true;
     });
     __privateAdd(this, _ExecuteRunner2, async (workerEx, runnerEx) => {
       __privateGet(this, _PostMessageToWorker).call(this, workerEx, eIWMessageCommands.ExecuteRunner, {
         runner: __privateMethod(this, _STSWorkerManager_instances, CreateRunnerCopy_fn).call(this, runnerEx)
       });
+      runnerEx.state = IRunnerState.running;
       return true;
     });
     __privateAdd(this, _StopRunner2, async (workerEx, runnerEx) => {
       __privateGet(this, _PostMessageToWorker).call(this, workerEx, eIWMessageCommands.StopRunner, {
         runner: __privateMethod(this, _STSWorkerManager_instances, CreateRunnerCopy_fn).call(this, runnerEx)
       });
+      runnerEx.state = IRunnerState.stopped;
       return true;
     });
     __privateAdd(this, _TerminateRunner2, async (workerEx, runnerEx = null) => {
@@ -2393,13 +2507,17 @@ CreateRunnerCopy_fn = function(runnerEx) {
     id: runnerEx.id,
     asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
     options: { ...runnerEx.options },
-    instrumentData: { ...runnerEx.instrumentData }
+    instrumentData: { ...runnerEx.instrumentData },
+    iteration: runnerEx.iteration,
+    state: runnerEx.state
   };
 };
 _SetRunnerIntoWorker = new WeakMap();
 _ProcessTelemetry = new WeakMap();
+_RunnerStateChange = new WeakMap();
 _ProcessCompleted = new WeakMap();
 _CreateAsyncRunner = new WeakMap();
+_PostMessageToWorkerUsingDefaultChannel = new WeakMap();
 _PostMessageToWorker = new WeakMap();
 _StartRunner2 = new WeakMap();
 _ResetRunner2 = new WeakMap();