@cloudnux/local-cloud-provider 0.12.0 → 0.14.0

package/dist/websocket-plugin/index.js

@@ -1,3 +1,1009 @@
+// src/logging/pretty-writer.ts
+import chalk from "chalk";
+import { EOL as EOL2 } from "os";
+
+// ../../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../../node_modules/lodash-es/_Symbol.js
+var Symbol = root_default.Symbol;
+var Symbol_default = Symbol;
+
+// ../../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../../node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// ../../../node_modules/lodash-es/_arrayMap.js
+function arrayMap(array2, iteratee) {
+  var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array2[index], index, array2);
+  }
+  return result;
+}
+var arrayMap_default = arrayMap;
+
+// ../../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../../node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0;
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var baseToString_default = baseToString;
+
+// ../../../node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var trimmedEndIndex_default = trimmedEndIndex;
+
+// ../../../node_modules/lodash-es/_baseTrim.js
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
+}
+var baseTrim_default = baseTrim;
+
+// ../../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../../../node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// ../../../node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// ../../../node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// ../../../node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// ../../../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// ../../../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// ../../../node_modules/lodash-es/_baseFindIndex.js
+function baseFindIndex(array2, predicate, fromIndex, fromRight) {
+  var length = array2.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array2[index], index, array2)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var baseFindIndex_default = baseFindIndex;
+
+// ../../../node_modules/lodash-es/_baseIsNaN.js
+function baseIsNaN(value) {
+  return value !== value;
+}
+var baseIsNaN_default = baseIsNaN;
+
+// ../../../node_modules/lodash-es/_strictIndexOf.js
+function strictIndexOf(array2, value, fromIndex) {
+  var index = fromIndex - 1, length = array2.length;
+  while (++index < length) {
+    if (array2[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+var strictIndexOf_default = strictIndexOf;
+
+// ../../../node_modules/lodash-es/_baseIndexOf.js
+function baseIndexOf(array2, value, fromIndex) {
+  return value === value ? strictIndexOf_default(array2, value, fromIndex) : baseFindIndex_default(array2, baseIsNaN_default, fromIndex);
+}
+var baseIndexOf_default = baseIndexOf;
+
+// ../../../node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var isIndex_default = isIndex;
+
+// ../../../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../../../node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// ../../../node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
+}
+var baseIsArguments_default = baseIsArguments;
+
+// ../../../node_modules/lodash-es/isArguments.js
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+var propertyIsEnumerable = objectProto4.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// ../../../node_modules/lodash-es/_isKey.js
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var isKey_default = isKey;
+
+// ../../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// ../../../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// ../../../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty4.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../../node_modules/lodash-es/_hashHas.js
+var objectProto6 = Object.prototype;
+var hasOwnProperty5 = objectProto6.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty5.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// ../../../node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// ../../../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// ../../../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// ../../../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array2, key) {
+  var length = array2.length;
+  while (length--) {
+    if (eq_default(array2[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// ../../../node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// ../../../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// ../../../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// ../../../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// ../../../node_modules/lodash-es/_Map.js
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
+
+// ../../../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// ../../../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// ../../../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// ../../../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// ../../../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// ../../../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// ../../../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// ../../../node_modules/lodash-es/memoize.js
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache_default)();
+  return memoized;
+}
+memoize.Cache = MapCache_default;
+var memoize_default = memoize;
+
+// ../../../node_modules/lodash-es/_memoizeCapped.js
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var memoizeCapped_default = memoizeCapped;
+
+// ../../../node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped_default(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var stringToPath_default = stringToPath;
+
+// ../../../node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : baseToString_default(value);
+}
+var toString_default = toString;
+
+// ../../../node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
+}
+var castPath_default = castPath;
+
+// ../../../node_modules/lodash-es/_toKey.js
+var INFINITY2 = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var toKey_default = toKey;
+
+// ../../../node_modules/lodash-es/_baseSlice.js
+function baseSlice(array2, start, end) {
+  var index = -1, length = array2.length;
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array2[index + start];
+  }
+  return result;
+}
+var baseSlice_default = baseSlice;
+
+// ../../../node_modules/lodash-es/_castSlice.js
+function castSlice(array2, start, end) {
+  var length = array2.length;
+  end = end === void 0 ? length : end;
+  return !start && end >= length ? array2 : baseSlice_default(array2, start, end);
+}
+var castSlice_default = castSlice;
+
+// ../../../node_modules/lodash-es/_hasUnicode.js
+var rsAstralRange = "\\ud800-\\udfff";
+var rsComboMarksRange = "\\u0300-\\u036f";
+var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+var rsVarRange = "\\ufe0e\\ufe0f";
+var rsZWJ = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+var hasUnicode_default = hasUnicode;
+
+// ../../../node_modules/lodash-es/_asciiToArray.js
+function asciiToArray(string) {
+  return string.split("");
+}
+var asciiToArray_default = asciiToArray;
+
+// ../../../node_modules/lodash-es/_unicodeToArray.js
+var rsAstralRange2 = "\\ud800-\\udfff";
+var rsComboMarksRange2 = "\\u0300-\\u036f";
+var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
+var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
+var rsVarRange2 = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange2 + "]";
+var rsCombo = "[" + rsComboRange2 + "]";
+var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+var rsNonAstral = "[^" + rsAstralRange2 + "]";
+var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+var rsZWJ2 = "\\u200d";
+var reOptMod = rsModifier + "?";
+var rsOptVar = "[" + rsVarRange2 + "]?";
+var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeToArray(string) {
+  return string.match(reUnicode) || [];
+}
+var unicodeToArray_default = unicodeToArray;
+
+// ../../../node_modules/lodash-es/_stringToArray.js
+function stringToArray(string) {
+  return hasUnicode_default(string) ? unicodeToArray_default(string) : asciiToArray_default(string);
+}
+var stringToArray_default = stringToArray;
+
+// ../../../node_modules/lodash-es/_hasPath.js
+function hasPath(object, path, hasFunc) {
+  path = castPath_default(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey_default(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var hasPath_default = hasPath;
+
+// ../../../node_modules/lodash-es/_baseHas.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty6 = objectProto7.hasOwnProperty;
+function baseHas(object, key) {
+  return object != null && hasOwnProperty6.call(object, key);
+}
+var baseHas_default = baseHas;
+
+// ../../../node_modules/lodash-es/has.js
+function has(object, path) {
+  return object != null && hasPath_default(object, path, baseHas_default);
+}
+var has_default = has;
+
+// ../../../node_modules/lodash-es/_charsEndIndex.js
+function charsEndIndex(strSymbols, chrSymbols) {
+  var index = strSymbols.length;
+  while (index-- && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
+  }
+  return index;
+}
+var charsEndIndex_default = charsEndIndex;
+
+// ../../../node_modules/lodash-es/_charsStartIndex.js
+function charsStartIndex(strSymbols, chrSymbols) {
+  var index = -1, length = strSymbols.length;
+  while (++index < length && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
+  }
+  return index;
+}
+var charsStartIndex_default = charsStartIndex;
+
+// ../../../node_modules/lodash-es/trim.js
+function trim(string, chars, guard) {
+  string = toString_default(string);
+  if (string && (guard || chars === void 0)) {
+    return baseTrim_default(string);
+  }
+  if (!string || !(chars = baseToString_default(chars))) {
+    return string;
+  }
+  var strSymbols = stringToArray_default(string), chrSymbols = stringToArray_default(chars), start = charsStartIndex_default(strSymbols, chrSymbols), end = charsEndIndex_default(strSymbols, chrSymbols) + 1;
+  return castSlice_default(strSymbols, start, end).join("");
+}
+var trim_default = trim;
+
+// ../../utils/src/config/env.ts
+function _env(key, defaultValue) {
+  return has_default(process.env, key) ? process.env[key] ?? "" : defaultValue ?? "";
+}
+function int(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? 0;
+  }
+  const value = process.env[key] ?? "0";
+  return parseInt(value, 10);
+}
+function float(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? 0;
+  }
+  const value = process.env[key] ?? "0";
+  return parseFloat(value);
+}
+function bool(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? false;
+  }
+  const value = process.env[key];
+  return value === "true";
+}
+function json(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? {};
+  }
+  const value = process.env[key] ?? "{}";
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
+  }
+}
+function array(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? [];
+  }
+  let value = process.env[key] ?? "";
+  if (value.startsWith("[") && value.endsWith("]")) {
+    value = value.substring(1, value.length - 1);
+  }
+  return value.split(",").map((v) => {
+    return trim_default(trim_default(v, " "), '"');
+  });
+}
+function date(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? /* @__PURE__ */ new Date();
+  }
+  const value = process.env[key] ?? Date();
+  return new Date(value);
+}
+var utils = {
+  int,
+  float,
+  bool,
+  json,
+  array,
+  date,
+  /**
+   * Gets a value from env that matches oneOf provided values
+   * @param {string} key
+   * @param {string[]} expectedValues
+   * @param {string|undefined} defaultValue
+   * @returns {string|undefined}
+   */
+  oneOf(key, expectedValues, defaultValue) {
+    if (!expectedValues) {
+      throw new Error(`env.oneOf requires expectedValues`);
+    }
+    if (defaultValue && !expectedValues.includes(defaultValue)) {
+      throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
+    }
+    const rawValue = env(key, defaultValue);
+    return expectedValues.includes(rawValue) ? rawValue : defaultValue ?? "";
+  }
+};
+var env = Object.assign(_env, utils);
+
+// ../../utils/src/logging/types.ts
+var logLevels = {
+  fatal: -1,
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+
+// ../../utils/src/logging/error-to-string.ts
+var safeJsonStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (key, currentValue) => {
+    if (key === "constructor") return void 0;
+    if (typeof currentValue === "object" && currentValue !== null) {
+      if (seen.has(currentValue)) return "[Circular]";
+      seen.add(currentValue);
+    }
+    return currentValue;
+  });
+};
+var hasOwnConstructorProp = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  return Object.prototype.hasOwnProperty.call(value, "constructor");
+};
+var errorToString = (error) => {
+  if (error === null) return "Null error";
+  if (error === void 0) return "Undefined error";
+  if (error instanceof Error) {
+    return [
+      `Name: ${error.name}`,
+      `Message: ${error.message}`,
+      `Stack: ${error.stack || "No stack trace available"}`,
+      // Handle additional properties that might exist on custom errors
+      ...Object.entries(error).filter(
+        ([key, value]) => !["name", "message", "stack"].includes(key) && !hasOwnConstructorProp(value)
+      ).map(([key, value]) => `${key}: ${safeJsonStringify(value)}`)
+    ].join("\n");
+  }
+  if (typeof error === "string") return error;
+  if (typeof error === "object") {
+    try {
+      return JSON.stringify(
+        error,
+        (key, value) => {
+          if (key === "constructor") return void 0;
+          return value;
+        },
+        2
+      );
+    } catch {
+      return `[Object that cannot be stringified: ${Object.prototype.toString.call(error)}]`;
+    }
+  }
+  return String(error);
+};
+
+// ../../utils/src/logging/writer.ts
+import { EOL } from "os";
+var jsonWriter = (entry) => {
+  process.stdout.write(JSON.stringify(entry) + EOL);
+};
+var _writer = jsonWriter;
+function setWriter(writer) {
+  _writer = writer;
+}
+function getWriter() {
+  return _writer;
+}
+
+// ../../utils/src/logging/index.ts
+var levelValues = {
+  fatal: 70,
+  error: 60,
+  warn: 50,
+  info: 40,
+  debug: 30,
+  trace: 20
+};
+var currentLogLevel = 2;
+var _module = "default";
+var _requestId = "";
+function writeLine(level, mergeObject, msg, bindings) {
+  getWriter()({
+    level: levelValues[level],
+    levelName: level,
+    time: Date.now(),
+    module: bindings.module || _module,
+    reqId: bindings.reqId || _requestId,
+    msg: level === "error" || level === "fatal" ? errorToString(msg) : msg,
+    ...mergeObject ? { meta: mergeObject } : {}
+  });
+}
+function createLogger(bindings = {}) {
+  const currentLogLevelName = env("LOG_LEVEL")?.toLowerCase() ?? "info";
+  currentLogLevel = logLevels[currentLogLevelName] ?? logLevels.info;
+  return {
+    level: currentLogLevelName,
+    fatal: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.fatal) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("fatal", null, mergeObject, bindings) : writeLine("fatal", mergeObject, msg ?? "", bindings);
+      }
+    },
+    error: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.error) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("error", null, mergeObject, bindings) : writeLine("error", mergeObject, msg ?? "", bindings);
+      }
+    },
+    warn: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.warn) {
+        typeof mergeObject === "string" ? writeLine("warn", null, mergeObject, bindings) : writeLine("warn", mergeObject, msg ?? "", bindings);
+      }
+    },
+    info: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.info) {
+        typeof mergeObject === "string" ? writeLine("info", null, mergeObject, bindings) : writeLine("info", mergeObject, msg ?? "", bindings);
+      }
+    },
+    debug: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.debug) {
+        typeof mergeObject === "string" ? writeLine("debug", null, mergeObject, bindings) : writeLine("debug", mergeObject, msg ?? "", bindings);
+      }
+    },
+    trace: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.trace) {
+        typeof mergeObject === "string" ? writeLine("trace", null, mergeObject, bindings) : writeLine("trace", mergeObject, msg ?? "", bindings);
+      }
+    },
+    silent: () => {
+    },
+    child: (childBindings) => createLogger({ ...bindings, ...childBindings })
+  };
+}
+var logger = createLogger();
+
+// src/logging/pretty-writer.ts
+var levelColor = {
+  fatal: chalk.bgRed.white,
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.cyan,
+  debug: chalk.gray,
+  trace: chalk.white
+};
+function formatTime(ms) {
+  return new Date(ms).toTimeString().slice(0, 8);
+}
+function formatMeta(meta) {
+  const { req, res, ...rest } = meta;
+  const lines = [];
+  if (req) {
+    const reqParts = [`${req.method} ${req.url}`];
+    if (req.remoteAddress) reqParts.push(`from ${req.remoteAddress}:${req.remotePort ?? ""}`);
+    if (req.headers) reqParts.push(`headers=${JSON.stringify(req.headers, null, 2)}`);
+    if (req.body !== void 0) reqParts.push(`body=${typeof req.body === "string" ? req.body : JSON.stringify(req.body, null, 2)}`);
+    lines.push(chalk.dim("  req: " + reqParts.join(" ")));
+  }
+  if (res) {
+    const resParts = [`${res.statusCode}`];
+    if (res.headers) resParts.push(`headers=${JSON.stringify(res.headers, null, 2)}`);
+    if (res.body !== void 0) resParts.push(`body=${typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)}`);
+    lines.push(chalk.dim("  res: " + resParts.join(" ")));
+  }
+  if (Object.keys(rest).length) {
+    lines.push(chalk.dim("  " + JSON.stringify(rest, null, 2)));
+  }
+  return lines.length ? EOL2 + lines.join(EOL2) : "";
+}
+var prettyWriter = (entry) => {
+  const color = levelColor[entry.levelName] ?? chalk.white;
+  const time = chalk.dim(formatTime(entry.time));
+  const level = color(entry.levelName.toUpperCase().padEnd(5));
+  const module = chalk.magenta(entry.module);
+  const reqId = entry.reqId ? chalk.dim(`[${entry.reqId}]`) + " " : "";
+  const meta = entry.meta ? formatMeta(entry.meta) : "";
+  process.stdout.write(`${time} ${level} ${module} ${reqId}- ${entry.msg}${meta}${EOL2}`);
+};
+setWriter(prettyWriter);
+
 // src/websocket-plugin/plugin.ts
 import crypto from "crypto";
 import fsPlugin from "fastify-plugin";
