@cloudnux/local-cloud-provider 0.18.0 → 0.19.0

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

@@ -1,1009 +1,3 @@
-// src/logging/pretty-writer.ts
-import chalk from "chalk";
-import { EOL as EOL2 } from "os";
-
-// ../../../node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// ../../../node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// ../../../node_modules/lodash-es/_Symbol.js
-var Symbol = root_default.Symbol;
-var Symbol_default = Symbol;
-
-// ../../../node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-var getRawTag_default = getRawTag;
-
-// ../../../node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
-}
-var objectToString_default = objectToString;
-
-// ../../../node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-}
-var baseGetTag_default = baseGetTag;
-
-// ../../../node_modules/lodash-es/isObjectLike.js
-function isObjectLike(value) {
-  return value != null && typeof value == "object";
-}
-var isObjectLike_default = isObjectLike;
-
-// ../../../node_modules/lodash-es/isSymbol.js
-var symbolTag = "[object Symbol]";
-function isSymbol(value) {
-  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
-}
-var isSymbol_default = isSymbol;
-
-// ../../../node_modules/lodash-es/_arrayMap.js
-function arrayMap(array2, iteratee) {
-  var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
-  while (++index < length) {
-    result[index] = iteratee(array2[index], index, array2);
-  }
-  return result;
-}
-var arrayMap_default = arrayMap;
-
-// ../../../node_modules/lodash-es/isArray.js
-var isArray = Array.isArray;
-var isArray_default = isArray;
-
-// ../../../node_modules/lodash-es/_baseToString.js
-var INFINITY = 1 / 0;
-var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
-var symbolToString = symbolProto ? symbolProto.toString : void 0;
-function baseToString(value) {
-  if (typeof value == "string") {
-    return value;
-  }
-  if (isArray_default(value)) {
-    return arrayMap_default(value, baseToString) + "";
-  }
-  if (isSymbol_default(value)) {
-    return symbolToString ? symbolToString.call(value) : "";
-  }
-  var result = value + "";
-  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
-}
-var baseToString_default = baseToString;
-
-// ../../../node_modules/lodash-es/_trimmedEndIndex.js
-var reWhitespace = /\s/;
-function trimmedEndIndex(string) {
-  var index = string.length;
-  while (index-- && reWhitespace.test(string.charAt(index))) {
-  }
-  return index;
-}
-var trimmedEndIndex_default = trimmedEndIndex;
-
-// ../../../node_modules/lodash-es/_baseTrim.js
-var reTrimStart = /^\s+/;
-function baseTrim(string) {
-  return string ? string.slice(0, trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
-}
-var baseTrim_default = baseTrim;
-
-// ../../../node_modules/lodash-es/isObject.js
-function isObject(value) {
-  var type = typeof value;
-  return value != null && (type == "object" || type == "function");
-}
-var isObject_default = isObject;
-
-// ../../../node_modules/lodash-es/isFunction.js
-var asyncTag = "[object AsyncFunction]";
-var funcTag = "[object Function]";
-var genTag = "[object GeneratorFunction]";
-var proxyTag = "[object Proxy]";
-function isFunction(value) {
-  if (!isObject_default(value)) {
-    return false;
-  }
-  var tag = baseGetTag_default(value);
-  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-}
-var isFunction_default = isFunction;
-
-// ../../../node_modules/lodash-es/_coreJsData.js
-var coreJsData = root_default["__core-js_shared__"];
-var coreJsData_default = coreJsData;
-
-// ../../../node_modules/lodash-es/_isMasked.js
-var maskSrcKey = function() {
-  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
-  return uid ? "Symbol(src)_1." + uid : "";
-}();
-function isMasked(func) {
-  return !!maskSrcKey && maskSrcKey in func;
-}
-var isMasked_default = isMasked;
-
-// ../../../node_modules/lodash-es/_toSource.js
-var funcProto = Function.prototype;
-var funcToString = funcProto.toString;
-function toSource(func) {
-  if (func != null) {
-    try {
-      return funcToString.call(func);
-    } catch (e) {
-    }
-    try {
-      return func + "";
-    } catch (e) {
-    }
-  }
-  return "";
-}
-var toSource_default = toSource;
-
-// ../../../node_modules/lodash-es/_baseIsNative.js
-var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
-var reIsHostCtor = /^\[object .+?Constructor\]$/;
-var funcProto2 = Function.prototype;
-var objectProto3 = Object.prototype;
-var funcToString2 = funcProto2.toString;
-var hasOwnProperty2 = objectProto3.hasOwnProperty;
-var reIsNative = RegExp(
-  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
-);
-function baseIsNative(value) {
-  if (!isObject_default(value) || isMasked_default(value)) {
-    return false;
-  }
-  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
-  return pattern.test(toSource_default(value));
-}
-var baseIsNative_default = baseIsNative;
-
-// ../../../node_modules/lodash-es/_getValue.js
-function getValue(object, key) {
-  return object == null ? void 0 : object[key];
-}
-var getValue_default = getValue;
-
-// ../../../node_modules/lodash-es/_getNative.js
-function getNative(object, key) {
-  var value = getValue_default(object, key);
-  return baseIsNative_default(value) ? value : void 0;
-}
-var getNative_default = getNative;
-
-// ../../../node_modules/lodash-es/_baseFindIndex.js
-function baseFindIndex(array2, predicate, fromIndex, fromRight) {
-  var length = array2.length, index = fromIndex + (fromRight ? 1 : -1);
-  while (fromRight ? index-- : ++index < length) {
-    if (predicate(array2[index], index, array2)) {
-      return index;
-    }
-  }
-  return -1;
-}
-var baseFindIndex_default = baseFindIndex;
-
-// ../../../node_modules/lodash-es/_baseIsNaN.js
-function baseIsNaN(value) {
-  return value !== value;
-}
-var baseIsNaN_default = baseIsNaN;
-
-// ../../../node_modules/lodash-es/_strictIndexOf.js
-function strictIndexOf(array2, value, fromIndex) {
-  var index = fromIndex - 1, length = array2.length;
-  while (++index < length) {
-    if (array2[index] === value) {
-      return index;
-    }
-  }
-  return -1;
-}
-var strictIndexOf_default = strictIndexOf;
-
-// ../../../node_modules/lodash-es/_baseIndexOf.js
-function baseIndexOf(array2, value, fromIndex) {
-  return value === value ? strictIndexOf_default(array2, value, fromIndex) : baseFindIndex_default(array2, baseIsNaN_default, fromIndex);
-}
-var baseIndexOf_default = baseIndexOf;
-
-// ../../../node_modules/lodash-es/_isIndex.js
-var MAX_SAFE_INTEGER = 9007199254740991;
-var reIsUint = /^(?:0|[1-9]\d*)$/;
-function isIndex(value, length) {
-  var type = typeof value;
-  length = length == null ? MAX_SAFE_INTEGER : length;
-  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
-}
-var isIndex_default = isIndex;
-
-// ../../../node_modules/lodash-es/eq.js
-function eq(value, other) {
-  return value === other || value !== value && other !== other;
-}
-var eq_default = eq;
-
-// ../../../node_modules/lodash-es/isLength.js
-var MAX_SAFE_INTEGER2 = 9007199254740991;
-function isLength(value) {
-  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
-}
-var isLength_default = isLength;
-
-// ../../../node_modules/lodash-es/_baseIsArguments.js
-var argsTag = "[object Arguments]";
-function baseIsArguments(value) {
-  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
-}
-var baseIsArguments_default = baseIsArguments;
-
-// ../../../node_modules/lodash-es/isArguments.js
-var objectProto4 = Object.prototype;
-var hasOwnProperty3 = objectProto4.hasOwnProperty;
-var propertyIsEnumerable = objectProto4.propertyIsEnumerable;
-var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
-  return arguments;
-}()) ? baseIsArguments_default : function(value) {
-  return isObjectLike_default(value) && hasOwnProperty3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
-};
-var isArguments_default = isArguments;
-
-// ../../../node_modules/lodash-es/_isKey.js
-var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
-var reIsPlainProp = /^\w*$/;
-function isKey(value, object) {
-  if (isArray_default(value)) {
-    return false;
-  }
-  var type = typeof value;
-  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
-    return true;
-  }
-  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
-}
-var isKey_default = isKey;
-
-// ../../../node_modules/lodash-es/_nativeCreate.js
-var nativeCreate = getNative_default(Object, "create");
-var nativeCreate_default = nativeCreate;
-
-// ../../../node_modules/lodash-es/_hashClear.js
-function hashClear() {
-  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
-  this.size = 0;
-}
-var hashClear_default = hashClear;
-
-// ../../../node_modules/lodash-es/_hashDelete.js
-function hashDelete(key) {
-  var result = this.has(key) && delete this.__data__[key];
-  this.size -= result ? 1 : 0;
-  return result;
-}
-var hashDelete_default = hashDelete;
-
-// ../../../node_modules/lodash-es/_hashGet.js
-var HASH_UNDEFINED = "__lodash_hash_undefined__";
-var objectProto5 = Object.prototype;
-var hasOwnProperty4 = objectProto5.hasOwnProperty;
-function hashGet(key) {
-  var data = this.__data__;
-  if (nativeCreate_default) {
-    var result = data[key];
-    return result === HASH_UNDEFINED ? void 0 : result;
-  }
-  return hasOwnProperty4.call(data, key) ? data[key] : void 0;
-}
-var hashGet_default = hashGet;
-
-// ../../../node_modules/lodash-es/_hashHas.js
-var objectProto6 = Object.prototype;
-var hasOwnProperty5 = objectProto6.hasOwnProperty;
-function hashHas(key) {
-  var data = this.__data__;
-  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty5.call(data, key);
-}
-var hashHas_default = hashHas;
-
-// ../../../node_modules/lodash-es/_hashSet.js
-var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
-function hashSet(key, value) {
-  var data = this.__data__;
-  this.size += this.has(key) ? 0 : 1;
-  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
-  return this;
-}
-var hashSet_default = hashSet;
-
-// ../../../node_modules/lodash-es/_Hash.js
-function Hash(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-Hash.prototype.clear = hashClear_default;
-Hash.prototype["delete"] = hashDelete_default;
-Hash.prototype.get = hashGet_default;
-Hash.prototype.has = hashHas_default;
-Hash.prototype.set = hashSet_default;
-var Hash_default = Hash;
-
-// ../../../node_modules/lodash-es/_listCacheClear.js
-function listCacheClear() {
-  this.__data__ = [];
-  this.size = 0;
-}
-var listCacheClear_default = listCacheClear;
-
-// ../../../node_modules/lodash-es/_assocIndexOf.js
-function assocIndexOf(array2, key) {
-  var length = array2.length;
-  while (length--) {
-    if (eq_default(array2[length][0], key)) {
-      return length;
-    }
-  }
-  return -1;
-}
-var assocIndexOf_default = assocIndexOf;
-
-// ../../../node_modules/lodash-es/_listCacheDelete.js
-var arrayProto = Array.prototype;
-var splice = arrayProto.splice;
-function listCacheDelete(key) {
-  var data = this.__data__, index = assocIndexOf_default(data, key);
-  if (index < 0) {
-    return false;
-  }
-  var lastIndex = data.length - 1;
-  if (index == lastIndex) {
-    data.pop();
-  } else {
-    splice.call(data, index, 1);
-  }
-  --this.size;
-  return true;
-}
-var listCacheDelete_default = listCacheDelete;
-
-// ../../../node_modules/lodash-es/_listCacheGet.js
-function listCacheGet(key) {
-  var data = this.__data__, index = assocIndexOf_default(data, key);
-  return index < 0 ? void 0 : data[index][1];
-}
-var listCacheGet_default = listCacheGet;
-
-// ../../../node_modules/lodash-es/_listCacheHas.js
-function listCacheHas(key) {
-  return assocIndexOf_default(this.__data__, key) > -1;
-}
-var listCacheHas_default = listCacheHas;
-
-// ../../../node_modules/lodash-es/_listCacheSet.js
-function listCacheSet(key, value) {
-  var data = this.__data__, index = assocIndexOf_default(data, key);
-  if (index < 0) {
-    ++this.size;
-    data.push([key, value]);
-  } else {
-    data[index][1] = value;
-  }
-  return this;
-}
-var listCacheSet_default = listCacheSet;
-
-// ../../../node_modules/lodash-es/_ListCache.js
-function ListCache(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-ListCache.prototype.clear = listCacheClear_default;
-ListCache.prototype["delete"] = listCacheDelete_default;
-ListCache.prototype.get = listCacheGet_default;
-ListCache.prototype.has = listCacheHas_default;
-ListCache.prototype.set = listCacheSet_default;
-var ListCache_default = ListCache;
-
-// ../../../node_modules/lodash-es/_Map.js
-var Map2 = getNative_default(root_default, "Map");
-var Map_default = Map2;
-
-// ../../../node_modules/lodash-es/_mapCacheClear.js
-function mapCacheClear() {
-  this.size = 0;
-  this.__data__ = {
-    "hash": new Hash_default(),
-    "map": new (Map_default || ListCache_default)(),
-    "string": new Hash_default()
-  };
-}
-var mapCacheClear_default = mapCacheClear;
-
-// ../../../node_modules/lodash-es/_isKeyable.js
-function isKeyable(value) {
-  var type = typeof value;
-  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
-}
-var isKeyable_default = isKeyable;
-
-// ../../../node_modules/lodash-es/_getMapData.js
-function getMapData(map, key) {
-  var data = map.__data__;
-  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
-}
-var getMapData_default = getMapData;
-
-// ../../../node_modules/lodash-es/_mapCacheDelete.js
-function mapCacheDelete(key) {
-  var result = getMapData_default(this, key)["delete"](key);
-  this.size -= result ? 1 : 0;
-  return result;
-}
-var mapCacheDelete_default = mapCacheDelete;
-
-// ../../../node_modules/lodash-es/_mapCacheGet.js
-function mapCacheGet(key) {
-  return getMapData_default(this, key).get(key);
-}
-var mapCacheGet_default = mapCacheGet;
-
-// ../../../node_modules/lodash-es/_mapCacheHas.js
-function mapCacheHas(key) {
-  return getMapData_default(this, key).has(key);
-}
-var mapCacheHas_default = mapCacheHas;
-
-// ../../../node_modules/lodash-es/_mapCacheSet.js
-function mapCacheSet(key, value) {
-  var data = getMapData_default(this, key), size = data.size;
-  data.set(key, value);
-  this.size += data.size == size ? 0 : 1;
-  return this;
-}
-var mapCacheSet_default = mapCacheSet;
-
-// ../../../node_modules/lodash-es/_MapCache.js
-function MapCache(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-MapCache.prototype.clear = mapCacheClear_default;
-MapCache.prototype["delete"] = mapCacheDelete_default;
-MapCache.prototype.get = mapCacheGet_default;
-MapCache.prototype.has = mapCacheHas_default;
-MapCache.prototype.set = mapCacheSet_default;
-var MapCache_default = MapCache;
-
-// ../../../node_modules/lodash-es/memoize.js
-var FUNC_ERROR_TEXT = "Expected a function";
-function memoize(func, resolver) {
-  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
-    throw new TypeError(FUNC_ERROR_TEXT);
-  }
-  var memoized = function() {
-    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-    if (cache.has(key)) {
-      return cache.get(key);
-    }
-    var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result) || cache;
-    return result;
-  };
-  memoized.cache = new (memoize.Cache || MapCache_default)();
-  return memoized;
-}
-memoize.Cache = MapCache_default;
-var memoize_default = memoize;
-
-// ../../../node_modules/lodash-es/_memoizeCapped.js
-var MAX_MEMOIZE_SIZE = 500;
-function memoizeCapped(func) {
-  var result = memoize_default(func, function(key) {
-    if (cache.size === MAX_MEMOIZE_SIZE) {
-      cache.clear();
-    }
-    return key;
-  });
-  var cache = result.cache;
-  return result;
-}
-var memoizeCapped_default = memoizeCapped;
-
-// ../../../node_modules/lodash-es/_stringToPath.js
-var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
-var reEscapeChar = /\\(\\)?/g;
-var stringToPath = memoizeCapped_default(function(string) {
-  var result = [];
-  if (string.charCodeAt(0) === 46) {
-    result.push("");
-  }
-  string.replace(rePropName, function(match, number, quote, subString) {
-    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
-  });
-  return result;
-});
-var stringToPath_default = stringToPath;
-
-// ../../../node_modules/lodash-es/toString.js
-function toString(value) {
-  return value == null ? "" : baseToString_default(value);
-}
-var toString_default = toString;
-
-// ../../../node_modules/lodash-es/_castPath.js
-function castPath(value, object) {
-  if (isArray_default(value)) {
-    return value;
-  }
-  return isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
-}
-var castPath_default = castPath;
-
-// ../../../node_modules/lodash-es/_toKey.js
-var INFINITY2 = 1 / 0;
-function toKey(value) {
-  if (typeof value == "string" || isSymbol_default(value)) {
-    return value;
-  }
-  var result = value + "";
-  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
-}
-var toKey_default = toKey;
-
-// ../../../node_modules/lodash-es/_baseSlice.js
-function baseSlice(array2, start, end) {
-  var index = -1, length = array2.length;
-  if (start < 0) {
-    start = -start > length ? 0 : length + start;
-  }
-  end = end > length ? length : end;
-  if (end < 0) {
-    end += length;
-  }
-  length = start > end ? 0 : end - start >>> 0;
-  start >>>= 0;
-  var result = Array(length);
-  while (++index < length) {
-    result[index] = array2[index + start];
-  }
-  return result;
-}
-var baseSlice_default = baseSlice;
-
-// ../../../node_modules/lodash-es/_castSlice.js
-function castSlice(array2, start, end) {
-  var length = array2.length;
-  end = end === void 0 ? length : end;
-  return !start && end >= length ? array2 : baseSlice_default(array2, start, end);
-}
-var castSlice_default = castSlice;
-
-// ../../../node_modules/lodash-es/_hasUnicode.js
-var rsAstralRange = "\\ud800-\\udfff";
-var rsComboMarksRange = "\\u0300-\\u036f";
-var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
-var rsComboSymbolsRange = "\\u20d0-\\u20ff";
-var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
-var rsVarRange = "\\ufe0e\\ufe0f";
-var rsZWJ = "\\u200d";
-var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
-function hasUnicode(string) {
-  return reHasUnicode.test(string);
-}
-var hasUnicode_default = hasUnicode;
-
-// ../../../node_modules/lodash-es/_asciiToArray.js
-function asciiToArray(string) {
-  return string.split("");
-}
-var asciiToArray_default = asciiToArray;
-
-// ../../../node_modules/lodash-es/_unicodeToArray.js
-var rsAstralRange2 = "\\ud800-\\udfff";
-var rsComboMarksRange2 = "\\u0300-\\u036f";
-var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
-var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
-var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
-var rsVarRange2 = "\\ufe0e\\ufe0f";
-var rsAstral = "[" + rsAstralRange2 + "]";
-var rsCombo = "[" + rsComboRange2 + "]";
-var rsFitz = "\\ud83c[\\udffb-\\udfff]";
-var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
-var rsNonAstral = "[^" + rsAstralRange2 + "]";
-var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
-var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
-var rsZWJ2 = "\\u200d";
-var reOptMod = rsModifier + "?";
-var rsOptVar = "[" + rsVarRange2 + "]?";
-var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
-var rsSeq = rsOptVar + reOptMod + rsOptJoin;
-var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
-var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
-function unicodeToArray(string) {
-  return string.match(reUnicode) || [];
-}
-var unicodeToArray_default = unicodeToArray;
-
-// ../../../node_modules/lodash-es/_stringToArray.js
-function stringToArray(string) {
-  return hasUnicode_default(string) ? unicodeToArray_default(string) : asciiToArray_default(string);
-}
-var stringToArray_default = stringToArray;
-
-// ../../../node_modules/lodash-es/_hasPath.js
-function hasPath(object, path4, hasFunc) {
-  path4 = castPath_default(path4, object);
-  var index = -1, length = path4.length, result = false;
-  while (++index < length) {
-    var key = toKey_default(path4[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, path4) {
-  return object != null && hasPath_default(object, path4, baseHas_default);
-}
-var has_default = has;
-
-// ../../../node_modules/lodash-es/_charsEndIndex.js
-function charsEndIndex(strSymbols, chrSymbols) {
-  var index = strSymbols.length;
-  while (index-- && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
-  }
-  return index;
-}
-var charsEndIndex_default = charsEndIndex;
-
-// ../../../node_modules/lodash-es/_charsStartIndex.js
-function charsStartIndex(strSymbols, chrSymbols) {
-  var index = -1, length = strSymbols.length;
-  while (++index < length && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
-  }
-  return index;
-}
-var charsStartIndex_default = charsStartIndex;
-
-// ../../../node_modules/lodash-es/trim.js
-function trim(string, chars, guard) {
-  string = toString_default(string);
-  if (string && (guard || chars === void 0)) {
-    return baseTrim_default(string);
-  }
-  if (!string || !(chars = baseToString_default(chars))) {
-    return string;
-  }
-  var strSymbols = stringToArray_default(string), chrSymbols = stringToArray_default(chars), start = charsStartIndex_default(strSymbols, chrSymbols), end = charsEndIndex_default(strSymbols, chrSymbols) + 1;
-  return castSlice_default(strSymbols, start, end).join("");
-}
-var trim_default = trim;
-
-// ../../utils/src/config/env.ts
-function _env(key, defaultValue) {
-  return has_default(process.env, key) ? process.env[key] ?? "" : defaultValue ?? "";
-}
-function int(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? 0;
-  }
-  const value = process.env[key] ?? "0";
-  return parseInt(value, 10);
-}
-function float(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? 0;
-  }
-  const value = process.env[key] ?? "0";
-  return parseFloat(value);
-}
-function bool(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? false;
-  }
-  const value = process.env[key];
-  return value === "true";
-}
-function json(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? {};
-  }
-  const value = process.env[key] ?? "{}";
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
-  }
-}
-function array(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? [];
-  }
-  let value = process.env[key] ?? "";
-  if (value.startsWith("[") && value.endsWith("]")) {
-    value = value.substring(1, value.length - 1);
-  }
-  return value.split(",").map((v) => {
-    return trim_default(trim_default(v, " "), '"');
-  });
-}
-function date(key, defaultValue) {
-  if (!has_default(process.env, key)) {
-    return defaultValue ?? /* @__PURE__ */ new Date();
-  }
-  const value = process.env[key] ?? Date();
-  return new Date(value);
-}
-var utils = {
-  int,
-  float,
-  bool,
-  json,
-  array,
-  date,
-  /**
-   * Gets a value from env that matches oneOf provided values
-   * @param {string} key
-   * @param {string[]} expectedValues
-   * @param {string|undefined} defaultValue
-   * @returns {string|undefined}
-   */
-  oneOf(key, expectedValues, defaultValue) {
-    if (!expectedValues) {
-      throw new Error(`env.oneOf requires expectedValues`);
-    }
-    if (defaultValue && !expectedValues.includes(defaultValue)) {
-      throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
-    }
-    const rawValue = env(key, defaultValue);
-    return expectedValues.includes(rawValue) ? rawValue : defaultValue ?? "";
-  }
-};
-var env = Object.assign(_env, utils);
-
-// ../../utils/src/logging/types.ts
-var logLevels = {
-  fatal: -1,
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
-};
-
-// ../../utils/src/logging/error-to-string.ts
-var safeJsonStringify = (value) => {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return JSON.stringify(value, (key, currentValue) => {
-    if (key === "constructor") return void 0;
-    if (typeof currentValue === "object" && currentValue !== null) {
-      if (seen.has(currentValue)) return "[Circular]";
-      seen.add(currentValue);
-    }
-    return currentValue;
-  });
-};
-var hasOwnConstructorProp = (value) => {
-  if (typeof value !== "object" || value === null) return false;
-  return Object.prototype.hasOwnProperty.call(value, "constructor");
-};
-var errorToString = (error) => {
-  if (error === null) return "Null error";
-  if (error === void 0) return "Undefined error";
-  if (error instanceof Error) {
-    return [
-      `Name: ${error.name}`,
-      `Message: ${error.message}`,
-      `Stack: ${error.stack || "No stack trace available"}`,
-      // Handle additional properties that might exist on custom errors
-      ...Object.entries(error).filter(
-        ([key, value]) => !["name", "message", "stack"].includes(key) && !hasOwnConstructorProp(value)
-      ).map(([key, value]) => `${key}: ${safeJsonStringify(value)}`)
-    ].join("\n");
-  }
-  if (typeof error === "string") return error;
-  if (typeof error === "object") {
-    try {
-      return JSON.stringify(
-        error,
-        (key, value) => {
-          if (key === "constructor") return void 0;
-          return value;
-        },
-        2
-      );
-    } catch {
-      return `[Object that cannot be stringified: ${Object.prototype.toString.call(error)}]`;
-    }
-  }
-  return String(error);
-};
-
-// ../../utils/src/logging/writer.ts
-import { EOL } from "os";
-var jsonWriter = (entry) => {
-  process.stdout.write(JSON.stringify(entry) + EOL);
-};
-var _writer = jsonWriter;
-function setWriter(writer) {
-  _writer = writer;
-}
-function getWriter() {
-  return _writer;
-}
-
-// ../../utils/src/logging/index.ts
-var levelValues = {
-  fatal: 70,
-  error: 60,
-  warn: 50,
-  info: 40,
-  debug: 30,
-  trace: 20
-};
-var currentLogLevel = 2;
-var _module = "default";
-var _requestId = "";
-function writeLine(level, mergeObject, msg, bindings) {
-  getWriter()({
-    level: levelValues[level],
-    levelName: level,
-    time: Date.now(),
-    module: bindings.module || _module,
-    reqId: bindings.reqId || _requestId,
-    msg: level === "error" || level === "fatal" ? errorToString(msg) : msg,
-    ...mergeObject ? { meta: mergeObject } : {}
-  });
-}
-function createLogger(bindings = {}) {
-  const currentLogLevelName = env("LOG_LEVEL")?.toLowerCase() ?? "info";
-  currentLogLevel = logLevels[currentLogLevelName] ?? logLevels.info;
-  return {
-    level: currentLogLevelName,
-    fatal: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.fatal) {
-        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("fatal", null, mergeObject, bindings) : writeLine("fatal", mergeObject, msg ?? "", bindings);
-      }
-    },
-    error: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.error) {
-        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("error", null, mergeObject, bindings) : writeLine("error", mergeObject, msg ?? "", bindings);
-      }
-    },
-    warn: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.warn) {
-        typeof mergeObject === "string" ? writeLine("warn", null, mergeObject, bindings) : writeLine("warn", mergeObject, msg ?? "", bindings);
-      }
-    },
-    info: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.info) {
-        typeof mergeObject === "string" ? writeLine("info", null, mergeObject, bindings) : writeLine("info", mergeObject, msg ?? "", bindings);
-      }
-    },
-    debug: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.debug) {
-        typeof mergeObject === "string" ? writeLine("debug", null, mergeObject, bindings) : writeLine("debug", mergeObject, msg ?? "", bindings);
-      }
-    },
-    trace: (mergeObject, msg) => {
-      if (currentLogLevel >= logLevels.trace) {
-        typeof mergeObject === "string" ? writeLine("trace", null, mergeObject, bindings) : writeLine("trace", mergeObject, msg ?? "", bindings);
-      }
-    },
-    silent: () => {
-    },
-    child: (childBindings) => createLogger({ ...bindings, ...childBindings })
-  };
-}
-var logger = createLogger();
-
-// src/logging/pretty-writer.ts
-var levelColor = {
-  fatal: chalk.bgRed.white,
-  error: chalk.red,
-  warn: chalk.yellow,
-  info: chalk.cyan,
-  debug: chalk.gray,
-  trace: chalk.white
-};
-function formatTime(ms) {
-  return new Date(ms).toTimeString().slice(0, 8);
-}
-function formatMeta(meta) {
-  const { req, res, ...rest } = meta;
-  const lines = [];
-  if (req) {
-    const reqParts = [`${req.method} ${req.url}`];
-    if (req.remoteAddress) reqParts.push(`from ${req.remoteAddress}:${req.remotePort ?? ""}`);
-    if (req.headers) reqParts.push(`headers=${JSON.stringify(req.headers, null, 2)}`);
-    if (req.body !== void 0) reqParts.push(`body=${typeof req.body === "string" ? req.body : JSON.stringify(req.body, null, 2)}`);
-    lines.push(chalk.dim("  req: " + reqParts.join(" ")));
-  }
-  if (res) {
-    const resParts = [`${res.statusCode}`];
-    if (res.headers) resParts.push(`headers=${JSON.stringify(res.headers, null, 2)}`);
-    if (res.body !== void 0) resParts.push(`body=${typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)}`);
-    lines.push(chalk.dim("  res: " + resParts.join(" ")));
-  }
-  if (Object.keys(rest).length) {
-    lines.push(chalk.dim("  " + JSON.stringify(rest, null, 2)));
-  }
-  return lines.length ? EOL2 + lines.join(EOL2) : "";
-}
-var prettyWriter = (entry) => {
-  const color = levelColor[entry.levelName] ?? chalk.white;
-  const time = chalk.dim(formatTime(entry.time));
-  const level = color(entry.levelName.toUpperCase().padEnd(5));
-  const module = chalk.magenta(entry.module);
-  const reqId = entry.reqId ? chalk.dim(`[${entry.reqId}]`) + " " : "";
-  const meta = entry.meta ? formatMeta(entry.meta) : "";
-  process.stdout.write(`${time} ${level} ${module} ${reqId}- ${entry.msg}${meta}${EOL2}`);
-};
-setWriter(prettyWriter);
-
 // src/dev-console-plugin/plugin.ts
 import path3 from "path";
 import fastifyStatic from "@fastify/static";
