@cadenza.io/core 3.15.13 → 3.16.1

package/dist/index.mjs

@@ -256,12 +256,983 @@ function debounce(func, wait, options) {
 }
 var debounce_default = debounce;
 
+// node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// node_modules/lodash-es/identity.js
+function identity(value) {
+  return value;
+}
+var identity_default = identity;
+
+// 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/_baseCreate.js
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ (function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject_default(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+})();
+var baseCreate_default = baseCreate;
+
+// node_modules/lodash-es/_apply.js
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+var apply_default = apply;
+
+// node_modules/lodash-es/_copyArray.js
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var copyArray_default = copyArray;
+
+// node_modules/lodash-es/_shortOut.js
+var HOT_COUNT = 800;
+var HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(void 0, arguments);
+  };
+}
+var shortOut_default = shortOut;
+
+// node_modules/lodash-es/constant.js
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+var constant_default = constant;
+
+// node_modules/lodash-es/_defineProperty.js
+var defineProperty = (function() {
+  try {
+    var func = getNative_default(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+})();
+var defineProperty_default = defineProperty;
+
+// node_modules/lodash-es/_baseSetToString.js
+var baseSetToString = !defineProperty_default ? identity_default : function(func, string) {
+  return defineProperty_default(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant_default(string),
+    "writable": true
+  });
+};
+var baseSetToString_default = baseSetToString;
+
+// node_modules/lodash-es/_setToString.js
+var setToString = shortOut_default(baseSetToString_default);
+var setToString_default = setToString;
+
+// 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/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty_default) {
+    defineProperty_default(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var baseAssignValue_default = baseAssignValue;
+
+// 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/_assignValue.js
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty3.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue_default(object, key, value);
+  }
+}
+var assignValue_default = assignValue;
+
+// node_modules/lodash-es/_copyObject.js
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue_default(object, key, newValue);
+    } else {
+      assignValue_default(object, key, newValue);
+    }
+  }
+  return object;
+}
+var copyObject_default = copyObject;
+
+// node_modules/lodash-es/_overRest.js
+var nativeMax2 = Math.max;
+function overRest(func, start, transform) {
+  start = nativeMax2(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax2(args.length - start, 0), array = Array(length);
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply_default(func, this, otherArgs);
+  };
+}
+var overRest_default = overRest;
+
+// node_modules/lodash-es/_baseRest.js
+function baseRest(func, start) {
+  return setToString_default(overRest_default(func, start, identity_default), func + "");
+}
+var baseRest_default = baseRest;
+
+// 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/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// node_modules/lodash-es/_isIterateeCall.js
+function isIterateeCall(value, index, object) {
+  if (!isObject_default(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike_default(object) && isIndex_default(index, object.length) : type == "string" && index in object) {
+    return eq_default(object[index], value);
+  }
+  return false;
+}
+var isIterateeCall_default = isIterateeCall;
+
+// node_modules/lodash-es/_createAssigner.js
+function createAssigner(assigner) {
+  return baseRest_default(function(object, sources) {
+    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+    if (guard && isIterateeCall_default(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? void 0 : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+var createAssigner_default = createAssigner;
+
+// node_modules/lodash-es/_isPrototype.js
+var objectProto5 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto5;
+  return value === proto;
+}
+var isPrototype_default = isPrototype;
+
+// node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var baseTimes_default = baseTimes;
+
+// 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 objectProto6 = Object.prototype;
+var hasOwnProperty4 = objectProto6.hasOwnProperty;
+var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root_default.Buffer : void 0;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
+}
+var baseIsTypedArray_default = baseIsTypedArray;
+
+// node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var baseUnary_default = baseUnary;
+
+// node_modules/lodash-es/_nodeUtil.js
+var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && freeGlobal_default.process;
+var nodeUtil = (function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+})();
+var nodeUtil_default = nodeUtil;
+
+// node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty5 = objectProto7.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty5.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var arrayLikeKeys_default = arrayLikeKeys;
+
+// node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// node_modules/lodash-es/_nativeKeysIn.js
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var nativeKeysIn_default = nativeKeysIn;
+
+// node_modules/lodash-es/_baseKeysIn.js
+var objectProto8 = Object.prototype;
+var hasOwnProperty6 = objectProto8.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject_default(object)) {
+    return nativeKeysIn_default(object);
+  }
+  var isProto = isPrototype_default(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty6.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeysIn_default = baseKeysIn;
+
+// node_modules/lodash-es/keysIn.js
+function keysIn(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object, true) : baseKeysIn_default(object);
+}
+var keysIn_default = keysIn;
+
+// 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 objectProto9 = Object.prototype;
+var hasOwnProperty7 = objectProto9.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty7.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// node_modules/lodash-es/_hashHas.js
+var objectProto10 = Object.prototype;
+var hasOwnProperty8 = objectProto10.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty8.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(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[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/_getPrototype.js
+var getPrototype = overArg_default(Object.getPrototypeOf, Object);
+var getPrototype_default = getPrototype;
+
+// node_modules/lodash-es/isPlainObject.js
+var objectTag2 = "[object Object]";
+var funcProto3 = Function.prototype;
+var objectProto11 = Object.prototype;
+var funcToString3 = funcProto3.toString;
+var hasOwnProperty9 = objectProto11.hasOwnProperty;
+var objectCtorString = funcToString3.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag2) {
+    return false;
+  }
+  var proto = getPrototype_default(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty9.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
+}
+var isPlainObject_default = isPlainObject;
+
+// node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new ListCache_default();
+  this.size = 0;
+}
+var stackClear_default = stackClear;
+
+// node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var stackDelete_default = stackDelete;
+
+// node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var stackGet_default = stackGet;
+
+// node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var stackHas_default = stackHas;
+
+// node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache_default) {
+    var pairs = data.__data__;
+    if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var stackSet_default = stackSet;
+
+// node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear_default;
+Stack.prototype["delete"] = stackDelete_default;
+Stack.prototype.get = stackGet_default;
+Stack.prototype.has = stackHas_default;
+Stack.prototype.set = stackSet_default;
+var Stack_default = Stack;
+
+// node_modules/lodash-es/_cloneBuffer.js
+var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
+var Buffer2 = moduleExports3 ? root_default.Buffer : void 0;
+var allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+var cloneBuffer_default = cloneBuffer;
+
+// node_modules/lodash-es/_Uint8Array.js
+var Uint8Array = root_default.Uint8Array;
+var Uint8Array_default = Uint8Array;
+
+// node_modules/lodash-es/_cloneArrayBuffer.js
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer));
+  return result;
+}
+var cloneArrayBuffer_default = cloneArrayBuffer;
+
+// node_modules/lodash-es/_cloneTypedArray.js
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var cloneTypedArray_default = cloneTypedArray;
+
+// node_modules/lodash-es/_initCloneObject.js
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
+}
+var initCloneObject_default = initCloneObject;
+
+// node_modules/lodash-es/_createBaseFor.js
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var createBaseFor_default = createBaseFor;
+
+// node_modules/lodash-es/_baseFor.js
+var baseFor = createBaseFor_default();
+var baseFor_default = baseFor;
+
+// node_modules/lodash-es/_assignMergeValue.js
+function assignMergeValue(object, key, value) {
+  if (value !== void 0 && !eq_default(object[key], value) || value === void 0 && !(key in object)) {
+    baseAssignValue_default(object, key, value);
+  }
+}
+var assignMergeValue_default = assignMergeValue;
+
+// node_modules/lodash-es/isArrayLikeObject.js
+function isArrayLikeObject(value) {
+  return isObjectLike_default(value) && isArrayLike_default(value);
+}
+var isArrayLikeObject_default = isArrayLikeObject;
+
+// node_modules/lodash-es/_safeGet.js
+function safeGet(object, key) {
+  if (key === "constructor" && typeof object[key] === "function") {
+    return;
+  }
+  if (key == "__proto__") {
+    return;
+  }
+  return object[key];
+}
+var safeGet_default = safeGet;
+
+// node_modules/lodash-es/toPlainObject.js
+function toPlainObject(value) {
+  return copyObject_default(value, keysIn_default(value));
+}
+var toPlainObject_default = toPlainObject;
+
+// node_modules/lodash-es/_baseMergeDeep.js
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet_default(object, key), srcValue = safeGet_default(source, key), stacked = stack.get(srcValue);
+  if (stacked) {
+    assignMergeValue_default(object, key, stacked);
+    return;
+  }
+  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+  var isCommon = newValue === void 0;
+  if (isCommon) {
+    var isArr = isArray_default(srcValue), isBuff = !isArr && isBuffer_default(srcValue), isTyped = !isArr && !isBuff && isTypedArray_default(srcValue);
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray_default(objValue)) {
+        newValue = objValue;
+      } else if (isArrayLikeObject_default(objValue)) {
+        newValue = copyArray_default(objValue);
+      } else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer_default(srcValue, true);
+      } else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray_default(srcValue, true);
+      } else {
+        newValue = [];
+      }
+    } else if (isPlainObject_default(srcValue) || isArguments_default(srcValue)) {
+      newValue = objValue;
+      if (isArguments_default(objValue)) {
+        newValue = toPlainObject_default(objValue);
+      } else if (!isObject_default(objValue) || isFunction_default(objValue)) {
+        newValue = initCloneObject_default(srcValue);
+      }
+    } else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack["delete"](srcValue);
+  }
+  assignMergeValue_default(object, key, newValue);
+}
+var baseMergeDeep_default = baseMergeDeep;
+
+// node_modules/lodash-es/_baseMerge.js
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor_default(source, function(srcValue, key) {
+    stack || (stack = new Stack_default());
+    if (isObject_default(srcValue)) {
+      baseMergeDeep_default(object, source, key, srcIndex, baseMerge, customizer, stack);
+    } else {
+      var newValue = customizer ? customizer(safeGet_default(object, key), srcValue, key + "", object, source, stack) : void 0;
+      if (newValue === void 0) {
+        newValue = srcValue;
+      }
+      assignMergeValue_default(object, key, newValue);
+    }
+  }, keysIn_default);
+}
+var baseMerge_default = baseMerge;
+
+// node_modules/lodash-es/merge.js
+var merge = createAssigner_default(function(object, source, srcIndex) {
+  baseMerge_default(object, source, srcIndex);
+});
+var merge_default = merge;
+
 // src/engine/SignalBroker.ts
 var SignalBroker = class _SignalBroker {
   constructor() {
     this.debug = false;
     this.verbose = false;
     this.debouncedEmitters = /* @__PURE__ */ new Map();
+    this.squashedEmitters = /* @__PURE__ */ new Map();
+    this.squashedContexts = /* @__PURE__ */ new Map();
     // TODO: Signals should be a class with a the observers, registered flag and other data.
     this.signalObservers = /* @__PURE__ */ new Map();
     this.emittedSignalsRegistry = /* @__PURE__ */ new Set();
@@ -345,6 +1316,9 @@ var SignalBroker = class _SignalBroker {
       "Register signal",
       (ctx) => {
         const { signalName } = ctx;
+        if (this.signalObservers.has(signalName)) {
+          this.addSignal(signalName);
+        }
         this.signalObservers.get(signalName).registered = true;
       }
     ).doOn("meta.signal.registered");
@@ -382,16 +1356,15 @@ var SignalBroker = class _SignalBroker {
    *
    * @param {string} signal - The name of the signal to be emitted.
    * @param {AnyObject} context - The context to be passed along with the signal.
-   * @param {number} [timeoutMs=60000] - The delay in milliseconds before the signal is emitted. Defaults to 60,000 ms.
-   * @param {Date} [exactDateTime] - An exact date and time at which to emit the signal. If provided, this overrides the `timeoutMs`.
+   * @param options
    * @return {AbortController} An AbortController instance that can be used to cancel the scheduled signal emission.
    */
-  schedule(signal, context, timeoutMs = 6e4, exactDateTime) {
-    let delay = timeoutMs;
-    if (exactDateTime != null) {
-      delay = exactDateTime.getTime() - Date.now();
+  schedule(signal, context, options = { delayMs: 6e4 }) {
+    let delay = options.delayMs;
+    if (options.exactDateTime != null) {
+      delay = options.exactDateTime.getTime() - Date.now();
     }
-    delay = Math.max(0, timeoutMs);
+    delay = Math.max(0, delay ?? 0);
     const controller = new AbortController();
     const { signal: signalController } = controller;
     const tick = () => this.emit(signal, context);
@@ -447,29 +1420,76 @@ var SignalBroker = class _SignalBroker {
       }
     };
   }
-  debounce(signal, context, delayMs = 500) {
+  debounce(signal, context, options = { delayMs: 500 }) {
     let debouncedEmitter = this.debouncedEmitters.get(signal);
     if (!debouncedEmitter) {
       this.debouncedEmitters.set(
         signal,
         debounce_default((ctx) => {
           this.emit(signal, ctx);
-        }, delayMs)
+        }, options.delayMs ?? 300)
       );
       debouncedEmitter = this.debouncedEmitters.get(signal);
     }
     debouncedEmitter(context);
   }
+  /**
+   * Aggregates and debounces multiple events with the same identifier to minimize redundant operations.
+   *
+   * @param {string} signal - The identifier for the event being emitted.
+   * @param {AnyObject} context - The context data associated with the event.
+   * @param {Object} [options] - Configuration options for handling the squashed event.
+   * @param {boolean} [options.squash=true] - Whether the event should be squashed.
+   * @param {string|null} [options.squashId=null] - A unique identifier for the squashed group of events. Defaults to the signal if null.
+   * @param {function|null} [options.mergeFunction=null] - A custom merge function that combines old and new contexts. If null, a default merge is used.
+   * @return {void} Does not return a value.
+   */
+  squash(signal, context, options = { squash: true }) {
+    let { squashId, delayMs } = options;
+    if (!squashId) {
+      squashId = signal;
+    }
+    if (!this.squashedEmitters.has(squashId)) {
+      this.squashedEmitters.set(
+        squashId,
+        debounce_default(() => {
+          this.emit(signal, this.squashedContexts.get(squashId));
+          this.squashedEmitters.delete(squashId);
+          this.squashedContexts.delete(squashId);
+        }, delayMs ?? 300)
+      );
+      this.squashedContexts.set(squashId, context);
+    } else {
+      this.squashedContexts.set(
+        squashId,
+        options.mergeFunction ? options.mergeFunction(this.squashedContexts.get(squashId), context) : merge_default(this.squashedContexts.get(squashId), context)
+      );
+    }
+    this.squashedEmitters.get(squashId)();
+  }
   /**
    * Emits a signal with the specified context, triggering any associated handlers for that signal.
    *
    * @param {string} signal - The name of the signal to emit.
    * @param {AnyObject} [context={}] - An optional context object containing additional information or metadata
    * associated with the signal. If the context includes a `__routineExecId`, it will be handled accordingly.
+   * @param options
    * @return {void} This method does not return a value.
    */
-  emit(signal, context = {}) {
+  emit(signal, context = {}, options = {}) {
     delete context.__routineExecId;
+    if (options.squash) {
+      this.squash(signal, context, options);
+      return;
+    }
+    if (options.debounce) {
+      this.debounce(signal, context);
+      return;
+    }
+    if (options.schedule) {
+      this.schedule(signal, context, options);
+      return;
+    }
     this.addSignal(signal);
     this.execute(signal, context);
   }
@@ -1018,16 +2038,18 @@ var SignalEmitter = class {
    * Emits a signal via the broker.
    * @param signal The signal name.
    * @param data Optional payload (defaults to empty object).
+   * @param options
    */
-  emit(signal, data = {}) {
+  emit(signal, data = {}, options = {}) {
     Cadenza.broker.emit(signal, data);
   }
   /**
    * Emits a signal via the broker if not silent.
    * @param signal The signal name.
    * @param data Optional payload (defaults to empty object).
+   * @param options
    */
-  emitMetrics(signal, data = {}) {
+  emitMetrics(signal, data = {}, options = {}) {
     if (this.silent) {
       return;
     }
@@ -1189,36 +2211,52 @@ var GraphNode = class _GraphNode extends SignalEmitter {
         context.__signalEmission.consumed = true;
         context.__signalEmission.consumedBy = this.id;
       }
+      const prevNodesIds = this.previousNodes.map((node) => node.id);
+      if (context.__previousTaskExecutionId) {
+        prevNodesIds.push(context.__previousTaskExecutionId);
+        context.__previousTaskExecutionId = null;
+      }
       const scheduledAt = Date.now();
-      this.emitMetricsWithMetadata("meta.node.scheduled", {
-        data: {
-          uuid: this.id,
-          routineExecutionId: this.routineExecId,
-          executionTraceId: this.executionTraceId,
-          context: this.context.getContext(),
-          metaContext: this.context.getMetadata(),
-          taskName: this.task.name,
-          taskVersion: this.task.version,
-          isMeta: this.isMeta(),
-          isScheduled: true,
-          splitGroupId: this.splitGroupId,
-          signalEmissionId,
-          created: formatTimestamp(scheduledAt)
-        }
-      });
-      this.previousNodes.forEach((node) => {
-        this.emitMetricsWithMetadata("meta.node.mapped", {
+      this.emitMetricsWithMetadata(
+        "meta.node.scheduled",
+        {
           data: {
-            taskExecutionId: this.id,
-            previousTaskExecutionId: node.id
-          },
-          filter: {
+            uuid: this.id,
+            routineExecutionId: this.routineExecId,
+            executionTraceId: this.executionTraceId,
+            context: this.context.getContext(),
+            metaContext: this.context.getMetadata(),
             taskName: this.task.name,
             taskVersion: this.task.version,
-            predecessorTaskName: node.task.name,
-            predecessorTaskVersion: node.task.version
+            isMeta: this.isMeta(),
+            isScheduled: true,
+            splitGroupId: this.splitGroupId,
+            signalEmissionId,
+            previousExecutionIds: {
+              ids: prevNodesIds
+            },
+            created: formatTimestamp(scheduledAt)
           }
-        });
+        },
+        { squash: true, squashId: this.id }
+      );
+      this.previousNodes.forEach((node) => {
+        this.emitMetricsWithMetadata(
+          "meta.node.mapped",
+          {
+            data: {
+              taskExecutionId: this.id,
+              previousTaskExecutionId: node.id
+            },
+            filter: {
+              taskName: this.task.name,
+              taskVersion: this.task.version,
+              predecessorTaskName: node.task.name,
+              predecessorTaskVersion: node.task.version
+            }
+          },
+          { schedule: true, delayMs: 1e3 }
+        );
       });
       if (!this.silent && context.__previousTaskExecutionId) {
         this.emitMetricsWithMetadata(
@@ -1234,7 +2272,8 @@ var GraphNode = class _GraphNode extends SignalEmitter {
               predecessorTaskName: context.__localTaskName,
               predecessorTaskVersion: context.__localTaskVersion
             }
-          }
+          },
+          { schedule: true, delayMs: 1e3 }
         );
         context.__previousTaskExecutionId = null;
       }
@@ -1257,24 +2296,32 @@ var GraphNode = class _GraphNode extends SignalEmitter {
       this.executionStart = Date.now();
     }
     if (this.previousNodes.length === 0) {
-      this.emitMetricsWithMetadata("meta.node.started_routine_execution", {
-        data: {
-          isRunning: true,
-          started: formatTimestamp(this.executionStart)
+      this.emitMetricsWithMetadata(
+        "meta.node.started_routine_execution",
+        {
+          data: {
+            isRunning: true,
+            started: formatTimestamp(this.executionStart)
+          },
+          filter: { uuid: this.routineExecId }
         },
-        filter: { uuid: this.routineExecId }
-      });
+        { squash: true, squashId: this.routineExecId }
+      );
     }
     if (this.debug && !this.task.isSubMeta && !this.context.getMetadata().__isSubMeta || this.verbose) {
       this.log();
     }
-    this.emitMetricsWithMetadata("meta.node.started", {
-      data: {
-        isRunning: true,
-        started: formatTimestamp(this.executionStart)
+    this.emitMetricsWithMetadata(
+      "meta.node.started",
+      {
+        data: {
+          isRunning: true,
+          started: formatTimestamp(this.executionStart)
+        },
+        filter: { uuid: this.id }
       },
-      filter: { uuid: this.id }
-    });
+      { squash: true, squashId: this.id }
+    );
     return this.executionStart;
   }
   /**
@@ -1303,20 +2350,24 @@ var GraphNode = class _GraphNode extends SignalEmitter {
         }
       });
     }
-    this.emitMetricsWithMetadata("meta.node.ended", {
-      data: {
-        isRunning: false,
-        isComplete: true,
-        resultContext: this.context.getContext(),
-        metaResultContext: this.context.getMetadata(),
-        errored: this.errored,
-        failed: this.failed,
-        errorMessage: context.__error,
-        progress: 1,
-        ended: formatTimestamp(end)
+    this.emitMetricsWithMetadata(
+      "meta.node.ended",
+      {
+        data: {
+          isRunning: false,
+          isComplete: true,
+          resultContext: this.context.getContext(),
+          metaResultContext: this.context.getMetadata(),
+          errored: this.errored,
+          failed: this.failed,
+          errorMessage: context.__error,
+          progress: 1,
+          ended: formatTimestamp(end)
+        },
+        filter: { uuid: this.id }
       },
-      filter: { uuid: this.id }
-    });
+      { squash: true, squashId: this.id }
+    );
     if (this.graphDone()) {
       const context2 = this.context.getFullContext();
       if (context2.__isDeputy)
@@ -1324,17 +2375,21 @@ var GraphNode = class _GraphNode extends SignalEmitter {
           `meta.node.graph_completed:${this.routineExecId}`,
           context2
         );
-      this.emitMetricsWithMetadata("meta.node.ended_routine_execution", {
-        data: {
-          isRunning: false,
-          isComplete: true,
-          resultContext: this.context.getContext(),
-          metaResultContext: this.context.getMetadata(),
-          progress: 1,
-          ended: formatTimestamp(end)
+      this.emitMetricsWithMetadata(
+        "meta.node.ended_routine_execution",
+        {
+          data: {
+            isRunning: false,
+            isComplete: true,
+            resultContext: this.context.getContext(),
+            metaResultContext: this.context.getMetadata(),
+            progress: 1,
+            ended: formatTimestamp(end)
+          },
+          filter: { uuid: this.routineExecId }
         },
-        filter: { uuid: this.routineExecId }
-      });
+        { squash: true, squashId: this.routineExecId }
+      );
     }
     return end;
   }
@@ -1451,9 +2506,10 @@ var GraphNode = class _GraphNode extends SignalEmitter {
    * @param {string} signal - The name of the signal to be emitted.
    * @param {AnyObject} data - The data object to be sent along with the signal. Metadata
    * will be injected into this object before being emitted.
+   * @param options
    * @return {void} No return value.
    */
-  emitWithMetadata(signal, data) {
+  emitWithMetadata(signal, data, options = {}) {
     if (!this.task?.isHidden) {
       data.__signalEmission = {
         fullSignalName: signal,
@@ -1470,7 +2526,7 @@ var GraphNode = class _GraphNode extends SignalEmitter {
         __executionTraceId: this.executionTraceId
       };
     }
-    this.emit(signal, data);
+    this.emit(signal, data, options);
     if (!this.task.emitsSignals.has(signal)) {
       this.task.emitsSignals.add(signal);
     }
@@ -1480,9 +2536,10 @@ var GraphNode = class _GraphNode extends SignalEmitter {
    *
    * @param {string} signal - The signal name being emitted.
    * @param {AnyObject} data - The data associated with the signal emission, enriched with metadata.
+   * @param options
    * @return {void} Emits the signal with enriched data and does not return a value.
    */
-  emitMetricsWithMetadata(signal, data) {
+  emitMetricsWithMetadata(signal, data, options = {}) {
     if (!this.task?.isHidden) {
       data.__signalEmission = {
         taskName: this.task.name,
@@ -1498,7 +2555,7 @@ var GraphNode = class _GraphNode extends SignalEmitter {
         __executionTraceId: this.executionTraceId
       };
     }
-    this.emitMetrics(signal, data);
+    this.emitMetrics(signal, data, options);
     if (!this.task.emitsSignals.has(signal)) {
       this.task.emitsSignals.add(signal);
     }
@@ -1511,14 +2568,18 @@ var GraphNode = class _GraphNode extends SignalEmitter {
    */
   onProgress(progress) {
     progress = Math.min(Math.max(0, progress), 1);
-    this.emitMetricsWithMetadata("meta.node.progress", {
-      data: {
-        progress
+    this.emitMetricsWithMetadata(
+      "meta.node.progress",
+      {
+        data: {
+          progress
+        },
+        filter: {
+          uuid: this.id
+        }
       },
-      filter: {
-        uuid: this.id
-      }
-    });
+      { debounce: true }
+    );
     this.emitMetricsWithMetadata(
       `meta.node.routine_execution_progress:${this.routineExecId}`,
       {
@@ -1528,7 +2589,8 @@ var GraphNode = class _GraphNode extends SignalEmitter {
         filter: {
           uuid: this.routineExecId
         }
-      }
+      },
+      { debounce: true }
     );
   }
   /**
@@ -2189,22 +3251,26 @@ var GraphRunner = class extends SignalEmitter {
           }
         });
       }
-      this.emitMetrics("meta.runner.added_tasks", {
-        data: {
-          uuid: routineExecId,
-          name: routineName,
-          routineVersion,
-          isMeta,
-          executionTraceId,
-          context: ctx.getContext(),
-          metaContext: ctx.getMetadata(),
-          previousRoutineExecution: context.__localRoutineExecId ?? context.__metadata?.__routineExecId ?? null,
-          created: formatTimestamp(Date.now())
+      this.emitMetrics(
+        "meta.runner.added_tasks",
+        {
+          data: {
+            uuid: routineExecId,
+            name: routineName,
+            routineVersion,
+            isMeta,
+            executionTraceId,
+            context: ctx.getContext(),
+            metaContext: ctx.getMetadata(),
+            previousRoutineExecution: context.__localRoutineExecId ?? context.__metadata?.__routineExecId ?? null,
+            created: formatTimestamp(Date.now())
+          },
+          __metadata: {
+            __executionTraceId: executionTraceId
+          }
         },
-        __metadata: {
-          __executionTraceId: executionTraceId
-        }
-      });
+        { squash: true, squashId: routineExecId }
+      );
     }
     allTasks.forEach(
       (task) => this.currentRun.addNode(
@@ -2403,7 +3469,6 @@ var Task = class _Task extends SignalEmitter {
     this.attachSignal(
       "meta.task.created",
       "meta.task.destroyed",
-      "meta.task.version_set",
       "meta.task.output_validation_failed",
       "meta.task.input_validation_failed",
       "meta.task.relationship_added",
@@ -4455,6 +5520,7 @@ var Cadenza = class {
    *
    * @param {string} event - The name of the event to emit.
    * @param {AnyObject} [data={}] - The data payload associated with the event.
+   * @param options
    * @return {void} - No return value.
    *
    * @example
@@ -4464,11 +5530,11 @@ var Cadenza = class {
    * Cadenza.emit('main.my_event', { foo: 'bar' });
    * ```
    */
-  static emit(event, data = {}) {
-    this.broker?.emit(event, data);
+  static emit(event, data = {}, options = {}) {
+    this.broker?.emit(event, data, options);
   }
-  static schedule(taskName, context, timeoutMs, exactDateTime) {
-    this.broker?.schedule(taskName, context, timeoutMs, exactDateTime);
+  static schedule(taskName, context, delayMs, exactDateTime) {
+    this.broker?.schedule(taskName, context, { delayMs, exactDateTime });
   }
   static interval(taskName, context, intervalMs, leading = false, startDateTime) {
     this.broker?.interval(
@@ -4480,7 +5546,7 @@ var Cadenza = class {
     );
   }
   static debounce(signalName, context, delayMs) {
-    this.broker?.debounce(signalName, context, delayMs);
+    this.broker?.debounce(signalName, context, { delayMs });
   }
   static get(taskName) {
     return this.registry?.tasks.get(taskName);
@@ -5048,4 +6114,17 @@ export {
   Task,
   index_default as default
 };
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/
 //# sourceMappingURL=index.mjs.map