@@ -13,12 +1019,25 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
   const connections = /* @__PURE__ */ new Map();
   const handlers = [];
   const registeredPaths = /* @__PURE__ */ new Set();
+  const pathModuleMap = /* @__PURE__ */ new Map();
   await app.register(websocketPlugin);
   function ensureRouteForPath(path) {
     if (registeredPaths.has(path)) return;
     registeredPaths.add(path);
-    app.get(path, { websocket: true }, (socket) => {
-      const connectionId = crypto.randomUUID();
+    app.get(path, {
+      websocket: true,
+      preHandler: async (request, reply) => {
+        const connectionId = crypto.randomUUID();
+        request._wsConnectionId = connectionId;
+        const connectHandlers = handlers.filter((h) => h.path === path && h.event === "connect");
+        for (const h of connectHandlers) {
+          await h.handler(connectionId, "connect", null, request, reply);
+        }
+        if (reply.statusCode !== 200)
+          return reply;
+      }
+    }, (socket, request) => {
+      const connectionId = request._wsConnectionId ?? crypto.randomUUID();
       const connection = {
         connectionId,
         socket,
@@ -27,15 +1046,15 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
       };
       connections.set(connectionId, connection);
       const pathHandlers = () => handlers.filter((h) => h.path === path);
-      const connectHandlers = pathHandlers().filter((h) => h.event === "connect");
-      for (const h of connectHandlers) {
-        h.handler(connectionId, "connect").catch(() => {
-        });
-      }
       socket.on("message", (raw) => {
         const data = raw.toString();
         const currentHandlers = pathHandlers();
-        const routeKey = typeof data === "object" && data !== null ? data[config.routeKeyField] : void 0;
+        let routeKey;
+        try {
+          const parsed = JSON.parse(data);
+          routeKey = parsed?.[config.routeKeyField];
+        } catch {
+        }
         let matched = false;
         if (routeKey) {
           const routeHandlers = currentHandlers.filter(
@@ -43,7 +1062,8 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
           );
           for (const h of routeHandlers) {
             matched = true;
-            h.handler(connectionId, "message", data).catch(() => {
+            h.handler(connectionId, "message", data, request).catch((e) => {
+              logger.error(e);
             });
           }
         }
@@ -52,7 +1072,8 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
             (h) => h.event === "message" && !h.route
           );
           for (const h of defaultHandlers) {
-            h.handler(connectionId, "message", data).catch(() => {
+            h.handler(connectionId, "message", data, request).catch((e) => {
+              logger.error(e);
             });
           }
         }
@@ -60,7 +1081,8 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
       socket.on("close", () => {
         const disconnectHandlers = pathHandlers().filter((h) => h.event === "disconnect");
         for (const h of disconnectHandlers) {
-          h.handler(connectionId, "disconnect").catch(() => {
+          h.handler(connectionId, "disconnect", null, request).catch((e) => {
+            logger.error(e);
           });
         }
         connections.delete(connectionId);
@@ -70,6 +1092,9 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
   const manager = {
     registerHandler(handler) {
       handlers.push(handler);
+      if (!pathModuleMap.has(handler.path)) {
+        pathModuleMap.set(handler.path, handler.module);
+      }
       ensureRouteForPath(handler.path);
     },
     getConnections(path) {
@@ -79,6 +1104,13 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
       }
       return allConnections;
     },
+    getRegisteredPaths(module) {
+      const all = Array.from(pathModuleMap.entries()).map(([path, mod]) => ({ path, module: mod }));
+      if (module) {
+        return all.filter((p) => p.module === module);
+      }
+      return all;
+    },
     async sendToClient(connectionId, data) {
       const connection = connections.get(connectionId);
       if (!connection) {
@@ -86,6 +1118,13 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
       }
       const payload = typeof data === "string" ? data : JSON.stringify(data);
       connection.socket.send(payload);
+    },
+    async disconnect(connectionId) {
+      const connection = connections.get(connectionId);
+      if (!connection) {
+        throw new Error(`WebSocket connection ${connectionId} not found`);
+      }
+      connection.socket.close();
     }
   };
   app.decorate("websockets", manager);
@@ -93,4 +1132,17 @@ var websocketsPlugin = fsPlugin(async (app, options) => {
 export {
   websocketsPlugin
 };
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/
 //# sourceMappingURL=index.js.map