@nsshunt/stsvueutils 1.0.23 → 1.0.24

package/dist/stsvueutils.umd.js

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