@@ -1015,6 +9,7 @@ import { WebSocketConnectionGoneError as WebSocketConnectionGoneError2 } from "@
 import fsPlugin from "fastify-plugin";
 
 // src/queue-plugin/core.ts
+var MAX_MESSAGE_HISTORY = 500;
 var DEFAULT_CONFIG = {
   batchSize: 10,
   batchWindowMs: 500,
@@ -1022,12 +17,12 @@ var DEFAULT_CONFIG = {
   parallel: true,
   maxConcurrent: 5,
   retryBackoff: true,
+  tickIntervalMs: 50,
   persistence: {
     enabled: true,
     directory: "./.develop/queue-data",
     saveInterval: 6e4,
-    saveOnShutdown: false,
-    loadOnStartup: true
+    saveOnShutdown: false
   }
 };
 var mergeConfig = (defaultConfig, userConfig) => ({
@@ -1043,7 +38,6 @@ var createQueueService = (handler, module) => ({
   incoming: [],
   processing: [],
   dlq: [],
-  timeoutId: null,
   processingBatch: false,
   module
 });
@@ -1062,6 +56,12 @@ var createQueueMessage = (body, headers) => {
   }
   return message;
 };
+var scheduleRetry = (queueService, message, delayMs) => {
+  removeFromProcessing(queueService, message.id);
+  message.attempts += 1;
+  message.nextAttempt = new Date(Date.now() + delayMs);
+  queueService.incoming.push(message);
+};
 var isMessageReady = (message, now = Date.now()) => {
   return !message.nextAttempt || message.nextAttempt.getTime() <= now;
 };
@@ -1079,11 +79,6 @@ var moveToProcessing = (queueService, batchSize) => {
   queueService.incoming = remaining;
   return ready;
 };
-var getNextReadyDelay = (queueService) => {
-  const nextAttempts = queueService.incoming.filter((message) => message.nextAttempt).map((message) => message.nextAttempt.getTime());
-  if (nextAttempts.length === 0) return null;
-  return Math.max(0, Math.min(...nextAttempts) - Date.now());
-};
 var removeFromProcessing = (queueService, messageId) => {
   queueService.processing = queueService.processing.filter((msg) => msg.id !== messageId);
 };
@@ -1095,21 +90,9 @@ var moveToDLQ = (queueService, message, error) => {
   });
   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,
@@ -1149,93 +132,21 @@ var purgeDLQ = (queueService) => {
   queueService.dlq = [];
   return dlqCount;
 };
-var logSuccess = (message, messageId, queueName) => {
-  logger.debug(`Success: ${message} ${messageId} in queue ${queueName}`);
-};
-var logError = (message, messageId, queueName, error) => {
-  logger.error(`Error: ${message} ${messageId} in queue ${queueName}: ${error}`);
-};
-var logRetryScheduled = (messageId, delayMs) => {
-  logger.debug(`Scheduling retry for message ${messageId} in ${delayMs}ms`);
-};
-var logDLQOperation = (operation, count, queueName) => {
-  logger.warn(`${operation} ${count} messages from DLQ for ${queueName}`);
-};
-
-// src/queue-plugin/processing.ts
-var createProcessMessageHandler = (config) => async (queueName, message, queueService) => {
-  try {
-    const result = await queueService.handler(message);
-    if (result?.failureId) {
-      await handleProcessingError(queueName, message, queueService, config);
-    } else {
-      removeFromProcessing(queueService, message.id);
-      logSuccess("Successfully processed message", message.id, queueName);
-    }
-  } catch {
-    await handleProcessingError(queueName, message, queueService, config);
-  }
-};
-var handleProcessingError = async (queueName, message, queueService, config) => {
-  logError("Error processing message", message.id, queueName, "handler returned failure");
-  if (message.attempts >= config.maxRetries) {
-    moveToDLQ(queueService, message, "max retries exceeded");
-    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, dirtyQueues, schedulerRef) => 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) {
-      queueService.processing.push(...messagesToProcess);
-      await Promise.all(messagesToProcess.map((message) => {
-        return processMessage(queueName, message, queueService);
-      }));
-      if (config.persistence.enabled && dirtyQueues) {
-        dirtyQueues.add(queueName);
-      }
-    }
-  } finally {
-    queueService.processingBatch = false;
-    const nextReadyDelay = getNextReadyDelay(queueService);
-    if (nextReadyDelay !== null) {
-      schedulerRef?.current?.(queueName, queueService, nextReadyDelay);
-    }
-  }
-};
-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));
+var createHistoryEntry = (queueName, message, status, error) => ({
+  id: message.id,
+  queueName,
+  status,
+  timestamp: message.timestamp,
+  completedAt: /* @__PURE__ */ new Date(),
+  attempts: message.attempts,
+  payload: message.payload,
+  attributes: message.attributes,
+  error
+});
+var recordMessageHistory = (history, entry) => {
+  history.push(entry);
+  if (history.length > MAX_MESSAGE_HISTORY) {
+    history.splice(0, history.length - MAX_MESSAGE_HISTORY);
   }
 };
 
