@nsshunt/ststestrunner 1.1.39 → 1.1.41

package/dist/ststestrunner.cjs

@@ -1,44 +1,49 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __create$1 = Object.create;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames$1 = Object.getOwnPropertyNames;
+var __getProtoOf$1 = Object.getPrototypeOf;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __commonJSMin$1 = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) __defProp(target, name, {
+	for (var name in all) __defProp$1(target, name, {
 		get: all[name],
 		enumerable: true
 	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+var __copyProps$1 = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames$1(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+		if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
 			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
 		});
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$1(isNodeMode || !mod || !mod.__esModule ? __defProp$1(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
 let _nsshunt_stsrunnerframework = require("@nsshunt/stsrunnerframework");
 let chalk = require("chalk");
-chalk = __toESM(chalk, 1);
+chalk = __toESM$1(chalk, 1);
 let _nsshunt_stsutils = require("@nsshunt/stsutils");
 let _nsshunt_stsfhirclient = require("@nsshunt/stsfhirclient");
 let node_http = require("node:http");
-node_http = __toESM(node_http, 1);
+node_http = __toESM$1(node_http, 1);
 let node_https = require("node:https");
-node_https = __toESM(node_https, 1);
+node_https = __toESM$1(node_https, 1);
+require("lodash.clonedeep");
+require("axios");
+require("vue");
+let _nsshunt_stssocketioutils = require("@nsshunt/stssocketioutils");
 //#region src/libmodule/testCaseFhirBase.ts
 var TestCaseFhirBase = class {
 	#options;
@@ -35765,55 +35770,1323 @@ var ResourceDataGenerator = class {
 		return this.#randomNameList[index.toString()];
 	};
 };
+(/* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	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 self = this;
+			function listener() {
+				self.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 < 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;
+		}
+	};
+	module.exports = E;
+	module.exports.TinyEmitter = E;
+})))();
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var Gauge = /* @__PURE__ */ function(Gauge) {
+	Gauge["ACTIVE_REQUEST_GAUGE"] = "a";
+	Gauge["AUTHENTICATION_COUNT_GAUGE"] = "b";
+	Gauge["AUTHENTICATION_ERROR_COUNT_GAUGE"] = "aa";
+	Gauge["AUTHENTICATION_RETRY_COUNT_GAUGE"] = "ab";
+	Gauge["CONNECTION_POOL_IDLE_GAUGE"] = "c";
+	Gauge["CONNECTION_POOL_TOTAL_GAUGE"] = "d";
+	Gauge["CONNECTION_POOL_WAITING_GAUGE"] = "e";
+	Gauge["CPU_LOAD_GAUGE"] = "f";
+	Gauge["CPU_SYSTEM_LOAD_GAUGE"] = "g";
+	Gauge["DURATION_GAUGE"] = "h";
+	Gauge["DURATION_HISTOGRAM_GAUGE"] = "i";
+	Gauge["ERROR_COUNT_GAUGE"] = "j";
+	Gauge["LATENCY_GAUGE"] = "k";
+	Gauge["LATENCY_HISTOGRAM_GAUGE"] = "l";
+	Gauge["LOGGER"] = "m";
+	Gauge["LOGGER_COPY"] = "n";
+	Gauge["NETWORK_RX_GAUGE"] = "o";
+	Gauge["NETWORK_TX_GAUGE"] = "p";
+	Gauge["REQUEST_COUNT_GAUGE"] = "q";
+	Gauge["RETRY_COUNT_GAUGE"] = "r";
+	Gauge["TIMER_GAUGE"] = "s";
+	Gauge["VELOCITY_GAUGE"] = "t";
+	Gauge["CONNECTION_COUNT_GAUGE"] = "u";
+	Gauge["OBJECT_GAUGE"] = "v";
+	Gauge["PAYLOAD_SIZE"] = "w";
+	Gauge["CORE_COUNT_GAUGE"] = "x";
+	Gauge["CHILD_COUNT"] = "y";
+	Gauge["UNKNOWN"] = "z";
+	return Gauge;
+}({});
+var GaugeTypes = /* @__PURE__ */ function(GaugeTypes) {
+	GaugeTypes["GAUGE_TYPE"] = "_";
+	GaugeTypes["INSTRUMENT_GAUGE"] = "a";
+	GaugeTypes["INSTRUMENT_VELOCITY"] = "b";
+	GaugeTypes["INSTRUMENT_HISTOGRAM"] = "c";
+	GaugeTypes["INSTRUMENT_LOG"] = "d";
+	GaugeTypes["INSTRUMENT_TIMER"] = "e";
+	GaugeTypes["INSTRUMENT_OBJECT"] = "f";
+	return GaugeTypes;
+}({});
+GaugeTypes.GAUGE_TYPE;
+var require_timsort$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/****
+	* The MIT License
+	*
+	* Copyright (c) 2015 Marco Ziccardi
+	*
+	* Permission is hereby granted, free of charge, to any person obtaining a copy
+	* of this software and associated documentation files (the "Software"), to deal
+	* in the Software without restriction, including without limitation the rights
+	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	* copies of the Software, and to permit persons to whom the Software is
+	* furnished to do so, subject to the following conditions:
+	*
+	* The above copyright notice and this permission notice shall be included in
+	* all copies or substantial portions of the Software.
+	*
+	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	* THE SOFTWARE.
+	*
+	****/
+	(function(global, factory) {
+		if (typeof define === "function" && define.amd) define("timsort", ["exports"], factory);
+		else if (typeof exports !== "undefined") factory(exports);
+		else {
+			var mod = { exports: {} };
+			factory(mod.exports);
+			global.timsort = mod.exports;
+		}
+	})(exports, function(exports$1) {
+		"use strict";
+		exports$1.__esModule = true;
+		exports$1.sort = sort;
+		function _classCallCheck(instance, Constructor) {
+			if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+		}
+		var DEFAULT_MIN_MERGE = 32;
+		var DEFAULT_MIN_GALLOPING = 7;
+		var DEFAULT_TMP_STORAGE_LENGTH = 256;
+		var POWERS_OF_TEN = [
+			1,
+			10,
+			100,
+			1e3,
+			1e4,
+			1e5,
+			1e6,
+			1e7,
+			1e8,
+			1e9
+		];
+		function log10(x) {
+			if (x < 1e5) {
+				if (x < 100) return x < 10 ? 0 : 1;
+				if (x < 1e4) return x < 1e3 ? 2 : 3;
+				return 4;
+			}
+			if (x < 1e7) return x < 1e6 ? 5 : 6;
+			if (x < 1e9) return x < 1e8 ? 7 : 8;
+			return 9;
+		}
+		function alphabeticalCompare(a, b) {
+			if (a === b) return 0;
+			if (~~a === a && ~~b === b) {
+				if (a === 0 || b === 0) return a < b ? -1 : 1;
+				if (a < 0 || b < 0) {
+					if (b >= 0) return -1;
+					if (a >= 0) return 1;
+					a = -a;
+					b = -b;
+				}
+				var al = log10(a);
+				var bl = log10(b);
+				var t = 0;
+				if (al < bl) {
+					a *= POWERS_OF_TEN[bl - al - 1];
+					b /= 10;
+					t = -1;
+				} else if (al > bl) {
+					b *= POWERS_OF_TEN[al - bl - 1];
+					a /= 10;
+					t = 1;
+				}
+				if (a === b) return t;
+				return a < b ? -1 : 1;
+			}
+			var aStr = String(a);
+			var bStr = String(b);
+			if (aStr === bStr) return 0;
+			return aStr < bStr ? -1 : 1;
+		}
+		function minRunLength(n) {
+			var r = 0;
+			while (n >= DEFAULT_MIN_MERGE) {
+				r |= n & 1;
+				n >>= 1;
+			}
+			return n + r;
+		}
+		function makeAscendingRun(array, lo, hi, compare) {
+			var runHi = lo + 1;
+			if (runHi === hi) return 1;
+			if (compare(array[runHi++], array[lo]) < 0) {
+				while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) runHi++;
+				reverseRun(array, lo, runHi);
+			} else while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) runHi++;
+			return runHi - lo;
+		}
+		function reverseRun(array, lo, hi) {
+			hi--;
+			while (lo < hi) {
+				var t = array[lo];
+				array[lo++] = array[hi];
+				array[hi--] = t;
+			}
+		}
+		function binaryInsertionSort(array, lo, hi, start, compare) {
+			if (start === lo) start++;
+			for (; start < hi; start++) {
+				var pivot = array[start];
+				var left = lo;
+				var right = start;
+				while (left < right) {
+					var mid = left + right >>> 1;
+					if (compare(pivot, array[mid]) < 0) right = mid;
+					else left = mid + 1;
+				}
+				var n = start - left;
+				switch (n) {
+					case 3: array[left + 3] = array[left + 2];
+					case 2: array[left + 2] = array[left + 1];
+					case 1:
+						array[left + 1] = array[left];
+						break;
+					default: while (n > 0) {
+						array[left + n] = array[left + n - 1];
+						n--;
+					}
+				}
+				array[left] = pivot;
+			}
+		}
+		function gallopLeft(value, array, start, length, hint, compare) {
+			var lastOffset = 0;
+			var maxOffset = 0;
+			var offset = 1;
+			if (compare(value, array[start + hint]) > 0) {
+				maxOffset = length - hint;
+				while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+					lastOffset = offset;
+					offset = (offset << 1) + 1;
+					if (offset <= 0) offset = maxOffset;
+				}
+				if (offset > maxOffset) offset = maxOffset;
+				lastOffset += hint;
+				offset += hint;
+			} else {
+				maxOffset = hint + 1;
+				while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+					lastOffset = offset;
+					offset = (offset << 1) + 1;
+					if (offset <= 0) offset = maxOffset;
+				}
+				if (offset > maxOffset) offset = maxOffset;
+				var tmp = lastOffset;
+				lastOffset = hint - offset;
+				offset = hint - tmp;
+			}
+			lastOffset++;
+			while (lastOffset < offset) {
+				var m = lastOffset + (offset - lastOffset >>> 1);
+				if (compare(value, array[start + m]) > 0) lastOffset = m + 1;
+				else offset = m;
+			}
+			return offset;
+		}
+		function gallopRight(value, array, start, length, hint, compare) {
+			var lastOffset = 0;
+			var maxOffset = 0;
+			var offset = 1;
+			if (compare(value, array[start + hint]) < 0) {
+				maxOffset = hint + 1;
+				while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+					lastOffset = offset;
+					offset = (offset << 1) + 1;
+					if (offset <= 0) offset = maxOffset;
+				}
+				if (offset > maxOffset) offset = maxOffset;
+				var tmp = lastOffset;
+				lastOffset = hint - offset;
+				offset = hint - tmp;
+			} else {
+				maxOffset = length - hint;
+				while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+					lastOffset = offset;
+					offset = (offset << 1) + 1;
+					if (offset <= 0) offset = maxOffset;
+				}
+				if (offset > maxOffset) offset = maxOffset;
+				lastOffset += hint;
+				offset += hint;
+			}
+			lastOffset++;
+			while (lastOffset < offset) {
+				var m = lastOffset + (offset - lastOffset >>> 1);
+				if (compare(value, array[start + m]) < 0) offset = m;
+				else lastOffset = m + 1;
+			}
+			return offset;
+		}
+		var TimSort = (function() {
+			function TimSort(array, compare) {
+				_classCallCheck(this, TimSort);
+				this.array = null;
+				this.compare = null;
+				this.minGallop = DEFAULT_MIN_GALLOPING;
+				this.length = 0;
+				this.tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
+				this.stackLength = 0;
+				this.runStart = null;
+				this.runLength = null;
+				this.stackSize = 0;
+				this.array = array;
+				this.compare = compare;
+				this.length = array.length;
+				if (this.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) this.tmpStorageLength = this.length >>> 1;
+				this.tmp = new Array(this.tmpStorageLength);
+				this.stackLength = this.length < 120 ? 5 : this.length < 1542 ? 10 : this.length < 119151 ? 19 : 40;
+				this.runStart = new Array(this.stackLength);
+				this.runLength = new Array(this.stackLength);
+			}
+			TimSort.prototype.pushRun = function pushRun(runStart, runLength) {
+				this.runStart[this.stackSize] = runStart;
+				this.runLength[this.stackSize] = runLength;
+				this.stackSize += 1;
+			};
+			TimSort.prototype.mergeRuns = function mergeRuns() {
+				while (this.stackSize > 1) {
+					var n = this.stackSize - 2;
+					if (n >= 1 && this.runLength[n - 1] <= this.runLength[n] + this.runLength[n + 1] || n >= 2 && this.runLength[n - 2] <= this.runLength[n] + this.runLength[n - 1]) {
+						if (this.runLength[n - 1] < this.runLength[n + 1]) n--;
+					} else if (this.runLength[n] > this.runLength[n + 1]) break;
+					this.mergeAt(n);
+				}
+			};
+			TimSort.prototype.forceMergeRuns = function forceMergeRuns() {
+				while (this.stackSize > 1) {
+					var n = this.stackSize - 2;
+					if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) n--;
+					this.mergeAt(n);
+				}
+			};
+			TimSort.prototype.mergeAt = function mergeAt(i) {
+				var compare = this.compare;
+				var array = this.array;
+				var start1 = this.runStart[i];
+				var length1 = this.runLength[i];
+				var start2 = this.runStart[i + 1];
+				var length2 = this.runLength[i + 1];
+				this.runLength[i] = length1 + length2;
+				if (i === this.stackSize - 3) {
+					this.runStart[i + 1] = this.runStart[i + 2];
+					this.runLength[i + 1] = this.runLength[i + 2];
+				}
+				this.stackSize--;
+				var k = gallopRight(array[start2], array, start1, length1, 0, compare);
+				start1 += k;
+				length1 -= k;
+				if (length1 === 0) return;
+				length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+				if (length2 === 0) return;
+				if (length1 <= length2) this.mergeLow(start1, length1, start2, length2);
+				else this.mergeHigh(start1, length1, start2, length2);
+			};
+			TimSort.prototype.mergeLow = function mergeLow(start1, length1, start2, length2) {
+				var compare = this.compare;
+				var array = this.array;
+				var tmp = this.tmp;
+				var i = 0;
+				for (i = 0; i < length1; i++) tmp[i] = array[start1 + i];
+				var cursor1 = 0;
+				var cursor2 = start2;
+				var dest = start1;
+				array[dest++] = array[cursor2++];
+				if (--length2 === 0) {
+					for (i = 0; i < length1; i++) array[dest + i] = tmp[cursor1 + i];
+					return;
+				}
+				if (length1 === 1) {
+					for (i = 0; i < length2; i++) array[dest + i] = array[cursor2 + i];
+					array[dest + length2] = tmp[cursor1];
+					return;
+				}
+				var minGallop = this.minGallop;
+				while (true) {
+					var count1 = 0;
+					var count2 = 0;
+					var exit = false;
+					do
+						if (compare(array[cursor2], tmp[cursor1]) < 0) {
+							array[dest++] = array[cursor2++];
+							count2++;
+							count1 = 0;
+							if (--length2 === 0) {
+								exit = true;
+								break;
+							}
+						} else {
+							array[dest++] = tmp[cursor1++];
+							count1++;
+							count2 = 0;
+							if (--length1 === 1) {
+								exit = true;
+								break;
+							}
+						}
+					while ((count1 | count2) < minGallop);
+					if (exit) break;
+					do {
+						count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+						if (count1 !== 0) {
+							for (i = 0; i < count1; i++) array[dest + i] = tmp[cursor1 + i];
+							dest += count1;
+							cursor1 += count1;
+							length1 -= count1;
+							if (length1 <= 1) {
+								exit = true;
+								break;
+							}
+						}
+						array[dest++] = array[cursor2++];
+						if (--length2 === 0) {
+							exit = true;
+							break;
+						}
+						count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+						if (count2 !== 0) {
+							for (i = 0; i < count2; i++) array[dest + i] = array[cursor2 + i];
+							dest += count2;
+							cursor2 += count2;
+							length2 -= count2;
+							if (length2 === 0) {
+								exit = true;
+								break;
+							}
+						}
+						array[dest++] = tmp[cursor1++];
+						if (--length1 === 1) {
+							exit = true;
+							break;
+						}
+						minGallop--;
+					} while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+					if (exit) break;
+					if (minGallop < 0) minGallop = 0;
+					minGallop += 2;
+				}
+				this.minGallop = minGallop;
+				if (minGallop < 1) this.minGallop = 1;
+				if (length1 === 1) {
+					for (i = 0; i < length2; i++) array[dest + i] = array[cursor2 + i];
+					array[dest + length2] = tmp[cursor1];
+				} else if (length1 === 0) throw new Error("mergeLow preconditions were not respected");
+				else for (i = 0; i < length1; i++) array[dest + i] = tmp[cursor1 + i];
+			};
+			TimSort.prototype.mergeHigh = function mergeHigh(start1, length1, start2, length2) {
+				var compare = this.compare;
+				var array = this.array;
+				var tmp = this.tmp;
+				var i = 0;
+				for (i = 0; i < length2; i++) tmp[i] = array[start2 + i];
+				var cursor1 = start1 + length1 - 1;
+				var cursor2 = length2 - 1;
+				var dest = start2 + length2 - 1;
+				var customCursor = 0;
+				var customDest = 0;
+				array[dest--] = array[cursor1--];
+				if (--length1 === 0) {
+					customCursor = dest - (length2 - 1);
+					for (i = 0; i < length2; i++) array[customCursor + i] = tmp[i];
+					return;
+				}
+				if (length2 === 1) {
+					dest -= length1;
+					cursor1 -= length1;
+					customDest = dest + 1;
+					customCursor = cursor1 + 1;
+					for (i = length1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
+					array[dest] = tmp[cursor2];
+					return;
+				}
+				var minGallop = this.minGallop;
+				while (true) {
+					var count1 = 0;
+					var count2 = 0;
+					var exit = false;
+					do
+						if (compare(tmp[cursor2], array[cursor1]) < 0) {
+							array[dest--] = array[cursor1--];
+							count1++;
+							count2 = 0;
+							if (--length1 === 0) {
+								exit = true;
+								break;
+							}
+						} else {
+							array[dest--] = tmp[cursor2--];
+							count2++;
+							count1 = 0;
+							if (--length2 === 1) {
+								exit = true;
+								break;
+							}
+						}
+					while ((count1 | count2) < minGallop);
+					if (exit) break;
+					do {
+						count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+						if (count1 !== 0) {
+							dest -= count1;
+							cursor1 -= count1;
+							length1 -= count1;
+							customDest = dest + 1;
+							customCursor = cursor1 + 1;
+							for (i = count1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
+							if (length1 === 0) {
+								exit = true;
+								break;
+							}
+						}
+						array[dest--] = tmp[cursor2--];
+						if (--length2 === 1) {
+							exit = true;
+							break;
+						}
+						count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+						if (count2 !== 0) {
+							dest -= count2;
+							cursor2 -= count2;
+							length2 -= count2;
+							customDest = dest + 1;
+							customCursor = cursor2 + 1;
+							for (i = 0; i < count2; i++) array[customDest + i] = tmp[customCursor + i];
+							if (length2 <= 1) {
+								exit = true;
+								break;
+							}
+						}
+						array[dest--] = array[cursor1--];
+						if (--length1 === 0) {
+							exit = true;
+							break;
+						}
+						minGallop--;
+					} while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+					if (exit) break;
+					if (minGallop < 0) minGallop = 0;
+					minGallop += 2;
+				}
+				this.minGallop = minGallop;
+				if (minGallop < 1) this.minGallop = 1;
+				if (length2 === 1) {
+					dest -= length1;
+					cursor1 -= length1;
+					customDest = dest + 1;
+					customCursor = cursor1 + 1;
+					for (i = length1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
+					array[dest] = tmp[cursor2];
+				} else if (length2 === 0) throw new Error("mergeHigh preconditions were not respected");
+				else {
+					customCursor = dest - (length2 - 1);
+					for (i = 0; i < length2; i++) array[customCursor + i] = tmp[i];
+				}
+			};
+			return TimSort;
+		})();
+		function sort(array, compare, lo, hi) {
+			if (!Array.isArray(array)) throw new TypeError("Can only sort arrays");
+			if (!compare) compare = alphabeticalCompare;
+			else if (typeof compare !== "function") {
+				hi = lo;
+				lo = compare;
+				compare = alphabeticalCompare;
+			}
+			if (!lo) lo = 0;
+			if (!hi) hi = array.length;
+			var remaining = hi - lo;
+			if (remaining < 2) return;
+			var runLength = 0;
+			if (remaining < DEFAULT_MIN_MERGE) {
+				runLength = makeAscendingRun(array, lo, hi, compare);
+				binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+				return;
+			}
+			var ts = new TimSort(array, compare);
+			var minRun = minRunLength(remaining);
+			do {
+				runLength = makeAscendingRun(array, lo, hi, compare);
+				if (runLength < minRun) {
+					var force = remaining;
+					if (force > minRun) force = minRun;
+					binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+					runLength = force;
+				}
+				ts.pushRun(lo, runLength);
+				ts.mergeRuns();
+				remaining -= runLength;
+				lo += runLength;
+			} while (remaining !== 0);
+			ts.forceMergeRuns();
+		}
+	});
+}));
+var require_timsort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_timsort$1();
+}));
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	@typedef {(Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array)} TypedArray
+	*/
+	/**
+	* Error message for a case when percentile is less than 0.
+	*
+	* @param {Number} p
+	*
+	* @return {String}
+	*/
+	function lessThanZeroError(p) {
+		return "Expect percentile to be >= 0 but given \"" + p + "\" and its type is \"" + typeof p + "\".";
+	}
+	/**
+	* Error message for a case when percentile is greater than 100.
+	*
+	* @param {Number} p
+	*
+	* @return {String}
+	*/
+	function greaterThanHundredError(p) {
+		return "Expect percentile to be <= 100 but given \"" + p + "\" and its type is \"" + typeof p + "\".";
+	}
+	/**
+	* Error message for a case when percentile is not a number (NaN).
+	*
+	* @param {Number} p
+	*
+	* @return {String}
+	*/
+	function nanError(p) {
+		return "Expect percentile to be a number but given \"" + p + "\" and its type is \"" + typeof p + "\".";
+	}
+	/**
+	* Checks that a list of percentiles are all numbers and they lie in range 0..100.
+	*
+	* @param {Array<Number>} ps - percentiles to calculate
+	*
+	* @return {Array} List of errors
+	*/
+	function validateInput(ps) {
+		return ps.reduce(function(errors, p) {
+			if (isNaN(Number(p))) errors.push(nanError(p));
+			else if (p < 0) errors.push(lessThanZeroError(p));
+			else if (p > 100) errors.push(greaterThanHundredError(p));
+			return errors;
+		}, []);
+	}
+	/**
+	* Get percentile value from an array.
+	*
+	* @param {Number} p - percentile
+	* @param {Array|TypedArray} list - list of values
+	*
+	* @return {*}
+	*/
+	function getPsValue(p, list) {
+		if (p === 0) return list[0];
+		return list[Math.ceil(list.length * (p / 100)) - 1];
+	}
+	/**
+	* Calculate percentile for given array of values.
+	*
+	* @template T
+	* @param {Number|Array<Number>} pOrPs - percentile or a list of percentiles
+	* @param {Array<T>|Array<Number>|TypedArray} list - array of values
+	* @param {function(T): Number} [fn] - optional function to extract a value from an array item
+	*
+	* @return {Number|T|Array<Number>|Array<T>}
+	*/
+	function percentile(pOrPs, list, fn) {
+		var ps = Array.isArray(pOrPs) ? pOrPs : [pOrPs];
+		var validationErrors = validateInput(ps);
+		if (validationErrors.length) throw new Error(validationErrors.join(" "));
+		list = list.slice().sort(function(a, b) {
+			if (fn) {
+				a = fn(a);
+				b = fn(b);
+			}
+			a = Number.isNaN(a) ? Number.NEGATIVE_INFINITY : a;
+			b = Number.isNaN(b) ? Number.NEGATIVE_INFINITY : b;
+			if (a > b) return 1;
+			if (a < b) return -1;
+			return 0;
+		});
+		if (ps.length === 1) return getPsValue(ps[0], list);
+		return ps.map(function(p) {
+			return getPsValue(p, list);
+		});
+	}
+	module.exports = percentile;
+}));
+require_timsort();
+require_lib();
 //#endregion
