@cadenza.io/core 3.13.3 → 3.15.0

package/dist/index.js

@@ -79,13 +79,230 @@ function formatTimestamp(timestamp) {
 
 // src/engine/SignalBroker.ts
 var import_uuid = require("uuid");
+
+// 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/_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/now.js
+var now = function() {
+  return root_default.Date.now();
+};
+var now_default = now;
+
+// 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/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// 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/toNumber.js
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol_default(value)) {
+    return NAN;
+  }
+  if (isObject_default(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject_default(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim_default(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_default = toNumber;
+
+// node_modules/lodash-es/debounce.js
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max;
+var nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber_default(wait) || 0;
+  if (isObject_default(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber_default(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now_default();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now_default());
+  }
+  function debounced() {
+    var time = now_default(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+var debounce_default = debounce;
+
+// src/engine/SignalBroker.ts
 var SignalBroker = class _SignalBroker {
   // execId -> emitted signals
   constructor() {
     this.debug = false;
     this.verbose = false;
+    this.debouncedEmitters = /* @__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();
     this.emitStacks = /* @__PURE__ */ new Map();
     this.addSignal("meta.signal_broker.added");
   }
@@ -192,6 +409,9 @@ var SignalBroker = class _SignalBroker {
     this.addSignal(signal);
     this.signalObservers.get(signal).tasks.add(routineOrTask);
   }
+  registerEmittedSignal(signal) {
+    this.emittedSignalsRegistry.add(signal);
+  }
   /**
    * Unsubscribes a routine/task from a signal.
    * @param signal The signal.
@@ -247,20 +467,20 @@ var SignalBroker = class _SignalBroker {
     }
     const emit = () => this.emit(signal, context);
     if (leading) {
-      const now = Date.now();
+      const now2 = Date.now();
       const start = startDateTime?.getTime();
-      if (!start || start <= now) {
+      if (!start || start <= now2) {
         emit();
       }
     }
     let firstDelay = intervalMs;
     if (startDateTime) {
       let slot = startDateTime.getTime();
-      const now = Date.now();
-      while (slot < now) {
+      const now2 = Date.now();
+      while (slot < now2) {
         slot += intervalMs;
       }
-      firstDelay = slot - now;
+      firstDelay = slot - now2;
     }
     let timer = null;
     let stopped = false;
@@ -277,6 +497,19 @@ var SignalBroker = class _SignalBroker {
       }
     };
   }
+  debounce(signal, context, delayMs = 500) {
+    let debouncedEmitter = this.debouncedEmitters.get(signal);
+    if (!debouncedEmitter) {
+      this.debouncedEmitters.set(
+        signal,
+        debounce_default((ctx) => {
+          this.emit(signal, ctx);
+        }, delayMs)
+      );
+      debouncedEmitter = this.debouncedEmitters.get(signal);
+    }
+    debouncedEmitter(context);
+  }
   /**
    * Emits a signal with the specified context, triggering any associated handlers for that signal.
    *
@@ -454,14 +687,18 @@ var SignalBroker = class _SignalBroker {
   listObservedSignals() {
     return Array.from(this.signalObservers.keys());
   }
+  listEmittedSignals() {
+    return Array.from(this.emittedSignalsRegistry);
+  }
   reset() {
     this.emitStacks.clear();
     this.signalObservers.clear();
+    this.emittedSignalsRegistry.clear();
   }
 };
 
 // src/engine/GraphRunner.ts
-var import_uuid6 = require("uuid");
+var import_uuid5 = require("uuid");
 
 // src/engine/GraphRun.ts
 var import_uuid2 = require("uuid");
@@ -1966,8 +2203,178 @@ var GraphRoutine = class extends SignalEmitter {
   }
 };
 
+// src/engine/GraphRunner.ts
+var GraphRunner = class extends SignalEmitter {
+  /**
+   * Constructs a runner.
+   * @param isMeta Meta flag (default false).
+   * @edge Creates 'Start run' meta-task chained to registry gets.
+   */
+  constructor(isMeta = false) {
+    super(isMeta);
+    this.debug = false;
+    this.verbose = false;
+    this.isRunning = false;
+    this.isMeta = false;
+    this.isMeta = isMeta;
+    this.strategy = Cadenza.runStrategy.PARALLEL;
+    this.currentRun = new GraphRun(this.strategy);
+  }
+  /**
+   * Adds tasks or routines to the current execution pipeline. Supports both individual tasks,
+   * routines, or arrays of tasks and routines. Handles metadata and execution context management.
+   *
+   * @param {Task|GraphRoutine|(Task|GraphRoutine)[]} tasks - The task(s) or routine(s) to be added.
+   * It can be a single task, a single routine, or an array of tasks and routines.
+   * @param {AnyObject} [context={}] - Optional context object to provide execution trace and metadata.
+   * Used to propagate information across task or routine executions.
+   * @return {void} - This method does not return a value.
+   */
+  addTasks(tasks, context = {}) {
+    let _tasks = Array.isArray(tasks) ? tasks : [tasks];
+    if (_tasks.length === 0) {
+      console.warn("No tasks/routines to add.");
+      return;
+    }
+    let routineName = _tasks.map((t) => t.name).join(" | ");
+    let routineVersion = null;
+    let isMeta = _tasks.every((t) => t.isMeta);
+    const allTasks = _tasks.flatMap((t) => {
+      if (t instanceof GraphRoutine) {
+        routineName = t.name;
+        routineVersion = t.version;
+        isMeta = t.isMeta;
+        const routineTasks = [];
+        t.forEachTask((task) => routineTasks.push(task));
+        return routineTasks;
+      }
+      return t;
+    });
+    const isSubMeta = allTasks.some((t) => t.isSubMeta) || !!context.__isSubMeta;
+    context.__isSubMeta = isSubMeta;
+    const isNewTrace = !context.__routineExecId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
+    const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? (0, import_uuid5.v4)();
+    context.__executionTraceId = executionTraceId;
+    const routineExecId = context.__routineExecId ?? (0, import_uuid5.v4)();
+    context.__routineExecId = routineExecId;
+    const ctx = new GraphContext(context || {});
+    if (!isSubMeta) {
+      const contextData = ctx.export();
+      if (isNewTrace) {
+        this.emitMetrics("meta.runner.new_trace", {
+          data: {
+            uuid: executionTraceId,
+            issuer_type: "service",
+            // TODO: Add issuer type
+            issuer_id: context.__metadata?.__issuerId ?? context.__issuerId ?? null,
+            issued_at: formatTimestamp(Date.now()),
+            intent: context.__metadata?.__intent ?? context.__intent ?? null,
+            context: contextData,
+            is_meta: isMeta
+          },
+          __metadata: {
+            __executionTraceId: executionTraceId
+          }
+        });
+      }
+      this.emitMetrics("meta.runner.added_tasks", {
+        data: {
+          uuid: routineExecId,
+          name: routineName,
+          routineVersion,
+          isMeta,
+          executionTraceId,
+          context: isNewTrace ? contextData.id : contextData,
+          previousRoutineExecution: context.__localRoutineExecId ?? context.__metadata?.__routineExecId ?? null,
+          created: formatTimestamp(Date.now())
+        },
+        __metadata: {
+          __executionTraceId: executionTraceId
+        }
+      });
+    }
+    allTasks.forEach(
+      (task) => this.currentRun.addNode(
+        new GraphNode(task, ctx, routineExecId, [], this.debug, this.verbose)
+      )
+    );
+  }
+  /**
+   * Executes the provided tasks or routines. Maintains the execution state
+   * and handles synchronous or asynchronous processing.
+   *
+   * @param {Task|GraphRoutine|(Task|GraphRoutine)[]} [tasks] - A single task, a single routine, or an array of tasks or routines to execute. Optional.
+   * @param {AnyObject} [context] - An optional context object to be used during task execution.
+   * @return {GraphRun|Promise<GraphRun>} - Returns a `GraphRun` instance if the execution is synchronous, or a `Promise` resolving to a `GraphRun` for asynchronous execution.
+   */
+  run(tasks, context) {
+    if (tasks) {
+      this.addTasks(tasks, context ?? {});
+    }
+    if (this.isRunning) {
+      return this.currentRun;
+    }
+    if (this.currentRun) {
+      this.isRunning = true;
+      const runResult = this.currentRun.run();
+      if (runResult instanceof Promise) {
+        return this.runAsync(runResult);
+      }
+    }
+    return this.reset();
+  }
+  /**
+   * Executes the provided asynchronous operation and resets the state afterwards.
+   *
+   * @param {Promise<void>} run - A promise representing the asynchronous operation to execute.
+   * @return {Promise<GraphRun>} A promise that resolves to the result of the reset operation after the asynchronous operation completes.
+   */
+  async runAsync(run) {
+    await run;
+    return this.reset();
+  }
+  /**
+   * Resets the current state of the graph, creating a new GraphRun instance
+   * and returning the previous run instance.
+   * If the debug mode is not enabled, it will destroy the existing resources.
+   *
+   * @return {GraphRun} The last GraphRun instance before the reset.
+   */
+  reset() {
+    this.isRunning = false;
+    const lastRun = this.currentRun;
+    if (!this.debug) {
+      this.destroy();
+    }
+    this.currentRun = new GraphRun(this.strategy);
+    return lastRun;
+  }
+  setDebug(value) {
+    this.debug = value;
+  }
+  setVerbose(value) {
+    this.verbose = value;
+  }
+  destroy() {
+    this.currentRun.destroy();
+  }
+  /**
+   * Sets the strategy to be used for running the graph and initializes
+   * the current run with the provided strategy if no process is currently running.
+   *
+   * @param {GraphRunStrategy} strategy - The strategy to use for running the graph.
+   * @return {void}
+   */
+  setStrategy(strategy) {
+    this.strategy = strategy;
+    if (!this.isRunning) {
+      this.currentRun = new GraphRun(this.strategy);
+    }
+  }
+};
+
 // src/graph/definition/Task.ts
-var import_uuid5 = require("uuid");
+var import_uuid6 = require("uuid");
 
 // src/graph/iterators/TaskIterator.ts
 var TaskIterator = class {
@@ -2116,7 +2523,7 @@ var Task = class _Task extends SignalEmitter {
   }
   clone(traverse = false, includeSignals = false) {
     const clonedTask = new _Task(
-      `${this.name} (clone ${(0, import_uuid5.v4)().slice(0, 8)})`,
+      `${this.name} (clone ${(0, import_uuid6.v4)().slice(0, 8)})`,
       this.taskFunction,
       this.description,
       this.concurrency,
@@ -2601,6 +3008,14 @@ var Task = class _Task extends SignalEmitter {
   mapPrevious(callback) {
     return Array.from(this.predecessorTasks).map(callback);
   }
+  makeRoutine(name, description) {
+    if (this.isMeta) {
+      Cadenza.createMetaRoutine(name, [this], description);
+    } else {
+      Cadenza.createRoutine(name, [this], description);
+    }
+    return this;
+  }
   /**
    * Adds the specified signals to the current instance, making it observe them.
    * If the instance is already observing a signal, it will be skipped.
@@ -2657,29 +3072,33 @@ var Task = class _Task extends SignalEmitter {
   emitsOnFail(...signals) {
     signals.forEach((signal) => {
       this.signalsToEmitOnFail.add(signal);
-      this.attachSignal(signal, true);
+      this.attachSignal(signal);
     });
     return this;
   }
   /**
    * Attaches a signal to the current context and emits metadata if the register flag is set.
    *
-   * @param {string} signal - The name of the signal to attach.
-   * @param {boolean} [isOnFail=false] - Indicates if the signal should be marked as "on fail".
+   * @param {...string} signals - The names of the signals to attach.
    * @return {void} This method does not return a value.
    */
-  attachSignal(signal, isOnFail = false) {
-    this.emitsSignals.add(signal);
-    if (this.register) {
-      this.emitWithMetadata("meta.task.attached_signal", {
-        data: {
-          signalName: signal.split(":")[0],
-          taskName: this.name,
-          taskVersion: this.version,
-          isOnFail
-        }
-      });
-    }
+  attachSignal(...signals) {
+    signals.forEach((signal) => {
+      this.emitsSignals.add(signal);
+      Cadenza.broker.registerEmittedSignal(signal);
+      if (this.register) {
+        const isOnFail = this.signalsToEmitOnFail.has(signal);
+        this.emitWithMetadata("meta.task.attached_signal", {
+          data: {
+            signalName: signal.split(":")[0],
+            taskName: this.name,
+            taskVersion: this.version,
+            isOnFail
+          }
+        });
+      }
+    });
+    return this;
   }
   /**
    * Unsubscribes the current instance from the specified signals.
@@ -3059,205 +3478,6 @@ var GraphRegistry = class _GraphRegistry {
   }
 };
 
-// src/engine/GraphRunner.ts
-var GraphRunner = class extends SignalEmitter {
-  /**
-   * Constructs a runner.
-   * @param isMeta Meta flag (default false).
-   * @edge Creates 'Start run' meta-task chained to registry gets.
-   */
-  constructor(isMeta = false) {
-    super(isMeta);
-    this.debug = false;
-    this.verbose = false;
-    this.isRunning = false;
-    this.isMeta = false;
-    this.isMeta = isMeta;
-    this.strategy = Cadenza.runStrategy.PARALLEL;
-    this.currentRun = new GraphRun(this.strategy);
-  }
-  init() {
-    if (this.isMeta) return;
-    Cadenza.createMetaTask(
-      "Start run",
-      this.startRun.bind(this),
-      "Starts a run"
-    ).doAfter(
-      GraphRegistry.instance.getTaskByName,
-      GraphRegistry.instance.getRoutineByName
-    );
-  }
-  /**
-   * Adds tasks or routines to the current execution pipeline. Supports both individual tasks,
-   * routines, or arrays of tasks and routines. Handles metadata and execution context management.
-   *
-   * @param {Task|GraphRoutine|(Task|GraphRoutine)[]} tasks - The task(s) or routine(s) to be added.
-   * It can be a single task, a single routine, or an array of tasks and routines.
-   * @param {AnyObject} [context={}] - Optional context object to provide execution trace and metadata.
-   * Used to propagate information across task or routine executions.
-   * @return {void} - This method does not return a value.
-   */
-  addTasks(tasks, context = {}) {
-    let _tasks = Array.isArray(tasks) ? tasks : [tasks];
-    if (_tasks.length === 0) {
-      console.warn("No tasks/routines to add.");
-      return;
-    }
-    let routineName = _tasks.map((t) => t.name).join(" | ");
-    let routineVersion = null;
-    let isMeta = _tasks.every((t) => t.isMeta);
-    const allTasks = _tasks.flatMap((t) => {
-      if (t instanceof GraphRoutine) {
-        routineName = t.name;
-        routineVersion = t.version;
-        isMeta = t.isMeta;
-        const routineTasks = [];
-        t.forEachTask((task) => routineTasks.push(task));
-        return routineTasks;
-      }
-      return t;
-    });
-    const isSubMeta = allTasks.some((t) => t.isSubMeta) || !!context.__isSubMeta;
-    context.__isSubMeta = isSubMeta;
-    const isNewTrace = !context.__routineExecId && !context.__metadata?.__executionTraceId && !context.__executionTraceId;
-    const executionTraceId = context.__metadata?.__executionTraceId ?? context.__executionTraceId ?? (0, import_uuid6.v4)();
-    context.__executionTraceId = executionTraceId;
-    const routineExecId = context.__routineExecId ?? (0, import_uuid6.v4)();
-    context.__routineExecId = routineExecId;
-    const ctx = new GraphContext(context || {});
-    if (!isSubMeta) {
-      const contextData = ctx.export();
-      if (isNewTrace) {
-        this.emitMetrics("meta.runner.new_trace", {
-          data: {
-            uuid: executionTraceId,
-            issuer_type: "service",
-            // TODO: Add issuer type
-            issuer_id: context.__metadata?.__issuerId ?? context.__issuerId ?? null,
-            issued_at: formatTimestamp(Date.now()),
-            intent: context.__metadata?.__intent ?? context.__intent ?? null,
-            context: contextData,
-            is_meta: isMeta
-          },
-          __metadata: {
-            __executionTraceId: executionTraceId
-          }
-        });
-      }
-      this.emitMetrics("meta.runner.added_tasks", {
-        data: {
-          uuid: routineExecId,
-          name: routineName,
-          routineVersion,
-          isMeta,
-          executionTraceId,
-          context: isNewTrace ? contextData.id : contextData,
-          previousRoutineExecution: context.__localRoutineExecId ?? context.__metadata?.__routineExecId ?? null,
-          // TODO: There is a chance this is not added to the database yet...
-          created: formatTimestamp(Date.now())
-        },
-        __metadata: {
-          __executionTraceId: executionTraceId
-        }
-      });
-    }
-    allTasks.forEach(
-      (task) => this.currentRun.addNode(
-        new GraphNode(task, ctx, routineExecId, [], this.debug, this.verbose)
-      )
-    );
-  }
-  /**
-   * Executes the provided tasks or routines. Maintains the execution state
-   * and handles synchronous or asynchronous processing.
-   *
-   * @param {Task|GraphRoutine|(Task|GraphRoutine)[]} [tasks] - A single task, a single routine, or an array of tasks or routines to execute. Optional.
-   * @param {AnyObject} [context] - An optional context object to be used during task execution.
-   * @return {GraphRun|Promise<GraphRun>} - Returns a `GraphRun` instance if the execution is synchronous, or a `Promise` resolving to a `GraphRun` for asynchronous execution.
-   */
-  run(tasks, context) {
-    if (tasks) {
-      this.addTasks(tasks, context ?? {});
-    }
-    if (this.isRunning) {
-      return this.currentRun;
-    }
-    if (this.currentRun) {
-      this.isRunning = true;
-      const runResult = this.currentRun.run();
-      if (runResult instanceof Promise) {
-        return this.runAsync(runResult);
-      }
-    }
-    return this.reset();
-  }
-  /**
-   * Executes the provided asynchronous operation and resets the state afterwards.
-   *
-   * @param {Promise<void>} run - A promise representing the asynchronous operation to execute.
-   * @return {Promise<GraphRun>} A promise that resolves to the result of the reset operation after the asynchronous operation completes.
-   */
-  async runAsync(run) {
-    await run;
-    return this.reset();
-  }
-  /**
-   * Resets the current state of the graph, creating a new GraphRun instance
-   * and returning the previous run instance.
-   * If the debug mode is not enabled, it will destroy the existing resources.
-   *
-   * @return {GraphRun} The last GraphRun instance before the reset.
-   */
-  reset() {
-    this.isRunning = false;
-    const lastRun = this.currentRun;
-    if (!this.debug) {
-      this.destroy();
-    }
-    this.currentRun = new GraphRun(this.strategy);
-    return lastRun;
-  }
-  setDebug(value) {
-    this.debug = value;
-  }
-  setVerbose(value) {
-    this.verbose = value;
-  }
-  destroy() {
-    this.currentRun.destroy();
-  }
-  /**
-   * Sets the strategy to be used for running the graph and initializes
-   * the current run with the provided strategy if no process is currently running.
-   *
-   * @param {GraphRunStrategy} strategy - The strategy to use for running the graph.
-   * @return {void}
-   */
-  setStrategy(strategy) {
-    this.strategy = strategy;
-    if (!this.isRunning) {
-      this.currentRun = new GraphRun(this.strategy);
-    }
-  }
-  // TODO This should not live here. This is deputy related.
-  startRun(context, emit) {
-    if (context.task || context.routine) {
-      const routine = context.task ?? context.routine;
-      delete context.task;
-      delete context.routine;
-      context.__routineExecId = context.__metadata?.__deputyExecId ?? null;
-      context.__isDeputy = true;
-      this.run(routine, context);
-      return true;
-    } else {
-      context.errored = true;
-      context.__error = "No routine or task defined.";
-      emit("meta.runner.failed", context);
-      return false;
-    }
-  }
-};
-
 // src/graph/definition/DebounceTask.ts
 var DebounceTask = class extends Task {
   constructor(name, task, description = "", debounceTime = 1e3, leading = false, trailing = true, maxWait = 0, concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false, isSubMeta = false, isHidden = false, inputSchema = void 0, validateInputSchema = false, outputSchema = void 0, validateOutputSchema = false) {
@@ -4216,8 +4436,6 @@ var Cadenza = class {
     }
     this.registry = GraphRegistry.instance;
     this.broker.init();
-    this.runner.init();
-    this.metaRunner.init();
   }
   /**
    * Retrieves the available strategies for running graphs.
@@ -4325,6 +4543,9 @@ var Cadenza = class {
       startDateTime
     );
   }
+  static debounce(signalName, context, delayMs) {
+    this.broker?.debounce(signalName, context, delayMs);
+  }
   static get(taskName) {
     return this.registry?.tasks.get(taskName);
   }