@@ -1255,123 +166,358 @@ var restoreDates = (messages) => {
     if (msg.failedAt) msg.failedAt = new Date(msg.failedAt);
   });
 };
-var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) => async () => {
-  try {
-    await fs.mkdir(config.persistence.directory, { recursive: true });
-    if (config.persistence.loadOnStartup) {
-      await loadAllQueueStates();
-    }
-    if (config.persistence.saveInterval && config.persistence.saveInterval > 0) {
-      intervalIdHolder.id = setInterval(saveDirtyQueueStates, config.persistence.saveInterval);
-    }
-    if (config.persistence.saveOnShutdown) {
-      const shutdownHandler = async () => {
-        logger.debug("Saving queue state before shutdown...");
-        if (intervalIdHolder.id) {
-          clearInterval(intervalIdHolder.id);
-        }
-        await saveAllQueueStates();
-        process.exit(0);
-      };
-      process.on("SIGINT", shutdownHandler);
-      process.on("SIGTERM", shutdownHandler);
-    }
-    logger.debug(`Queue persistence initialized: ${config.persistence.directory}`);
-  } catch (error) {
-    logger.error(`Failed to initialize queue persistence: ${error?.message}`);
-  }
-};
-var createQueueStateSaver = (config) => async (queueName, queueService) => {
+var saveQueueState = async (runtime, queueName, queueService) => {
   try {
-    if (!queueService) return;
     const queueData = createQueueData(queueService);
     const now = Date.now();
-    const queueFilePath = path.join(config.persistence.directory, `${queueName}.json`);
-    const tempFilePath = path.join(config.persistence.directory, `${queueName}.${now}temp.json`);
-    await fs.writeFile(tempFilePath, JSON.stringify(queueData, null, 2), "utf8");
-    await fs.rename(tempFilePath, queueFilePath);
-    logger.debug(`Queue state saved: ${queueName}`);
+    const queueFilePath = path.join(runtime.config.persistence.directory, `${queueName}.json`);
+    const tempFilePath2 = path.join(runtime.config.persistence.directory, `${queueName}.${now}temp.json`);
+    await fs.writeFile(tempFilePath2, JSON.stringify(queueData, null, 2), "utf8");
+    await fs.rename(tempFilePath2, queueFilePath);
+    runtime.logging.debug({ module: queueService.module }, `Queue state saved: ${queueName}`);
   } catch (error) {
-    logger.error(`Failed to save queue state for ${queueName}:`, error?.message);
+    runtime.logging.error(
+      { module: queueService.module, error: error?.message },
+      `Failed to save queue state for ${queueName}`
+    );
   }
 };
-var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async () => {
+var saveAllQueueStates = async (runtime) => {
   try {
-    for (const [queueName, queueService] of Object.entries(queues)) {
-      await saveQueueState(queueName, queueService);
+    for (const [queueName, queueService] of Object.entries(runtime.queues)) {
+      await saveQueueState(runtime, queueName, queueService);
     }
-    logger.debug(`All queue states saved to ${config.persistence.directory}`);
+    runtime.logging.debug(`All queue states saved to ${runtime.config.persistence.directory}`);
   } catch (error) {
-    logger.error(`Failed to save all queue states: ${error?.message}`);
+    runtime.logging.error({ error: error?.message }, `Failed to save all queue states`);
   }
 };
-var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => async () => {
-  if (dirtyQueues.size === 0) return;
+var saveDirtyQueueStates = async (runtime) => {
+  if (runtime.dirtyQueues.size === 0) return;
   try {
-    const queueNames = [...dirtyQueues];
-    dirtyQueues.clear();
+    const queueNames = [...runtime.dirtyQueues];
+    runtime.dirtyQueues.clear();
     for (const queueName of queueNames) {
-      if (queues[queueName]) {
-        await saveQueueState(queueName, queues[queueName]);
+      if (runtime.queues[queueName]) {
+        await saveQueueState(runtime, queueName, runtime.queues[queueName]);
       }
     }
   } catch (error) {
-    logger.error(`Failed to save dirty queue states: ${error?.message}`);
+    runtime.logging.error({ error: error?.message }, `Failed to save dirty queue states`);
   }
 };
-var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
+var loadQueueState = async (runtime, queueName) => {
   try {
-    if (!queues[queueName]) {
-      logger.warn(`Skipping load for non-existent queue: ${queueName}`);
+    const queueService = runtime.queues[queueName];
+    if (!queueService) {
+      runtime.logging.warn(`Skipping load for non-existent queue: ${queueName}`);
       return;
     }
-    const queueFilePath = path.join(config.persistence.directory, `${queueName}.json`);
+    const queueFilePath = path.join(runtime.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));
+      queueService.incoming = queueData.incoming;
+      queueService.dlq = queueData.dlq;
+      queueService.processing = [];
+      for (const message of queueData.processing) {
+        if (message.attempts >= runtime.config.maxRetries) {
+          queueService.dlq.push({ ...message, error: "max retries exceeded before restart", failedAt: /* @__PURE__ */ new Date() });
+        } else {
+          message.nextAttempt = /* @__PURE__ */ new Date();
+          queueService.incoming.push(message);
         }
       }
+      runtime.logging.debug(
+        { module: queueService.module },
+        `Queue state loaded: ${queueName} (saved at ${queueData.savedAt})`
+      );
     } catch (error) {
       if (error.code === "ENOENT") {
-        logger.debug(`No saved state found for queue: ${queueName}`);
+        runtime.logging.debug({ module: queueService.module }, `No saved state found for queue: ${queueName}`);
       } else {
         throw error;
       }
     }
   } catch (error) {
-    logger.error(`Failed to load queue state for ${queueName}:`, error?.message);
+    runtime.logging.error({ error: error?.message }, `Failed to load queue state for ${queueName}`);
   }
 };
-var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
+var initializePersistence = async (runtime) => {
   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 = path.basename(file, ".json");
-      await loadQueueState(queueName);
+    await fs.mkdir(runtime.config.persistence.directory, { recursive: true });
+    if (runtime.config.persistence.saveOnShutdown) {
+      const shutdownHandler = async () => {
+        runtime.logging.debug("Saving queue state before shutdown...");
+        await saveAllQueueStates(runtime);
+        process.exit(0);
+      };
+      process.on("SIGINT", shutdownHandler);
+      process.on("SIGTERM", shutdownHandler);
     }
-    logger.debug("All queue states loaded");
+    runtime.logging.debug(`Queue persistence initialized: ${runtime.config.persistence.directory}`);
   } catch (error) {
-    logger.error("Failed to load queue states:", error?.message);
+    runtime.logging.error({ error: error?.message }, `Failed to initialize queue persistence`);
   }
 };
 
+// src/queue-plugin/processing.ts
+var processMessage = async (runtime, queueName, message, queueService) => {
+  try {
+    const result = await queueService.handler(message);
+    if (result?.failureId) {
+      handleFailure(runtime, queueName, message, queueService);
+    } else {
+      removeFromProcessing(queueService, message.id);
+      recordMessageHistory(runtime.messageHistory, createHistoryEntry(queueName, message, "completed"));
+      runtime.logging.debug(`Successfully processed message ${message.id} in queue ${queueName}`);
+    }
+  } catch {
+    handleFailure(runtime, queueName, message, queueService);
+  }
+};
+var handleFailure = (runtime, queueName, message, queueService) => {
+  runtime.logging.error(`Error processing message ${message.id} in queue ${queueName}: handler returned failure`);
+  if (message.attempts >= runtime.config.maxRetries) {
+    moveToDLQ(queueService, message, "max retries exceeded");
+    recordMessageHistory(runtime.messageHistory, createHistoryEntry(queueName, message, "failed", "max retries exceeded"));
+    return;
+  }
+  const delayMs = runtime.config.retryBackoff ? calculateBackoffDelay(message.attempts + 1) : 0;
+  scheduleRetry(queueService, message, delayMs);
+  runtime.logging.debug(`Scheduling retry for message ${message.id} in ${delayMs}ms`);
+};
+var processBatch = async (runtime, queueName, queueService) => {
+  if (queueService.processingBatch) {
+    return;
+  }
+  try {
+    queueService.processingBatch = true;
+    const messagesToProcess = moveToProcessing(queueService, runtime.config.batchSize);
+    if (messagesToProcess.length === 0) {
+      return;
+    }
+    queueService.processing.push(...messagesToProcess);
+    await Promise.all(
+      messagesToProcess.map((message) => runtime.logging.runWithLogContext(
+        { module: queueService.module, reqId: message.id },
+        () => processMessage(runtime, queueName, message, queueService)
+      ))
+    );
+    if (runtime.config.persistence.enabled) {
+      runtime.dirtyQueues.add(queueName);
+    }
+  } finally {
+    queueService.processingBatch = false;
+  }
+};
+var dispatchBatchIfDue = (runtime, queueName, queueService, now) => {
+  if (queueService.processingBatch) {
+    return;
+  }
+  const ready = queueService.incoming.filter((message) => isMessageReady(message, now));
+  if (ready.length === 0) {
+    return;
+  }
+  const dueBySize = ready.length >= runtime.config.batchSize;
+  const oldestReadyAge = now - Math.min(...ready.map((message) => message.timestamp.getTime()));
+  const dueByWindow = oldestReadyAge >= runtime.config.batchWindowMs;
+  if (dueBySize || dueByWindow) {
+    processBatch(runtime, queueName, queueService);
+  }
+};
+var maybeSavePersistence = (runtime, now) => {
+  if (!runtime.config.persistence.enabled) {
+    return;
+  }
+  const saveInterval = runtime.config.persistence.saveInterval ?? 0;
+  if (saveInterval > 0 && now - runtime.lastSavedAt >= saveInterval) {
+    runtime.lastSavedAt = now;
+    saveDirtyQueueStates(runtime);
+  }
+};
+var tick = (runtime) => {
+  const now = Date.now();
+  for (const [queueName, queueService] of Object.entries(runtime.queues)) {
+    dispatchBatchIfDue(runtime, queueName, queueService, now);
+  }
+  maybeSavePersistence(runtime, now);
+};
+
+// src/queue-plugin/decorator.ts
+var isValidQueueName = (queueName) => {
+  return typeof queueName === "string" && queueName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(queueName);
+};
+var 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");
+  }
+};
+var validateHandler = (handler) => {
+  if (typeof handler !== "function") {
+    throw new Error("Handler must be a function");
+  }
+};
+var addQueue = async (runtime, queueName, handler, module) => {
+  try {
+    validateQueueName(queueName);
+    validateHandler(handler);
+    if (runtime.queues[queueName]) {
+      runtime.logging.warn({ module }, `Queue already exists: ${queueName}.`);
+      return;
+    }
+    runtime.queues[queueName] = createQueueService(handler, module);
+    if (runtime.config.persistence.enabled) {
+      await loadQueueState(runtime, queueName);
+    }
+    runtime.logging.info({ module }, `Queue added: ${queueName}`);
+  } catch (error) {
+    runtime.logging.error({ module, error: error.message }, `Failed to add queue ${queueName}`);
+    throw error;
+  }
+};
+var removeQueue = async (runtime, queueName) => {
+  try {
+    validateQueueName(queueName);
+    const queueService = runtime.queues[queueName];
+    if (!queueService) {
+      throw new Error(`Queue '${queueName}' does not exist`);
+    }
+    const totalMessages = queueService.incoming.length + queueService.processing.length;
+    if (totalMessages > 0) {
+      runtime.logging.warn(
+        { module: queueService.module },
+        `Removing queue with ${totalMessages} pending messages: ${queueName}`
+      );
+    }
+    if (runtime.config.persistence.enabled) {
+      await saveQueueState(runtime, queueName, queueService);
+    }
+    delete runtime.queues[queueName];
+    runtime.logging.info({ module: queueService.module }, `Queue removed: ${queueName}`);
+  } catch (error) {
+    runtime.logging.error({ error: error.message }, `Failed to remove queue ${queueName}`);
+    throw error;
+  }
+};
+var hasQueue = (runtime, queueName) => {
+  try {
+    validateQueueName(queueName);
+    return queueName in runtime.queues;
+  } catch {
+    return false;
+  }
+};
+var listQueues = (runtime, module) => {
+  return Object.keys(runtime.queues).filter((queueName) => !module || runtime.queues[queueName].module === module).sort();
+};
+var getQueueStats = (runtime, queueName) => {
+  try {
+    validateQueueName(queueName);
+    return runtime.queues[queueName] || null;
+  } catch {
+    return null;
+  }
+};
+var getQueuesMap = (runtime) => {
+  return { ...runtime.queues };
+};
+var getDashboardSummary = (runtime) => createDashboardSummary(runtime.queues, runtime.config);
+var getQueueSummary = (runtime, queueName) => {
+  const queue = runtime.queues[queueName];
+  if (!queue) {
+    return null;
+  }
+  return {
+    stats: createQueueSummary(queue, runtime.config),
+    messages: {
+      incoming: queue.incoming,
+      processing: queue.processing,
+      dlq: queue.dlq
+    }
+  };
+};
+var enqueueMessage = async (runtime, queueName, body, attributes) => {
+  const queueService = runtime.queues[queueName];
+  if (!queueService) {
+    return null;
+  }
+  const message = createQueueMessage(body, attributes);
+  queueService.incoming.push(message);
+  if (runtime.config.persistence.enabled) {
+    runtime.dirtyQueues.add(queueName);
+  }
+  return { id: message.id, queueName };
+};
+var processDlq = async (runtime, queueName) => {
+  const queueService = runtime.queues[queueName];
+  if (!queueService) {
+    return null;
+  }
+  const processedCount = moveDLQToIncoming(queueService);
+  if (processedCount === 0) {
+    return { status: "success", message: "No messages in DLQ to process", processed: 0 };
+  }
+  runtime.logging.warn(
+    { module: queueService.module },
+    `Moving ${processedCount} messages from DLQ for ${queueName}`
+  );
+  if (runtime.config.persistence.enabled) {
+    runtime.dirtyQueues.add(queueName);
+  }
+  return {
+    status: "success",
+    message: `Moved ${processedCount} messages from DLQ to processing queue`,
+    processed: processedCount
+  };
+};
+var purgeDlq = async (runtime, queueName) => {
+  const queueService = runtime.queues[queueName];
+  if (!queueService) {
+    return null;
+  }
+  const purgedCount = purgeDLQ(queueService);
+  if (purgedCount === 0) {
+    return { status: "success", message: "No messages in DLQ to purge", purged: 0 };
+  }
+  runtime.logging.warn(
+    { module: queueService.module },
+    `Purging ${purgedCount} messages from DLQ for ${queueName}`
+  );
+  if (runtime.config.persistence.enabled) {
+    runtime.dirtyQueues.add(queueName);
+  }
+  return {
+    status: "success",
+    message: `Purged ${purgedCount} messages from DLQ`,
+    purged: purgedCount
+  };
+};
+var getMessageHistory = (runtime, queueName, limit = 50) => {
+  return runtime.messageHistory.filter((entry) => entry.queueName === queueName).slice(-limit).reverse();
+};
+var createQueueManager = (runtime) => ({
+  addQueue: (queueName, handler, module) => addQueue(runtime, queueName, handler, module),
+  removeQueue: (queueName) => removeQueue(runtime, queueName),
+  hasQueue: (queueName) => hasQueue(runtime, queueName),
+  listQueues: (module) => listQueues(runtime, module),
+  getQueueStats: (queueName) => getQueueStats(runtime, queueName),
+  getQueuesMap: () => getQueuesMap(runtime),
+  getConfig: () => runtime.config,
+  getDashboardSummary: () => getDashboardSummary(runtime),
+  getQueueSummary: (queueName) => getQueueSummary(runtime, queueName),
+  enqueueMessage: (queueName, body, attributes) => enqueueMessage(runtime, queueName, body, attributes),
+  processDlq: (queueName) => processDlq(runtime, queueName),
+  purgeDlq: (queueName) => purgeDlq(runtime, queueName),
+  getMessageHistory: (queueName, limit) => getMessageHistory(runtime, queueName, limit)
+});
+
 // src/queue-plugin/routes.ts
 var registerQueueRoutes = (app, prefix = "") => {
   app.get(
@@ -1408,270 +554,45 @@ var registerQueueRoutes = (app, prefix = "") => {
     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
-var isValidQueueName = (queueName) => {
-  return typeof queueName === "string" && queueName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(queueName);
-};
-var createQueueManager = ({
-  config,
-  queues,
-  dirtyQueues,
-  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(`Queue already exists: ${queueName}.`);
-        return;
-      }
-      queues[queueName] = createQueueService(handler, module);
-      if (config.persistence.enabled && loadQueueState) {
-        await loadQueueState(queueName);
-      }
-      logger.info(`Queue added: ${queueName}`);
-    } catch (error) {
-      logger.error(`Failed to add queue ${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(`Removing queue with ${totalMessages} pending messages: ${queueName}`);
-      }
-      if (queueService.timeoutId) {
-        clearTimeout(queueService.timeoutId);
-      }
-      if (config.persistence.enabled && saveQueueState) {
-        await saveQueueState(queueName, queueService);
-      }
-      delete queues[queueName];
-      logger.info(`Queue removed: ${queueName}`);
-    } catch (error) {
-      logger.error(`Failed to remove queue ${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) {
-      dirtyQueues.add(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 (config.persistence.enabled) {
-      dirtyQueues.add(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
-      };
+      if (result === null) {
+        return reply.status(404).send(result);
+      }
+      return reply.status(200).send(result);
     }
-    logDLQOperation("Purging", purgedCount, queueName);
-    if (config.persistence.enabled) {
-      dirtyQueues.add(queueName);
+  );
+  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);
     }
-    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 dirtyQueues = /* @__PURE__ */ new Set();
-  const intervalIdHolder = {};
-  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 saveDirtyQueueStates = config.persistence.enabled && saveQueueState ? createDirtyQueuesStateSaver(saveQueueState, dirtyQueues)(queues) : async () => {
-  };
-  const schedulerRef = {};
-  const processBatch = createBatchProcessor(
-    processMessage,
-    config,
-    config.persistence.enabled ? dirtyQueues : void 0,
-    schedulerRef
-  );
-  const scheduleProcessing = createProcessingScheduler(processBatch, config);
-  schedulerRef.current = scheduleProcessing;
-  const loadQueueState = config.persistence.enabled ? createQueueStateLoader(
-    config,
-    scheduleProcessing,
-    processMessage
-  )(queues) : async () => {
+  const runtime = {
+    config: mergeConfig(DEFAULT_CONFIG, options.config),
+    queues: {},
+    dirtyQueues: /* @__PURE__ */ new Set(),
+    lastSavedAt: Date.now(),
+    messageHistory: [],
+    logging: app.logging
   };
-  const loadAllQueueStates = config.persistence.enabled ? createAllQueuesStateLoader(config, loadQueueState) : async () => {
-  };
-  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) : async () => {
-  };
-  const queueManager = createQueueManager({
-    config,
-    queues,
-    dirtyQueues,
-    saveQueueState: saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0,
-    loadQueueState,
-    scheduleProcessing,
-    processBatch
-  });
-  const decorateQueues = createQueueDecorator(queueManager);
-  decorateQueues(app);
-  registerQueueRoutes(
-    app,
-    options.prefix
-  );
-  await initializePersistence();
+  const tickIntervalId = setInterval(() => tick(runtime), runtime.config.tickIntervalMs);
+  app.addHook("onClose", async () => clearInterval(tickIntervalId));
+  app.decorate("queues", createQueueManager(runtime));
+  registerQueueRoutes(app, options.prefix);
+  await initializePersistence(runtime);
 });
 
 // src/schedule-plugin/plugin.ts
 import fsPlugin2 from "fastify-plugin";
 
-// src/schedule-plugin/core.ts
-import * as fs3 from "fs/promises";
-
 // src/schedule-plugin/cron-utils.ts
 import { parseExpression } from "cron-parser";
 function parseCronExpression(cronExpression, lastRun, options = {}) {
@@ -1704,7 +625,6 @@ function parseCronExpression(cronExpression, lastRun, options = {}) {
       description: describeCronExpression(normalizedCron)
     };
   } catch (error) {
-    logger.error(`Invalid cron expression: ${cronExpression} - ${error.message}`);
     const fallbackTime = /* @__PURE__ */ new Date();
     fallbackTime.setHours(fallbackTime.getHours() + 1);
     fallbackTime.setMinutes(0);
@@ -1732,8 +652,7 @@ function getNextExecutions(cronExpression, count = 5, options = {}) {
       executions.push(interval.next().toDate());
     }
     return executions;
-  } catch (error) {
-    logger.error(`Error getting next executions: ${error.message}`);
+  } catch {
     return [];
   }
 }
@@ -2006,9 +925,111 @@ var shouldSkipJob = (job) => {
   if (job.maxRuns && job.runCount >= job.maxRuns) return true;
   return false;
 };
+var isJobReadyToRun = (job) => {
+  const now = /* @__PURE__ */ new Date();
+  return job.nextRun.getTime() <= now.getTime();
+};
 var getTimeUntilNextRun = (job) => Math.max(0, job.nextRun.getTime() - Date.now());
 
-// src/schedule-plugin/execution.ts
+// src/schedule-plugin/core.ts
+var DEFAULT_CONFIG2 = {
+  tickIntervalMs: 1e3,
+  persistence: {
+    enabled: true,
+    directory: "./.develop/scheduler-data",
+    saveInterval: 3e4,
+    // 30 seconds
+    saveOnShutdown: false
+  },
+  execution: {
+    maxConcurrent: 5,
+    defaultTimeout: 3e5
+    // 5 minutes
+  },
+  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 createDashboardSummary2 = (runtime) => {
+  const jobs = Object.values(runtime.schedulers).map((scheduler) => {
+    const upcomingExecutions = scheduler.job.cronExpression ? getNextExecutions(scheduler.job.cronExpression, 3, { timezone: scheduler.job.timezone }) : [];
+    const cronDescription = scheduler.job.cronExpression ? parseCronExpression(scheduler.job.cronExpression, void 0, { timezone: scheduler.job.timezone }).description : void 0;
+    return {
+      ...scheduler.job,
+      isRunning: scheduler.isRunning,
+      timeUntilNextRun: getTimeUntilNextRun(scheduler.job),
+      upcomingExecutions,
+      cronDescription
+    };
+  });
+  return { jobs, runningExecutions: runtime.runningExecutions };
+};
+var createExecutionsSummary = (runtime) => ({
+  executions: runtime.executionHistory.slice(-50),
+  // Last 50 executions
+  running: Object.values(runtime.executions).filter((e) => e.status === "running")
+});
+
+// src/schedule-plugin/jobs.ts
+var validateJobDefinition = (jobDef) => {
+  if (!jobDef.cronExpression && !jobDef.intervalMs && !jobDef.delayMs) {
+    throw new Error(`Job ${jobDef.name} must specify a cronExpression, intervalMs, or delayMs`);
+  }
+  if (jobDef.cronExpression && detectExpressionType(jobDef.cronExpression) === "unknown") {
+    throw new Error(`Invalid cron expression for job: ${jobDef.name}`);
+  }
+};
+var createJobFromDefinition = (jobDef, config) => {
+  validateJobDefinition(jobDef);
+  const expressionType = detectExpressionType(jobDef.cronExpression);
+  const cronExpression = expressionType === "rate" ? convertRateToCron(jobDef.cronExpression).cronExpression : jobDef.cronExpression;
+  const job = {
+    id: generateJobId(),
+    name: jobDef.name,
+    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, config.restartBehavior.preserveNaturalTiming);
+  return job;
+};
+var createSchedulerService = (job, handler) => ({
+  job,
+  handler,
+  isRunning: false
+});
 var createJobExecution = (jobId) => ({
   id: generateExecutionId(),
   jobId,
@@ -2022,655 +1043,516 @@ var completeExecution = (execution, result, error) => ({
   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.debug(`Scheduled job ${scheduler.job.name} to run in ${Math.round(timeUntilNextRun / 1e3)}s`);
-  }
-  return updatedScheduler;
-};
-var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
-  let timerId;
-  try {
-    return await Promise.race([
-      handler(job, execution),
-      new Promise((_, reject) => {
-        timerId = setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs);
-      })
-    ]);
-  } finally {
-    clearTimeout(timerId);
-  }
-};
 var updateJobAfterExecution = (job, execution, config) => {
   const updatedJob = {
     ...job,
     lastRun: execution.startTime,
     runCount: job.runCount + 1
   };
-  if (job.enabled) {
+  if (updatedJob.enabled) {
     updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
   }
   return updatedJob;
 };
-var handleExecutionError = (execution, error) => {
-  logger.error(`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(`Job completed in ${duration}ms`);
-  return completeExecution(execution, result);
-};
+var enableJob = (scheduler) => ({
+  ...scheduler,
+  job: {
+    ...scheduler.job,
+    enabled: true,
+    nextRun: calculateNextRun(scheduler.job)
+  }
+});
+var disableJob = (scheduler) => ({
+  ...scheduler,
+  job: { ...scheduler.job, enabled: false }
+});
 
 // src/schedule-plugin/persistence.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-var createStateFilePath = (directory) => path2.join(directory, "scheduler-state.json");
-var createTempFilePath = (directory) => path2.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) => {
+var stateFilePath = (directory) => path2.join(directory, "scheduler-state.json");
+var tempFilePath = (directory) => path2.join(directory, `scheduler-state.${Date.now()}.temp.json`);
+var restoreExecutionHistory = (savedExecutions) => savedExecutions.map((exec) => ({
+  ...exec,
+  startTime: new Date(exec.startTime),
+  endTime: exec.endTime ? new Date(exec.endTime) : void 0
+}));
+var readStateData = async (directory) => {
+  const data = await fs2.readFile(stateFilePath(directory), "utf8");
+  return JSON.parse(data);
+};
+var saveSchedulerState = async (runtime) => {
   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.debug("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);
+    const stateData = {
+      jobs: Object.values(runtime.schedulers).map((s) => s.job),
+      executions: runtime.executionHistory.slice(-100),
+      savedAt: /* @__PURE__ */ new Date(),
+      version: "1.0"
+    };
+    const file = stateFilePath(runtime.config.persistence.directory);
+    const temp = tempFilePath(runtime.config.persistence.directory);
+    await fs2.writeFile(temp, JSON.stringify(stateData, null, 2), "utf8");
+    await fs2.rename(temp, file);
+    runtime.logging.debug("Scheduler state saved");
   } catch (error) {
-    if (error.code === "ENOENT") {
-      logger.debug("No previous scheduler state found - starting fresh");
-    } else {
-      logger.error("Failed to load scheduler state:", error);
-    }
-    return null;
+    runtime.logging.error({ error: error?.message }, "Failed to save scheduler state");
   }
 };
-var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
+var validateAndAdjustNextRun = (job, savedNextRun, runtime) => {
+  const { config, lastRestartTime, logging } = runtime;
   const now = /* @__PURE__ */ new Date();
-  if (!savedNextRun) {
-    return calculateNextRunFromLastRun(job, job.lastRun, config);
-  }
-  if (savedNextRun <= now) {
-    logger.debug(`Saved next run is in the past for ${job.name} - recalculating`);
+  if (!savedNextRun || savedNextRun <= now) {
+    logging.debug({ module: job.module }, `Saved next run is in the past for ${job.name} - recalculating`);
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
-  const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
-  const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
+  const isRapidRestart = now.getTime() - lastRestartTime.getTime() < config.restartBehavior.rapidRestartThreshold;
   if (isRapidRestart) {
-    logger.debug(`Rapid restart detected for ${job.name} - preserving saved timing`);
+    logging.debug({ module: job.module }, `Rapid restart detected for ${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.debug(`Adjusting timing for ${job.name} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+    const drift = Math.abs(savedNextRun.getTime() - expectedNextRun.getTime());
+    if (drift > config.restartBehavior.maxTimingDrift) {
+      logging.debug({ module: job.module }, `Adjusting timing for ${job.name} - drift of ${Math.round(drift / 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.debug(`Job definition changed: ${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.debug(`Job restored: ${savedJob.name} - ${result.description} - next: ${updatedJob.nextRun.toLocaleString()}`);
+var loadJobState = async (runtime, scheduler) => {
+  try {
+    const stateData = await readStateData(runtime.config.persistence.directory);
+    if (!stateData) {
+      return scheduler;
+    }
+    const savedJob = stateData.jobs.find((job) => job.name === scheduler.job.name);
+    if (!savedJob) {
+      return scheduler;
+    }
+    const definitionChanged = hasJobDefinitionChanged(scheduler.job, savedJob);
+    const lastRun = savedJob.lastRun ? new Date(savedJob.lastRun) : void 0;
+    const updatedJob = {
+      ...scheduler.job,
+      runCount: savedJob.runCount,
+      lastRun
+    };
+    if (definitionChanged) {
+      runtime.logging.debug({ module: scheduler.job.module }, `Job definition changed: ${savedJob.name} - recalculating schedule`);
+      updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, lastRun, runtime.config);
+    } else {
+      updatedJob.nextRun = validateAndAdjustNextRun(updatedJob, savedJob.nextRun ? new Date(savedJob.nextRun) : void 0, runtime);
+    }
+    if (runtime.config.cron.logCronDetails && updatedJob.cronExpression) {
+      const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, { timezone: updatedJob.timezone });
+      runtime.logging.debug(
+        { module: scheduler.job.module },
+        `Job restored: ${savedJob.name} - ${result.description} - next: ${updatedJob.nextRun.toLocaleString()}`
+      );
+    } else {
+      runtime.logging.debug({ module: scheduler.job.module }, `Job state restored: ${savedJob.name}`);
+    }
+    return { ...scheduler, job: updatedJob };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      runtime.logging.debug("No saved scheduler state found - starting fresh");
+    } else {
+      runtime.logging.error({ error: error?.message }, `Failed to load job state for ${scheduler.job.name}`);
+    }
+    return scheduler;
   }
-  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;
+var loadExecutionHistory = async (runtime) => {
+  try {
+    const stateData = await readStateData(runtime.config.persistence.directory);
+    if (stateData?.executions) {
+      runtime.executionHistory = restoreExecutionHistory(stateData.executions);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      runtime.logging.error({ error: error?.message }, "Failed to load execution history");
     }
   }
-  const executionHistory = stateData.executions ? restoreExecutionHistory(stateData.executions) : [];
-  logger.debug(`Enhanced scheduler state loaded (saved at ${stateData.savedAt})`);
-  return { schedulers: restoredSchedulers, executionHistory };
 };
-
-// src/schedule-plugin/cleanup.ts
-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.debug(`Cleaned up ${removed.length} old execution records`);
-    return removed;
+var initializePersistence2 = async (runtime) => {
+  try {
+    await fs2.mkdir(runtime.config.persistence.directory, { recursive: true });
+    await loadExecutionHistory(runtime);
+    if (runtime.config.persistence.saveOnShutdown) {
+      const shutdownHandler = async () => {
+        runtime.logging.debug("Saving scheduler state before shutdown...");
+        await saveSchedulerState(runtime);
+        process.exit(0);
+      };
+      process.on("SIGINT", shutdownHandler);
+      process.on("SIGTERM", shutdownHandler);
+    }
+    runtime.logging.debug(`Scheduler persistence initialized: ${runtime.config.persistence.directory}`);
+  } catch (error) {
+    runtime.logging.error({ error: error?.message }, "Failed to initialize scheduler persistence");
   }
-  return [];
 };
 
-// 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
+// src/schedule-plugin/processing.ts
+var canExecuteJob = (runtime, scheduler) => {
+  if (runtime.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 (runtime.runningExecutions >= runtime.config.execution.maxConcurrent) {
+    return { canExecute: false, reason: "Maximum concurrent executions reached" };
+  }
+  return { canExecute: 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,
-    isDirty: false,
-    lastCleanupTime: Date.now(),
-    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(`Delaying job ${scheduler.job.name} - ${reason}`);
-        scheduler.job.nextRun = new Date(Date.now() + 3e4);
-        scheduleJobFn(scheduler);
-      } else if (reason === "Job reached maximum runs") {
-        logger.info(`Job ${scheduler.job.name} reached max runs (${scheduler.job.maxRuns})`);
-      }
-      return;
+var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
+  let timerId;
+  try {
+    return await Promise.race([
+      handler(job, execution),
+      new Promise((_, reject) => {
+        timerId = setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timerId);
+  }
+};
+var executeJob = async (runtime, scheduler) => {
+  const execution = createJobExecution(scheduler.job.id);
+  runtime.executions[execution.id] = execution;
+  runtime.executionHistory.push(execution);
+  scheduler.isRunning = true;
+  runtime.runningExecutions++;
+  runtime.logging.info(`Executing job ${scheduler.job.name} (${execution.id})`);
+  try {
+    const result = await executeJobWithTimeout(
+      scheduler.handler,
+      scheduler.job,
+      execution,
+      runtime.config.execution.defaultTimeout
+    );
+    Object.assign(execution, completeExecution(execution, result));
+    const duration = execution.endTime.getTime() - execution.startTime.getTime();
+    runtime.logging.debug(`Job completed in ${duration}ms`);
+  } catch (error) {
+    Object.assign(execution, completeExecution(execution, void 0, error.message));
+    runtime.logging.error(`Job failed ${scheduler.job.name}: ${error.message}`);
+  } finally {
+    scheduler.isRunning = false;
+    runtime.runningExecutions--;
+    scheduler.job = updateJobAfterExecution(scheduler.job, execution, runtime.config);
+    if (scheduler.job.maxRuns && scheduler.job.runCount >= scheduler.job.maxRuns) {
+      runtime.logging.info(`Job ${scheduler.job.name} reached max runs (${scheduler.job.maxRuns})`);
     }
-    const execution = createJobExecution(scheduler.job.id);
-    state.executions[execution.id] = execution;
-    state.executionHistory.push(execution);
-    scheduler.isRunning = true;
-    state.runningExecutions++;
-    logger.info(`Executing job ${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;
-    } catch (error) {
-      const failedExecution = handleExecutionError(execution, error);
-      state.executions[execution.id] = failedExecution;
-    } finally {
-      scheduler.isRunning = false;
-      state.runningExecutions--;
-      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
-      if (scheduler.job.enabled && !state.isShuttingDown) {
-        scheduleJobFn(scheduler);
-      }
-      if (state.config.persistence.enabled) {
-        state.isDirty = true;
-      }
+    if (runtime.config.persistence.enabled) {
+      runtime.isDirty = true;
     }
-  };
-  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;
-    }
-    const tickInterval = (state.config.persistence.saveInterval || 0) > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
-    state.tickInterval = setInterval(async () => {
-      if (state.isDirty && state.config.persistence.enabled) {
-        state.isDirty = false;
-        await saveSchedulerState(state);
-      }
-      if (Date.now() - state.lastCleanupTime >= state.config.cleanup.cleanupInterval) {
-        state.lastCleanupTime = Date.now();
-        cleanupExecutionHistory(state);
-      }
-    }, tickInterval);
-    for (const scheduler of Object.values(state.schedulers)) {
-      if (scheduler.job.enabled) {
-        scheduleJobFn(scheduler);
-      }
+var dispatchJobIfDue = (runtime, scheduler) => {
+  if (!scheduler.job.enabled || !isJobReadyToRun(scheduler.job)) {
+    return;
+  }
+  const { canExecute, reason } = canExecuteJob(runtime, scheduler);
+  if (!canExecute) {
+    if (reason === "Maximum concurrent executions reached") {
+      runtime.logging.debug({ module: scheduler.job.module }, `Delaying job ${scheduler.job.name} - ${reason}`);
     }
-    logger.debug(`Scheduler initialized: ${Object.keys(state.schedulers).length} jobs loaded`);
-  } catch (error) {
-    logger.error(`Failed to initialize scheduler: ${error.message}`);
-    throw error;
+    return;
   }
+  runtime.logging.runWithLogContext(
+    { module: scheduler.job.module, reqId: scheduler.job.id },
+    () => executeJob(runtime, scheduler)
+  );
 };
-
-// src/schedule-plugin/jobs.ts
-var validateJobDefinition = (jobDef) => {
-  const expressionType = detectExpressionType(jobDef.cronExpression);
-  if (expressionType === "unknown") {
-    logger.error(`Invalid cron expression for job: ${jobDef.name}`);
-    throw new Error(`Invalid cron expression for job: ${jobDef.name}`);
+var cleanupExecutionHistory = (runtime) => {
+  const { maxExecutionHistory } = runtime.config.cleanup;
+  if (runtime.executionHistory.length <= maxExecutionHistory) {
+    return;
   }
+  const removed = runtime.executionHistory.splice(0, runtime.executionHistory.length - maxExecutionHistory);
+  runtime.logging.debug(`Cleaned up ${removed.length} old execution records`);
 };
-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.debug(`Job ${jobDef.name}: ${result.description} - Next: ${result.nextRun.toLocaleString()}`);
-    const upcoming = getNextExecutions(cronExpression, 3, {
-      timezone: jobDef.timezone ?? config.cron.defaultTimezone
-    });
-    logger.debug(`Upcoming: ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+var maybeCleanup = (runtime, now) => {
+  if (now - runtime.lastCleanupTime < runtime.config.cleanup.cleanupInterval) {
+    return;
   }
-  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;
+  runtime.lastCleanupTime = now;
+  cleanupExecutionHistory(runtime);
 };
-var createSchedulerService = (job, handler) => ({
-  job,
-  handler,
-  isRunning: false
-});
-var enableJob = (scheduler) => ({
-  ...scheduler,
-  job: {
-    ...scheduler.job,
-    enabled: true,
-    nextRun: calculateNextRun(scheduler.job)
+var maybeSavePersistence2 = (runtime, now) => {
+  if (!runtime.config.persistence.enabled || !runtime.isDirty) {
+    return;
   }
-});
-var disableJob = (scheduler) => {
-  if (scheduler.timerId) {
-    clearTimeout(scheduler.timerId);
+  const saveInterval = runtime.config.persistence.saveInterval ?? 0;
+  if (saveInterval > 0 && now - runtime.lastSavedAt >= saveInterval) {
+    runtime.lastSavedAt = now;
+    runtime.isDirty = false;
+    saveSchedulerState(runtime);
   }
-  return {
-    ...scheduler,
-    job: { ...scheduler.job, enabled: false },
-    timerId: void 0
-  };
+};
+var tick2 = (runtime) => {
+  const now = Date.now();
+  for (const scheduler of Object.values(runtime.schedulers)) {
+    dispatchJobIfDue(runtime, scheduler);
+  }
+  maybeCleanup(runtime, now);
+  maybeSavePersistence2(runtime, now);
 };
 
-// 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 };
+// src/schedule-plugin/decorator.ts
+var isValidJobName = (jobName) => {
+  return typeof jobName === "string" && jobName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(jobName);
 };
-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("/schedule/dashboard", async function(_, reply) {
-    const dashboardData = createDashboardData(state);
-    return reply.status(200).send(dashboardData);
-  });
+var 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");
+  }
 };
-var registerExecutionsRoute = (app, state) => {
-  app.get("/schedule/executions", async function(_, reply) {
-    const executionsData = createExecutionsData(state);
-    return reply.status(200).send(executionsData);
-  });
+var validateHandler2 = (handler) => {
+  if (typeof handler !== "function") {
+    throw new Error("Handler must be a function");
+  }
 };
-var registerTriggerJobRoute = (app, state, executeJobFn) => {
-  app.post("/schedule/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" });
+var findSchedulerByName = (runtime, jobName) => Object.values(runtime.schedulers).find((scheduler) => scheduler.job.name === jobName);
+var addJob = async (runtime, jobDefinition) => {
+  try {
+    validateJobName(jobDefinition.name);
+    validateHandler2(jobDefinition.handler);
+    const existing = findSchedulerByName(runtime, jobDefinition.name);
+    if (existing) {
+      runtime.logging.warn({ module: jobDefinition.module }, `Job already exists: ${jobDefinition.name}.`);
+      return existing.job.id;
+    }
+    const job = createJobFromDefinition(jobDefinition, runtime.config);
+    if (runtime.config.cron.logCronDetails && job.cronExpression) {
+      const timezone = job.timezone ?? runtime.config.cron.defaultTimezone;
+      const result = parseCronExpression(job.cronExpression, void 0, { timezone });
+      runtime.logging.debug(
+        { module: jobDefinition.module },
+        `Job ${jobDefinition.name}: ${result.description} - Next: ${result.nextRun.toLocaleString()}`
+      );
+      const upcoming = getNextExecutions(job.cronExpression, 3, { timezone });
+      runtime.logging.debug(
+        { module: jobDefinition.module },
+        `Upcoming: ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`
+      );
     }
-    if (scheduler.isRunning) {
-      return reply.status(409).send({ error: "Job is already running" });
+    let scheduler = createSchedulerService(job, jobDefinition.handler);
+    if (runtime.config.persistence.enabled) {
+      scheduler = await loadJobState(runtime, scheduler);
     }
-    setImmediate(() => executeJobFn(scheduler));
-    return reply.status(200).send({ message: "Job triggered successfully" });
-  });
+    runtime.schedulers[scheduler.job.id] = scheduler;
+    runtime.logging.info({ module: jobDefinition.module }, `Job added: ${jobDefinition.name} (${scheduler.job.id})`);
+    return scheduler.job.id;
+  } catch (error) {
+    runtime.logging.error({ module: jobDefinition.module, error: error.message }, `Failed to add job ${jobDefinition.name}`);
+    throw error;
+  }
 };
-var registerEnableJobRoute = (app, state, scheduleJobFn) => {
-  app.put("/schedule/jobs/:jobId/enable", async function(request, reply) {
-    const scheduler = state.schedulers[request.params.jobId];
+var removeJob = async (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    const scheduler = findSchedulerByName(runtime, jobName);
     if (!scheduler) {
-      return reply.status(404).send({ error: "Job not found" });
+      throw new Error(`Job '${jobName}' does not exist`);
     }
-    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("/schedule/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" });
+    if (scheduler.isRunning) {
+      runtime.logging.warn({ module: scheduler.job.module }, `Removing job that is currently running: ${jobName}`);
     }
-    const disabledScheduler = disableJob(scheduler);
-    state.schedulers[request.params.jobId] = disabledScheduler;
-    return reply.status(200).send({ message: "Job disabled successfully" });
-  });
+    delete runtime.schedulers[scheduler.job.id];
+    runtime.logging.info({ module: scheduler.job.module }, `Job removed: ${jobName}`);
+  } catch (error) {
+    runtime.logging.error({ error: error.message }, `Failed to remove job ${jobName}`);
+    throw error;
+  }
+};
+var hasJob = (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    return !!findSchedulerByName(runtime, jobName);
+  } catch {
+    return false;
+  }
 };
-var registerAllRoutes = (app, state, executeJobFn, scheduleJobFn) => {
-  registerDashboardRoute(app, state);
-  registerExecutionsRoute(app, state);
-  registerTriggerJobRoute(app, state, executeJobFn);
-  registerEnableJobRoute(app, state, scheduleJobFn);
-  registerDisableJobRoute(app, state);
+var listJobs = (runtime, module) => {
+  return Object.values(runtime.schedulers).filter((scheduler) => !module || scheduler.job.module === module).map((scheduler) => scheduler.job.name).sort();
 };
-
-// src/schedule-plugin/decorator.ts
-var isValidJobName = (jobName) => {
-  return typeof jobName === "string" && jobName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(jobName);
+var getJobStats = (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    return findSchedulerByName(runtime, jobName) ?? null;
+  } catch {
+    return null;
+  }
+};
+var getJobsMap = (runtime) => {
+  return { ...runtime.schedulers };
 };
-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");
+var enableJob2 = async (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    const scheduler = findSchedulerByName(runtime, jobName);
+    if (!scheduler) {
+      throw new Error(`Job '${jobName}' does not exist`);
     }
-    if (!isValidJobName(jobName)) {
-      throw new Error("Job name must contain only alphanumeric characters, hyphens, and underscores");
+    if (scheduler.job.enabled) {
+      runtime.logging.debug({ module: scheduler.job.module }, `Job is already enabled: ${jobName}`);
+      return;
     }
-  };
-  const validateHandler = (handler) => {
-    if (typeof handler !== "function") {
-      throw new Error("Handler must be a function");
+    runtime.schedulers[scheduler.job.id] = enableJob(scheduler);
+    runtime.logging.info({ module: scheduler.job.module }, `Job enabled: ${jobName}`);
+  } catch (error) {
+    runtime.logging.error({ error: error.message }, `Failed to enable job ${jobName}`);
+    throw error;
+  }
+};
+var disableJob2 = async (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    const scheduler = findSchedulerByName(runtime, jobName);
+    if (!scheduler) {
+      throw new Error(`Job '${jobName}' does not exist`);
     }
-  };
-  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(`Job already exists: ${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(`Job added: ${jobDefinition.name} (${job.id})`);
-      return job.id;
-    } catch (error) {
-      logger.error(`Failed to add job ${jobDefinition.name}: ${error.message}`);
-      throw error;
+    if (!scheduler.job.enabled) {
+      runtime.logging.debug({ module: scheduler.job.module }, `Job is already disabled: ${jobName}`);
+      return;
     }
-  };
-  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(`Removing job that is currently running: ${jobName}`);
-      }
-      if (scheduler.timerId) {
-        clearTimeout(scheduler.timerId);
-      }
-      delete state.schedulers[scheduler.job.id];
-      logger.info(`Job removed: ${jobName}`);
-    } catch (error) {
-      logger.error(`Failed to remove job ${jobName}: ${error.message}`);
-      throw error;
+    runtime.schedulers[scheduler.job.id] = disableJob(scheduler);
+    runtime.logging.info({ module: scheduler.job.module }, `Job disabled: ${jobName}`);
+  } catch (error) {
+    runtime.logging.error({ error: error.message }, `Failed to disable job ${jobName}`);
+    throw error;
+  }
+};
+var triggerJob = async (runtime, jobName) => {
+  try {
+    validateJobName(jobName);
+    const scheduler = findSchedulerByName(runtime, jobName);
+    if (!scheduler) {
+      throw new Error(`Job '${jobName}' does not exist`);
     }
-  };
-  const hasJob = (jobName) => {
-    try {
-      validateJobName(jobName);
-      return Object.values(state.schedulers).some((s) => s.job.name === jobName);
-    } catch {
-      return false;
+    if (scheduler.isRunning) {
+      throw new Error(`Job '${jobName}' is already running`);
     }
-  };
-  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;
+    runtime.logging.info({ module: scheduler.job.module }, `Job triggered: ${jobName}`);
+    runtime.logging.runWithLogContext(
+      { module: scheduler.job.module, reqId: scheduler.job.id },
+      () => executeJob(runtime, scheduler)
+    );
+  } catch (error) {
+    runtime.logging.error({ error: error.message }, `Failed to trigger job ${jobName}`);
+    throw error;
+  }
+};
+var getDashboardSummary2 = (runtime) => createDashboardSummary2(runtime);
+var getExecutionsSummary = (runtime) => createExecutionsSummary(runtime);
+var getJobExecutionHistory = (runtime, jobName, limit = 50) => {
+  const scheduler = findSchedulerByName(runtime, jobName);
+  if (!scheduler) {
+    return [];
+  }
+  return runtime.executionHistory.filter((execution) => execution.jobId === scheduler.job.id).slice(-limit).reverse();
+};
+var createSchedulerManager = (runtime) => ({
+  addJob: (jobDefinition) => addJob(runtime, jobDefinition),
+  removeJob: (jobName) => removeJob(runtime, jobName),
+  hasJob: (jobName) => hasJob(runtime, jobName),
+  listJobs: (module) => listJobs(runtime, module),
+  getJobStats: (jobName) => getJobStats(runtime, jobName),
+  getJobsMap: () => getJobsMap(runtime),
+  getConfig: () => runtime.config,
+  enableJob: (jobName) => enableJob2(runtime, jobName),
+  disableJob: (jobName) => disableJob2(runtime, jobName),
+  triggerJob: (jobName) => triggerJob(runtime, jobName),
+  getDashboardSummary: () => getDashboardSummary2(runtime),
+  getExecutionsSummary: () => getExecutionsSummary(runtime),
+  getJobExecutionHistory: (jobName, limit) => getJobExecutionHistory(runtime, jobName, limit)
+});
+
+// src/schedule-plugin/routes.ts
+var registerSchedulerRoutes = (app, prefix = "schedule") => {
+  app.get(
+    `/${prefix}/dashboard`,
+    async (_, reply) => {
+      return reply.status(200).send(app.scheduler.getDashboardSummary());
     }
-  };
-  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.debug(`Job is already enabled: ${jobName}`);
-        return;
-      }
-      scheduler.job.enabled = true;
-      scheduleJobFn(scheduler);
-      logger.info(`Job enabled: ${jobName}`);
-    } catch (error) {
-      logger.error(`Failed to enable job ${jobName}: ${error.message}`);
-      throw error;
+  );
+  app.get(
+    `/${prefix}/executions`,
+    async (_, reply) => {
+      return reply.status(200).send(app.scheduler.getExecutionsSummary());
     }
-  };
-  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.debug(`Job is already disabled: ${jobName}`);
-        return;
-      }
-      scheduler.job.enabled = false;
-      if (scheduler.timerId) {
-        clearTimeout(scheduler.timerId);
-        scheduler.timerId = void 0;
+  );
+  app.post(
+    `/${prefix}/jobs/:jobName/trigger`,
+    async (request, reply) => {
+      try {
+        await app.scheduler.triggerJob(request.params.jobName);
+        return reply.status(200).send({ message: "Job triggered successfully" });
+      } catch (error) {
+        return reply.status(404).send({ error: error.message });
       }
-      logger.info(`Job disabled: ${jobName}`);
-    } catch (error) {
-      logger.error(`Failed to disable job ${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`);
+  );
+  app.put(
+    `/${prefix}/jobs/:jobName/enable`,
+    async (request, reply) => {
+      try {
+        await app.scheduler.enableJob(request.params.jobName);
+        return reply.status(200).send({ message: "Job enabled successfully" });
+      } catch (error) {
+        return reply.status(404).send({ error: error.message });
       }
-      if (scheduler.isRunning) {
-        throw new Error(`Job '${jobName}' is already running`);
+    }
+  );
+  app.put(
+    `/${prefix}/jobs/:jobName/disable`,
+    async (request, reply) => {
+      try {
+        await app.scheduler.disableJob(request.params.jobName);
+        return reply.status(200).send({ message: "Job disabled successfully" });
+      } catch (error) {
+        return reply.status(404).send({ error: error.message });
       }
-      setImmediate(() => executeJob(scheduler));
-      logger.info(`Job triggered: ${jobName}`);
-    } catch (error) {
-      logger.error(`Failed to trigger job ${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 runtime = {
+    config: mergeConfig2(DEFAULT_CONFIG2, options.config),
+    schedulers: {},
+    executions: {},
+    executionHistory: [],
+    isShuttingDown: false,
+    runningExecutions: 0,
+    isDirty: false,
+    lastCleanupTime: Date.now(),
+    lastSavedAt: Date.now(),
+    lastRestartTime: /* @__PURE__ */ new Date(),
+    logging: app.logging
+  };
+  const tickIntervalId = setInterval(() => tick2(runtime), runtime.config.tickIntervalMs);
+  app.addHook("onClose", async () => {
+    runtime.isShuttingDown = true;
+    clearInterval(tickIntervalId);
   });
-  const decorateScheduler = createSchedulerDecorator(schedulerManager);
-  decorateScheduler(app);
-  registerAllRoutes(app, state, executeJob, scheduleJobFn);
+  app.decorate("scheduler", createSchedulerManager(runtime));
+  registerSchedulerRoutes(app, options.prefix);
+  if (runtime.config.persistence.enabled) {
+    await initializePersistence2(runtime);
+  }
 });
 
 // src/websocket-plugin/plugin.ts
@@ -2699,15 +1581,20 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
       preHandler: async (request, reply) => {
         const connectionId = crypto.randomUUID();
         request._wsConnectionId = connectionId;
+        const reqId = `${request.id}:${connectionId}`;
         const connectHandlers = handlers.filter((h) => h.path === path4 && h.event === "connect");
         for (const h of connectHandlers) {
-          await h.handler(connectionId, "connect", null, request, reply);
+          await app.logging.runWithLogContext(
+            { module: h.module, reqId },
+            () => h.handler(connectionId, "connect", null, request, reply)
+          );
         }
         if (reply.statusCode !== 200)
           return reply;
       }
     }, (socket, request) => {
       const connectionId = request._wsConnectionId ?? crypto.randomUUID();
+      const reqId = `${request.id}:${connectionId}`;
       const connection = {
         connectionId,
         socket,
@@ -2732,9 +1619,10 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
           );
           for (const h of routeHandlers) {
             matched = true;
-            h.handler(connectionId, "message", data, request).catch((e) => {
-              logger.error(e);
-            });
+            app.logging.runWithLogContext(
+              { module: h.module, reqId },
+              () => h.handler(connectionId, "message", data, request).catch((e) => app.logging.error(e))
+            );
           }
         }
         if (!matched) {
@@ -2742,18 +1630,20 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
             (h) => h.event === "message" && !h.route
           );
           for (const h of defaultHandlers) {
-            h.handler(connectionId, "message", data, request).catch((e) => {
-              logger.error(e);
-            });
+            app.logging.runWithLogContext(
+              { module: h.module, reqId },
+              () => h.handler(connectionId, "message", data, request).catch((e) => app.logging.error(e))
+            );
           }
         }
       });
       socket.on("close", () => {
         const disconnectHandlers = pathHandlers().filter((h) => h.event === "disconnect");
         for (const h of disconnectHandlers) {
-          h.handler(connectionId, "disconnect", null, request).catch((e) => {
-            logger.error(e);
-          });
+          app.logging.runWithLogContext(
+            { module: h.module, reqId },
+            () => h.handler(connectionId, "disconnect", null, request).catch((e) => app.logging.error(e))
+          );
         }
         connections.delete(connectionId);
       });
@@ -2865,10 +1755,29 @@ var LogStore = class {
   }
 };
 var logStore = new LogStore();
+var HttpHistoryStore = class {
+  entries = /* @__PURE__ */ new Map();
+  maxPerRoute = 50;
+  add(entry) {
+    const key = `${entry.method} ${entry.routeUrl}`;
+    const existing = this.entries.get(key) ?? [];
+    existing.unshift(entry);
+    if (existing.length > this.maxPerRoute) {
+      existing.length = this.maxPerRoute;
+    }
+    this.entries.set(key, existing);
+  }
+  get(method, routeUrl) {
+    return this.entries.get(`${method.toUpperCase()} ${routeUrl}`) ?? [];
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var httpHistoryStore = new HttpHistoryStore();
 async function devConsolePluginFunction(fastify, options = {}) {
   const { prefix = "console", enableUI = true } = options;
-  const upstream = getWriter();
-  setWriter((entry) => {
+  const unsubscribe = fastify.logging.subscribeToLogs((entry) => {
     logStore.addLog({
       id: Date.now().toString() + Math.random().toString(36).slice(2, 9),
       timestamp: new Date(entry.time),
@@ -2878,11 +1787,11 @@ async function devConsolePluginFunction(fastify, options = {}) {
       module: entry.module,
       reqId: entry.reqId
     });
-    upstream(entry);
   });
   fastify.addHook("onClose", (_instance, done) => {
-    setWriter(upstream);
+    unsubscribe();
     logStore.clear();
+    httpHistoryStore.clear();
     done();
   });
   fastify.addHook("onRoute", (routeOptions) => {
@@ -2890,6 +1799,29 @@ async function devConsolePluginFunction(fastify, options = {}) {
       routeRegistry.register(routeOptions);
     }
   });
+  fastify.addHook("onRequest", (request, _reply, done) => {
+    request._historyStart = Date.now();
+    done();
+  });
+  fastify.addHook("onResponse", (request, reply, done) => {
+    const routeUrl = request.routeOptions.url;
+    if (routeUrl?.startsWith("/api")) {
+      const start = request._historyStart;
+      httpHistoryStore.add({
+        id: Date.now().toString() + Math.random().toString(36).slice(2, 9),
+        method: request.method,
+        routeUrl,
+        url: request.url,
+        statusCode: reply.statusCode,
+        duration: start ? Date.now() - start : 0,
+        reqId: request.id,
+        requestHeaders: request.headers,
+        requestBody: request.body,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+    done();
+  });
   fastify.get(`/${prefix}/routes`, async () => {
     return { routes: routeRegistry.getAll() };
   });
@@ -2897,6 +1829,13 @@ async function devConsolePluginFunction(fastify, options = {}) {
     const { method } = request.params;
     return { routes: routeRegistry.getByMethod(method) };
   });
+  fastify.get(`/${prefix}/routes/history`, async (request, reply) => {
+    const { method, url } = request.query;
+    if (!method || !url) {
+      return reply.status(400).send({ error: "method and url query params are required" });
+    }
+    return { history: httpHistoryStore.get(method, url) };
+  });
   fastify.get(`/${prefix}/registry/stats`, async () => {
     return {
       totalRoutes: routeRegistry.count(),
@@ -3013,6 +1952,17 @@ async function devConsolePluginFunction(fastify, options = {}) {
       }
     };
   });
+  fastify.get(`/${prefix}/queues/:queueName/history`, async (request, reply) => {
+    const { queueName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    if (!queueManager.getQueueStats(queueName)) {
+      return reply.status(404).send({ error: "Queue not found" });
+    }
+    return { history: queueManager.getMessageHistory(queueName) };
+  });
   fastify.get(`/${prefix}/queues/:queueName/process-dlq`, async (request, reply) => {
     const { queueName } = request.params;
     const queueManager = fastify.queues;
@@ -3142,6 +2092,17 @@ async function devConsolePluginFunction(fastify, options = {}) {
       timerId: jobStats.timerId ? "scheduled" : "not_scheduled"
     };
   });
+  fastify.get(`/${prefix}/schedules/:jobName/executions`, async (request, reply) => {
+    const { jobName } = request.params;
+    const schedulerManager = fastify.scheduler;
+    if (!schedulerManager) {
+      return reply.status(503).send({ error: "Scheduler service not available" });
+    }
+    if (!schedulerManager.getJobStats(jobName)) {
+      return reply.status(404).send({ error: "Job not found" });
+    }
+    return { executions: schedulerManager.getJobExecutionHistory(jobName) };
+  });
   fastify.post(`/${prefix}/schedules/:jobName/trigger`, async (request, reply) => {
     const { jobName } = request.params;
     const schedulerManager = fastify.scheduler;
@@ -3261,21 +2222,30 @@ async function devConsolePluginFunction(fastify, options = {}) {
     }
   });
   fastify.get(`/${prefix}/logs/stream`, async (request, reply) => {
+    const { level, module, reqId } = request.query;
+    const matchesFilters = (log) => {
+      if (level && log.levelName !== level) return false;
+      if (module && log.module !== module) return false;
+      if (reqId && log.reqId !== reqId) return false;
+      return true;
+    };
     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);
+    const initialLogs = logStore.getLogs(50).filter(matchesFilters);
     reply.raw.write(`data: ${JSON.stringify({ type: "initial", logs: initialLogs })}
 
 `);
-    const unsubscribe = logStore.subscribe((log) => {
-      reply.raw.write(`data: ${JSON.stringify({ type: "log", log })}
+    const unsubscribe2 = logStore.subscribe((log) => {
+      if (matchesFilters(log)) {
+        reply.raw.write(`data: ${JSON.stringify({ type: "log", log })}
 
 `);
+      }
     });
     request.raw.on("close", () => {
-      unsubscribe();
+      unsubscribe2();
     });
   });
   if (enableUI) {
@@ -3299,17 +2269,4 @@ 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.js.map