@cloudnux/local-cloud-provider 0.2.0 → 0.2.2

package/dist/dev-console-plugin/index.mjs

@@ -0,0 +1,3047 @@
+// ../../../node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/dev-console-plugin/plugin.ts
+import path4 from "path";
+import fastifyStatic from "@fastify/static";
+import fsPlugin3 from "fastify-plugin";
+
+// src/queue-plugin/plugin.ts
+import fsPlugin from "fastify-plugin";
+
+// src/queue-plugin/core.ts
+import chalk2 from "chalk";
+import logSymbols from "log-symbols";
+
+// ../../../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 Map = getNative_default(root_default, "Map");
+var Map_default = Map;
+
+// ../../../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, path5, hasFunc) {
+  path5 = castPath_default(path5, object);
+  var index = -1, length = path5.length, result = false;
+  while (++index < length) {
+    var key = toKey_default(path5[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, path5) {
+  return object != null && hasPath_default(object, path5, 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/index.ts
+import chalk from "chalk";
+import { EOL } from "os";
+
+// ../../utils/src/logging/types.ts
+var logLevels = {
+  fatal: -1,
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+
+// ../../utils/src/logging/error-to-string.ts
+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]) => !["name", "message", "stack"].includes(key)).map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+    ].join("\n");
+  }
+  if (typeof error === "string") return error;
+  if (typeof error === "object") {
+    try {
+      return JSON.stringify(error, null, 2);
+    } catch {
+      return `[Object that cannot be stringified: ${Object.prototype.toString.call(error)}]`;
+    }
+  }
+  return String(error);
+};
+
+// ../../utils/src/logging/index.ts
+var currentLogLevel = logLevels[env("LOG_LEVEL")?.toLowerCase()] ?? logLevels.info;
+var logger = {
+  fatal: (message, meta) => {
+    if (currentLogLevel >= logLevels.fatal) {
+      console.error(
+        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
+        `${chalk.bgRed.white(" fatal ")}${EOL}`,
+        errorToString(message),
+        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
+      );
+    }
+  },
+  error: (message, meta) => {
+    if (currentLogLevel >= logLevels.error) {
+      console.error(
+        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
+        `${chalk.bgRed.white(" error ")}${EOL}`,
+        errorToString(message),
+        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
+      );
+    }
+  },
+  warn: (message, meta) => {
+    if (currentLogLevel >= logLevels.warn) {
+      console.warn(
+        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
+        `${chalk.bgYellow.black(" warn ")}${EOL}`,
+        errorToString(message),
+        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
+      );
+    }
+  },
+  info: (message, meta) => {
+    if (currentLogLevel >= logLevels.info) {
+      console.info(
+        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
+        `${chalk.bgBlue.white(" info ")}${EOL}`,
+        message,
+        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
+      );
+    }
+  },
+  debug: (message, meta) => {
+    if (currentLogLevel >= logLevels.debug) {
+      console.debug(
+        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
+        `${chalk.bgWhite.black(" debug ")}${EOL}`,
+        message,
+        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
+      );
+    }
+  }
+};
+
+// src/queue-plugin/core.ts
+var DEFAULT_CONFIG = {
+  batchSize: 10,
+  batchWindowMs: 500,
+  maxRetries: 3,
+  parallel: true,
+  maxConcurrent: 5,
+  retryBackoff: true,
+  persistence: {
+    enabled: true,
+    directory: "./.develop/queue-data",
+    saveInterval: 6e4,
+    saveOnShutdown: false,
+    loadOnStartup: true
+  }
+};
+var mergeConfig = (defaultConfig, userConfig) => ({
+  ...defaultConfig,
+  ...userConfig,
+  persistence: {
+    ...defaultConfig.persistence,
+    ...userConfig?.persistence || {}
+  }
+});
+var createQueueService = (handler, module) => ({
+  handler,
+  incoming: [],
+  processing: [],
+  dlq: [],
+  timeoutId: null,
+  processingBatch: false,
+  activeProcessing: 0,
+  module
+});
+var createQueueMessage = (body, headers) => {
+  const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+  return {
+    id,
+    timestamp: /* @__PURE__ */ new Date(),
+    attempts: 0,
+    payload: body,
+    attributes: headers
+  };
+};
+var moveToProcessing = (queueService, batchSize) => {
+  return queueService.incoming.splice(0, batchSize);
+};
+var removeFromProcessing = (queueService, messageId) => {
+  queueService.processing = queueService.processing.filter((msg) => msg.id !== messageId);
+};
+var moveToDLQ = (queueService, message, error) => {
+  queueService.dlq.push({
+    ...message,
+    error,
+    failedAt: /* @__PURE__ */ new Date()
+  });
+  removeFromProcessing(queueService, message.id);
+};
+var incrementAttempts = (queueService, messageId) => {
+  const index = queueService.processing.findIndex((m) => m.id === messageId);
+  if (index >= 0) {
+    queueService.processing[index].attempts += 1;
+    return queueService.processing[index];
+  }
+  return null;
+};
+var calculateBackoffDelay = (attempts) => {
+  return Math.pow(2, attempts) * 100;
+};
+var setNextAttemptTime = (message, delayMs) => ({
+  ...message,
+  nextAttempt: new Date(Date.now() + delayMs)
+});
+var createQueueSummary = (queueService, config) => ({
+  incoming: queueService.incoming.length,
+  processing: queueService.processing.length,
+  dlq: queueService.dlq.length,
+  isProcessing: queueService.processingBatch,
+  activeProcessing: queueService.activeProcessing,
+  configuration: {
+    batchSize: config.batchSize,
+    batchWindowMs: config.batchWindowMs,
+    parallel: config.parallel,
+    maxConcurrent: config.maxConcurrent
+  }
+});
+var createDashboardSummary = (queues, config) => {
+  return Object.entries(queues).reduce((summary, [queueName, queue]) => {
+    summary[queueName] = createQueueSummary(queue, config);
+    return summary;
+  }, {});
+};
+var moveDLQToIncoming = (queueService) => {
+  const dlqCount = queueService.dlq.length;
+  if (dlqCount === 0) return 0;
+  const movedMessages = queueService.dlq.map((message) => ({
+    ...message,
+    attempts: 0,
+    error: void 0,
+    failedAt: void 0,
+    reprocessed: true,
+    originalId: message.id,
+    id: Date.now().toString() + Math.random().toString(36).substring(2, 7)
+  }));
+  queueService.incoming.push(...movedMessages);
+  queueService.dlq = [];
+  return dlqCount;
+};
+var purgeDLQ = (queueService) => {
+  const dlqCount = queueService.dlq.length;
+  queueService.dlq = [];
+  return dlqCount;
+};
+var logSuccess = (message, messageId, queueName) => {
+  logger.debug(`${logSymbols.success} ${chalk2.green(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}`);
+};
+var logError = (message, messageId, queueName, error) => {
+  logger.error(`${logSymbols.error} ${chalk2.red(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}: ${error}`);
+};
+var logRetryScheduled = (messageId, delayMs) => {
+  logger.info(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
+};
+var logDLQOperation = (operation, count, queueName) => {
+  logger.warn(`${logSymbols.warning} ${chalk2.yellow(operation)} ${chalk2.red(count)} messages from DLQ for ${chalk2.green(queueName)}`);
+};
+
+// src/queue-plugin/processing.ts
+var createProcessMessageHandler = (config) => async (queueName, message, queueService) => {
+  try {
+    await queueService.handler(message);
+    removeFromProcessing(queueService, message.id);
+    logSuccess("Successfully processed message", message.id, queueName);
+  } catch (error) {
+    await handleProcessingError(queueName, message, queueService, error, config);
+  }
+};
+var handleProcessingError = async (queueName, message, queueService, error, config) => {
+  logError("Error processing message", message.id, queueName, error.message);
+  if (message.attempts >= config.maxRetries) {
+    moveToDLQ(queueService, message, error.message);
+    return;
+  }
+  const updatedMessage = incrementAttempts(queueService, message.id);
+  if (!updatedMessage) return;
+  if (config.retryBackoff) {
+    const delayMs = calculateBackoffDelay(updatedMessage.attempts);
+    const messageWithNextAttempt = setNextAttemptTime(updatedMessage, delayMs);
+    logRetryScheduled(message.id, delayMs);
+    setTimeout(() => {
+      createProcessMessageHandler(config)(queueName, messageWithNextAttempt, queueService);
+    }, delayMs);
+  }
+};
+var createBatchProcessor = (processMessage, config, saveQueueState) => async (queueName, queueService) => {
+  if (queueService.timeoutId) {
+    clearTimeout(queueService.timeoutId);
+    queueService.timeoutId = null;
+  }
+  if (queueService.processingBatch) {
+    return;
+  }
+  try {
+    queueService.processingBatch = true;
+    const messagesToProcess = moveToProcessing(queueService, config.batchSize);
+    if (messagesToProcess.length === 0) {
+      return;
+    }
+    queueService.processing.push(...messagesToProcess);
+    await Promise.all(messagesToProcess.map((message) => {
+      return processMessage(queueName, message, queueService);
+    }));
+    if (config.persistence.enabled && saveQueueState) {
+      await saveQueueState(queueName);
+    }
+  } finally {
+    queueService.processingBatch = false;
+  }
+};
+var createProcessingScheduler = (processBatch, config) => (queueName, queueService, overrideDelay = null) => {
+  if (!queueService.timeoutId) {
+    const delay = overrideDelay ?? config.batchWindowMs;
+    queueService.timeoutId = setTimeout(() => {
+      processBatch(queueName, queueService);
+    }, delay);
+  }
+};
+var handleImmediateProcessing = (queueService, config, processBatch, queueName) => {
+  if (queueService.incoming.length >= config.batchSize) {
+    if (queueService.timeoutId) {
+      clearTimeout(queueService.timeoutId);
+      queueService.timeoutId = null;
+    }
+    setImmediate(() => processBatch(queueName, queueService));
+  }
+};
+
+// src/queue-plugin/persistence.ts
+import * as fs from "fs/promises";
+import * as path2 from "path";
+import chalk3 from "chalk";
+import logSymbols2 from "log-symbols";
+var createQueueData = (queueService) => ({
+  incoming: queueService.incoming,
+  processing: queueService.processing,
+  dlq: queueService.dlq,
+  savedAt: /* @__PURE__ */ new Date()
+});
+var restoreDates = (messages) => {
+  messages.forEach((msg) => {
+    msg.timestamp = new Date(msg.timestamp);
+    if (msg.nextAttempt) msg.nextAttempt = new Date(msg.nextAttempt);
+    if (msg.failedAt) msg.failedAt = new Date(msg.failedAt);
+  });
+};
+var createPersistenceInitializer = (config, loadAllQueueStates, saveAllQueueStates) => async () => {
+  try {
+    await fs.mkdir(config.persistence.directory, { recursive: true });
+    if (config.persistence.loadOnStartup) {
+      await loadAllQueueStates();
+    }
+    if (config.persistence.saveInterval > 0) {
+      setInterval(saveAllQueueStates, config.persistence.saveInterval);
+    }
+    if (config.persistence.saveOnShutdown) {
+      const shutdownHandler = async () => {
+        logger.debug("Saving queue state before shutdown...");
+        await saveAllQueueStates();
+        process.exit(0);
+      };
+      process.on("SIGINT", shutdownHandler);
+      process.on("SIGTERM", shutdownHandler);
+    }
+    logger.debug(`${logSymbols2.success} ${chalk3.green("Queue persistence initialized:")} ${chalk3.yellow(config.persistence.directory)}`);
+  } catch (error) {
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error.message)}`);
+  }
+};
+var createQueueStateSaver = (config) => async (queueName, queueService) => {
+  try {
+    if (!queueService) return;
+    const queueData = createQueueData(queueService);
+    const now = Date.now();
+    const queueFilePath = path2.join(config.persistence.directory, `${queueName}.json`);
+    const tempFilePath = path2.join(config.persistence.directory, `${queueName}.${now}temp.json`);
+    await fs.writeFile(tempFilePath, JSON.stringify(queueData, null, 2), "utf8");
+    await fs.rename(tempFilePath, queueFilePath);
+    logger.info(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
+  } catch (error) {
+    logger.error(`Failed to save queue state for ${queueName}:`, error);
+  }
+};
+var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async () => {
+  try {
+    for (const [queueName, queueService] of Object.entries(queues)) {
+      await saveQueueState(queueName, queueService);
+    }
+    logger.debug(`${logSymbols2.success} ${chalk3.green("All queue states saved to")} ${chalk3.yellow(config.persistence.directory)}`);
+  } catch (error) {
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error.message)}`);
+  }
+};
+var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
+  try {
+    if (!queues[queueName]) {
+      logger.warn(`Skipping load for non-existent queue: ${queueName}`);
+      return;
+    }
+    const queueFilePath = path2.join(config.persistence.directory, `${queueName}.json`);
+    try {
+      const data = await fs.readFile(queueFilePath, "utf8");
+      const queueData = JSON.parse(data);
+      restoreDates(queueData.incoming);
+      restoreDates(queueData.processing);
+      restoreDates(queueData.dlq);
+      queues[queueName].incoming = queueData.incoming;
+      queues[queueName].processing = queueData.processing;
+      queues[queueName].dlq = queueData.dlq;
+      logger.debug(`Queue state loaded: ${queueName} (saved at ${queueData.savedAt})`);
+      if (queues[queueName].incoming.length > 0) {
+        scheduleProcessing(queueName, queues[queueName]);
+      }
+      if (queues[queueName].processing.length > 0) {
+        for (const message of [...queues[queueName].processing]) {
+          if (message.attempts >= config.maxRetries) continue;
+          setTimeout(() => {
+            processMessage(queueName, message, queues[queueName]);
+          }, 100 * (Math.random() * 10));
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        logger.debug(`No saved state found for queue: ${queueName}`);
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    logger.error(`Failed to load queue state for ${queueName}:`, error);
+  }
+};
+var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
+  try {
+    const files = await fs.readdir(config.persistence.directory);
+    const queueFiles = files.filter((file) => file.endsWith(".json") && !file.includes(".temp."));
+    for (const file of queueFiles) {
+      const queueName = path2.basename(file, ".json");
+      await loadQueueState(queueName);
+    }
+    logger.debug("All queue states loaded");
+  } catch (error) {
+    logger.error("Failed to load queue states:", error);
+  }
+};
+
+// src/queue-plugin/routes.ts
+var registerQueueRoutes = (app, prefix = "") => {
+  app.get(
+    `/${prefix}/dashboard`,
+    async (_, reply) => {
+      const summary = app.queues.getDashboardSummary();
+      return reply.status(200).send(summary);
+    }
+  );
+  app.get(
+    `/${prefix}/:queue`,
+    async (request, reply) => {
+      const queueName = request.params.queue;
+      const summary = app.queues.getQueueSummary(queueName);
+      if (summary === null) {
+        return reply.status(404).send({ error: "Queue not found" });
+      }
+      return reply.status(200).send(summary);
+    }
+  );
+  app.post(
+    `/${prefix}/:queue`,
+    async (request, reply) => {
+      const queueName = request.params.queue;
+      const result = await app.queues.enqueueMessage(queueName, request.body, request.headers);
+      if (result === null) {
+        return reply.status(404).send({ error: "Queue not found" });
+      }
+      return reply.status(200).send(result);
+    }
+  );
+  app.get(
+    `/${prefix}/:queue/process-dlq`,
+    async (request, reply) => {
+      const queueName = request.params.queue;
+      const result = await app.queues.processDlq(queueName);
+      if (result === null) {
+        return reply.status(404).send(result);
+      }
+      return reply.status(200).send(result);
+    }
+  );
+  app.post(
+    `/${prefix}/:queue/purge-dlq`,
+    async (request, reply) => {
+      const queueName = request.params.queue;
+      const result = await app.queues.purgeDlq(queueName);
+      if (result === null) {
+        return reply.status(404).send({ error: "Queue not found" });
+      }
+      return reply.status(200).send(result);
+    }
+  );
+};
+
+// src/queue-plugin/decorator.ts
+import chalk4 from "chalk";
+import logSymbols3 from "log-symbols";
+var isValidQueueName = (queueName) => {
+  return typeof queueName === "string" && queueName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(queueName);
+};
+var createQueueManager = ({
+  config,
+  queues,
+  saveQueueState,
+  loadQueueState,
+  scheduleProcessing,
+  processBatch
+}) => {
+  const validateQueueName = (queueName) => {
+    if (!queueName || typeof queueName !== "string") {
+      throw new Error("Queue name must be a non-empty string");
+    }
+    if (!isValidQueueName(queueName)) {
+      throw new Error("Queue name must contain only alphanumeric characters, hyphens, and underscores");
+    }
+  };
+  const validateHandler = (handler) => {
+    if (typeof handler !== "function") {
+      throw new Error("Handler must be a function");
+    }
+  };
+  const addQueue = async (queueName, handler, module) => {
+    try {
+      validateQueueName(queueName);
+      validateHandler(handler);
+      if (queues[queueName]) {
+        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Queue already exists:")} ${chalk4.magenta(queueName)}.`);
+        return;
+      }
+      queues[queueName] = createQueueService(handler, module);
+      if (config.persistence.enabled && loadQueueState) {
+        await loadQueueState(queueName);
+      }
+      logger.info(`${logSymbols3.success} ${chalk4.green("Queue added:")} ${chalk4.magenta(queueName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to add queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const removeQueue = async (queueName) => {
+    try {
+      validateQueueName(queueName);
+      if (!queues[queueName]) {
+        throw new Error(`Queue '${queueName}' does not exist`);
+      }
+      const queueService = queues[queueName];
+      const totalMessages = queueService.incoming.length + queueService.processing.length;
+      if (totalMessages > 0) {
+        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Removing queue with")} ${chalk4.red(totalMessages)} ${chalk4.yellow("pending messages:")} ${chalk4.magenta(queueName)}`);
+      }
+      if (queueService.timeoutId) {
+        clearTimeout(queueService.timeoutId);
+      }
+      if (config.persistence.enabled && saveQueueState) {
+        await saveQueueState(queueName, queueService);
+      }
+      delete queues[queueName];
+      logger.info(`${logSymbols3.success} ${chalk4.green("Queue removed:")} ${chalk4.magenta(queueName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to remove queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const hasQueue = (queueName) => {
+    try {
+      validateQueueName(queueName);
+      return queueName in queues;
+    } catch {
+      return false;
+    }
+  };
+  const listQueues = (module) => {
+    return Object.keys(queues).filter((queueName) => {
+      const queueService = queues[queueName];
+      return !module || queueService.module === module;
+    }).sort();
+  };
+  const getQueueStats = (queueName) => {
+    try {
+      validateQueueName(queueName);
+      return queues[queueName] || null;
+    } catch {
+      return null;
+    }
+  };
+  const getQueuesMap = () => {
+    return { ...queues };
+  };
+  const getConfig = () => config;
+  const getDashboardSummary = () => createDashboardSummary(queues, config);
+  const getQueueSummary = (queueName) => {
+    if (!queues[queueName]) {
+      return null;
+    }
+    const queue = queues[queueName];
+    const stats = createQueueSummary(queue, config);
+    return {
+      stats,
+      messages: {
+        incoming: queue.incoming,
+        processing: queue.processing,
+        dlq: queue.dlq
+      }
+    };
+  };
+  const enqueueMessage = async (queueName, body, attributes) => {
+    if (!queues[queueName]) {
+      return null;
+    }
+    const message = createQueueMessage(body, attributes);
+    queues[queueName].incoming.push(message);
+    scheduleProcessing(queueName, queues[queueName]);
+    handleImmediateProcessing(queues[queueName], config, processBatch, queueName);
+    if (config.persistence.enabled && saveQueueState) {
+      await saveQueueState(queueName, queues[queueName]);
+    }
+    return {
+      id: message.id,
+      queueName
+    };
+  };
+  const processDlq = async (queueName) => {
+    if (!queues[queueName]) {
+      return null;
+    }
+    const processedCount = moveDLQToIncoming(queues[queueName]);
+    if (processedCount === 0) {
+      return {
+        status: "success",
+        message: "No messages in DLQ to process",
+        processed: 0
+      };
+    }
+    logDLQOperation("Moving", processedCount, queueName);
+    scheduleProcessing(queueName, queues[queueName]);
+    if (saveQueueState) {
+      await saveQueueState(queueName, queues[queueName]);
+    }
+    return {
+      status: "success",
+      message: `Moved ${processedCount} messages from DLQ to processing queue`,
+      processed: processedCount
+    };
+  };
+  const purgeDlq = async (queueName) => {
+    if (!queues[queueName]) {
+      return null;
+    }
+    const purgedCount = purgeDLQ(queues[queueName]);
+    if (purgedCount === 0) {
+      return {
+        status: "success",
+        message: "No messages in DLQ to purge",
+        purged: 0
+      };
+    }
+    logDLQOperation("Purging", purgedCount, queueName);
+    if (saveQueueState) {
+      await saveQueueState(queueName, queues[queueName]);
+    }
+    return {
+      status: "success",
+      message: `Purged ${purgedCount} messages from DLQ`,
+      purged: purgedCount
+    };
+  };
+  return {
+    addQueue,
+    removeQueue,
+    hasQueue,
+    listQueues,
+    getQueueStats,
+    getQueuesMap,
+    getConfig,
+    getDashboardSummary,
+    getQueueSummary,
+    enqueueMessage,
+    processDlq,
+    purgeDlq
+  };
+};
+var createQueueDecorator = (queueManager) => (app) => {
+  app.decorate("queues", queueManager);
+};
+
+// src/queue-plugin/plugin.ts
+var queuesPlugin = fsPlugin(async (app, options) => {
+  const config = mergeConfig(DEFAULT_CONFIG, options.config);
+  const queues = {};
+  const processMessage = createProcessMessageHandler(config);
+  const saveQueueState = config.persistence.enabled ? createQueueStateSaver(config) : void 0;
+  const saveAllQueueStates = config.persistence.enabled && saveQueueState ? createAllQueuesStateSaver(config, saveQueueState)(queues) : async () => {
+  };
+  const processBatch = createBatchProcessor(
+    processMessage,
+    config,
+    saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0
+  );
+  const scheduleProcessing = createProcessingScheduler(processBatch, config);
+  const loadQueueState = config.persistence.enabled ? createQueueStateLoader(
+    config,
+    scheduleProcessing,
+    processMessage
+  )(queues) : async () => {
+  };
+  const loadAllQueueStates = config.persistence.enabled ? createAllQueuesStateLoader(config, loadQueueState) : async () => {
+  };
+  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveAllQueueStates) : async () => {
+  };
+  const queueManager = createQueueManager({
+    config,
+    queues,
+    saveQueueState: saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0,
+    loadQueueState,
+    scheduleProcessing,
+    processBatch
+  });
+  const decorateQueues = createQueueDecorator(queueManager);
+  decorateQueues(app);
+  registerQueueRoutes(
+    app,
+    options.prefix
+  );
+  await initializePersistence();
+});
+
+// src/schedule-plugin/plugin.ts
+import fsPlugin2 from "fastify-plugin";
+
+// src/schedule-plugin/core.ts
+import * as fs3 from "fs/promises";
+import chalk9 from "chalk";
+import logSymbols7 from "log-symbols";
+
+// src/schedule-plugin/execution.ts
+import chalk6 from "chalk";
+import logSymbols4 from "log-symbols";
+
+// src/schedule-plugin/cron-utils.ts
+import chalk5 from "chalk";
+import { parseExpression } from "cron-parser";
+function parseCronExpression(cronExpression, lastRun, options = {}) {
+  const {
+    preserveNaturalTiming = true,
+    timezone,
+    utc = false,
+    currentDate
+  } = options;
+  try {
+    const normalizedCron = normalizeCronExpression(cronExpression);
+    const parseOptions = {
+      tz: timezone,
+      utc,
+      currentDate: currentDate ?? /* @__PURE__ */ new Date()
+    };
+    if (preserveNaturalTiming && lastRun) {
+      parseOptions.currentDate = lastRun;
+    }
+    const interval = parseExpression(normalizedCron, parseOptions);
+    let nextRun = interval.next().toDate();
+    const now = /* @__PURE__ */ new Date();
+    while (nextRun <= now) {
+      nextRun = interval.next().toDate();
+    }
+    return {
+      nextRun,
+      isValid: true,
+      pattern: normalizedCron,
+      description: describeCronExpression(normalizedCron)
+    };
+  } catch (error) {
+    logger.error(`${chalk5.red("Invalid cron expression:")} ${cronExpression} - ${error.message}`);
+    const fallbackTime = /* @__PURE__ */ new Date();
+    fallbackTime.setHours(fallbackTime.getHours() + 1);
+    fallbackTime.setMinutes(0);
+    fallbackTime.setSeconds(0);
+    fallbackTime.setMilliseconds(0);
+    return {
+      nextRun: fallbackTime,
+      isValid: false,
+      error: error.message,
+      pattern: cronExpression
+    };
+  }
+}
+function getNextExecutions(cronExpression, count = 5, options = {}) {
+  try {
+    const normalizedCron = normalizeCronExpression(cronExpression);
+    const parseOptions = {
+      tz: options.timezone,
+      utc: options.utc ?? false,
+      currentDate: options.currentDate ?? /* @__PURE__ */ new Date()
+    };
+    const interval = parseExpression(normalizedCron, parseOptions);
+    const executions = [];
+    for (let i = 0; i < count; i++) {
+      executions.push(interval.next().toDate());
+    }
+    return executions;
+  } catch (error) {
+    logger.error(`${chalk5.red("Error getting next executions:")} ${error.message}`);
+    return [];
+  }
+}
+function validateCronExpression(cronExpression) {
+  try {
+    const normalized = normalizeCronExpression(cronExpression);
+    parseExpression(normalized);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeCronExpression(cronExpression) {
+  const parts = cronExpression.trim().split(/\s+/);
+  if (parts.length === 5) {
+    return cronExpression;
+  } else if (parts.length === 6) {
+    return cronExpression;
+  } else if (parts.length === 7) {
+    return cronExpression;
+  } else {
+    throw new Error(`Invalid cron format: expected 5, 6, or 7 fields, got ${parts.length}`);
+  }
+}
+function describeCronExpression(cronExpression) {
+  const parts = cronExpression.split(" ");
+  const patterns = {
+    "*/5 * * * *": "Every 5 minutes",
+    "0 * * * *": "Every hour at minute 0",
+    "0 */2 * * *": "Every 2 hours",
+    "0 0 * * *": "Daily at midnight",
+    "0 6 * * *": "Daily at 6:00 AM",
+    "0 0 * * 0": "Weekly on Sunday at midnight",
+    "0 0 1 * *": "Monthly on the 1st at midnight",
+    "0 0 1 1 *": "Yearly on January 1st at midnight"
+  };
+  if (patterns[cronExpression]) {
+    return patterns[cronExpression];
+  }
+  if (parts.length >= 5) {
+    const [minute, hour, day, month, dayOfWeek] = parts;
+    let description = "Runs ";
+    if (minute.includes("*/")) {
+      const interval = minute.split("*/")[1];
+      description += `every ${interval} minutes`;
+    } else if (minute === "*") {
+      description += "every minute";
+    } else {
+      description += `at minute ${minute}`;
+    }
+    if (hour.includes("*/")) {
+      const interval = hour.split("*/")[1];
+      description += `, every ${interval} hours`;
+    } else if (hour !== "*") {
+      description += `, at hour ${hour}`;
+    }
+    if (day !== "*") {
+      description += `, on day ${day}`;
+    }
+    if (month !== "*") {
+      description += `, in month ${month}`;
+    }
+    if (dayOfWeek !== "*") {
+      const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+      const dayNames = dayOfWeek.split(",").map((d) => days[parseInt(d)] || d).join(", ");
+      description += `, on ${dayNames}`;
+    }
+    return description;
+  }
+  return "Custom schedule";
+}
+function detectExpressionType(expression) {
+  if (!expression || typeof expression !== "string") {
+    return "unknown";
+  }
+  const trimmedExpression = expression.trim();
+  const ratePattern = /^rate\(\s*(\d+)\s+(minute|minutes|hour|hours|day|days)\s*\)$/i;
+  if (ratePattern.test(trimmedExpression)) {
+    return "rate";
+  }
+  const cronParts = trimmedExpression.split(/\s+/);
+  if (cronParts.length >= 5 && cronParts.length <= 7) {
+    const cronCharPattern = /^[\d\*\-\,\/\?\#LW]+$/;
+    const validCronParts = cronParts.every((part) => cronCharPattern.test(part) || part === "*");
+    if (validCronParts) {
+      return "cron";
+    }
+  }
+  return "unknown";
+}
+function convertRateToCron(rateExpression) {
+  const trimmedExpression = rateExpression.trim();
+  const ratePattern = /^rate\(\s*(\d+)\s+(minute|minutes|hour|hours|day|days)\s*\)$/i;
+  const match = trimmedExpression.match(ratePattern);
+  if (!match) {
+    return {
+      cronExpression: "",
+      isValid: false,
+      error: "Invalid rate expression format. Expected: rate(value unit)",
+      originalRate: rateExpression,
+      description: ""
+    };
+  }
+  const value = parseInt(match[1]);
+  const unit = match[2].toLowerCase();
+  if (value <= 0) {
+    return {
+      cronExpression: "",
+      isValid: false,
+      error: "Rate value must be greater than 0",
+      originalRate: rateExpression,
+      description: ""
+    };
+  }
+  let cronExpression = "";
+  let description = "";
+  try {
+    switch (unit) {
+      case "minute":
+      case "minutes":
+        if (value > 59) {
+          return {
+            cronExpression: "",
+            isValid: false,
+            error: "Minutes value cannot exceed 59. Use hours for longer intervals.",
+            originalRate: rateExpression,
+            description: ""
+          };
+        }
+        if (value === 1) {
+          cronExpression = "* * * * *";
+          description = "Every minute";
+        } else {
+          cronExpression = `*/${value} * * * *`;
+          description = `Every ${value} minutes`;
+        }
+        break;
+      case "hour":
+      case "hours":
+        if (value > 23) {
+          if (value % 24 === 0) {
+            const days = value / 24;
+            cronExpression = `0 0 */${days} * *`;
+            description = `Every ${days} day${days > 1 ? "s" : ""}`;
+          } else {
+            return {
+              cronExpression: "",
+              isValid: false,
+              error: "Hours value greater than 23 must be divisible by 24, or use days unit.",
+              originalRate: rateExpression,
+              description: ""
+            };
+          }
+        } else if (value === 1) {
+          cronExpression = "0 * * * *";
+          description = "Every hour";
+        } else {
+          cronExpression = `0 */${value} * * *`;
+          description = `Every ${value} hours`;
+        }
+        break;
+      case "day":
+      case "days":
+        if (value > 365) {
+          return {
+            cronExpression: "",
+            isValid: false,
+            error: "Days value cannot exceed 365",
+            originalRate: rateExpression,
+            description: ""
+          };
+        }
+        if (value === 1) {
+          cronExpression = "0 0 * * *";
+          description = "Every day (daily)";
+        } else if (value === 7) {
+          cronExpression = "0 0 * * 0";
+          description = "Every 7 days (weekly)";
+        } else if (value <= 31) {
+          cronExpression = `0 0 */${value} * *`;
+          description = `Every ${value} days`;
+        } else {
+          cronExpression = `0 0 */${value} * *`;
+          description = `Every ${value} days (approximate)`;
+        }
+        break;
+      default:
+        return {
+          cronExpression: "",
+          isValid: false,
+          error: `Unsupported time unit: ${unit}. Use minute(s), hour(s), or day(s).`,
+          originalRate: rateExpression,
+          description: ""
+        };
+    }
+    if (!validateCronExpression(cronExpression)) {
+      return {
+        cronExpression: "",
+        isValid: false,
+        error: "Generated cron expression is invalid",
+        originalRate: rateExpression,
+        description: ""
+      };
+    }
+    return {
+      cronExpression,
+      isValid: true,
+      originalRate: rateExpression,
+      description
+    };
+  } catch (error) {
+    return {
+      cronExpression: "",
+      isValid: false,
+      error: `Conversion error: ${error.message}`,
+      originalRate: rateExpression,
+      description: ""
+    };
+  }
+}
+
+// src/schedule-plugin/utils.ts
+var generateJobId = () => `job_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+var generateExecutionId = () => `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+var calculateNextRun = (job, preserveNaturalTiming = true) => {
+  const now = /* @__PURE__ */ new Date();
+  if (job.cronExpression) {
+    const result = parseCronExpression(job.cronExpression, job.lastRun, {
+      preserveNaturalTiming,
+      timezone: job.timezone,
+      currentDate: preserveNaturalTiming && job.lastRun ? job.lastRun : now
+    });
+    return result.nextRun;
+  }
+  if (job.intervalMs) {
+    return new Date(now.getTime() + job.intervalMs);
+  }
+  if (job.delayMs) {
+    return new Date(now.getTime() + job.delayMs);
+  }
+  return new Date(now.getTime() + 36e5);
+};
+var calculateNextRunFromLastRun = (job, lastRun, config) => {
+  const now = /* @__PURE__ */ new Date();
+  if (job.cronExpression) {
+    const result = parseCronExpression(job.cronExpression, lastRun, {
+      preserveNaturalTiming: config.restartBehavior.preserveNaturalTiming,
+      timezone: job.timezone ?? config.cron.defaultTimezone
+    });
+    return result.nextRun;
+  }
+  if (job.intervalMs && lastRun) {
+    let nextRun = new Date(lastRun.getTime() + job.intervalMs);
+    if (config.restartBehavior.skipMissedRuns) {
+      while (nextRun <= now) {
+        nextRun = new Date(nextRun.getTime() + job.intervalMs);
+      }
+    } else {
+      if (nextRun <= now) {
+        nextRun = new Date(now.getTime() + job.intervalMs);
+      }
+    }
+    return nextRun;
+  }
+  return calculateNextRun(job, config.restartBehavior.preserveNaturalTiming);
+};
+var hasJobDefinitionChanged = (currentJob, savedJob) => currentJob.cronExpression !== savedJob.cronExpression || currentJob.intervalMs !== savedJob.intervalMs || currentJob.delayMs !== savedJob.delayMs || currentJob.maxRuns !== savedJob.maxRuns || currentJob.timezone !== savedJob.timezone;
+var shouldSkipJob = (job) => {
+  if (!job.enabled) return true;
+  if (job.maxRuns && job.runCount >= job.maxRuns) return true;
+  return false;
+};
+var getTimeUntilNextRun = (job) => Math.max(0, job.nextRun.getTime() - Date.now());
+
+// src/schedule-plugin/execution.ts
+var createJobExecution = (jobId) => ({
+  id: generateExecutionId(),
+  jobId,
+  startTime: /* @__PURE__ */ new Date(),
+  status: "running"
+});
+var completeExecution = (execution, result, error) => ({
+  ...execution,
+  endTime: /* @__PURE__ */ new Date(),
+  status: error ? "failed" : "completed",
+  result,
+  error
+});
+var canExecuteJob = (scheduler, state) => {
+  if (state.isShuttingDown) {
+    return { canExecute: false, reason: "System is shutting down" };
+  }
+  if (scheduler.isRunning) {
+    return { canExecute: false, reason: "Job is already running" };
+  }
+  if (shouldSkipJob(scheduler.job)) {
+    const reason = !scheduler.job.enabled ? "Job is disabled" : "Job reached maximum runs";
+    return { canExecute: false, reason };
+  }
+  if (state.runningExecutions >= state.config.execution.maxConcurrent) {
+    return { canExecute: false, reason: "Maximum concurrent executions reached" };
+  }
+  return { canExecute: true };
+};
+var scheduleJob = (scheduler, state, executeJobFn) => {
+  if (state.isShuttingDown) return scheduler;
+  const timeUntilNextRun = getTimeUntilNextRun(scheduler.job);
+  const updatedScheduler = { ...scheduler };
+  if (timeUntilNextRun <= 0) {
+    setImmediate(() => executeJobFn(updatedScheduler));
+  } else {
+    updatedScheduler.timerId = setTimeout(() => {
+      executeJobFn(updatedScheduler);
+    }, timeUntilNextRun);
+    logger.info(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+  }
+  return updatedScheduler;
+};
+var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
+  return Promise.race([
+    handler(job, execution),
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs)
+    )
+  ]);
+};
+var updateJobAfterExecution = (job, execution, config) => {
+  const updatedJob = {
+    ...job,
+    lastRun: execution.startTime,
+    runCount: job.runCount + 1
+  };
+  if (job.enabled) {
+    updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
+  }
+  return updatedJob;
+};
+var handleExecutionError = (execution, error) => {
+  logger.error(`${logSymbols4.error} ${chalk6.red("Job failed")} ${execution.jobId}: ${error.message}`);
+  return completeExecution(execution, void 0, error.message);
+};
+var handleExecutionSuccess = (execution, result) => {
+  const duration = execution.endTime ? execution.endTime.getTime() - execution.startTime.getTime() : 0;
+  logger.debug(`${logSymbols4.success} ${chalk6.green("Job completed")} in ${duration}ms`);
+  return completeExecution(execution, result);
+};
+
+// src/schedule-plugin/persistence.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+import chalk7 from "chalk";
+import logSymbols5 from "log-symbols";
+var createStateFilePath = (directory) => path3.join(directory, "scheduler-state.json");
+var createTempFilePath = (directory) => path3.join(directory, `scheduler-state.${Date.now()}.temp.json`);
+var serializeSchedulerState = (schedulers, executionHistory) => ({
+  jobs: Object.values(schedulers).map((s) => s.job),
+  executions: executionHistory.slice(-100),
+  savedAt: /* @__PURE__ */ new Date(),
+  version: "1.0"
+});
+var saveSchedulerState = async (state) => {
+  try {
+    const serializedState = serializeSchedulerState(state.schedulers, state.executionHistory);
+    const stateFile = createStateFilePath(state.config.persistence.directory);
+    const tempFile = createTempFilePath(state.config.persistence.directory);
+    await fs2.writeFile(tempFile, JSON.stringify(serializedState, null, 2), "utf8");
+    await fs2.rename(tempFile, stateFile);
+    logger.info(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
+  } catch (error) {
+    logger.error("Failed to save scheduler state:", error);
+  }
+};
+var loadSchedulerStateData = async (directory) => {
+  try {
+    const stateFile = createStateFilePath(directory);
+    const data = await fs2.readFile(stateFile, "utf8");
+    return JSON.parse(data);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      logger.info(`${chalk7.blue("No previous scheduler state found - starting fresh")}`);
+    } else {
+      logger.error("Failed to load scheduler state:", error);
+    }
+    return null;
+  }
+};
+var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
+  const now = /* @__PURE__ */ new Date();
+  if (!savedNextRun) {
+    return calculateNextRunFromLastRun(job, job.lastRun, config);
+  }
+  if (savedNextRun <= now) {
+    logger.info(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.green(job.name)} - recalculating`);
+    return calculateNextRunFromLastRun(job, job.lastRun, config);
+  }
+  const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
+  const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
+  if (isRapidRestart) {
+    logger.info(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.green(job.name)} - preserving saved timing`);
+    return savedNextRun;
+  }
+  if (job.cronExpression || job.intervalMs) {
+    const expectedNextRun = calculateNextRunFromLastRun(job, job.lastRun, config);
+    const timeDiff = Math.abs(savedNextRun.getTime() - expectedNextRun.getTime());
+    if (timeDiff > config.restartBehavior.maxTimingDrift) {
+      logger.info(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+      return expectedNextRun;
+    }
+  }
+  return savedNextRun;
+};
+var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) => {
+  const definitionChanged = hasJobDefinitionChanged(scheduler.job, savedJob);
+  const updatedJob = {
+    ...scheduler.job,
+    runCount: savedJob.runCount,
+    lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
+  };
+  if (definitionChanged) {
+    logger.info(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.green(savedJob.name)} - recalculating schedule`);
+    updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
+  } else {
+    const savedNextRun = savedJob.nextRun ? new Date(savedJob.nextRun) : void 0;
+    updatedJob.nextRun = validateAndAdjustNextRun(updatedJob, savedNextRun, lastRestartTime, config);
+  }
+  if (config.cron.logCronDetails && updatedJob.cronExpression) {
+    const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
+      timezone: updatedJob.timezone
+    });
+    logger.info(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
+  }
+  return { ...scheduler, job: updatedJob };
+};
+var restoreExecutionHistory = (savedExecutions) => {
+  return savedExecutions.map((exec) => ({
+    ...exec,
+    startTime: new Date(exec.startTime),
+    endTime: exec.endTime ? new Date(exec.endTime) : void 0
+  }));
+};
+var loadSchedulerState = async (schedulers, config, lastRestartTime) => {
+  const stateData = await loadSchedulerStateData(config.persistence.directory);
+  if (!stateData) {
+    return { schedulers, executionHistory: [] };
+  }
+  const restoredSchedulers = { ...schedulers };
+  for (const savedJob of stateData.jobs) {
+    const existingScheduler = Object.values(schedulers).find((s) => s.job.name === savedJob.name);
+    if (existingScheduler) {
+      const restoredScheduler = restoreJobFromSavedData(
+        existingScheduler,
+        savedJob,
+        config,
+        lastRestartTime
+      );
+      restoredSchedulers[restoredScheduler.job.id] = restoredScheduler;
+    }
+  }
+  const executionHistory = stateData.executions ? restoreExecutionHistory(stateData.executions) : [];
+  logger.debug(`${logSymbols5.success} ${chalk7.green("Enhanced scheduler state loaded")} (saved at ${stateData.savedAt})`);
+  return { schedulers: restoredSchedulers, executionHistory };
+};
+
+// src/schedule-plugin/cleanup.ts
+import chalk8 from "chalk";
+import logSymbols6 from "log-symbols";
+var cleanupExecutionHistory = (state) => {
+  if (state.executionHistory.length > state.config.cleanup.maxExecutionHistory) {
+    const removed = state.executionHistory.splice(
+      0,
+      state.executionHistory.length - state.config.cleanup.maxExecutionHistory
+    );
+    logger.info(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    return removed;
+  }
+  return [];
+};
+var startCleanupInterval = (state) => {
+  return setInterval(() => {
+    cleanupExecutionHistory(state);
+  }, state.config.cleanup.cleanupInterval);
+};
+
+// src/schedule-plugin/core.ts
+var DEFAULT_CONFIG2 = {
+  persistence: {
+    enabled: true,
+    directory: "./.develop/scheduler-data",
+    saveInterval: 3e4
+    // 30 seconds
+  },
+  execution: {
+    maxConcurrent: 5,
+    defaultTimeout: 3e5,
+    // 5 minutes
+    retryOnError: false,
+    maxRetries: 3
+  },
+  cleanup: {
+    maxExecutionHistory: 1e3,
+    cleanupInterval: 6e5
+    // 10 minutes
+  },
+  restartBehavior: {
+    preserveNaturalTiming: true,
+    skipMissedRuns: true,
+    maxTimingDrift: 6e4,
+    // 1 minute
+    rapidRestartThreshold: 1e4
+    // 10 seconds
+  },
+  cron: {
+    defaultTimezone: void 0,
+    // Use system timezone
+    logCronDetails: true
+  }
+};
+var mergeConfig2 = (defaultConfig, userConfig) => ({
+  ...defaultConfig,
+  ...userConfig,
+  persistence: { ...defaultConfig.persistence, ...userConfig?.persistence },
+  execution: { ...defaultConfig.execution, ...userConfig?.execution },
+  cleanup: { ...defaultConfig.cleanup, ...userConfig?.cleanup },
+  restartBehavior: { ...defaultConfig.restartBehavior, ...userConfig?.restartBehavior },
+  cron: { ...defaultConfig.cron, ...userConfig?.cron }
+});
+var createInitialState = (config) => {
+  return {
+    schedulers: {},
+    executions: {},
+    executionHistory: [],
+    isShuttingDown: false,
+    runningExecutions: 0,
+    lastRestartTime: /* @__PURE__ */ new Date(),
+    config
+  };
+};
+var createSchedulerFunctions = (state) => {
+  const executeJob = async (scheduler) => {
+    const { canExecute, reason } = canExecuteJob(scheduler, state);
+    if (!canExecute) {
+      if (reason === "Maximum concurrent executions reached") {
+        logger.warn(`${chalk9.yellow("\u26A0\uFE0F  Delaying job")} ${chalk9.green(scheduler.job.name)} - ${reason}`);
+        scheduler.job.nextRun = new Date(Date.now() + 3e4);
+        scheduleJobFn(scheduler);
+      } else if (reason === "Job reached maximum runs") {
+        logger.info(`${chalk9.yellow("\u23F9\uFE0F  Job")} ${chalk9.green(scheduler.job.name)} reached max runs (${scheduler.job.maxRuns})`);
+      }
+      return;
+    }
+    const execution = createJobExecution(scheduler.job.id);
+    state.executions[execution.id] = execution;
+    state.executionHistory.push(execution);
+    scheduler.isRunning = true;
+    state.runningExecutions++;
+    logger.info(`${chalk9.blue("\u{1F680} Executing job")} ${chalk9.green(scheduler.job.name)} (${execution.id})`);
+    try {
+      const result = await executeJobWithTimeout(
+        scheduler.handler,
+        scheduler.job,
+        execution,
+        state.config.execution.defaultTimeout
+      );
+      const completedExecution = handleExecutionSuccess(execution, result);
+      state.executions[execution.id] = completedExecution;
+      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
+    } catch (error) {
+      const failedExecution = handleExecutionError(execution, error);
+      state.executions[execution.id] = failedExecution;
+    } finally {
+      scheduler.isRunning = false;
+      state.runningExecutions--;
+      if (scheduler.job.enabled && !state.isShuttingDown) {
+        scheduleJobFn(scheduler);
+      }
+      if (state.config.persistence.enabled) {
+        await saveSchedulerState(state);
+      }
+    }
+  };
+  const scheduleJobFn = (scheduler) => {
+    const updatedScheduler = scheduleJob(scheduler, state, executeJob);
+    state.schedulers[scheduler.job.id] = updatedScheduler;
+    return updatedScheduler;
+  };
+  return { executeJob, scheduleJobFn };
+};
+var initializeScheduler = async (state, scheduleJobFn) => {
+  try {
+    if (state.config.persistence.enabled) {
+      await fs3.mkdir(state.config.persistence.directory, { recursive: true });
+      const { schedulers, executionHistory } = await loadSchedulerState(
+        state.schedulers,
+        state.config,
+        state.lastRestartTime
+      );
+      state.schedulers = schedulers;
+      state.executionHistory = executionHistory;
+      if (state.config.persistence.saveInterval > 0) {
+        setInterval(() => saveSchedulerState(state), state.config.persistence.saveInterval);
+      }
+    }
+    state.cleanupInterval = startCleanupInterval(state);
+    for (const scheduler of Object.values(state.schedulers)) {
+      if (scheduler.job.enabled) {
+        scheduleJobFn(scheduler);
+      }
+    }
+    logger.debug(`${logSymbols7.success} ${chalk9.green("Scheduler initialized:")} ${Object.keys(state.schedulers).length} jobs loaded`);
+  } catch (error) {
+    logger.error(`${logSymbols7.error} ${chalk9.red("Failed to initialize scheduler:")} ${error.message}`);
+    throw error;
+  }
+};
+
+// src/schedule-plugin/jobs.ts
+import chalk10 from "chalk";
+import logSymbols8 from "log-symbols";
+var validateJobDefinition = (jobDef) => {
+  const expressionType = detectExpressionType(jobDef.cronExpression);
+  if (expressionType === "unknown") {
+    logger.error(`${logSymbols8.error} ${chalk10.red("Invalid cron expression for job:")} ${jobDef.name}`);
+    throw new Error(`Invalid cron expression for job: ${jobDef.name}`);
+  }
+};
+var createJobFromDefinition = (jobDef, config) => {
+  validateJobDefinition(jobDef);
+  const expressionType = detectExpressionType(jobDef.cronExpression);
+  if (config.cron.logCronDetails && jobDef.cronExpression) {
+    const cronExpression = expressionType === "rate" ? convertRateToCron(jobDef.cronExpression).cronExpression : jobDef.cronExpression;
+    const result = parseCronExpression(cronExpression, void 0, {
+      timezone: jobDef.timezone ?? config.cron.defaultTimezone
+    });
+    logger.info(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.cyan(result.nextRun.toLocaleString())}`);
+    const upcoming = getNextExecutions(cronExpression, 3, {
+      timezone: jobDef.timezone ?? config.cron.defaultTimezone
+    });
+    logger.info(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+  }
+  const job = {
+    id: generateJobId(),
+    name: jobDef.name,
+    cronExpression: expressionType === "rate" ? convertRateToCron(jobDef.cronExpression).cronExpression : jobDef.cronExpression,
+    intervalMs: jobDef.intervalMs,
+    delayMs: jobDef.delayMs,
+    nextRun: /* @__PURE__ */ new Date(),
+    enabled: jobDef.enabled ?? true,
+    runCount: 0,
+    maxRuns: jobDef.maxRuns,
+    metadata: jobDef.metadata,
+    createdAt: /* @__PURE__ */ new Date(),
+    timezone: jobDef.timezone,
+    module: jobDef.module
+  };
+  job.nextRun = calculateNextRun(job);
+  return job;
+};
+var createSchedulerService = (job, handler) => ({
+  job,
+  handler,
+  isRunning: false
+});
+var enableJob = (scheduler) => ({
+  ...scheduler,
+  job: {
+    ...scheduler.job,
+    enabled: true,
+    nextRun: calculateNextRun(scheduler.job)
+  }
+});
+var disableJob = (scheduler) => {
+  if (scheduler.timerId) {
+    clearTimeout(scheduler.timerId);
+  }
+  return {
+    ...scheduler,
+    job: { ...scheduler.job, enabled: false },
+    timerId: void 0
+  };
+};
+
+// src/schedule-plugin/routes.ts
+var createDashboardData = (state) => {
+  const jobs = Object.values(state.schedulers).map((s) => {
+    const nextExecutions = s.job.cronExpression ? getNextExecutions(s.job.cronExpression, 3, { timezone: s.job.timezone }) : [];
+    return {
+      ...s.job,
+      isRunning: s.isRunning,
+      timeUntilNextRun: getTimeUntilNextRun(s.job),
+      upcomingExecutions: nextExecutions,
+      cronDescription: s.job.cronExpression ? parseCronExpression(s.job.cronExpression, void 0, { timezone: s.job.timezone }).description : void 0
+    };
+  });
+  return { jobs, runningExecutions: state.runningExecutions };
+};
+var createExecutionsData = (state) => ({
+  executions: state.executionHistory.slice(-50),
+  // Last 50 executions
+  running: Object.values(state.executions).filter((e) => e.status === "running")
+});
+var registerDashboardRoute = (app, state) => {
+  app.get("/dashboard", async function(_, reply) {
+    const dashboardData = createDashboardData(state);
+    return reply.status(200).send(dashboardData);
+  });
+};
+var registerExecutionsRoute = (app, state) => {
+  app.get("/executions", async function(_, reply) {
+    const executionsData = createExecutionsData(state);
+    return reply.status(200).send(executionsData);
+  });
+};
+var registerTriggerJobRoute = (app, state, executeJobFn) => {
+  app.post("/jobs/:jobId/trigger", async function(request, reply) {
+    const scheduler = state.schedulers[request.params.jobId];
+    if (!scheduler) {
+      return reply.status(404).send({ error: "Job not found" });
+    }
+    if (scheduler.isRunning) {
+      return reply.status(409).send({ error: "Job is already running" });
+    }
+    setImmediate(() => executeJobFn(scheduler));
+    return reply.status(200).send({ message: "Job triggered successfully" });
+  });
+};
+var registerEnableJobRoute = (app, state, scheduleJobFn) => {
+  app.put("/jobs/:jobId/enable", async function(request, reply) {
+    const scheduler = state.schedulers[request.params.jobId];
+    if (!scheduler) {
+      return reply.status(404).send({ error: "Job not found" });
+    }
+    const enabledScheduler = enableJob(scheduler);
+    state.schedulers[request.params.jobId] = enabledScheduler;
+    scheduleJobFn(enabledScheduler);
+    return reply.status(200).send({ message: "Job enabled successfully" });
+  });
+};
+var registerDisableJobRoute = (app, state) => {
+  app.put("/jobs/:jobId/disable", async function(request, reply) {
+    const scheduler = state.schedulers[request.params.jobId];
+    if (!scheduler) {
+      return reply.status(404).send({ error: "Job not found" });
+    }
+    const disabledScheduler = disableJob(scheduler);
+    state.schedulers[request.params.jobId] = disabledScheduler;
+    return reply.status(200).send({ message: "Job disabled successfully" });
+  });
+};
+var registerAllRoutes = (app, state, executeJobFn, scheduleJobFn) => {
+  registerDashboardRoute(app, state);
+  registerExecutionsRoute(app, state);
+  registerTriggerJobRoute(app, state, executeJobFn);
+  registerEnableJobRoute(app, state, scheduleJobFn);
+  registerDisableJobRoute(app, state);
+};
+
+// src/schedule-plugin/decorator.ts
+import chalk11 from "chalk";
+import logSymbols9 from "log-symbols";
+var isValidJobName = (jobName) => {
+  return typeof jobName === "string" && jobName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(jobName);
+};
+var createSchedulerManager = ({
+  state,
+  scheduleJobFn,
+  executeJob,
+  config
+}) => {
+  const validateJobName = (jobName) => {
+    if (!jobName || typeof jobName !== "string") {
+      throw new Error("Job name must be a non-empty string");
+    }
+    if (!isValidJobName(jobName)) {
+      throw new Error("Job name must contain only alphanumeric characters, hyphens, and underscores");
+    }
+  };
+  const validateHandler = (handler) => {
+    if (typeof handler !== "function") {
+      throw new Error("Handler must be a function");
+    }
+  };
+  const addJob = async (jobDefinition) => {
+    try {
+      validateJobName(jobDefinition.name);
+      validateHandler(jobDefinition.handler);
+      validateJobDefinition(jobDefinition);
+      const existingJob = Object.values(state.schedulers).find((s) => s.job.name === jobDefinition.name);
+      if (existingJob) {
+        logger.warn(`${logSymbols9.warning} ${chalk11.yellow("Job already exists:")} ${chalk11.magenta(jobDefinition.name)}.`);
+        return existingJob.job.id;
+      }
+      const job = createJobFromDefinition(jobDefinition, config);
+      const scheduler = createSchedulerService(job, jobDefinition.handler);
+      state.schedulers[job.id] = scheduler;
+      if (job.enabled) {
+        scheduleJobFn(scheduler);
+      }
+      logger.info(`${logSymbols9.success} ${chalk11.green("Job added:")} ${chalk11.magenta(jobDefinition.name)} (${job.id})`);
+      return job.id;
+    } catch (error) {
+      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to add job")} ${chalk11.magenta(jobDefinition.name)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const removeJob = async (jobName) => {
+    try {
+      validateJobName(jobName);
+      const scheduler = Object.values(state.schedulers).find((s) => s.job.name === jobName);
+      if (!scheduler) {
+        throw new Error(`Job '${jobName}' does not exist`);
+      }
+      if (scheduler.isRunning) {
+        logger.warn(`${logSymbols9.warning} ${chalk11.yellow("Removing job that is currently running:")} ${chalk11.magenta(jobName)}`);
+      }
+      if (scheduler.timerId) {
+        clearTimeout(scheduler.timerId);
+      }
+      delete state.schedulers[scheduler.job.id];
+      logger.info(`${logSymbols9.success} ${chalk11.green("Job removed:")} ${chalk11.magenta(jobName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to remove job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const hasJob = (jobName) => {
+    try {
+      validateJobName(jobName);
+      return Object.values(state.schedulers).some((s) => s.job.name === jobName);
+    } catch {
+      return false;
+    }
+  };
+  const listJobs = (module) => {
+    return Object.values(state.schedulers).filter((s) => !module || s.job.module === module).map((s) => s.job.name).sort();
+  };
+  const getJobStats = (jobName) => {
+    try {
+      validateJobName(jobName);
+      const scheduler = Object.values(state.schedulers).find((s) => s.job.name === jobName);
+      return scheduler || null;
+    } catch {
+      return null;
+    }
+  };
+  const enableJob2 = async (jobName) => {
+    try {
+      validateJobName(jobName);
+      const scheduler = Object.values(state.schedulers).find((s) => s.job.name === jobName);
+      if (!scheduler) {
+        throw new Error(`Job '${jobName}' does not exist`);
+      }
+      if (scheduler.job.enabled) {
+        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
+        return;
+      }
+      scheduler.job.enabled = true;
+      scheduleJobFn(scheduler);
+      logger.info(`${logSymbols9.success} ${chalk11.green("Job enabled:")} ${chalk11.magenta(jobName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to enable job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const disableJob2 = async (jobName) => {
+    try {
+      validateJobName(jobName);
+      const scheduler = Object.values(state.schedulers).find((s) => s.job.name === jobName);
+      if (!scheduler) {
+        throw new Error(`Job '${jobName}' does not exist`);
+      }
+      if (!scheduler.job.enabled) {
+        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
+        return;
+      }
+      scheduler.job.enabled = false;
+      if (scheduler.timerId) {
+        clearTimeout(scheduler.timerId);
+        scheduler.timerId = void 0;
+      }
+      logger.info(`${logSymbols9.success} ${chalk11.green("Job disabled:")} ${chalk11.magenta(jobName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to disable job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const triggerJob = async (jobName) => {
+    try {
+      validateJobName(jobName);
+      const scheduler = Object.values(state.schedulers).find((s) => s.job.name === jobName);
+      if (!scheduler) {
+        throw new Error(`Job '${jobName}' does not exist`);
+      }
+      if (scheduler.isRunning) {
+        throw new Error(`Job '${jobName}' is already running`);
+      }
+      setImmediate(() => executeJob(scheduler));
+      logger.info(`${logSymbols9.success} ${chalk11.green("Job triggered:")} ${chalk11.magenta(jobName)}`);
+    } catch (error) {
+      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to trigger job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      throw error;
+    }
+  };
+  const getJobsMap = () => {
+    return { ...state.schedulers };
+  };
+  return {
+    addJob,
+    removeJob,
+    hasJob,
+    listJobs,
+    getJobStats,
+    enableJob: enableJob2,
+    disableJob: disableJob2,
+    triggerJob,
+    getJobsMap
+  };
+};
+var createSchedulerDecorator = (schedulerManager) => (app) => {
+  app.decorate("scheduler", schedulerManager);
+};
+
+// src/schedule-plugin/plugin.ts
+var schedulerPlugin = fsPlugin2(async (app, options) => {
+  const config = mergeConfig2(DEFAULT_CONFIG2, options.config);
+  const state = createInitialState(config);
+  const { executeJob, scheduleJobFn } = createSchedulerFunctions(state);
+  await initializeScheduler(state, scheduleJobFn);
+  const schedulerManager = createSchedulerManager({
+    state,
+    config,
+    scheduleJobFn,
+    executeJob
+  });
+  const decorateScheduler = createSchedulerDecorator(schedulerManager);
+  decorateScheduler(app);
+  registerAllRoutes(app, state, executeJob, scheduleJobFn);
+});
+
+// src/dev-console-plugin/route-registry.ts
+var RouteRegistry = class {
+  routes = [];
+  register(routeOptions) {
+    const routeInfo = {
+      method: routeOptions.method,
+      url: routeOptions.url,
+      handler: routeOptions.handler?.name || "anonymous",
+      registeredAt: /* @__PURE__ */ new Date(),
+      module: routeOptions.module
+    };
+    this.routes.push(routeInfo);
+  }
+  getAll() {
+    return [...this.routes];
+  }
+  getByMethod(method) {
+    return this.routes.filter((route) => {
+      if (Array.isArray(route.method)) {
+        return route.method.includes(method.toUpperCase());
+      }
+      return route.method.toUpperCase() === method.toUpperCase();
+    });
+  }
+  clear() {
+    this.routes = [];
+  }
+  count() {
+    return this.routes.length;
+  }
+};
+var routeRegistry = new RouteRegistry();
+
+// src/dev-console-plugin/plugin.ts
+var LogStore = class {
+  logs = [];
+  maxLogs = 1e3;
+  listeners = [];
+  addLog(entry) {
+    this.logs.unshift(entry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(0, this.maxLogs);
+    }
+    this.listeners.forEach((listener) => listener(entry));
+  }
+  getLogs(limit = 100) {
+    return this.logs.slice(0, limit);
+  }
+  getLogsByLevel(level, limit = 100) {
+    return this.logs.filter((log) => log.level === level).slice(0, limit);
+  }
+  getLogsByModule(module, limit = 100) {
+    return this.logs.filter((log) => log.module === module).slice(0, limit);
+  }
+  getLogsByTrigger(triggerType, triggerName, limit = 100) {
+    return this.logs.filter(
+      (log) => log.triggerType === triggerType && log.trigger === triggerName
+    ).slice(0, limit);
+  }
+  clear() {
+    this.logs = [];
+  }
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener);
+    };
+  }
+};
+var logStore = new LogStore();
+var originalConsole = {
+  log: console.log,
+  error: console.error,
+  warn: console.warn,
+  info: console.info,
+  debug: console.debug
+};
+var captureConsoleLog = (level, originalMethod) => {
+  return (...args) => {
+    originalMethod.apply(console, args);
+    const message = args.join(" ");
+    let source = "unknown";
+    let module;
+    let trigger;
+    let triggerType;
+    if (message.includes("Queue") || message.includes("queue")) {
+      source = "queue";
+      triggerType = "queue";
+      const queueMatch = message.match(/queue[:\s]+([a-zA-Z0-9_-]+)/i);
+      if (queueMatch) trigger = queueMatch[1];
+    } else if (message.includes("Schedule") || message.includes("job")) {
+      source = "schedule";
+      triggerType = "schedule";
+      const jobMatch = message.match(/(?:job|schedule)[:\s]+([a-zA-Z0-9_-]+)/i);
+      if (jobMatch) trigger = jobMatch[1];
+    } else if (message.includes("HTTP") || message.includes("api") || message.includes("/api/")) {
+      source = "http";
+      triggerType = "http";
+      const routeMatch = message.match(/\/api\/[^\s]+/);
+      if (routeMatch) trigger = routeMatch[0];
+    }
+    const moduleMatch = message.match(/module[:\s]+([a-zA-Z0-9_-]+)/i) || message.match(/\[([a-zA-Z0-9_-]+)\]/) || message.match(/in\s+([a-zA-Z0-9_-]+)\s+module/i);
+    if (moduleMatch) module = moduleMatch[1];
+    logStore.addLog({
+      id: Date.now().toString() + Math.random().toString(36).substr(2, 9),
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      message: message.replace(/\x1b\[[0-9;]*m/g, ""),
+      // Remove ANSI colors
+      source,
+      module,
+      trigger,
+      triggerType
+    });
+  };
+};
+console.error = captureConsoleLog("error", originalConsole.error);
+console.warn = captureConsoleLog("warn", originalConsole.warn);
+console.info = captureConsoleLog("info", originalConsole.info);
+console.log = captureConsoleLog("info", originalConsole.log);
+console.debug = captureConsoleLog("debug", originalConsole.debug);
+async function devConsolePluginFunction(fastify, options = {}) {
+  const { prefix = "console", enableUI = true } = options;
+  fastify.addHook("onRoute", (routeOptions) => {
+    if (routeOptions.prefix === "/api") {
+      routeRegistry.register(routeOptions);
+    }
+  });
+  fastify.get(`/${prefix}/routes`, async () => {
+    return { routes: routeRegistry.getAll() };
+  });
+  fastify.get(`/${prefix}/routes/:method`, async (request) => {
+    const { method } = request.params;
+    return { routes: routeRegistry.getByMethod(method) };
+  });
+  fastify.get(`/${prefix}/registry/stats`, async () => {
+    return {
+      totalRoutes: routeRegistry.count(),
+      registeredAt: /* @__PURE__ */ new Date()
+    };
+  });
+  fastify.get(`/${prefix}/modules`, async (_, reply) => {
+    const queueManager = fastify.queues;
+    const schedulerManager = fastify.scheduler;
+    if (!queueManager || !schedulerManager) {
+      return reply.status(503).send({ error: "Services not available" });
+    }
+    const allRoutes = routeRegistry.getAll();
+    const httpRoutes = allRoutes;
+    const moduleSet = /* @__PURE__ */ new Set();
+    httpRoutes.forEach((route) => {
+      if (route.module) moduleSet.add(route.module);
+    });
+    const allQueueNames = queueManager.listQueues();
+    const allJobNames = schedulerManager.listJobs();
+    allQueueNames.forEach((queueName) => {
+      const queueStats = queueManager.getQueueStats(queueName);
+      if (queueStats?.module) moduleSet.add(queueStats.module);
+    });
+    allJobNames.forEach((jobName) => {
+      const jobStats = schedulerManager.getJobStats(jobName);
+      if (jobStats?.job.module) moduleSet.add(jobStats.job.module);
+    });
+    const modules = Array.from(moduleSet).map((moduleName) => {
+      const moduleRoutes = httpRoutes.filter((route) => route.module === moduleName);
+      const moduleQueueNames = queueManager.listQueues(moduleName);
+      const moduleQueues = moduleQueueNames.map((name) => {
+        const stats = queueManager.getQueueStats(name);
+        return {
+          name,
+          stats: stats ? {
+            incoming: stats.incoming.length,
+            processing: stats.processing.length,
+            dlq: stats.dlq.length
+          } : null
+        };
+      });
+      const moduleJobNames = schedulerManager.listJobs(moduleName);
+      const moduleSchedules = moduleJobNames.map((name) => {
+        const jobStats = schedulerManager.getJobStats(name);
+        return {
+          name,
+          enabled: jobStats?.job.enabled || false,
+          isRunning: jobStats?.isRunning || false,
+          cronExpression: jobStats?.job.cronExpression,
+          timezone: jobStats?.job.timezone
+        };
+      });
+      return {
+        name: moduleName,
+        routes: moduleRoutes,
+        queues: moduleQueues,
+        schedules: moduleSchedules
+      };
+    });
+    return { modules };
+  });
+  fastify.get(`/${prefix}/queues`, async (_, reply) => {
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    const queueNames = queueManager.listQueues();
+    const queues = queueNames.map((name) => {
+      const stats = queueManager.getQueueStats(name);
+      return {
+        name,
+        stats: stats ? {
+          incoming: stats.incoming.length,
+          processing: stats.processing.length,
+          dlq: stats.dlq.length
+        } : null
+      };
+    });
+    return { queues };
+  });
+  fastify.get(`/${prefix}/queues/:queueName`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    const queueStats = queueManager.getQueueStats(queueName);
+    if (!queueStats) {
+      return reply.status(404).send({ error: "Queue not found" });
+    }
+    const config = queueManager.getConfig();
+    return {
+      name: queueName,
+      stats: {
+        incoming: queueStats.incoming.length,
+        processing: queueStats.processing.length,
+        dlq: queueStats.dlq.length,
+        configuration: config
+      },
+      messages: {
+        incoming: queueStats.incoming,
+        processing: queueStats.processing,
+        dlq: queueStats.dlq
+      }
+    };
+  });
+  fastify.get(`/${prefix}/queues/:queueName/process-dlq`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    try {
+      const result = await queueManager.processDlq(queueName);
+      return reply.status(200).send(result);
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to process DLQ",
+        error
+      });
+    }
+  });
+  fastify.get(`/${prefix}/queues/:queueName/purge-dlq`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    try {
+      const result = await queueManager.purgeDlq(queueName);
+      return reply.status(200).send(result);
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to purge DLQ",
+        error
+      });
+    }
+  });
+  fastify.post(`/${prefix}/queues/:queueName/enqueue`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    try {
+      const result = await queueManager.enqueueMessage(queueName, request.body, request.headers);
+      return reply.status(200).send(result);
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to enqueue message",
+        error
+      });
+    }
+  });
+  fastify.delete(`/${prefix}/queues/:queueName`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    try {
+      await queueManager.removeQueue(queueName);
+      return reply.status(200).send({
+        status: "success",
+        message: `Queue ${queueName} removed successfully`
+      });
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to remove queue",
+        error
+      });
+    }
+  });
+  fastify.post(`/${prefix}/queues`, async (request, reply) => {
+    const { queueName, module } = request.body;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    if (!queueName) {
+      return reply.status(400).send({ error: "Queue name is required" });
+    }
+    try {
+      const handler = async (message) => {
+        console.log(`Processing message in ${queueName}:`, message);
+      };
+      await queueManager.addQueue(queueName, handler, module);
+      return reply.status(201).send({
+        status: "success",
+        message: `Queue ${queueName} created successfully`,
+        queueName
+      });
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to create queue",
+        error
+      });
+    }
+  });
+  fastify.get(`/${prefix}/schedules`, async (_, reply) => {
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    const jobNames = schedulerManager.listJobs();
+    const jobs = jobNames.map((name) => {
+      const jobStats = schedulerManager.getJobStats(name);
+      return {
+        name,
+        enabled: jobStats?.job.enabled || false,
+        isRunning: jobStats?.isRunning || false,
+        cronExpression: jobStats?.job.cronExpression,
+        timezone: jobStats?.job.timezone
+      };
+    });
+    return { schedules: jobs };
+  });
+  fastify.get(`/${prefix}/schedules/:jobName`, async (request, reply) => {
+    const { jobName } = request.params;
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    const jobStats = schedulerManager.getJobStats(jobName);
+    if (!jobStats) {
+      return reply.status(404).send({ error: "Job not found" });
+    }
+    return {
+      name: jobName,
+      job: jobStats.job,
+      isRunning: jobStats.isRunning,
+      timerId: jobStats.timerId ? "scheduled" : "not_scheduled"
+    };
+  });
+  fastify.post(`/${prefix}/schedules/:jobName/trigger`, async (request, reply) => {
+    const { jobName } = request.params;
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    try {
+      await schedulerManager.triggerJob(jobName);
+      return reply.status(200).send({
+        status: "success",
+        message: `Schedule ${jobName} triggered successfully`
+      });
+    } catch {
+      return reply.status(500).send({ error: "Failed to trigger schedule" });
+    }
+  });
+  fastify.put(`/${prefix}/schedules/:jobName/enable`, async (request, reply) => {
+    const { jobName } = request.params;
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    try {
+      await schedulerManager.enableJob(jobName);
+      return reply.status(200).send({
+        status: "success",
+        message: `Schedule ${jobName} enabled successfully`
+      });
+    } catch {
+      return reply.status(500).send({ error: "Failed to enable schedule" });
+    }
+  });
+  fastify.put(`/${prefix}/schedules/:jobName/disable`, async (request, reply) => {
+    const { jobName } = request.params;
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    try {
+      await schedulerManager.disableJob(jobName);
+      return reply.status(200).send({
+        status: "success",
+        message: `Schedule ${jobName} disabled successfully`
+      });
+    } catch {
+      return reply.status(500).send({ error: "Failed to disable schedule" });
+    }
+  });
+  fastify.get(`/${prefix}/logs`, async (request) => {
+    const {
+      limit = 100,
+      level,
+      source,
+      module,
+      trigger,
+      triggerType
+    } = request.query;
+    let logs = logStore.getLogs(Number(limit));
+    if (level) {
+      logs = logs.filter((log) => log.level === level);
+    }
+    if (source) {
+      logs = logs.filter((log) => log.source === source);
+    }
+    if (module) {
+      logs = logs.filter(
+        (log) => log.module === module || log.message.toLowerCase().includes(module.toLowerCase())
+      );
+    }
+    if (trigger && triggerType) {
+      logs = logs.filter(
+        (log) => log.trigger === trigger && log.triggerType === triggerType || log.message.toLowerCase().includes(trigger.toLowerCase())
+      );
+    }
+    return { logs };
+  });
+  fastify.delete(`/${prefix}/logs`, async () => {
+    logStore.clear();
+    return { status: "success", message: "Logs cleared" };
+  });
+  fastify.get(`/${prefix}/logs/stream`, async (request, reply) => {
+    reply.type("text/event-stream");
+    reply.header("Cache-Control", "no-cache");
+    reply.header("Connection", "keep-alive");
+    reply.header("Access-Control-Allow-Origin", "*");
+    const initialLogs = logStore.getLogs(50);
+    reply.raw.write(`data: ${JSON.stringify({ type: "initial", logs: initialLogs })}
+
+`);
+    const unsubscribe = logStore.subscribe((log) => {
+      reply.raw.write(`data: ${JSON.stringify({ type: "log", log })}
+
+`);
+    });
+    request.raw.on("close", () => {
+      unsubscribe();
+    });
+  });
+  if (enableUI) {
+    const devConsolePath = path4.resolve(__dirname, "../../../packages/dev-console/dist");
+    await fastify.register(fastifyStatic, {
+      root: devConsolePath,
+      decorateReply: true
+    });
+    fastify.get(`/${prefix}`, async (_, reply) => {
+      return reply.sendFile("index.html");
+    });
+  }
+}
+var devConsolePlugin = fsPlugin3(devConsolePluginFunction, {
+  name: "dev-console-plugin"
+});
+export {
+  devConsolePlugin,
+  routeRegistry
+};
+/*! 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.mjs.map