-//#region src/libmodule/workerTestCaseLogger.ts
-var WorkerTestCaseLogger = class {
+//#region node_modules/@nsshunt/stsinstrumentmanagerclient/dist/index.mjs
+var SubscriptionTopic = /* @__PURE__ */ function(SubscriptionTopic) {
+	SubscriptionTopic["AllServicesCombined"] = "AllServicesCombined";
+	SubscriptionTopic["Services"] = "Services";
+	SubscriptionTopic["ServiceInstances"] = "ServiceInstances";
+	SubscriptionTopic["ServiceInstance"] = "ServiceInstance";
+	SubscriptionTopic["AllAgentsCombined"] = "AllAgentsCombined";
+	SubscriptionTopic["Agents"] = "Agents";
+	SubscriptionTopic["AgentWorkers"] = "AgentWorkers";
+	SubscriptionTopic["AgentWorker"] = "AgentWorker";
+	SubscriptionTopic["AllLambdasCombined"] = "AllLambdasCombined";
+	SubscriptionTopic["LambdaTechnologies"] = "LambdaTechnologies";
+	SubscriptionTopic["LambdaSubTechnologies"] = "LambdaSubTechnologies";
+	SubscriptionTopic["LambdaSubTechnologiesInstance"] = "LambdaSubTechnologiesInstance";
+	SubscriptionTopic["LogProcessing"] = "LogProcessing";
+	return SubscriptionTopic;
+}({});
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+var styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles$1.modifier);
+var foregroundColorNames = Object.keys(styles$1.color);
+var backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+var ansiStyles = assembleStyles();
+var level = (() => {
+	if (!("navigator" in globalThis)) return 0;
+	if (globalThis.navigator.userAgentData) {
+		const brand = navigator.userAgentData.brands.find(({ brand }) => brand === "Chromium");
+		if (brand && brand.version > 93) return 3;
+	}
+	if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) return 1;
+	return 0;
+})();
+var colorSupport = level !== 0 && {
+	level,
+	hasBasic: true,
+	has256: level >= 2,
+	has16m: level >= 3
+};
+var supportsColor = {
+	stdout: colorSupport,
+	stderr: colorSupport
+};
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+var { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+var styles = Object.create(null);
+var applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+var getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+var proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+var createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+var applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+var chalk$1 = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+new TextEncoder();
+new TextDecoder();
+/**
+* ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+*/
+var ExtData = class {
+	type;
+	data;
+	constructor(type, data) {
+		this.type = type;
+		this.data = data;
+	}
+};
+var DecodeError = class DecodeError extends Error {
+	constructor(message) {
+		super(message);
+		const proto = Object.create(DecodeError.prototype);
+		Object.setPrototypeOf(this, proto);
+		Object.defineProperty(this, "name", {
+			configurable: true,
+			enumerable: false,
+			value: DecodeError.name
+		});
+	}
+};
+function setInt64(view, offset, value) {
+	const high = Math.floor(value / 4294967296);
+	const low = value;
+	view.setUint32(offset, high);
+	view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+	const high = view.getInt32(offset);
+	const low = view.getUint32(offset + 4);
+	return high * 4294967296 + low;
+}
+var TIMESTAMP32_MAX_SEC = 4294967295;
+var TIMESTAMP64_MAX_SEC = 17179869183;
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+	if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+		const rv = new Uint8Array(4);
+		new DataView(rv.buffer).setUint32(0, sec);
+		return rv;
+	} else {
+		const secHigh = sec / 4294967296;
+		const secLow = sec & 4294967295;
+		const rv = new Uint8Array(8);
+		const view = new DataView(rv.buffer);
+		view.setUint32(0, nsec << 2 | secHigh & 3);
+		view.setUint32(4, secLow);
+		return rv;
+	}
+	else {
+		const rv = new Uint8Array(12);
+		const view = new DataView(rv.buffer);
+		view.setUint32(0, nsec);
+		setInt64(view, 4, sec);
+		return rv;
+	}
+}
+function encodeDateToTimeSpec(date) {
+	const msec = date.getTime();
+	const sec = Math.floor(msec / 1e3);
+	const nsec = (msec - sec * 1e3) * 1e6;
+	const nsecInSec = Math.floor(nsec / 1e9);
+	return {
+		sec: sec + nsecInSec,
+		nsec: nsec - nsecInSec * 1e9
+	};
+}
+function encodeTimestampExtension(object) {
+	if (object instanceof Date) return encodeTimeSpecToTimestamp(encodeDateToTimeSpec(object));
+	else return null;
+}
+function decodeTimestampToTimeSpec(data) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	switch (data.byteLength) {
+		case 4: return {
+			sec: view.getUint32(0),
+			nsec: 0
+		};
+		case 8: {
+			const nsec30AndSecHigh2 = view.getUint32(0);
+			const secLow32 = view.getUint32(4);
+			return {
+				sec: (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32,
+				nsec: nsec30AndSecHigh2 >>> 2
+			};
+		}
+		case 12: return {
+			sec: getInt64(view, 4),
+			nsec: view.getUint32(0)
+		};
+		default: throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+	}
+}
+function decodeTimestampExtension(data) {
+	const timeSpec = decodeTimestampToTimeSpec(data);
+	return /* @__PURE__ */ new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+var timestampExtension = {
+	type: -1,
+	encode: encodeTimestampExtension,
+	decode: decodeTimestampExtension
+};
+(class ExtensionCodec {
+	static defaultCodec = new ExtensionCodec();
+	__brand;
+	builtInEncoders = [];
+	builtInDecoders = [];
+	encoders = [];
+	decoders = [];
+	constructor() {
+		this.register(timestampExtension);
+	}
+	register({ type, encode, decode }) {
+		if (type >= 0) {
+			this.encoders[type] = encode;
+			this.decoders[type] = decode;
+		} else {
+			const index = -1 - type;
+			this.builtInEncoders[index] = encode;
+			this.builtInDecoders[index] = decode;
+		}
+	}
+	tryToEncode(object, context) {
+		for (let i = 0; i < this.builtInEncoders.length; i++) {
+			const encodeExt = this.builtInEncoders[i];
+			if (encodeExt != null) {
+				const data = encodeExt(object, context);
+				if (data != null) return new ExtData(-1 - i, data);
+			}
+		}
+		for (let i = 0; i < this.encoders.length; i++) {
+			const encodeExt = this.encoders[i];
+			if (encodeExt != null) {
+				const data = encodeExt(object, context);
+				if (data != null) return new ExtData(i, data);
+			}
+		}
+		if (object instanceof ExtData) return object;
+		return null;
+	}
+	decode(data, type, context) {
+		const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+		if (decodeExt) return decodeExt(data, type, context);
+		else return new ExtData(type, data);
+	}
+});
+var influxDBDataType = /* @__PURE__ */ function(influxDBDataType) {
+	influxDBDataType["intField"] = "intField";
+	influxDBDataType["floatField"] = "floatField";
+	influxDBDataType["stringField"] = "stringField";
+	return influxDBDataType;
+}({});
+Gauge.REQUEST_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.ERROR_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.RETRY_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.VELOCITY_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.ACTIVE_REQUEST_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CORE_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.NETWORK_RX_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.NETWORK_TX_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.TIMER_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_TIMER, Gauge.DURATION_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.DURATION_HISTOGRAM_GAUGE, Gauge.LATENCY_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.LATENCY_HISTOGRAM_GAUGE, Gauge.LOGGER, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_LOG, Gauge.CPU_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_TOTAL_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_IDLE_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_WAITING_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CPU_SYSTEM_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.OBJECT_GAUGE, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_OBJECT, SubscriptionTopic.AllServicesCombined, SubscriptionTopic.Services, SubscriptionTopic.ServiceInstances, SubscriptionTopic.ServiceInstance, Gauge.CHILD_COUNT, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, SubscriptionTopic.AllAgentsCombined, SubscriptionTopic.Agents, SubscriptionTopic.AgentWorkers, SubscriptionTopic.AgentWorker, Gauge.CPU_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_TOTAL_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_IDLE_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_WAITING_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CPU_SYSTEM_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.OBJECT_GAUGE, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_OBJECT, SubscriptionTopic.AllLambdasCombined, SubscriptionTopic.LambdaTechnologies, SubscriptionTopic.LambdaSubTechnologies, SubscriptionTopic.LambdaSubTechnologiesInstance;
+var SOCKET_NAMESPACE = "stsinstrumentmanager/stsmonitor";
+var SocketBrowserClientLogPublisher = class extends _nsshunt_stssocketioutils.SocketIoClient {
+	#id;
+	#options;
+	constructor(options) {
+		super("stsinstrumentmanagerclient:SocketBrowserClientLogPublisher");
+		this.#options = options;
+		this.#id = globalThis.crypto.randomUUID();
+		this.LogDebugMessage(chalk$1.cyan(`${this.logPrefix}Start()`));
+		const url = `${this.#options.imendpoint}:${this.#options.import}/${SOCKET_NAMESPACE}/`;
+		this.LogDebugMessage(chalk$1.cyan(`${this.logPrefix}SetupSocket() url: [${url}]`));
+		this.WithAddress(url).WithLogger(_nsshunt_stsutils.defaultLogger).SetupSocket();
+	}
+	get id() {
+		return this.#id;
+	}
+	get logPrefix() {
+		return `stsinstrumentmanagerclient:SocketBrowserClientLogPublisher:`;
+	}
+	SocketConnect(socket) {
+		this.LogDebugMessage(chalk$1.magenta(`${this.logPrefix}SocketConnect(): Socket ID: [${socket.id}], Joining Room: [${this.#options.rooms}]`));
+		socket.emit("__STSjoinRoom", this.#options.rooms);
+	}
+	SocketError(error) {
+		this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketError(): Error: [${error}]`));
+	}
+	SetupSocketEvents(socket) {
+		this.LogDebugMessage(chalk$1.magenta(`${this.logPrefix}SetupSocketEvents(): Socket ID: [${socket.id}]`));
+	}
+	SocketConnectError(error) {
+		this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketConnectError(): Error: [${error}]`));
+	}
+	SocketDisconnect(reason) {
+		this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketDisconnect(): reason: [${reason}]`));
+	}
+};
+var STSLoggerSocket = class {
 	#options;
-	#logger;
+	#socketIoClient;
 	constructor(opts) {
 		this.#options = opts;
-		if (this.#options.outputToDefaultLogger === true) this.#logger = _nsshunt_stsutils.defaultLogger;
-		else this.#logger = _nsshunt_stsutils.emptyLogger;
+		this.#socketIoClient = new SocketBrowserClientLogPublisher({
+			rooms: this.#options.rooms,
+			imendpoint: this.#options.imendpoint,
+			import: this.#options.import
+		});
+		this.#socketIoClient.socket?.emit("__STSjoinRoom", this.#options.rooms);
 	}
-	UsePrefix = (message) => {
-		return `[][] ==>> ${message}`;
-	};
-	error = (message) => {
-		this.#logger.error(this.UsePrefix(message));
-	};
-	warn = (message) => {
-		this.#logger.warn(this.UsePrefix(message));
-	};
-	info = (message) => {
-		this.#logger.info(this.UsePrefix(message));
-	};
-	http = (message) => {
-		this.#logger.http(this.UsePrefix(message));
-	};
-	verbose = (message) => {
-		this.#logger.verbose(this.UsePrefix(message));
-	};
-	debug = (message) => {
-		this.#logger.debug(this.UsePrefix(message));
-	};
-	silly = (message) => {
-		this.#logger.silly(this.UsePrefix(message));
+	JoinRoom = () => {
+		this.#socketIoClient.socket?.emit("__STSjoinRoom", this.#options.rooms);
 	};
+	error(message) {
+		this.#log({
+			level: "error",
+			message
+		});
+	}
+	warn(message) {
+		this.#log({
+			level: "warn",
+			message
+		});
+	}
+	info(message) {
+		this.#log({
+			level: "info",
+			message
+		});
+	}
+	http(message) {
+		this.#log({
+			level: "http",
+			message
+		});
+	}
+	verbose(message) {
+		this.#log({
+			level: "verbose",
+			message
+		});
+	}
+	debug(message) {
+		this.#log({
+			level: "debug",
+			message
+		});
+	}
+	silly(message) {
+		this.#log({
+			level: "silly",
+			message
+		});
+	}
+	#log(info) {
+		this.#socketIoClient.socket?.emit("__STSsendToRoom", this.#options.rooms, {
+			command: "logmessage",
+			payload: {
+				level: info.level,
+				message: info.message,
+				dateTime: Date.now()
+			}
+		});
+	}
 };
 //#endregion
 //#region src/libmodule/workerFhirTestCases.ts
 var WorkerFhirTestCases = class extends _nsshunt_stsrunnerframework.AbstractRunnerExecutionWorker {
 	_resourceDataGenerator;
-	_workerTestCaseLogger;
 	_logRoom = `logs_workerTestCase`;
+	_loggerSocket;
 	constructor() {
 		super();
 		this._resourceDataGenerator = new ResourceDataGenerator();
-		this._workerTestCaseLogger = new WorkerTestCaseLogger({
-			outputToDefaultLogger: true,
+		this._loggerSocket = new STSLoggerSocket({
 			imendpoint: "https://stscore.stsmda.org",
-			import: 3001,
-			imsocketnamespace: "stsinstrumentmanager/stsmonitor",
+			import: "3001",
 			rooms: [this._logRoom]
 		});
 	}
@@ -35821,7 +37094,7 @@ var WorkerFhirTestCases = class extends _nsshunt_stsrunnerframework.AbstractRunn
 		return this._resourceDataGenerator;
 	}
 	get logger() {
-		return this._workerTestCaseLogger;
+		return this._loggerSocket;
 	}
 	CreateAsyncRunner = async (testRunnerTelemetryPayload) => {
 		return AsyncRunnerFactory.CreateAsyncRunner(this, testRunnerTelemetryPayload);