@nsshunt/stsvueutils 1.0.22 → 1.0.24

package/dist/stsvueutils.mjs

@@ -1,453 +1,651 @@
-var me = Object.defineProperty;
-var he = (s, e, t) => e in s ? me(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var c = (s, e, t) => (he(s, typeof e != "symbol" ? e + "" : e, t), t), x = (s, e, t) => {
-  if (!e.has(s))
-    throw TypeError("Cannot " + t);
+var __defProp = Object.defineProperty;
+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);
+  return value;
 };
-var n = (s, e, t) => (x(s, e, "read from private field"), t ? t.call(s) : e.get(s)), l = (s, e, t) => {
-  if (e.has(s))
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
-  e instanceof WeakSet ? e.add(s) : e.set(s, t);
-}, g = (s, e, t, r) => (x(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t), Z = (s, e, t, r) => ({
-  set _(o) {
-    g(s, e, o, t);
+  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);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
   },
   get _() {
-    return n(s, e, r);
+    return __privateGet(obj, member, getter);
   }
-}), ee = (s, e, t) => (x(s, e, "access private method"), t);
-import { inject as ue } from "vue";
-import Y from "debug";
-import { STSInstrumentControllerPluginKey as A, GetSTSInstrumentController as fe, PublishMessageCommands as h, GetSTSInstrumentControllerPluginKey as Se } from "@nsshunt/stspublisherserver";
-import { Gauge as de } from "@nsshunt/stsinstrumentation";
-import { ModelDelimeter as te } from "@nsshunt/stsmodels";
-import { defineStore as ye } from "pinia";
-import { Sleep as ke } from "@nsshunt/stsutils";
-const oe = Symbol("storage"), ne = Symbol("emitter"), ie = Symbol("workerManager");
-var ae = {}, Te = {
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _store, _storage, _workersEx, _runner, _workerId, _options, _STSInstrumentController, _app, _CreateRunnerCopy, CreateRunnerCopy_fn, _SetRunnerIntoWorker, _ProcessTelemetry, _CreateAsyncRunner, _PostMessageToWorker, _TerminateWorker, _StopRunner, _StopWorker, _requestResponseMessages, _requestResponseMessageTimeout, _port, _SetupListener, _collectorCollectorPort, _requestResponseHelper, _runners, _options2, _SetMessagePort, _AddAsyncRunner, _StopRunners;
+import { inject } from "vue";
+import debugModule from "debug";
+import { STSInstrumentControllerPluginKey, GetSTSInstrumentController, PublishMessageCommands, GetSTSInstrumentControllerPluginKey } from "@nsshunt/stspublisherserver";
+import { Gauge } from "@nsshunt/stsinstrumentation";
+import { ModelDelimeter } from "@nsshunt/stsmodels";
+import { defineStore } from "pinia";
+import { Sleep } from "@nsshunt/stsutils";
+const STSStoragePluginKey = Symbol("storage");
+const STSEmitterPluginKey = Symbol("emitter");
+const STSWorkerManagerPluginKey = Symbol("workerManager");
+var tinyEmitterExports = {};
+var tinyEmitter = {
   get exports() {
-    return ae;
+    return tinyEmitterExports;
   },
-  set exports(s) {
-    ae = s;
+  set exports(v) {
+    tinyEmitterExports = v;
   }
 };
-function ge() {
+function E() {
 }
-ge.prototype = {
-  on: function(s, e, t) {
-    var r = this.e || (this.e = {});
-    return (r[s] || (r[s] = [])).push({
-      fn: e,
-      ctx: t
-    }), this;
+E.prototype = {
+  on: function(name, callback, ctx) {
+    var e = this.e || (this.e = {});
+    (e[name] || (e[name] = [])).push({
+      fn: callback,
+      ctx
+    });
+    return this;
   },
-  once: function(s, e, t) {
-    var r = this;
-    function o() {
-      r.off(s, o), e.apply(t, arguments);
+  once: function(name, callback, ctx) {
+    var self = this;
+    function listener() {
+      self.off(name, listener);
+      callback.apply(ctx, arguments);
     }
-    return o._ = e, this.on(s, o, t);
+    listener._ = callback;
+    return this.on(name, listener, ctx);
   },
-  emit: function(s) {
-    var e = [].slice.call(arguments, 1), t = ((this.e || (this.e = {}))[s] || []).slice(), r = 0, o = t.length;
-    for (r; r < o; r++)
-      t[r].fn.apply(t[r].ctx, e);
+  emit: function(name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
     return this;
   },
-  off: function(s, e) {
-    var t = this.e || (this.e = {}), r = t[s], o = [];
-    if (r && e)
-      for (var i = 0, a = r.length; i < a; i++)
-        r[i].fn !== e && r[i].fn._ !== e && o.push(r[i]);
-    return o.length ? t[s] = o : delete t[s], this;
+  off: function(name, callback) {
+    var e = this.e || (this.e = {});
+    var evts = e[name];
+    var liveEvents = [];
+    if (evts && callback) {
+      for (var i = 0, len = evts.length; i < len; i++) {
+        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+          liveEvents.push(evts[i]);
+      }
+    }
+    liveEvents.length ? e[name] = liveEvents : delete e[name];
+    return this;
   }
 };
-Te.exports = ge;
-var Re = ae.TinyEmitter = ge;
-const Je = () => ue(ne), He = {
+tinyEmitter.exports = E;
+var TinyEmitter = tinyEmitterExports.TinyEmitter = E;
+const useSTSEmitterPlugin = () => inject(STSEmitterPluginKey);
+const STSEmitterPlugin = {
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  install: (s) => {
-    const e = new Re();
-    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[ne] = e, s.provide(ne, e);
+  install: (app) => {
+    const tinyEmitter2 = new TinyEmitter();
+    if (!app.config.globalProperties.$sts) {
+      app.config.globalProperties.$sts = {};
+    }
+    app.config.globalProperties.$sts[STSEmitterPluginKey] = tinyEmitter2;
+    app.provide(STSEmitterPluginKey, tinyEmitter2);
   }
 };
 /*! js-cookie v3.0.1 | MIT */
-function _(s) {
-  for (var e = 1; e < arguments.length; e++) {
-    var t = arguments[e];
-    for (var r in t)
-      s[r] = t[r];
+function assign(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
   }
-  return s;
+  return target;
 }
-var We = {
-  read: function(s) {
-    return s[0] === '"' && (s = s.slice(1, -1)), s.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+var defaultConverter = {
+  read: function(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
   },
-  write: function(s) {
-    return encodeURIComponent(s).replace(
+  write: function(value) {
+    return encodeURIComponent(value).replace(
       /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
       decodeURIComponent
     );
   }
 };
-function le(s, e) {
-  function t(o, i, a) {
-    if (!(typeof document > "u")) {
-      a = _({}, e, a), typeof a.expires == "number" && (a.expires = new Date(Date.now() + a.expires * 864e5)), a.expires && (a.expires = a.expires.toUTCString()), o = encodeURIComponent(o).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
-      var u = "";
-      for (var m in a)
-        a[m] && (u += "; " + m, a[m] !== !0 && (u += "=" + a[m].split(";")[0]));
-      return document.cookie = o + "=" + s.write(i, o) + u;
+function init(converter, defaultAttributes) {
+  function set(key, value, attributes) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    attributes = assign({}, defaultAttributes, attributes);
+    if (typeof attributes.expires === "number") {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
     }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+    key = encodeURIComponent(key).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue;
+      }
+      stringifiedAttributes += "; " + attributeName;
+      if (attributes[attributeName] === true) {
+        continue;
+      }
+      stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+    }
+    return document.cookie = key + "=" + converter.write(value, key) + stringifiedAttributes;
   }
-  function r(o) {
-    if (!(typeof document > "u" || arguments.length && !o)) {
-      for (var i = document.cookie ? document.cookie.split("; ") : [], a = {}, u = 0; u < i.length; u++) {
-        var m = i[u].split("="), pe = m.slice(1).join("=");
-        try {
-          var X = decodeURIComponent(m[0]);
-          if (a[X] = s.read(pe, X), o === X)
-            break;
-        } catch {
+  function get(key) {
+    if (typeof document === "undefined" || arguments.length && !key) {
+      return;
+    }
+    var cookies = document.cookie ? document.cookie.split("; ") : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split("=");
+      var value = parts.slice(1).join("=");
+      try {
+        var foundKey = decodeURIComponent(parts[0]);
+        jar[foundKey] = converter.read(value, foundKey);
+        if (key === foundKey) {
+          break;
         }
+      } catch (e) {
       }
-      return o ? a[o] : a;
     }
+    return key ? jar[key] : jar;
   }
   return Object.create(
     {
-      set: t,
-      get: r,
-      remove: function(o, i) {
-        t(
-          o,
+      set,
+      get,
+      remove: function(key, attributes) {
+        set(
+          key,
           "",
-          _({}, i, {
+          assign({}, attributes, {
             expires: -1
           })
         );
       },
-      withAttributes: function(o) {
-        return le(this.converter, _({}, this.attributes, o));
+      withAttributes: function(attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes));
       },
-      withConverter: function(o) {
-        return le(_({}, this.converter, o), this.attributes);
+      withConverter: function(converter2) {
+        return init(assign({}, this.converter, converter2), this.attributes);
       }
     },
     {
-      attributes: { value: Object.freeze(e) },
-      converter: { value: Object.freeze(s) }
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
     }
   );
 }
-var se = le(We, { path: "/" });
-const Q = Y(`proc:${process.pid}:storage.ts`);
-let p = "_ststra_";
-var Pe = /* @__PURE__ */ ((s) => (s.LOCAL_STORAGE = "LocalStorage", s.SESSION_STORAGE = "SessionStorage", s.COOKIE_STORAGE = "CookieStorage", s.MEMORY_STORAGE = "MemoryStorage", s))(Pe || {});
-class ve {
+var api = init(defaultConverter, { path: "/" });
+const debug$3 = debugModule(`proc:${process.pid}:storage.ts`);
+let PREFIX = "_ststra_";
+var ClientStorageType = /* @__PURE__ */ ((ClientStorageType2) => {
+  ClientStorageType2["LOCAL_STORAGE"] = "LocalStorage";
+  ClientStorageType2["SESSION_STORAGE"] = "SessionStorage";
+  ClientStorageType2["COOKIE_STORAGE"] = "CookieStorage";
+  ClientStorageType2["MEMORY_STORAGE"] = "MemoryStorage";
+  return ClientStorageType2;
+})(ClientStorageType || {});
+class CookieStorage {
   constructor() {
-    c(this, "get", (e) => {
-      const t = se.get(p + e);
-      return t ? JSON.parse(t) : null;
+    __publicField(this, "get", (key) => {
+      const raw = api.get(PREFIX + key);
+      if (raw) {
+        return JSON.parse(raw);
+      } else {
+        return null;
+      }
     });
-    c(this, "set", (e, t, r = {}) => {
-      let o = {};
-      window.location.protocol === "https:" && (o = {
-        secure: !0,
-        sameSite: "none"
-      }), r && r.daysUntilExpire ? o.expires = r.daysUntilExpire : o.expires = 1, Q(`CookieStorage.set: key: ${e}, value: [${t}]`), se.set(p + e, JSON.stringify(t), o);
+    __publicField(this, "set", (key, value, options = {}) => {
+      let cookieAttributes = {};
+      if ("https:" === window.location.protocol) {
+        cookieAttributes = {
+          secure: true,
+          sameSite: "none"
+        };
+      }
+      if (options && options.daysUntilExpire) {
+        cookieAttributes.expires = options.daysUntilExpire;
+      } else {
+        cookieAttributes.expires = 1;
+      }
+      debug$3(`CookieStorage.set: key: ${key}, value: [${value}]`);
+      api.set(PREFIX + key, JSON.stringify(value), cookieAttributes);
     });
-    c(this, "remove", (e) => {
-      se.remove(p + e);
+    __publicField(this, "remove", (key) => {
+      api.remove(PREFIX + key);
     });
   }
 }
-class Oe {
+class SessionStorage {
   constructor() {
-    c(this, "get", (e) => {
-      const t = sessionStorage.getItem(p + e);
-      return t ? JSON.parse(t) : null;
+    __publicField(this, "get", (key) => {
+      const value = sessionStorage.getItem(PREFIX + key);
+      if (value) {
+        return JSON.parse(value);
+      } else {
+        return null;
+      }
     });
-    c(this, "set", (e, t) => {
-      Q(`SessionStorage.set: key: ${e}, value: [${t}]`), sessionStorage.setItem(p + e, JSON.stringify(t));
+    __publicField(this, "set", (key, value) => {
+      debug$3(`SessionStorage.set: key: ${key}, value: [${value}]`);
+      sessionStorage.setItem(PREFIX + key, JSON.stringify(value));
     });
-    c(this, "remove", (e) => {
-      sessionStorage.removeItem(p + e);
+    __publicField(this, "remove", (key) => {
+      sessionStorage.removeItem(PREFIX + key);
     });
   }
 }
-class $e {
+class LocalStorage {
   constructor() {
-    c(this, "get", (e) => {
-      const t = localStorage.getItem(p + e);
-      return t ? JSON.parse(t) : null;
+    __publicField(this, "get", (key) => {
+      const value = localStorage.getItem(PREFIX + key);
+      if (value) {
+        return JSON.parse(value);
+      } else {
+        return null;
+      }
     });
-    c(this, "set", (e, t) => {
-      Q(`LocalStorage.set: key: ${e}, value: [${t}]`), localStorage.setItem(p + e, JSON.stringify(t));
+    __publicField(this, "set", (key, value) => {
+      debug$3(`LocalStorage.set: key: ${key}, value: [${value}]`);
+      localStorage.setItem(PREFIX + key, JSON.stringify(value));
     });
-    c(this, "remove", (e) => {
-      localStorage.removeItem(p + e);
+    __publicField(this, "remove", (key) => {
+      localStorage.removeItem(PREFIX + key);
     });
   }
 }
-var v;
-class Ie {
+class MemoryStorage {
   constructor() {
-    l(this, v, {});
-    c(this, "get", (e) => {
-      const t = n(this, v)[p + e];
-      return t || null;
+    __privateAdd(this, _store, {});
+    __publicField(this, "get", (key) => {
+      const value = __privateGet(this, _store)[PREFIX + key];
+      if (value) {
+        return value;
+      } else {
+        return null;
+      }
     });
-    c(this, "set", (e, t) => {
-      Q(`MemoryStorage.set: key: ${e}, value: [${t}]`), n(this, v)[p + e] = t;
+    __publicField(this, "set", (key, value) => {
+      debug$3(`MemoryStorage.set: key: ${key}, value: [${value}]`);
+      __privateGet(this, _store)[PREFIX + key] = value;
     });
-    c(this, "remove", (e) => {
-      delete n(this, v)[p + e];
+    __publicField(this, "remove", (key) => {
+      delete __privateGet(this, _store)[PREFIX + key];
     });
   }
 }
-v = new WeakMap();
-var y;
-class Me {
-  constructor(e) {
-    l(this, y, void 0);
-    switch (e.usePrefix === !1 && (p = ""), e.clientStorageType) {
+_store = new WeakMap();
+class ClientStorageFactory {
+  constructor(options) {
+    __privateAdd(this, _storage, void 0);
+    if (options.usePrefix === false) {
+      PREFIX = "";
+    }
+    switch (options.clientStorageType) {
       case "SessionStorage":
-        g(this, y, new Oe());
+        __privateSet(this, _storage, new SessionStorage());
         break;
       case "LocalStorage":
-        g(this, y, new $e());
+        __privateSet(this, _storage, new LocalStorage());
         break;
       case "CookieStorage":
-        g(this, y, new ve());
+        __privateSet(this, _storage, new CookieStorage());
         break;
       case "MemoryStorage":
-        g(this, y, new Ie());
+        __privateSet(this, _storage, new MemoryStorage());
         break;
       default:
-        throw new Error(`Unknown [${e.clientStorageType}] storage type.`);
+        throw new Error(`Unknown [${options.clientStorageType}] storage type.`);
     }
+    return;
   }
   GetStorage() {
-    return n(this, y);
+    return __privateGet(this, _storage);
   }
 }
-y = new WeakMap();
-const Le = () => ue(oe), Fe = {
+_storage = new WeakMap();
+const useSTSStoragePlugin = () => inject(STSStoragePluginKey);
+const STSStoragePlugin = {
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  install: (s, e) => {
-    const r = new Me({ clientStorageType: e.clientStorageType, usePrefix: !0 }).GetStorage();
-    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[oe] = r, s.provide(oe, r);
+  install: (app, options) => {
+    const cs = new ClientStorageFactory({ clientStorageType: options.clientStorageType, usePrefix: true });
+    const pluginInstance = cs.GetStorage();
+    if (!app.config.globalProperties.$sts) {
+      app.config.globalProperties.$sts = {};
+    }
+    app.config.globalProperties.$sts[STSStoragePluginKey] = pluginInstance;
+    app.provide(STSStoragePluginKey, pluginInstance);
   }
-}, re = ye("__sts__TelemetryStore", {
+};
+const TelemetryStore = defineStore("__sts__TelemetryStore", {
   // State
   // https://pinia.vuejs.org/core-concepts/state.html
-  state: () => ({
-    workers: {}
-  }),
+  state: () => {
+    return {
+      workers: {}
+    };
+  },
   // Getters
   // https://pinia.vuejs.org/core-concepts/getters.html
   // Actions
   // https://pinia.vuejs.org/core-concepts/actions.html
   actions: {
-    RemoveWorker(s) {
-      delete this.workers[s.id];
+    RemoveWorker(workerEx) {
+      delete this.workers[workerEx.id];
     },
-    RemoveRunner(s, e) {
-      const t = this.workers[s.id];
-      t && t.runners && delete t.runners[e.id];
+    RemoveRunner(workerEx, runnerEx) {
+      const worker = this.workers[workerEx.id];
+      if (worker && worker.runners) {
+        delete worker.runners[runnerEx.id];
+      }
     },
-    Update(s, e) {
-      this.workers[s.id] || (this.workers[s.id] = {
-        id: s.id,
-        state: s.state,
-        primaryThreadWorkerOptions: { ...s.primaryThreadWorkerOptions },
-        workerThreadWorkerOptions: { ...s.workerThreadWorkerOptions },
-        runners: {}
-      });
-      const t = this.workers[s.id];
-      if (t.runners)
-        if (t.runners[e.id]) {
-          const r = t.runners[e.id];
-          r.instrumentData = { ...e.instrumentData };
-        } else {
-          const r = {
-            id: e.id,
-            asyncRunnerContext: { ...e.asyncRunnerContext },
-            options: { ...e.options },
-            state: e.state,
-            instrumentData: { ...e.instrumentData }
+    Update(workerEx, runnerEx) {
+      if (!this.workers[workerEx.id]) {
+        this.workers[workerEx.id] = {
+          id: workerEx.id,
+          state: workerEx.state,
+          primaryThreadWorkerOptions: { ...workerEx.primaryThreadWorkerOptions },
+          workerThreadWorkerOptions: { ...workerEx.workerThreadWorkerOptions },
+          runners: {}
+        };
+      }
+      const worker = this.workers[workerEx.id];
+      if (worker.runners) {
+        if (!worker.runners[runnerEx.id]) {
+          const runner = {
+            id: runnerEx.id,
+            asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
+            options: { ...runnerEx.options },
+            state: runnerEx.state,
+            instrumentData: { ...runnerEx.instrumentData }
           };
-          t.runners[r.id] = r;
+          worker.runners[runner.id] = runner;
+        } else {
+          const runner = worker.runners[runnerEx.id];
+          runner.instrumentData = { ...runnerEx.instrumentData };
         }
+      }
     }
   }
 });
-var C = /* @__PURE__ */ ((s) => (s.created = "created", s.running = "running", s.stopped = "stopped", s.paused = "paused", s.error = "error", s))(C || {}), q = /* @__PURE__ */ ((s) => (s.starting = "starting", s.started = "started", s.stopped = "stopped", s))(q || {});
-const P = Y(`proc:${process.pid}:workerManager`);
-var O, k, j, T, R, D, N, ce, E, J, H, W, L, $, F;
-class be {
+var IRunnerState = /* @__PURE__ */ ((IRunnerState2) => {
+  IRunnerState2["created"] = "created";
+  IRunnerState2["running"] = "running";
+  IRunnerState2["stopped"] = "stopped";
+  IRunnerState2["paused"] = "paused";
+  IRunnerState2["error"] = "error";
+  return IRunnerState2;
+})(IRunnerState || {});
+var IWorkerState = /* @__PURE__ */ ((IWorkerState2) => {
+  IWorkerState2["starting"] = "starting";
+  IWorkerState2["started"] = "started";
+  IWorkerState2["stopped"] = "stopped";
+  return IWorkerState2;
+})(IWorkerState || {});
+const debug$2 = debugModule(`proc:${process.pid}:workerManager`);
+class STSWorkerManager {
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  constructor(e, t) {
-    l(this, N);
+  constructor(app, options) {
+    __privateAdd(this, _CreateRunnerCopy);
     //#agentSession: string = null;
-    l(this, O, {});
-    l(this, k, 0);
-    l(this, j, 0);
-    l(this, T, void 0);
-    l(this, R, void 0);
+    __privateAdd(this, _workersEx, {});
+    __privateAdd(this, _runner, 0);
+    __privateAdd(this, _workerId, 0);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _STSInstrumentController, void 0);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    l(this, D, void 0);
-    c(this, "AddWorker", async (e) => {
-      let t;
-      e ? t = e : t = n(this, T).workerFactory;
-      const r = {
-        id: Z(this, j)._++,
+    __privateAdd(this, _app, void 0);
+    __publicField(this, "AddWorker", async (useWorkerFactory) => {
+      let workerFactory;
+      if (useWorkerFactory) {
+        workerFactory = useWorkerFactory;
+      } else {
+        workerFactory = __privateGet(this, _options).workerFactory;
+      }
+      const stsWorkerEx = {
+        id: __privateWrapper(this, _workerId)._++,
         // uuidv4()
-        worker: t.createWorkerThreadWorker(),
-        primaryWorker: t.createPrimaryThreadWorker(n(this, D), t.primaryThreadWorkerOptions),
-        state: q.starting,
-        workerThreadWorkerOptions: t.workerThreadWorkerOptions,
-        primaryThreadWorkerOptions: t.primaryThreadWorkerOptions,
+        worker: workerFactory.createWorkerThreadWorker(),
+        primaryWorker: workerFactory.createPrimaryThreadWorker(__privateGet(this, _app), workerFactory.primaryThreadWorkerOptions),
+        state: IWorkerState.starting,
+        workerThreadWorkerOptions: workerFactory.workerThreadWorkerOptions,
+        primaryThreadWorkerOptions: workerFactory.primaryThreadWorkerOptions,
         runnersEx: {},
-        AddRunner: (u) => this.AddRunnerToWorker(r, u),
-        StopRunner: (u) => n(this, $).call(this, r, u),
-        Stop: async () => n(this, F).call(this, r)
+        AddRunner: (runnerOptions) => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
+        StopRunner: (runner) => __privateGet(this, _StopRunner).call(this, stsWorkerEx, runner),
+        Stop: async () => __privateGet(this, _StopWorker).call(this, stsWorkerEx)
       };
-      console.log(`Adding worker: [${r.id}]`), r.worker.onmessage = function(u) {
-        console.log(u.data);
-      }, r.worker.onerror = function(u) {
-        console.log(u);
+      console.log(`Adding worker: [${stsWorkerEx.id}]`);
+      stsWorkerEx.worker.onmessage = function(data) {
+        console.log(data.data);
+      };
+      stsWorkerEx.worker.onerror = function(error) {
+        console.log(error);
       };
       const {
-        port1: o,
+        port1,
         // process message port
-        port2: i
+        port2
         // collector message port
-      } = new MessageChannel(), a = o;
-      return console.log(`STSWorkerManager::AddWorker::workerThreadWorkerOptions: [${JSON.stringify(r.workerThreadWorkerOptions)}]`), n(this, W).call(this, r, h.MessagePort, {
-        port: i,
+      } = new MessageChannel();
+      const workerPort = port1;
+      console.log(`STSWorkerManager::AddWorker::workerThreadWorkerOptions: [${JSON.stringify(stsWorkerEx.workerThreadWorkerOptions)}]`);
+      __privateGet(this, _PostMessageToWorker).call(this, stsWorkerEx, PublishMessageCommands.MessagePort, {
+        port: port2,
         //applicationStoreState: stateCopy,
-        options: { ...r.workerThreadWorkerOptions }
-      }, i), a.onmessage = async (u) => {
-        const m = u.data;
-        switch (m.command) {
-          case h.MessagePortResponse:
-            r.state = q.started;
+        options: { ...stsWorkerEx.workerThreadWorkerOptions }
+      }, port2);
+      workerPort.onmessage = async (data) => {
+        const publishMessagePayload = data.data;
+        switch (publishMessagePayload.command) {
+          case PublishMessageCommands.MessagePortResponse:
+            stsWorkerEx.state = IWorkerState.started;
             break;
-          case h.InstrumentTelemetry:
-            n(this, J).call(this, r, m.payload);
+          case PublishMessageCommands.InstrumentTelemetry:
+            __privateGet(this, _ProcessTelemetry).call(this, stsWorkerEx, publishMessagePayload.payload);
             break;
           default:
-            r.primaryWorker.ProcessMessageFromWorker(a, m);
+            stsWorkerEx.primaryWorker.ProcessMessageFromWorker(workerPort, publishMessagePayload);
         }
-      }, n(this, O)[r.id] = r, console.log(`Added worker: [${r.id}]`), r;
-    });
-    c(this, "AddRunnerToWorker", (e, t) => {
-      const r = n(this, H).call(this, e, t);
-      return e.runnersEx[r.id] = r, n(this, E).call(this, e, r), r;
-    });
-    l(this, E, (e, t) => {
-      const r = {
-        runner: ee(this, N, ce).call(this, t)
       };
-      n(this, W).call(this, e, h.Add, r);
-    });
-    l(this, J, (e, t) => {
-      const r = re(), { runner: o } = t;
-      if (e.runnersEx[o.id]) {
-        const i = e.runnersEx[o.id];
-        let a = !1;
-        i.instrumentData.count = o.instrumentData.count, i.instrumentData.velocity = o.instrumentData.velocity, o.instrumentData.message ? i.instrumentData.message = [...o.instrumentData.message] : i.instrumentData.message = [], o.instrumentData.message && (o.instrumentData.message.forEach((u) => {
-          i.publishInstrumentController.LogEx(u);
-        }), a = !0), o.instrumentData.count && (i.publishInstrumentController.UpdateInstrument(de.REQUEST_COUNT_GAUGE, {
-          val: i.instrumentData.count
-        }), i.publishInstrumentController.UpdateInstrument(de.VELOCITY_GAUGE, {
-          Inc: i.instrumentData.velocity
-        }), a = !0), a && r.Update(e, i);
+      __privateGet(this, _workersEx)[stsWorkerEx.id] = stsWorkerEx;
+      console.log(`Added worker: [${stsWorkerEx.id}]`);
+      return stsWorkerEx;
+    });
+    __publicField(this, "AddRunnerToWorker", (stsWorkerEx, runnerOptions) => {
+      const runnerEx = __privateGet(this, _CreateAsyncRunner).call(this, stsWorkerEx, runnerOptions);
+      stsWorkerEx.runnersEx[runnerEx.id] = runnerEx;
+      __privateGet(this, _SetRunnerIntoWorker).call(this, stsWorkerEx, runnerEx);
+      return runnerEx;
+    });
+    __privateAdd(this, _SetRunnerIntoWorker, (workerEx, runnerEx) => {
+      const payload = {
+        runner: __privateMethod(this, _CreateRunnerCopy, CreateRunnerCopy_fn).call(this, runnerEx)
+      };
+      __privateGet(this, _PostMessageToWorker).call(this, workerEx, PublishMessageCommands.Add, payload);
+    });
+    __privateAdd(this, _ProcessTelemetry, (workerEx, payloadContents) => {
+      const store = TelemetryStore();
+      const { runner } = payloadContents;
+      if (workerEx.runnersEx[runner.id]) {
+        const runnerEx = workerEx.runnersEx[runner.id];
+        let update = false;
+        runnerEx.instrumentData.count = runner.instrumentData.count;
+        runnerEx.instrumentData.velocity = runner.instrumentData.velocity;
+        if (runner.instrumentData.message) {
+          runnerEx.instrumentData.message = [...runner.instrumentData.message];
+        } else {
+          runnerEx.instrumentData.message = [];
+        }
+        if (runner.instrumentData.message) {
+          runner.instrumentData.message.forEach((message) => {
+            runnerEx.publishInstrumentController.LogEx(message);
+          });
+          update = true;
+        }
+        if (runner.instrumentData.count) {
+          runnerEx.publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
+            val: runnerEx.instrumentData.count
+          });
+          runnerEx.publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
+            Inc: runnerEx.instrumentData.velocity
+          });
+          update = true;
+        }
+        if (update) {
+          store.Update(workerEx, runnerEx);
+        }
       }
     });
-    l(this, H, (e, t) => {
-      Z(this, k)._++;
-      const r = {
-        nid: `${e.workerThreadWorkerOptions.hostName}${te.COMPONENT_SEPERATOR}${e.workerThreadWorkerOptions.agentId}-${e.workerThreadWorkerOptions.userAgent}${te.NID_SEPERATOR}worker${e.id}${te.SEPERATOR}${n(this, k)}`,
-        id: n(this, k).toString(),
-        hostName: e.workerThreadWorkerOptions.hostName ? e.workerThreadWorkerOptions.hostName : "host",
-        agentName: `${e.workerThreadWorkerOptions.agentId}-${e.workerThreadWorkerOptions.userAgent}`,
-        threadId: `worker${e.id}`,
-        asyncRunnerId: n(this, k)
-      }, o = {
-        id: n(this, k),
-        publishInstrumentController: n(this, R).AddPublishInstrumentController(r),
-        asyncRunnerContext: r,
-        state: C.created,
-        options: t,
+    __privateAdd(this, _CreateAsyncRunner, (workerEx, runnerOptions) => {
+      __privateWrapper(this, _runner)._++;
+      const asyncRunnerContext = {
+        nid: `${workerEx.workerThreadWorkerOptions.hostName}${ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}${ModelDelimeter.NID_SEPERATOR}worker${workerEx.id}${ModelDelimeter.SEPERATOR}${__privateGet(this, _runner)}`,
+        id: __privateGet(this, _runner).toString(),
+        hostName: workerEx.workerThreadWorkerOptions.hostName ? workerEx.workerThreadWorkerOptions.hostName : "host",
+        agentName: `${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}`,
+        threadId: `worker${workerEx.id}`,
+        asyncRunnerId: __privateGet(this, _runner)
+      };
+      const runnerEx = {
+        id: __privateGet(this, _runner),
+        publishInstrumentController: __privateGet(this, _STSInstrumentController).AddPublishInstrumentController(asyncRunnerContext),
+        asyncRunnerContext,
+        state: IRunnerState.created,
+        options: runnerOptions,
         instrumentData: {
           count: 0,
           velocity: 0,
           message: []
         },
-        Stop: async () => n(this, $).call(this, e, o)
+        Stop: async () => __privateGet(this, _StopRunner).call(this, workerEx, runnerEx)
       };
-      return o;
+      return runnerEx;
     });
     // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-    l(this, W, (e, t, r, o) => {
-      o ? (console.log("#PostMessageToWorker with transfer object"), e.worker.postMessage({ command: t, payload: r }, [o]), console.log("#PostMessageToWorker with transfer object - done...")) : (console.log("#PostMessageToWorker"), e.worker.postMessage({ command: t, payload: r }));
+    __privateAdd(this, _PostMessageToWorker, (workerEx, command, payload, transferObject) => {
+      if (transferObject) {
+        console.log(`#PostMessageToWorker with transfer object`);
+        workerEx.worker.postMessage({ command, payload }, [transferObject]);
+        console.log(`#PostMessageToWorker with transfer object - done...`);
+      } else {
+        console.log(`#PostMessageToWorker`);
+        workerEx.worker.postMessage({ command, payload });
+      }
     });
-    l(this, L, (e) => {
-      if (e.worker) {
-        const t = re();
-        e.worker.terminate(), console.log(`Terminated worker: [${e.id}]`), t.RemoveWorker(e), delete n(this, O)[e.id];
+    __privateAdd(this, _TerminateWorker, (workerEx) => {
+      if (workerEx.worker) {
+        const store = TelemetryStore();
+        workerEx.worker.terminate();
+        console.log(`Terminated worker: [${workerEx.id}]`);
+        store.RemoveWorker(workerEx);
+        delete __privateGet(this, _workersEx)[workerEx.id];
       }
     });
-    l(this, $, async (e, t = null) => {
-      if (t === null) {
-        const r = Object.keys(e.runnersEx);
-        if (r.length > 0) {
-          const o = r[0];
-          t = e.runnersEx[o];
+    __privateAdd(this, _StopRunner, async (workerEx, runnerEx = null) => {
+      if (runnerEx === null) {
+        const ids = Object.keys(workerEx.runnersEx);
+        if (ids.length > 0) {
+          const id = ids[0];
+          runnerEx = workerEx.runnersEx[id];
         }
       }
-      if (t !== null) {
-        n(this, W).call(this, e, h.Stop, {
-          runner: ee(this, N, ce).call(this, t)
-        }), t.publishInstrumentController.LogEx(`Terminating runner: [${t.id}]`);
-        const r = [];
-        r.push((async () => (await ke(100), t.publishInstrumentController.InstrumentTerminate()))()), re().RemoveRunner(e, t), delete e.runnersEx[t.id];
-        const i = await Promise.all(r);
-        console.log(`Removed instrument workers: [${i}]`);
+      if (runnerEx !== null) {
+        __privateGet(this, _PostMessageToWorker).call(this, workerEx, PublishMessageCommands.Stop, {
+          runner: __privateMethod(this, _CreateRunnerCopy, CreateRunnerCopy_fn).call(this, runnerEx)
+        });
+        runnerEx.publishInstrumentController.LogEx(`Terminating runner: [${runnerEx.id}]`);
+        const promArray = [];
+        promArray.push((async () => {
+          await Sleep(100);
+          return runnerEx.publishInstrumentController.InstrumentTerminate();
+        })());
+        const store = TelemetryStore();
+        store.RemoveRunner(workerEx, runnerEx);
+        delete workerEx.runnersEx[runnerEx.id];
+        const retVal = await Promise.all(promArray);
+        console.log(`Removed instrument workers: [${retVal}]`);
       }
-      return !0;
+      return true;
     });
-    l(this, F, async (e) => {
+    __privateAdd(this, _StopWorker, async (workerEx) => {
       try {
-        if (e.state !== q.stopped) {
-          n(this, W).call(this, e, h.Stop, null), console.log(`Terminating worker: [${e.id}]`);
-          const t = [];
-          Object.keys(e.runnersEx).forEach((o) => {
-            const i = e.runnersEx[o];
-            t.push(n(this, $).call(this, e, i));
-          }), await Promise.all(t), n(this, L).call(this, e);
+        if (workerEx.state !== IWorkerState.stopped) {
+          __privateGet(this, _PostMessageToWorker).call(this, workerEx, PublishMessageCommands.Stop, null);
+          console.log(`Terminating worker: [${workerEx.id}]`);
+          const promArray = [];
+          const ids = Object.keys(workerEx.runnersEx);
+          ids.forEach((id) => {
+            const runnerEx = workerEx.runnersEx[id];
+            promArray.push(__privateGet(this, _StopRunner).call(this, workerEx, runnerEx));
+          });
+          await Promise.all(promArray);
+          __privateGet(this, _TerminateWorker).call(this, workerEx);
         }
-        return !0;
-      } catch (t) {
-        return console.log(`Error in STSTestWorker:StopWorker: [${t}]`), !1;
+        return true;
+      } catch (error) {
+        console.log(`Error in STSTestWorker:StopWorker: [${error}]`);
+        return false;
       }
     });
-    c(this, "GetNextAvailableWorker", () => {
-      let e = null;
-      for (const [, t] of Object.entries(this.WorkersEx))
-        e ? Object.keys(t.runnersEx).length < Object.keys(e.runnersEx).length && (e = t) : e = t;
-      return e;
-    });
-    c(this, "GetBusyWorker", () => {
-      let e = null;
-      for (const [, t] of Object.entries(this.WorkersEx))
-        e ? Object.keys(t.runnersEx).length > Object.keys(e.runnersEx).length && (e = t) : e = t;
-      return e;
+    __publicField(this, "GetNextAvailableWorker", () => {
+      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;
+    });
+    __publicField(this, "GetBusyWorker", () => {
+      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;
     });
     /*
     StopRunner = async () => {
@@ -481,201 +679,281 @@ class be {
         if (largestRunnerWorker) largestRunnerWorker.Stop();
     }
     */
-    c(this, "StopAllWorkers", async () => {
-      const e = [];
-      for (const [, t] of Object.entries(this.WorkersEx))
-        e.push(t.Stop());
-      await Promise.all(e);
-    });
-    g(this, D, e), t ? g(this, T, t) : g(this, T, {}), P(`CompareSTSInstrumentControllerPluginKeyWMEx(): [${we()}]`), P(`Attempting to get STSInstrumentControllerPlugin using symbol: [${String(A)}]`), g(this, R, fe(e)), P(n(this, R)), P("keys within app.config.globalProperties.$sts");
-    for (const [r, o] of Object.entries(e.config.globalProperties.$sts))
-      P(`${r}`);
-    n(this, R) || P(`Failed to get STSInstrumentControllerPlugin using symbol: [${String(A)}]`);
+    __publicField(this, "StopAllWorkers", async () => {
+      const promArray = [];
+      for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+        promArray.push(stsWorker.Stop());
+      }
+      await Promise.all(promArray);
+    });
+    __privateSet(this, _app, app);
+    if (options) {
+      __privateSet(this, _options, options);
+    } else {
+      __privateSet(this, _options, {});
+    }
+    debug$2(`CompareSTSInstrumentControllerPluginKeyWMEx(): [${CompareSTSInstrumentControllerPluginKeyWMEx()}]`);
+    debug$2(`Attempting to get STSInstrumentControllerPlugin using symbol: [${String(STSInstrumentControllerPluginKey)}]`);
+    __privateSet(this, _STSInstrumentController, GetSTSInstrumentController(app));
+    debug$2(__privateGet(this, _STSInstrumentController));
+    debug$2("keys within app.config.globalProperties.$sts");
+    for (const [key, value] of Object.entries(app.config.globalProperties.$sts)) {
+      debug$2(`${key}`);
+    }
+    if (!__privateGet(this, _STSInstrumentController)) {
+      debug$2(`Failed to get STSInstrumentControllerPlugin using symbol: [${String(STSInstrumentControllerPluginKey)}]`);
+    }
   }
   get WorkersEx() {
-    return n(this, O);
+    return __privateGet(this, _workersEx);
   }
   get Options() {
-    return n(this, T);
+    return __privateGet(this, _options);
   }
-  set Options(e) {
-    g(this, T, e);
+  set Options(options) {
+    __privateSet(this, _options, options);
   }
 }
-O = new WeakMap(), k = new WeakMap(), j = new WeakMap(), T = new WeakMap(), R = new WeakMap(), D = new WeakMap(), N = new WeakSet(), ce = function(e) {
+_workersEx = new WeakMap();
+_runner = new WeakMap();
+_workerId = new WeakMap();
+_options = new WeakMap();
+_STSInstrumentController = new WeakMap();
+_app = new WeakMap();
+_CreateRunnerCopy = new WeakSet();
+CreateRunnerCopy_fn = function(runnerEx) {
   return {
-    id: e.id,
-    asyncRunnerContext: { ...e.asyncRunnerContext },
-    options: { ...e.options },
-    state: e.state,
-    instrumentData: { ...e.instrumentData }
+    id: runnerEx.id,
+    asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
+    options: { ...runnerEx.options },
+    state: runnerEx.state,
+    instrumentData: { ...runnerEx.instrumentData }
   };
-}, E = new WeakMap(), J = new WeakMap(), H = new WeakMap(), W = new WeakMap(), L = new WeakMap(), $ = new WeakMap(), F = new WeakMap();
-const Ke = () => A, Be = (s) => s === A, we = () => A === Se(), ze = () => ue(ie), Ve = {
+};
+_SetRunnerIntoWorker = new WeakMap();
+_ProcessTelemetry = new WeakMap();
+_CreateAsyncRunner = new WeakMap();
+_PostMessageToWorker = new WeakMap();
+_TerminateWorker = new WeakMap();
+_StopRunner = new WeakMap();
+_StopWorker = new WeakMap();
+const GetSTSInstrumentControllerPluginKeyWM = () => STSInstrumentControllerPluginKey;
+const CompareSTSInstrumentControllerPluginKeyWM = (val) => val === STSInstrumentControllerPluginKey;
+const CompareSTSInstrumentControllerPluginKeyWMEx = () => STSInstrumentControllerPluginKey === GetSTSInstrumentControllerPluginKey();
+const useSTSWorkerManager = () => inject(STSWorkerManagerPluginKey);
+const STSWorkerManagerPlugin = {
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  install: (s, e) => {
-    const t = new be(s, e);
-    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[ie] = t, s.provide(ie, t);
+  install: (app, options) => {
+    const wm = new STSWorkerManager(app, options);
+    if (!app.config.globalProperties.$sts) {
+      app.config.globalProperties.$sts = {};
+    }
+    app.config.globalProperties.$sts[STSWorkerManagerPluginKey] = wm;
+    app.provide(STSWorkerManagerPluginKey, wm);
   }
-}, w = Y(`proc:${process.pid}`);
-var d, G, I, K;
-class Ce {
-  constructor(e) {
-    l(this, d, {});
-    l(this, G, 1e4);
+};
+const debug$1 = debugModule(`proc:${process.pid}`);
+class RequestResponseHelper {
+  constructor(port) {
+    __privateAdd(this, _requestResponseMessages, {});
+    __privateAdd(this, _requestResponseMessageTimeout, 1e4);
     //@@ config
-    l(this, I, void 0);
-    c(this, "PostMessage", (e) => new Promise((t, r) => {
-      const { messageId: o } = e.payload;
-      if (o)
-        n(this, d)[o] ? r(`RequestResponseHelper: Message with id: [${o}] already exists within the Request/Response record structure`) : (n(this, d)[o] = {
-          publishMessagePayload: { ...e },
-          cb: () => {
-            const i = n(this, d)[o].publishMessagePayloadResponse;
-            if (clearTimeout(n(this, d)[o].timeout), setTimeout(() => {
-              delete n(this, d)[o];
-            }, 0), i)
-              w(`RequestResponseHelper: Resolving response message with id: [${o}] from target worker port. Details: [${JSON.stringify(i)}]`), t(i);
-            else {
-              const a = "Could not get detail from this.#requestResponseMessages[messageId].publishMessagePayloadResponse";
-              w(a), r(a);
+    __privateAdd(this, _port, void 0);
+    __publicField(this, "PostMessage", (message) => {
+      return new Promise((resolve, reject) => {
+        const { messageId } = message.payload;
+        if (messageId) {
+          if (__privateGet(this, _requestResponseMessages)[messageId]) {
+            reject(`RequestResponseHelper: Message with id: [${messageId}] already exists within the Request/Response record structure`);
+          } else {
+            __privateGet(this, _requestResponseMessages)[messageId] = {
+              publishMessagePayload: { ...message },
+              cb: () => {
+                const detail = __privateGet(this, _requestResponseMessages)[messageId].publishMessagePayloadResponse;
+                clearTimeout(__privateGet(this, _requestResponseMessages)[messageId].timeout);
+                setTimeout(() => {
+                  delete __privateGet(this, _requestResponseMessages)[messageId];
+                }, 0);
+                if (detail) {
+                  debug$1(`RequestResponseHelper: Resolving response message with id: [${messageId}] from target worker port. Details: [${JSON.stringify(detail)}]`);
+                  resolve(detail);
+                } else {
+                  const msg = `Could not get detail from this.#requestResponseMessages[messageId].publishMessagePayloadResponse`;
+                  debug$1(msg);
+                  reject(msg);
+                }
+              },
+              timeout: setTimeout(() => {
+                setTimeout(() => {
+                  delete __privateGet(this, _requestResponseMessages)[messageId];
+                }, 0);
+                debug$1(`RequestResponseHelper: Timeout has occurred after: [${__privateGet(this, _requestResponseMessageTimeout)}]ms with message id: [${messageId}]. Details: [${JSON.stringify(__privateGet(this, _requestResponseMessages)[messageId].publishMessagePayload)}]`);
+                reject("RequestResponseHelper: Did not receive response form parent process.");
+              }, __privateGet(this, _requestResponseMessageTimeout))
+              // max message timeout allowed
+            };
+            debug$1(`RequestResponseHelper: Sending message with id: [${messageId}] to target worker port. Details: [${JSON.stringify(__privateGet(this, _requestResponseMessages)[messageId].publishMessagePayload)}]`);
+            __privateGet(this, _port).postMessage(message);
+          }
+        } else {
+          const msg = `RequestResponseHelper: Response did not include a message id`;
+          debug$1(msg);
+          reject(msg);
+        }
+      });
+    });
+    __privateAdd(this, _SetupListener, () => {
+      __privateGet(this, _port).onmessage = async (msg) => {
+        const publishMessagePayload = msg.data;
+        if (publishMessagePayload.payload.messageId) {
+          const messageId = publishMessagePayload.payload.messageId;
+          if (messageId && messageId !== "") {
+            if (__privateGet(this, _requestResponseMessages)[messageId]) {
+              const requestResponseMessage = __privateGet(this, _requestResponseMessages)[messageId];
+              requestResponseMessage.publishMessagePayloadResponse = { ...publishMessagePayload };
+              requestResponseMessage.cb();
+            } else {
+              throw new Error(`RequestResponseHelper: Could not find Request/Response message with id: [${messageId}]`);
             }
-          },
-          timeout: setTimeout(() => {
-            setTimeout(() => {
-              delete n(this, d)[o];
-            }, 0), w(`RequestResponseHelper: Timeout has occurred after: [${n(this, G)}]ms with message id: [${o}]. Details: [${JSON.stringify(n(this, d)[o].publishMessagePayload)}]`), r("RequestResponseHelper: Did not receive response form parent process.");
-          }, n(this, G))
-          // max message timeout allowed
-        }, w(`RequestResponseHelper: Sending message with id: [${o}] to target worker port. Details: [${JSON.stringify(n(this, d)[o].publishMessagePayload)}]`), n(this, I).postMessage(e));
-      else {
-        const i = "RequestResponseHelper: Response did not include a message id";
-        w(i), r(i);
-      }
-    }));
-    l(this, K, () => {
-      n(this, I).onmessage = async (e) => {
-        const t = e.data;
-        if (t.payload.messageId) {
-          const r = t.payload.messageId;
-          if (r && r !== "")
-            if (n(this, d)[r]) {
-              const o = n(this, d)[r];
-              o.publishMessagePayloadResponse = { ...t }, o.cb();
-            } else
-              throw new Error(`RequestResponseHelper: Could not find Request/Response message with id: [${r}]`);
+          }
         }
       };
     });
-    g(this, I, e), n(this, K).call(this);
+    __privateSet(this, _port, port);
+    __privateGet(this, _SetupListener).call(this);
   }
 }
-d = new WeakMap(), G = new WeakMap(), I = new WeakMap(), K = new WeakMap();
-const f = Y(`proc:${process.pid}:workerInstance`);
-var S, U, M, b, B, z, V;
-class Ye {
+_requestResponseMessages = new WeakMap();
+_requestResponseMessageTimeout = new WeakMap();
+_port = new WeakMap();
+_SetupListener = new WeakMap();
+const debug = debugModule(`proc:${process.pid}:workerInstance`);
+class WorkerInstance {
   constructor() {
-    l(this, S, null);
-    l(this, U, null);
-    l(this, M, {});
-    l(this, b, null);
-    c(this, "GetRandomInt", (e) => (f("WorkerInstance::GetRandomInt"), Math.floor(Math.random() * Math.floor(e))));
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    c(this, "StartWork", async (e) => {
-      f("WorkerInstance::StartWork");
+    __privateAdd(this, _collectorCollectorPort, null);
+    __privateAdd(this, _requestResponseHelper, null);
+    __privateAdd(this, _runners, {});
+    __privateAdd(this, _options2, null);
+    __publicField(this, "GetRandomInt", (max) => {
+      debug(`WorkerInstance::GetRandomInt`);
+      return Math.floor(Math.random() * Math.floor(max));
     });
-    c(this, "PostTelemetry", (e) => {
-      if (n(this, S)) {
-        const t = {
-          command: h.InstrumentTelemetry,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    __publicField(this, "StartWork", async (runner) => {
+      debug(`WorkerInstance::StartWork`);
+      return;
+    });
+    __publicField(this, "PostTelemetry", (runner) => {
+      if (__privateGet(this, _collectorCollectorPort)) {
+        const message = {
+          command: PublishMessageCommands.InstrumentTelemetry,
           payload: {
-            runner: e
+            runner
           }
         };
-        n(this, S).postMessage(t);
+        __privateGet(this, _collectorCollectorPort).postMessage(message);
       }
     });
-    l(this, B, (e) => {
-      f("WorkerInstance::SetMessagePort"), g(this, S, e.port), n(this, S).onmessage = function(r) {
-        console.log(`collectorCollectorPort onmessage: ${r.data}`);
-      }, g(this, U, new Ce(n(this, S)));
-      const t = {
-        command: h.MessagePortResponse,
+    __privateAdd(this, _SetMessagePort, (workerMessagePort) => {
+      debug(`WorkerInstance::SetMessagePort`);
+      __privateSet(this, _collectorCollectorPort, workerMessagePort.port);
+      __privateGet(this, _collectorCollectorPort).onmessage = function(data) {
+        console.log(`collectorCollectorPort onmessage: ${data.data}`);
+      };
+      __privateSet(this, _requestResponseHelper, new RequestResponseHelper(__privateGet(this, _collectorCollectorPort)));
+      const response = {
+        command: PublishMessageCommands.MessagePortResponse,
         payload: {}
       };
-      n(this, S).postMessage(t);
-    });
-    c(this, "StartRunner", async (e) => {
-      f("WorkerInstance::StartRunner"), console.log(`StartTests: [${JSON.stringify(e)}]`), e.state = C.running, this.StartWork(e);
-    });
-    l(this, z, (e) => {
-      f("WorkerInstance::AddAsyncRunner");
-      const { runner: t } = e;
-      n(this, M)[t.id] = t, this.StartRunner(t);
-    });
-    l(this, V, (e) => {
-      if (f("WorkerInstance::StopRunners"), e === null)
-        for (const [, t] of Object.entries(n(this, M)))
-          t.state = C.stopped;
-      else {
-        const t = n(this, M)[e.runner.id];
-        t && (t.state = C.stopped);
+      __privateGet(this, _collectorCollectorPort).postMessage(response);
+    });
+    __publicField(this, "StartRunner", async (runner) => {
+      debug(`WorkerInstance::StartRunner`);
+      console.log(`StartTests: [${JSON.stringify(runner)}]`);
+      runner.state = IRunnerState.running;
+      this.StartWork(runner);
+    });
+    __privateAdd(this, _AddAsyncRunner, (testRunnerTelemetryPayload) => {
+      debug(`WorkerInstance::AddAsyncRunner`);
+      const { runner } = testRunnerTelemetryPayload;
+      __privateGet(this, _runners)[runner.id] = runner;
+      this.StartRunner(runner);
+    });
+    __privateAdd(this, _StopRunners, (testRunnerTelemetryPayload) => {
+      debug(`WorkerInstance::StopRunners`);
+      if (testRunnerTelemetryPayload === null) {
+        for (const [, testRunner] of Object.entries(__privateGet(this, _runners))) {
+          testRunner.state = IRunnerState.stopped;
+        }
+      } else {
+        const runner = __privateGet(this, _runners)[testRunnerTelemetryPayload.runner.id];
+        if (runner) {
+          runner.state = IRunnerState.stopped;
+        }
       }
     });
-    c(this, "ProcessMessage", async (e) => {
-      f("WorkerInstance::ProcessMessage");
+    __publicField(this, "ProcessMessage", async (data) => {
+      debug(`WorkerInstance::ProcessMessage`);
       try {
-        const t = e.data;
-        switch (t.command) {
-          case h.MessagePort:
-            n(this, B).call(this, t.payload), g(this, b, t.payload.options), f(`WorkerInstance::ProcessMessage::#options: [${JSON.stringify(n(this, b))}]`);
+        const payloadMessage = data.data;
+        switch (payloadMessage.command) {
+          case PublishMessageCommands.MessagePort:
+            __privateGet(this, _SetMessagePort).call(this, payloadMessage.payload);
+            __privateSet(this, _options2, payloadMessage.payload.options);
+            debug(`WorkerInstance::ProcessMessage::#options: [${JSON.stringify(__privateGet(this, _options2))}]`);
             break;
-          case h.Add:
-            n(this, z).call(this, t.payload);
+          case PublishMessageCommands.Add:
+            __privateGet(this, _AddAsyncRunner).call(this, payloadMessage.payload);
             break;
-          case h.Stop:
-            n(this, V).call(this, t.payload);
+          case PublishMessageCommands.Stop:
+            __privateGet(this, _StopRunners).call(this, payloadMessage.payload);
             break;
           default:
-            f(`Invalid payloadMessage.command: [${t.command}] - Ignoring`);
+            debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
         }
-      } catch (t) {
-        console.log(t);
+      } catch (error) {
+        console.log(error);
       }
     });
-    f("WorkerInstance::constructor");
+    debug(`WorkerInstance::constructor`);
   }
   get RequestResponseHelper() {
-    return n(this, U);
+    return __privateGet(this, _requestResponseHelper);
   }
   get CollectorCollectorPort() {
-    return n(this, S);
+    return __privateGet(this, _collectorCollectorPort);
   }
   get Options() {
-    return n(this, b);
+    return __privateGet(this, _options2);
   }
 }
-S = new WeakMap(), U = new WeakMap(), M = new WeakMap(), b = new WeakMap(), B = new WeakMap(), z = new WeakMap(), V = new WeakMap();
+_collectorCollectorPort = new WeakMap();
+_requestResponseHelper = new WeakMap();
+_runners = new WeakMap();
+_options2 = new WeakMap();
+_SetMessagePort = new WeakMap();
+_AddAsyncRunner = new WeakMap();
+_StopRunners = new WeakMap();
 export {
-  Me as ClientStorageFactory,
-  Pe as ClientStorageType,
-  Be as CompareSTSInstrumentControllerPluginKeyWM,
-  we as CompareSTSInstrumentControllerPluginKeyWMEx,
-  Ke as GetSTSInstrumentControllerPluginKeyWM,
-  C as IRunnerState,
-  q as IWorkerState,
-  Ce as RequestResponseHelper,
-  He as STSEmitterPlugin,
-  ne as STSEmitterPluginKey,
-  Fe as STSStoragePlugin,
-  oe as STSStoragePluginKey,
-  be as STSWorkerManager,
-  Ve as STSWorkerManagerPlugin,
-  ie as STSWorkerManagerPluginKey,
-  re as TelemetryStore,
-  Ye as WorkerInstance,
-  Je as useSTSEmitterPlugin,
-  Le as useSTSStoragePlugin,
-  ze as useSTSWorkerManager
+  ClientStorageFactory,
+  ClientStorageType,
+  CompareSTSInstrumentControllerPluginKeyWM,
+  CompareSTSInstrumentControllerPluginKeyWMEx,
+  GetSTSInstrumentControllerPluginKeyWM,
+  IRunnerState,
+  IWorkerState,
+  RequestResponseHelper,
+  STSEmitterPlugin,
+  STSEmitterPluginKey,
+  STSStoragePlugin,
+  STSStoragePluginKey,
+  STSWorkerManager,
+  STSWorkerManagerPlugin,
+  STSWorkerManagerPluginKey,
+  TelemetryStore,
+  WorkerInstance,
+  useSTSEmitterPlugin,
+  useSTSStoragePlugin,
+  useSTSWorkerManager
 };
 //# sourceMappingURL=stsvueutils.mjs.map