@cadenza.io/core 3.27.0 → 3.28.1

package/dist/index.d.ts

@@ -130,33 +130,6 @@ declare class GraphNodeIterator implements Iterator {
     next(): any;
 }
 
-/**
- * Abstract class representing a signal emitter.
- * Allows emitting events or signals, with the option to suppress emissions if desired.
- */
-declare abstract class SignalEmitter {
-    silent: boolean;
-    /**
-     * Constructor for signal emitters.
-     * @param silent If true, suppresses all emissions (e.g., for meta-runners to avoid loops; affects all emits).
-     */
-    constructor(silent?: boolean);
-    /**
-     * Emits a signal via the broker.
-     * @param signal The signal name.
-     * @param data Optional payload (defaults to empty object).
-     * @param options
-     */
-    emit(signal: string, data?: AnyObject, options?: EmitOptions): void;
-    /**
-     * 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: string, data?: AnyObject, options?: EmitOptions): void;
-}
-
 /**
  * Represents an abstract chain of execution, where each instance can be
  * connected to a succeeding or preceding instance to form a chain of steps.
@@ -319,1350 +292,1427 @@ declare abstract class GraphLayer extends ExecutionChain implements Graph {
     log(): void;
 }
 
-type SchemaType = "string" | "number" | "boolean" | "array" | "object" | "any";
-type SchemaConstraints = {
-    min?: number;
-    max?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    enum?: any[];
-    multipleOf?: number;
-    format?: "email" | "url" | "date-time" | "uuid" | "custom";
-    oneOf?: any[];
-};
-type SchemaDefinition = {
-    type: SchemaType;
-    required?: string[];
-    properties?: {
-        [key: string]: Schema;
-    };
-    items?: Schema;
-    constraints?: SchemaConstraints;
-    description?: string;
-    strict?: boolean;
-};
-type SchemaMap = Record<string, SchemaDefinition>;
-type Schema = SchemaDefinition | SchemaMap;
-
-interface Intent {
-    name: string;
-    description?: string;
-    input?: SchemaDefinition;
-    output?: SchemaDefinition;
-}
-interface InquiryOptions {
-    timeout?: number;
-    rejectOnTimeout?: boolean;
-    includePendingTasks?: boolean;
-    requireComplete?: boolean;
-}
-declare class InquiryBroker extends SignalEmitter {
-    static instance_: InquiryBroker;
-    static get instance(): InquiryBroker;
-    debug: boolean;
-    verbose: boolean;
-    setDebug(value: boolean): void;
-    setVerbose(value: boolean): void;
-    validateInquiryName(inquiryName: string): void;
-    runner: GraphRunner | undefined;
-    metaRunner: GraphRunner | undefined;
-    inquiryObservers: Map<string, {
-        fn: (runner: GraphRunner, tasks: Task[], context: AnyObject) => void;
-        tasks: Set<Task>;
-        registered: boolean;
-    }>;
-    intents: Map<string, Intent>;
-    /**
-     * Initializes with runners.
-     * @param runner Standard runner for user signals.
-     * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
-     */
-    bootstrap(runner: GraphRunner, metaRunner: GraphRunner): void;
-    init(): void;
-    /**
-     * Observes an inquiry with a routine/task.
-     * @param inquiry The inquiry (e.g., 'domain.action', 'domain.*' for wildcards).
-     * @param task The observer.
-     * @edge Duplicates ignored; supports wildcards for broad listening.
-     */
-    observe(inquiry: string, task: Task): void;
+/**
+ * Represents a synchronous graph layer derived from the GraphLayer base class.
+ * This class is designed to execute graph nodes in a strictly synchronous manner.
+ * Asynchronous functions are explicitly disallowed, ensuring consistency and predictability.
+ */
+declare class SyncGraphLayer extends GraphLayer {
     /**
-     * Unsubscribes a routine/task from an inquiry.
-     * @param inquiry The inquiry.
-     * @param task The observer.
-     * @edge Removes all instances if duplicate; deletes if empty.
+     * Executes the processing logic of the current set of graph nodes. Iterates through all
+     * nodes, skipping any that have already been processed, and executes their respective
+     * logic to generate new nodes. Asynchronous functions are not supported and will
+     * trigger an error log.
+     *
+     * @return {GraphNode[]} An array of newly generated graph nodes after executing the logic of each unprocessed node.
      */
-    unsubscribe(inquiry: string, task: Task): void;
-    addInquiry(inquiry: string): void;
-    addIntent(intent: Intent): void;
-    inquire(inquiry: string, context: AnyObject, options?: InquiryOptions): Promise<AnyObject>;
-    reset(): void;
+    execute(): GraphNode[];
 }
 
 /**
- * Represents a node in a graph structure used for executing tasks.
- * A Node is a container for a task and its associated context, providing
- * methods for executing the task and managing its lifecycle.
- *
- * It extends the SignalEmitter class to emit and handle signals related to
- * the node's lifecycle, such as "meta.node.started" and "meta.node.completed".
- *
- * It also implements the Graph interface, allowing it to be used as a part of
- * a graph structure, such as a GraphLayer or GraphRoutine.
+ * An abstract class representing a GraphExporter.
+ * This class defines a structure for exporting graph data in different formats,
+ * depending on the implementations provided by subclasses.
+ */
+declare abstract class GraphExporter {
+    abstract exportGraph(graph: SyncGraphLayer): any;
+    abstract exportStaticGraph(graph: Task[]): any;
+}
+
+/**
+ * GraphBuilder is an abstract base class designed to construct and manage a graph structure
+ * composed of multiple layers. Subclasses are expected to implement the `compose` method
+ * based on specific requirements. This class provides methods for adding nodes, managing
+ * layers, and resetting the graph construction process.
  *
- * @extends SignalEmitter
- * @implements Graph
+ * This class supports creating layered graph structures, dynamically adding layers and nodes,
+ * and debugging graph-building operations.
  */
-declare class GraphNode extends SignalEmitter implements Graph {
-    id: string;
-    routineExecId: string;
-    executionTraceId: string;
-    task: Task;
-    context: GraphContext;
-    layer: GraphLayer | undefined;
-    divided: boolean;
-    splitGroupId: string;
-    processing: boolean;
-    subgraphComplete: boolean;
-    graphComplete: boolean;
-    result: TaskResult;
-    retryCount: number;
-    retryDelay: number;
-    retries: number;
-    previousNodes: GraphNode[];
-    nextNodes: GraphNode[];
-    executionTime: number;
-    executionStart: number;
-    failed: boolean;
-    errored: boolean;
-    destroyed: boolean;
+declare abstract class GraphBuilder {
+    graph: GraphLayer | undefined;
+    topLayerIndex: number;
+    layers: GraphLayer[];
     debug: boolean;
-    verbose: boolean;
-    constructor(task: Task, context: GraphContext, routineExecId: string, prevNodes?: GraphNode[], debug?: boolean, verbose?: boolean);
     setDebug(value: boolean): void;
-    isUnique(): boolean;
-    isMeta(): boolean;
-    isProcessed(): boolean;
-    isProcessing(): boolean;
-    subgraphDone(): boolean;
-    graphDone(): boolean;
-    /**
-     * Compares the current GraphNode instance with another GraphNode to determine if they are considered equal.
-     *
-     * @param {GraphNode} node - The GraphNode object to compare with the current instance.
-     * @return {boolean} Returns true if the nodes share the same task, context, and belong to the same graph; otherwise, false.
-     */
-    isEqualTo(node: GraphNode): boolean;
+    getResult(): GraphLayer;
     /**
-     * Determines if the given node is part of the same graph as the current node.
+     * Composes a series of functions or operations.
+     * This method should be implemented in the child class
+     * to define custom composition logic.
      *
-     * @param {GraphNode} node - The node to compare with the current node.
-     * @return {boolean} Returns true if the provided node is part of the same graph
-     *                   (i.e., has the same routineExecId), otherwise false.
+     * @return {any} The result of the composed operations or functions
+     * when implemented in the child class.
      */
-    isPartOfSameGraph(node: GraphNode): boolean;
+    compose(): void;
     /**
-     * Determines whether the current instance shares a task with the provided node.
+     * Adds a node to the appropriate layer of the graph.
      *
-     * @param {GraphNode} node - The graph node to compare with the current instance.
-     * @return {boolean} Returns true if the task names of both nodes match, otherwise false.
+     * @param {GraphNode} node - The node to be added to the graph. The node contains
+     *                           layer information that determines which layer it belongs to.
+     * @return {void} Does not return a value.
      */
-    sharesTaskWith(node: GraphNode): boolean;
+    addNode(node: GraphNode): void;
     /**
-     * Determines whether the current node shares the same context as the specified node.
+     * Adds multiple nodes to the graph.
      *
-     * @param {GraphNode} node - The graph node to compare with the current node's context.
-     * @return {boolean} True if both nodes share the same context; otherwise, false.
+     * @param {GraphNode[]} nodes - An array of nodes to be added to the graph.
+     * @return {void} This method does not return a value.
      */
-    sharesContextWith(node: GraphNode): boolean;
-    getLayerIndex(): number;
-    getConcurrency(): number;
+    addNodes(nodes: GraphNode[]): void;
     /**
-     * Retrieves the tag associated with the current task and context.
+     * Adds a new layer to the graph at the specified index. If the graph does not exist,
+     * it creates the graph using the specified index. Updates the graph's top layer index
+     * and maintains the order of layers.
      *
-     * @return {string} The tag retrieved from the task within the given context.
+     * @param {number} index - The index at which the new layer should be added to the graph.
+     * @return {void} This method does not return a value.
      */
-    getTag(): string;
+    addLayer(index: number): void;
     /**
-     * Schedules the current node/task on the specified graph layer if applicable.
-     *
-     * This method assesses whether the current node/task should be scheduled
-     * on the given graph layer. It ensures that tasks are only scheduled
-     * under certain conditions, such as checking if the task shares
-     * execution contexts or dependencies with other nodes, and handles
-     * various metadata emissions and context updates during the scheduling process.
+     * Creates a new layer for the graph at the specified index.
      *
-     * @param {GraphLayer} layer - The graph layer on which the current task should be scheduled.
-     * @returns {void} Does not return a value.
+     * @param {number} index - The index of the layer to be created.
+     * @return {GraphLayer} A new instance of the graph layer corresponding to the provided index.
      */
-    scheduleOn(layer: GraphLayer): void;
+    createLayer(index: number): GraphLayer;
     /**
-     * Starts the execution process by initializing the execution start timestamp,
-     * emitting relevant metadata, and logging debug information if applicable.
-     *
-     * The method performs the following actions:
-     * 1. Sets the execution start timestamp if it's not already initialized.
-     * 2. Emits metrics with metadata about the routine execution starting, including additional data if there are no previous nodes.
-     * 3. Optionally logs debug or verbose information based on the current settings.
-     * 4. Emits additional metrics to indicate that the execution has started.
+     * Retrieves a specific layer from the current set of layers.
      *
-     * @return {number} The timestamp indicating when the execution started.
+     * @param {number} layerIndex - The index of the layer to retrieve.
+     * @return {*} The layer corresponding to the given index.
      */
-    start(): number;
-    /**
-     * Marks the end of an execution process, performs necessary cleanup, emits
-     * metrics with associated metadata, and signals the completion of execution.
-     * Also handles specific cases when the graph completes.
-     *
-     * @return {number} The timestamp corresponding to the end of execution. If execution
-     * was not started, it returns 0.
-     */
-    end(): number;
-    /**
-     * Executes the main logic of the task, including input validation, processing, and post-processing.
-     * Handles both synchronous and asynchronous workflows.
-     *
-     * @return {Array|Promise|undefined} Returns the next nodes to process if available.
-     * If asynchronous processing is required, it returns a Promise that resolves to the next nodes.
-     * Returns undefined in case of an error during input validation or preconditions that prevent processing.
-     */
-    execute(): GraphNode[] | Promise<GraphNode[]>;
-    /**
-     * Executes an asynchronous workflow that processes a result and retries on errors.
-     * The method handles different result states, checks for error properties, and invokes
-     * error handling when necessary.
-     *
-     * @return {Promise<void>} A promise that resolves when the operation completes successfully,
-     * or rejects if an unhandled error occurs.
-     */
-    workAsync(): Promise<void>;
-    /**
-     * Executes an asynchronous operation, processes the result, and determines the next nodes to execute.
-     * This method will manage asynchronous work, handle post-processing of results, and ensure proper handling of both synchronous and asynchronous next node configurations.
-     *
-     * @return {Promise<any>} A promise resolving to the next nodes to be executed. Can be the result of post-processing or a directly resolved next nodes object.
-     */
-    executeAsync(): Promise<GraphNode[]>;
+    getLayer(layerIndex: number): GraphLayer;
+    reset(): void;
+}
+
+/**
+ * Abstract class representing a strategy for configuring and executing graph operations.
+ * Provides a structure for managing graph builders, altering strategies, and updating the execution context.
+ *
+ * This class cannot be instantiated directly and must be extended by concrete implementations.
+ */
+declare abstract class GraphRunStrategy {
+    graphBuilder: GraphBuilder;
+    runInstance?: GraphRun;
+    constructor();
+    setRunInstance(runInstance: GraphRun): void;
+    changeStrategy(builder: GraphBuilder): void;
+    reset(): void;
+    addNode(node: GraphNode): void;
+    updateRunInstance(): void;
+    abstract run(): void;
+    abstract export(): any;
+}
+
+interface RunJson {
+    __id: string;
+    __label: string;
+    __graph: any;
+    __data: any;
+}
+/**
+ * Represents a GraphRun instance which manages the execution of a graph-based workflow.
+ * It utilizes a specific strategy and export mechanism to manage, execute, and export the graph data.
+ */
+declare class GraphRun {
+    readonly id: string;
+    graph: GraphLayer | undefined;
+    strategy: GraphRunStrategy;
+    exporter: GraphExporter | undefined;
+    constructor(strategy: GraphRunStrategy);
+    setGraph(graph: GraphLayer): void;
+    addNode(node: GraphNode): void;
+    run(): void | Promise<void>;
+    destroy(): void;
+    log(): void;
+    export(): RunJson;
+    setExporter(exporter: GraphExporter): void;
+}
+
+/**
+ * Represents a routine in a graph structure with tasks and signal observation capabilities.
+ * Routines are named entrypoint for a sub-graph, describing the purpose for the subsequent flow.
+ * Since Task names are specific to the task it performs, it doesn't describe the overall flow.
+ * Routines, therefore are used to assign names to sub-flows that can be referenced using that name instead of the name of the task(s).
+ * Extends SignalEmitter to emit and handle signals related to the routine's lifecycle and tasks.
+ */
+declare class GraphRoutine extends SignalEmitter {
+    readonly name: string;
+    version: number;
+    readonly description: string;
+    readonly isMeta: boolean;
+    tasks: Set<Task>;
+    registered: boolean;
+    registeredTasks: Set<Task>;
+    observedSignals: Set<string>;
+    constructor(name: string, tasks: Task[], description: string, isMeta?: boolean);
     /**
-     * Executes the task associated with the current instance, using the given context,
-     * progress callback, and metadata. If the task fails or an error occurs, it attempts
-     * to retry the execution. If the retry is not successful, it propagates the error and
-     * returns the result.
+     * Iterates over each task in the `tasks` collection and applies the provided callback function.
+     * If the callback returns a Promise, resolves all Promises concurrently.
      *
-     * @return {TaskResult | Promise<TaskResult>} The result of the task execution, or a
-     * promise that resolves to the task result. This includes handling for retries on
-     * failure and error propagation.
+     * @param {function} callBack - A function to be executed on each task from the `tasks` collection.
+     *                              The callback receives the current task as its argument.
+     * @return {Promise<void>} A Promise that resolves once all callback executions, including asynchronous ones, are complete.
      */
-    work(): TaskResult | Promise<TaskResult>;
-    inquire(inquiry: string, context: AnyObject, options: InquiryOptions): Promise<any>;
+    forEachTask(callBack: (task: Task) => any): Promise<void>;
     /**
-     * Emits a signal along with its associated metadata. The metadata includes
-     * task-specific information such as task name, version, execution ID, and
-     * additional context metadata like routine execution ID and execution trace ID.
-     * This method is designed to enrich emitted signals with relevant details
-     * before broadcasting them.
-     *
-     * @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.
+     * Sets global Version.
+     * @param version The Version.
      */
-    emitWithMetadata(signal: string, data: AnyObject, options?: EmitOptions): void;
+    setVersion(version: number): void;
     /**
-     * Emits metrics with additional metadata describing the task execution and context.
+     * Subscribes the current instance to the specified signals, enabling it to observe them.
      *
-     * @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.
+     * @param {...string} signals - The names of the signals to observe.
+     * @return {this} Returns the instance to allow for method chaining.
      */
-    emitMetricsWithMetadata(signal: string, data: AnyObject, options?: EmitOptions): void;
+    doOn(...signals: string[]): this;
     /**
-     * Updates the progress of a task and emits metrics with associated metadata.
+     * Unsubscribes from all observed signals and clears the internal collection
+     * of observed signals. This ensures that the instance is no longer listening
+     * or reacting to any previously subscribed signals.
      *
-     * @param {number} progress - A number representing the progress value, which will be clamped between 0 and 1.
-     * @return {void} This method does not return a value.
+     * @return {this} Returns the current instance for chaining purposes.
      */
-    onProgress(progress: number): void;
+    unsubscribeAll(): this;
     /**
-     * Processes the result of the current operation, validates it, and determines the next set of nodes.
-     *
-     * This method ensures that results of certain types such as strings or arrays
-     * are flagged as errors. It divides the current context into subsequent nodes
-     * for further processing. If the division returns a promise, it delegates the
-     * processing to `postProcessAsync`. For synchronous division, it sets the
-     * `nextNodes` and finalizes the operation.
+     * Unsubscribes the current instance from the specified signals.
      *
-     * @return {(Array|undefined)} Returns an array of next nodes for further processing,
-     * or undefined if no further processing is required.
+     * @param {...string} signals - The signals to unsubscribe from.
+     * @return {this} The current instance for method chaining.
      */
-    postProcess(): GraphNode[] | Promise<GraphNode[]>;
+    unsubscribe(...signals: string[]): this;
     /**
-     * Asynchronously processes and finalizes the provided graph nodes.
+     * Cleans up resources and emits an event indicating the destruction of the routine.
      *
-     * @param {Promise<GraphNode[]>} nextNodes A promise that resolves to an array of graph nodes to be processed.
-     * @return {Promise<GraphNode[]>} A promise that resolves to the processed array of graph nodes.
-     */
-    postProcessAsync(nextNodes: Promise<GraphNode[]>): Promise<GraphNode[]>;
-    /**
-     * Finalizes the current task execution by determining if the task is complete, handles any errors or failures,
-     * emits relevant signals based on the task outcomes, and ensures proper end of the task lifecycle.
+     * This method unsubscribes from all events, clears the tasks list,
+     * and emits a "meta.routine.destroyed" event with details of the destruction.
      *
-     * @return {void} Does not return a value.
+     * @return {void}
      */
-    finalize(): void;
+    destroy(): void;
+}
+
+/**
+ * Represents a runner for managing and executing tasks or routines within a graph.
+ * The `GraphRunner` extends `SignalEmitter` to include signal-based event-driven mechanisms.
+ */
+declare class GraphRunner extends SignalEmitter {
+    currentRun: GraphRun;
+    debug: boolean;
+    verbose: boolean;
+    isRunning: boolean;
+    readonly isMeta: boolean;
+    strategy: GraphRunStrategy;
     /**
-     * Handles an error event, processes the error, and updates the state accordingly.
-     *
-     * @param {unknown} error - The error object or message that occurred.
-     * @param {AnyObject} [errorData={}] - Additional error data to include in the result.
-     * @return {void} This method does not return any value.
+     * Constructs a runner.
+     * @param isMeta Meta flag (default false).
+     * @edge Creates 'Start run' meta-task chained to registry gets.
      */
-    onError(error: unknown, errorData?: AnyObject): void;
+    constructor(isMeta?: boolean);
     /**
-     * Retries a task based on the defined retry count and delay time. If the retry count is 0, it immediately resolves with the provided previous result.
+     * 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 {any} [prevResult] - The result from a previous attempt, if any, to return when no retries are performed.
-     * @return {Promise<TaskResult>} - A promise that resolves with the result of the retried task or the previous result if no retries occur.
+     * @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.
      */
-    retry(prevResult?: any): Promise<TaskResult>;
+    addTasks(tasks: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): void;
     /**
-     * Retries an asynchronous operation and returns its result.
-     * If the retry count is zero, the method immediately returns the provided previous result.
+     * Executes the provided tasks or routines. Maintains the execution state
+     * and handles synchronous or asynchronous processing.
      *
-     * @param {any} [prevResult] - The optional result from a previous operation attempt, if applicable.
-     * @return {Promise<TaskResult>} A promise that resolves to the result of the retried operation.
+     * @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.
      */
-    retryAsync(prevResult?: any): Promise<TaskResult>;
-    delayRetry(): Promise<void>;
+    run(tasks?: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): GraphRun | Promise<GraphRun>;
     /**
-     * Processes the result of a task by generating new nodes based on the task output.
-     * The method handles synchronous and asynchronous generators, validates task output,
-     * and creates new nodes accordingly. If errors occur, the method attempts to handle them
-     * by generating alternative task nodes.
+     * Executes the provided asynchronous operation and resets the state afterwards.
      *
-     * @return {GraphNode[] | Promise<GraphNode[]>} Returns an array of generated GraphNode objects
-     * (synchronously or wrapped in a Promise) based on the task result, or propagates errors if validation fails.
+     * @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.
      */
-    divide(): GraphNode[] | Promise<GraphNode[]>;
+    runAsync(run: Promise<void>): Promise<GraphRun>;
     /**
-     * Processes an asynchronous iterator result, validates its output, and generates new graph nodes accordingly.
-     * Additionally, continues to process and validate results from an asynchronous generator.
+     * 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.
      *
-     * @param {Promise<IteratorResult<any>>} current - A promise resolving to the current step result from an asynchronous iterator.
-     * @return {Promise<GraphNode[]>} A promise resolving to an array of generated GraphNode objects based on validated outputs.
+     * @return {GraphRun} The last GraphRun instance before the reset.
      */
-    divideAsync(current: Promise<IteratorResult<any>>): Promise<GraphNode[]>;
+    reset(): GraphRun;
+    setDebug(value: boolean): void;
+    setVerbose(value: boolean): void;
+    destroy(): void;
     /**
-     * Generates new nodes based on the provided result and task configuration.
+     * 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 {any} result - The result of the previous operation, which determines the configuration and context for new nodes. It can be a boolean or an object containing details like failure, errors, or metadata.
-     * @return {GraphNode[]} An array of newly generated graph nodes configured based on the task and context.
+     * @param {GraphRunStrategy} strategy - The strategy to use for running the graph.
+     * @return {void}
      */
-    generateNewNodes(result: any): GraphNode[];
-    /**
-     * Executes the differentiation process based on a given task and updates the instance properties accordingly.
-     *
-     * @param {Task} task - The task object containing information such as retry count, retry delay, and metadata status.
-     * @return {GraphNode} The updated instance after processing the task.
-     */
-    differentiate(task: Task): GraphNode;
+    setStrategy(strategy: GraphRunStrategy): void;
+}
+
+interface EmitOptions {
+    squash?: boolean;
+    squashId?: string | null;
+    groupId?: string | null;
+    mergeFunction?: ((oldContext: AnyObject, ...newContext: AnyObject[]) => AnyObject) | null;
+    debounce?: boolean;
+    throttle?: boolean;
+    delayMs?: number;
+    schedule?: boolean;
+    exactDateTime?: Date | null;
+    throttleBatch?: number;
+    flushStrategy?: string;
+}
+type SignalDeliveryMode = "single" | "broadcast";
+type SignalReceiverFilter = {
+    serviceNames?: string[];
+    serviceInstanceIds?: string[];
+    origins?: string[];
+    roles?: string[];
+    protocols?: string[];
+    runtimeStates?: string[];
+};
+type SignalMetadata = {
+    deliveryMode?: SignalDeliveryMode;
+    broadcastFilter?: SignalReceiverFilter | null;
+};
+type PassiveSignalListener = (signal: string, context: AnyObject, metadata: SignalMetadata | null) => void;
+type SignalDefinitionInput = string | ({
+    name: string;
+} & SignalMetadata);
+type FlushStrategyName = string;
+interface FlushStrategy {
+    intervalMs: number;
+    maxBatchSize: number;
+}
+/**
+ * This class manages signals and observers, enabling communication across different parts of an application.
+ * It follows a singleton design pattern, allowing for centralized signal management.
+ */
+declare class SignalBroker {
+    static instance_: SignalBroker;
+    static get instance(): SignalBroker;
+    debug: boolean;
+    verbose: boolean;
+    setDebug(value: boolean): void;
+    setVerbose(value: boolean): void;
+    runner: GraphRunner | undefined;
+    metaRunner: GraphRunner | undefined;
+    throttleEmitters: Map<string, any>;
+    throttleQueues: Map<string, any>;
+    getSignalsTask: Task | undefined;
+    registerSignalTask: Task | undefined;
+    signalObservers: Map<string, {
+        fn: (runner: GraphRunner, tasks: (Task | GraphRoutine)[], context: AnyObject) => void;
+        tasks: Set<Task | GraphRoutine>;
+        registered: boolean;
+    }>;
+    emittedSignalsRegistry: Set<string>;
+    signalMetadataRegistry: Map<string, SignalMetadata>;
+    passiveSignalListeners: Map<string, PassiveSignalListener>;
+    private flushStrategies;
+    private strategyData;
+    private strategyTimers;
+    private isStrategyFlushing;
+    private readonly defaultStrategyName;
+    constructor();
+    private resolveSignalMetadataKey;
+    private normalizeSignalMetadata;
+    setSignalMetadata(signal: string, metadata?: SignalMetadata | null): void;
+    getSignalMetadata(signal: string): SignalMetadata | undefined;
+    logMemoryFootprint(label?: string): void;
     /**
-     * Migrates the current instance to a new context and returns the updated instance.
+     * Validates the provided signal name string to ensure it adheres to specific formatting rules.
+     * Throws an error if any of the validation checks fail.
      *
-     * @param {any} ctx - The context data to be used for migration.
-     * @return {GraphNode} The updated instance after migration.
+     * @param {string} signalName - The signal name to be validated.
+     * @return {void} - Returns nothing if the signal name is valid.
+     * @throws {Error} - Throws an error if the signal name is longer than 100 characters, contains spaces,
+     *                   contains backslashes, or contains uppercase letters in restricted parts of the name.
      */
-    migrate(ctx: any): GraphNode;
+    validateSignalName(signalName: string): void;
     /**
-     * Splits the current node into a new group identified by the provided ID.
+     * Initializes with runners.
+     * @param runner Standard runner for user signals.
+     * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
+     */
+    bootstrap(runner: GraphRunner, metaRunner: GraphRunner): void;
+    /**
+     * Initializes and sets up the various tasks for managing and processing signals.
      *
-     * @param {string} id - The unique identifier for the new split group.
-     * @return {GraphNode} The current instance of the GraphNode with the updated split group ID.
+     * @return {void} This method does not return a value.
      */
-    split(id: string): GraphNode;
+    init(): void;
+    setFlushStrategy(name: FlushStrategyName, config: {
+        intervalMs: number;
+        maxBatchSize?: number;
+    }): void;
+    updateFlushStrategy(name: FlushStrategyName, config: FlushStrategy): void;
+    removeFlushStrategy(name: FlushStrategyName): void;
+    getFlushStrategies(): Record<FlushStrategyName, FlushStrategy>;
+    private readonly MAX_FLUSH_DURATION_MS;
+    squash(signal: string, context: AnyObject, options?: EmitOptions): void;
+    private flushGroup;
+    private flushStrategy;
+    clearSquashState(): void;
+    private clearScheduledState;
+    private scheduledBuckets;
+    private scheduleTimer;
+    schedule(signal: string, context: AnyObject, options?: EmitOptions): AbortController;
+    private flushScheduled;
+    private debouncedEmitters;
+    private readonly MAX_DEBOUNCERS;
+    private clearDebounceState;
+    private clearThrottleState;
+    debounce(signal: string, context: any, options?: {
+        delayMs: number;
+    }): void;
+    throttle(signal: string, context: any, options?: EmitOptions): void;
     /**
-     * Creates a new instance of the GraphNode with the current node's properties.
-     * This method allows for duplicating the existing graph node.
+     * Emits `signal` repeatedly with a fixed interval.
      *
-     * @return {GraphNode} A new instance of GraphNode that is a copy of the current node.
+     * @param signal
+     * @param context
+     * @param intervalMs
+     * @param leading  If true, emits immediately (unless a startDateTime is given and we are before it).
+     * @param startDateTime  Optional absolute Date when the *first* emission after `leading` should occur.
+     * @returns a handle with `clear()` to stop the loop.
      */
-    clone(): GraphNode;
+    interval(signal: string, context: AnyObject, intervalMs?: number, leading?: boolean, startDateTime?: Date): ThrottleHandle;
     /**
-     * Consumes the given graph node by combining contexts, merging previous nodes,
-     * and performing associated operations on the provided node.
+     * Emits a signal with the specified context, triggering any associated handlers for that signal.
      *
-     * @param {GraphNode} node - The graph node to be consumed.
+     * @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.
      */
-    consume(node: GraphNode): void;
+    emit(signal: string, context?: AnyObject, options?: EmitOptions): void;
     /**
-     * Changes the identity of the current instance by updating the `id` property.
+     * Executes a signal by emitting events, updating context, and invoking listeners.
+     * Creates a new execution trace if necessary and updates the context with relevant metadata.
+     * Handles specific, hierarchy-based, and wildcard signals.
      *
-     * @param {string} id - The new identity value to be assigned.
-     * @return {void} Does not return a value.
+     * @param {string} signal - The signal name to be executed, potentially including namespaces or tags (e.g., "meta.*" or "signal:type").
+     * @param {AnyObject} context - An object containing relevant metadata and execution details used for handling the signal.
+     * @return {boolean} Returns true if any listeners were successfully executed, otherwise false.
      */
-    changeIdentity(id: string): void;
+    execute(signal: string, context: AnyObject): boolean;
     /**
-     * Completes the subgraph for the current node and recursively for its previous nodes
-     * once all next nodes have their subgraphs marked as done. If there are no previous nodes,
-     * it completes the entire graph.
+     * Executes the tasks associated with a given signal and context.
+     * It processes both normal and meta tasks depending on the signal type
+     * and the availability of the appropriate runner.
      *
-     * @return {void} Does not return a value.
+     * @param {string} signal - The signal identifier that determines which tasks to execute.
+     * @param {AnyObject} context - The context object passed to the task execution function.
+     * @return {boolean} - Returns true if tasks were executed; otherwise, false.
      */
-    completeSubgraph(): void;
+    executeListener(signal: string, context: AnyObject): boolean;
     /**
-     * Completes the current graph by setting a flag indicating the graph has been completed
-     * and recursively completes all subsequent nodes in the graph.
+     * Adds a signal to the signalObservers for tracking and execution.
+     * Performs validation on the signal name and emits a meta signal event when added.
+     * If the signal contains a namespace (denoted by a colon ":"), its base signal is
+     * also added if it doesn't already exist.
      *
-     * @return {void} Does not return a value.
+     * @param {string} signal - The name of the signal to be added.
+     * @return {void} This method does not return any value.
      */
-    completeGraph(): void;
+    addSignal(signal: string, metadata?: SignalMetadata | null): void;
     /**
-     * Destroys the current instance by releasing resources, breaking references,
-     * and resetting properties to ensure proper cleanup.
-     *
-     * @return {void} No return value.
+     * Observes a signal with a routine/task.
+     * @param signal The signal (e.g., 'domain.action', 'domain.*' for wildcards).
+     * @param routineOrTask The observer.
+     * @edge Duplicates ignored; supports wildcards for broad listening.
      */
-    destroy(): void;
+    observe(signal: string, routineOrTask: Task | GraphRoutine, metadata?: SignalMetadata | null): void;
+    addPassiveSignalListener(listener: PassiveSignalListener): () => void;
+    private notifyPassiveSignalListeners;
+    registerEmittedSignal(signal: string, metadata?: SignalMetadata | null): void;
     /**
-     * Retrieves an iterator for traversing through the graph nodes.
-     *
-     * @return {GraphNodeIterator} An iterator instance specific to this graph node.
+     * Unsubscribes a routine/task from a signal.
+     * @param signal The signal.
+     * @param routineOrTask The observer.
+     * @edge Removes all instances if duplicate; deletes if empty.
      */
-    getIterator(): GraphNodeIterator;
+    unsubscribe(signal: string, routineOrTask: Task | GraphRoutine): void;
     /**
-     * Applies a callback function to each node in the `nextNodes` array and returns
-     * the resulting array from the map operation.
-     *
-     * @param {function} callback - A function to execute on each `GraphNode` in the `nextNodes` array.
-     * The function receives a `GraphNode` as its argument.
-     * @return {Array} The resulting array after applying the callback function to each node in `nextNodes`.
+     * Lists all observed signals.
+     * @returns Array of signals.
      */
-    mapNext(callback: (node: GraphNode) => any): any[];
+    listObservedSignals(): string[];
+    listEmittedSignals(): string[];
+    reset(): void;
+    shutdown(): void;
+}
+
+/**
+ * Abstract class representing a signal emitter.
+ * Allows emitting events or signals, with the option to suppress emissions if desired.
+ */
+declare abstract class SignalEmitter {
+    silent: boolean;
     /**
-     * Accepts a visitor object and calls its visitNode method with the current instance.
-     *
-     * @param {GraphVisitor} visitor - The visitor instance implementing the GraphVisitor interface.
-     * @return {void} This method does not return a value.
+     * Constructor for signal emitters.
+     * @param silent If true, suppresses all emissions (e.g., for meta-runners to avoid loops; affects all emits).
      */
-    accept(visitor: GraphVisitor): void;
+    constructor(silent?: boolean);
     /**
-     * Exports the current object's state and returns it in a serialized format.
-     * The exported object contains metadata, task details, context information, execution times, node relationships, routine execution status, and other state information.
-     *
-     * @return {Object} An object representing the current state.
+     * Emits a signal via the broker.
+     * @param signal The signal name.
+     * @param data Optional payload (defaults to empty object).
+     * @param options
      */
-    export(): {
-        __id: string;
-        __task: AnyObject;
-        __context: {
-            id: string;
-            context: AnyObject;
-        };
-        __result: TaskResult;
-        __executionTime: number;
-        __executionStart: number;
-        __executionEnd: number;
-        __nextNodes: string[];
-        __previousNodes: string[];
-        __routineExecId: string;
-        __isProcessing: boolean;
-        __isMeta: boolean;
-        __graphComplete: boolean;
-        __failed: boolean;
-        __errored: boolean;
-        __isUnique: boolean;
-        __splitGroupId: string;
-        __tag: string;
-    };
-    lightExport(): {
-        __id: string;
-        __task: {
-            __name: string;
-            __version: number;
-        };
-        __context: {
-            id: string;
-            context: AnyObject;
-        };
-        __executionTime: number;
-        __executionStart: number;
-        __nextNodes: string[];
-        __previousNodes: string[];
-        __routineExecId: string;
-        __isProcessing: boolean;
-        __graphComplete: boolean;
-        __isMeta: boolean;
-        __failed: boolean;
-        __errored: boolean;
-        __isUnique: boolean;
-        __splitGroupId: string;
-        __tag: string;
-    };
-    log(): void;
-}
-
-declare abstract class GraphVisitor {
-    abstract visitLayer(layer: GraphLayer): any;
-    abstract visitNode(node: GraphNode): any;
-    abstract visitTask(task: Task): any;
+    emit(signal: string, data?: AnyObject, options?: EmitOptions): void;
+    /**
+     * 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: string, data?: AnyObject, options?: EmitOptions): void;
 }
 
-/**
- * TaskIterator is a custom iterator for traversing over a set of tasks.
- * It provides mechanisms to iterate through tasks in a layered manner,
- * where each task can branch out to other tasks forming multiple layers.
- */
-declare class TaskIterator implements Iterator {
-    currentTask: Task | undefined;
-    currentLayer: Set<Task>;
-    nextLayer: Set<Task>;
-    iterator: {
-        next: () => {
-            value: Task | undefined;
-        };
+type SchemaType = "string" | "number" | "boolean" | "array" | "object" | "any";
+type SchemaConstraints = {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: any[];
+    multipleOf?: number;
+    format?: "email" | "url" | "date-time" | "uuid" | "custom";
+    oneOf?: any[];
+};
+type SchemaDefinition = {
+    type: SchemaType;
+    required?: string[];
+    properties?: {
+        [key: string]: Schema;
     };
-    constructor(task: Task);
-    hasNext(): boolean;
-    next(): Task | undefined;
-}
+    items?: Schema;
+    constraints?: SchemaConstraints;
+    description?: string;
+    strict?: boolean;
+};
+type SchemaMap = Record<string, SchemaDefinition>;
+type Schema = SchemaDefinition | SchemaMap;
 
-type TaskFunction = (context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void) => TaskResult;
-type TaskResult = boolean | AnyObject | Generator | Promise<any> | void;
-type ThrottleTagGetter = (context?: AnyObject, task?: Task) => string;
-/**
- * Represents a task with a specific behavior, configuration, and lifecycle management.
- * Tasks are used to define units of work that can be executed and orchestrated.
- * Tasks can specify input/output validation, concurrency, retry policies, and more.
- * This class extends SignalEmitter and implements Graph, allowing tasks to emit and observe signals.
- */
-declare class Task extends SignalEmitter implements Graph {
-    readonly name: string;
-    readonly description: string;
-    version: number;
-    concurrency: number;
-    timeout: number;
-    readonly isMeta: boolean;
-    readonly isSubMeta: boolean;
-    readonly isHidden: boolean;
-    readonly isUnique: boolean;
-    readonly throttled: boolean;
-    readonly isSignal: boolean;
-    readonly isDeputy: boolean;
-    readonly isEphemeral: boolean;
-    readonly isDebounce: boolean;
-    inputContextSchema: Schema;
-    hasExplicitInputContextSchema: boolean;
-    validateInputContext: boolean;
-    outputContextSchema: Schema;
-    hasExplicitOutputContextSchema: boolean;
-    validateOutputContext: boolean;
-    readonly retryCount: number;
-    readonly retryDelay: number;
-    readonly retryDelayMax: number;
-    readonly retryDelayFactor: number;
-    layerIndex: number;
-    progressWeight: number;
-    nextTasks: Set<Task>;
-    predecessorTasks: Set<Task>;
-    destroyed: boolean;
-    register: boolean;
-    registered: boolean;
-    registeredSignals: Set<string>;
-    taskMapRegistration: Set<string>;
-    emitsSignals: Set<string>;
-    signalsToEmitAfter: Set<string>;
-    signalsToEmitOnFail: Set<string>;
-    observedSignals: Set<string>;
-    handlesIntents: Set<string>;
-    inquiresIntents: Set<string>;
-    readonly taskFunction: TaskFunction;
-    /**
-     * Constructs an instance of the task with the specified properties and configuration options.
-     *
-     * @param {string} name - The name of the task.
-     * @param {TaskFunction} task - The function that represents the task logic.
-     * @param {string} [description=""] - A description of the task.
-     * @param {number} [concurrency=0] - The number of concurrent executions allowed for the task.
-     * @param {number} [timeout=0] - The maximum execution time for the task in milliseconds.
-     * @param {boolean} [register=true] - Indicates if the task should be registered or not.
-     * @param {boolean} [isUnique=false] - Specifies if the task should only allow one instance to exist at any time.
-     * @param {boolean} [isMeta=false] - Indicates if the task is a meta-task.
-     * @param {boolean} [isSubMeta=false] - Indicates if the task is a sub-meta-task.
-     * @param {boolean} [isHidden=false] - Determines if the task is hidden and not exposed publicly.
-     * @param {ThrottleTagGetter} [getTagCallback=undefined] - A callback to generate a throttle tag for the task.
-     * @param {Schema} [inputSchema=undefined] - The input schema for validating the task's input context.
-     * @param {boolean} [validateInputContext=false] - Specifies if the input context should be validated against the input schema.
-     * @param {Schema} [outputSchema=undefined] - The output schema for validating the task's output context.
-     * @param {boolean} [validateOutputContext=false] - Specifies if the output context should be validated against the output schema.
-     * @param {number} [retryCount=0] - The number of retry attempts allowed for the task in case of failure.
-     * @param {number} [retryDelay=0] - The initial delay (in milliseconds) between retry attempts.
-     * @param {number} [retryDelayMax=0] - The maximum delay (in milliseconds) allowed between retries.
-     * @param {number} [retryDelayFactor=1] - The factor by which the retry delay increases after each attempt.
-     */
-    constructor(name: string, task: TaskFunction, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: Schema, validateInputContext?: boolean, outputSchema?: Schema, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
-    clone(traverse?: boolean, includeSignals?: boolean): Task;
+interface Intent {
+    name: string;
+    description?: string;
+    input?: SchemaDefinition;
+    output?: SchemaDefinition;
+}
+interface InquiryOptions {
+    timeout?: number;
+    rejectOnTimeout?: boolean;
+    includePendingTasks?: boolean;
+    requireComplete?: boolean;
+}
+declare class InquiryBroker extends SignalEmitter {
+    static instance_: InquiryBroker;
+    static get instance(): InquiryBroker;
+    debug: boolean;
+    verbose: boolean;
+    setDebug(value: boolean): void;
+    setVerbose(value: boolean): void;
+    validateInquiryName(inquiryName: string): void;
+    runner: GraphRunner | undefined;
+    metaRunner: GraphRunner | undefined;
+    inquiryObservers: Map<string, {
+        fn: (runner: GraphRunner, tasks: Task[], context: AnyObject) => void;
+        tasks: Set<Task>;
+        registered: boolean;
+    }>;
+    intents: Map<string, Intent>;
     /**
-     * Retrieves the tag associated with the instance.
-     * Can be overridden by subclasses.
-     *
-     * @param {AnyObject} [context] - Optional context parameter that can be provided.
-     * @return {string} The tag value of the instance.
+     * Initializes with runners.
+     * @param runner Standard runner for user signals.
+     * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
      */
-    getTag(context?: AnyObject): string;
-    setVersion(version: number): void;
-    setTimeout(timeout: number): void;
-    setConcurrency(concurrency: number): void;
-    setProgressWeight(weight: number): void;
-    setInputContextSchema(schema: Schema): void;
-    setOutputContextSchema(schema: Schema): void;
-    setValidateInputContext(value: boolean): void;
-    setValidateOutputContext(value: boolean): void;
+    bootstrap(runner: GraphRunner, metaRunner: GraphRunner): void;
+    init(): void;
     /**
-     * Emits a signal along with metadata if certain conditions are met.
-     *
-     * This method sends a signal with optional context data and adds metadata
-     * to the emitted data if the instance is not hidden and not a subordinate metadata object.
-     *
-     * @param {string} signal - The name of the signal to emit.
-     * @param {AnyObject} [ctx={}] - Additional context data to include with the emitted signal.
-     * @return {void} Does not return a value.
+     * Observes an inquiry with a routine/task.
+     * @param inquiry The inquiry (e.g., 'domain.action', 'domain.*' for wildcards).
+     * @param task The observer.
+     * @edge Duplicates ignored; supports wildcards for broad listening.
      */
-    emitWithMetadata(signal: string, ctx?: AnyObject): void;
+    observe(inquiry: string, task: Task): void;
     /**
-     * Emits metrics with additional metadata enhancement based on the context and the state of the instance.
-     * This is used to prevent loops on the meta layer in debug mode.
-     *
-     * @param {string} signal - The signal identifier for the metric being emitted.
-     * @param {AnyObject} [ctx={}] - Optional context object to provide additional information with the metric.
-     * @return {void} This method does not return any value.
+     * Unsubscribes a routine/task from an inquiry.
+     * @param inquiry The inquiry.
+     * @param task The observer.
+     * @edge Removes all instances if duplicate; deletes if empty.
      */
-    emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
-    private isSchemaDefinition;
-    private isDefaultAnyObjectSchema;
-    private mergeSchemaVariant;
-    private validateValueAgainstSchema;
+    unsubscribe(inquiry: string, task: Task): void;
+    addInquiry(inquiry: string): void;
+    addIntent(intent: Intent): void;
+    inquire(inquiry: string, context: AnyObject, options?: InquiryOptions): Promise<AnyObject>;
+    reset(): void;
+}
+
+/**
+ * Represents a node in a graph structure used for executing tasks.
+ * A Node is a container for a task and its associated context, providing
+ * methods for executing the task and managing its lifecycle.
+ *
+ * It extends the SignalEmitter class to emit and handle signals related to
+ * the node's lifecycle, such as "meta.node.started" and "meta.node.completed".
+ *
+ * It also implements the Graph interface, allowing it to be used as a part of
+ * a graph structure, such as a GraphLayer or GraphRoutine.
+ *
+ * @extends SignalEmitter
+ * @implements Graph
+ */
+declare class GraphNode extends SignalEmitter implements Graph {
+    id: string;
+    routineExecId: string;
+    executionTraceId: string;
+    task: Task;
+    context: GraphContext;
+    layer: GraphLayer | undefined;
+    divided: boolean;
+    splitGroupId: string;
+    processing: boolean;
+    subgraphComplete: boolean;
+    graphComplete: boolean;
+    result: TaskResult;
+    retryCount: number;
+    retryDelay: number;
+    retries: number;
+    previousNodes: GraphNode[];
+    nextNodes: GraphNode[];
+    executionTime: number;
+    executionStart: number;
+    failed: boolean;
+    errored: boolean;
+    destroyed: boolean;
+    debug: boolean;
+    verbose: boolean;
+    constructor(task: Task, context: GraphContext, routineExecId: string, prevNodes?: GraphNode[], debug?: boolean, verbose?: boolean);
+    setDebug(value: boolean): void;
+    isUnique(): boolean;
+    isMeta(): boolean;
+    isProcessed(): boolean;
+    isProcessing(): boolean;
+    subgraphDone(): boolean;
+    graphDone(): boolean;
     /**
-     * Validates a data object against a specified schema definition and returns validation results.
+     * Compares the current GraphNode instance with another GraphNode to determine if they are considered equal.
      *
-     * @param {any} data - The target object to validate against the schema.
-     * @param {Schema | undefined} schema - The schema definition describing the expected structure and constraints of the data.
-     * @param {string} [path="context"] - The base path or context for traversing the data, used in generating error messages.
-     * @return {{ valid: boolean, errors: Record<string, string> }} - An object containing a validity flag (`valid`)
-     * and a map (`errors`) of validation error messages keyed by property paths.
+     * @param {GraphNode} node - The GraphNode object to compare with the current instance.
+     * @return {boolean} Returns true if the nodes share the same task, context, and belong to the same graph; otherwise, false.
      */
-    validateSchema(data: any, schema: Schema | undefined, path?: string): {
-        valid: boolean;
-        errors: Record<string, string>;
-    };
-    validateProp(prop: SchemaDefinition, key: string, value?: any, path?: string): Record<string, string>;
+    isEqualTo(node: GraphNode): boolean;
     /**
-     * Validates the input context against the predefined schema and emits metadata if validation fails.
+     * Determines if the given node is part of the same graph as the current node.
      *
-     * @param {AnyObject} context - The input context to validate.
-     * @return {true | AnyObject} - Returns `true` if validation succeeds, otherwise returns an error object containing details of the validation failure.
+     * @param {GraphNode} node - The node to compare with the current node.
+     * @return {boolean} Returns true if the provided node is part of the same graph
+     *                   (i.e., has the same routineExecId), otherwise false.
      */
-    private getEffectiveValidationMode;
-    private warnMissingSchema;
-    private logValidationFailure;
-    validateInput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
+    isPartOfSameGraph(node: GraphNode): boolean;
     /**
-     * Validates the output context using the provided schema and emits metadata if validation fails.
+     * Determines whether the current instance shares a task with the provided node.
      *
-     * @param {AnyObject} context - The output context to validate.
-     * @return {true | AnyObject} Returns `true` if the output context is valid; otherwise, returns an object
-     * containing error information when validation fails.
+     * @param {GraphNode} node - The graph node to compare with the current instance.
+     * @return {boolean} Returns true if the task names of both nodes match, otherwise false.
      */
-    validateOutput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
+    sharesTaskWith(node: GraphNode): boolean;
     /**
-     * Executes a task within a given context, optionally emitting signals and reporting progress.
+     * Determines whether the current node shares the same context as the specified node.
      *
-     * @param {GraphContext} context The execution context which provides data and functions necessary for the task.
-     * @param {function(string, AnyObject): void} emit A function to emit signals and communicate intermediate results or states.
-     * @param {function(string, AnyObject, InquiryOptions): Promise<AnyObject>} inquire A function to inquire something from another task.
-     * @param {function(number): void} progressCallback A callback function used to report task progress as a percentage (0 to 100).
-     * @param {{ nodeId: string; routineExecId: string }} nodeData An object containing identifiers related to the node and execution routine.
-     * @return {TaskResult} The result of the executed task.
+     * @param {GraphNode} node - The graph node to compare with the current node's context.
+     * @return {boolean} True if both nodes share the same context; otherwise, false.
      */
-    execute(context: GraphContext, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void, nodeData: {
-        nodeId: string;
-        routineExecId: string;
-    }): TaskResult;
+    sharesContextWith(node: GraphNode): boolean;
+    getLayerIndex(): number;
+    getConcurrency(): number;
     /**
-     * Adds tasks as predecessors to the current task and establishes dependencies between them.
-     * Ensures that adding predecessors does not create cyclic dependencies.
-     * Updates task relationships, progress weights, and emits relevant metrics after operations.
+     * Retrieves the tag associated with the current task and context.
      *
-     * @param {Task[]} tasks - An array of tasks to be added as predecessors to the current task.
-     * @return {this} The current task instance for method chaining.
-     * @throws {Error} Throws an error if adding a predecessor creates a cycle in the task structure.
+     * @return {string} The tag retrieved from the task within the given context.
      */
-    doAfter(...tasks: (Task | undefined)[]): this;
+    getTag(): string;
+    private classifyBusinessRoutineLifecycle;
+    private getBusinessRoutineLifecycleDecision;
+    private rememberBusinessRoutineLifecycleDecision;
     /**
-     * Adds a sequence of tasks as successors to the current task, ensuring no cyclic dependencies are introduced.
-     * Metrics are emitted when a relationship is successfully added.
+     * Schedules the current node/task on the specified graph layer if applicable.
      *
-     * @param {...Task} tasks - The tasks to be added as successors to the current task.
-     * @return {this} Returns the current task instance for method chaining.
-     * @throws {Error} Throws an error if adding a task causes a cyclic dependency.
-     */
-    then(...tasks: (Task | undefined)[]): this;
-    /**
-     * Decouples the current task from the provided task by removing mutual references.
+     * This method assesses whether the current node/task should be scheduled
+     * on the given graph layer. It ensures that tasks are only scheduled
+     * under certain conditions, such as checking if the task shares
+     * execution contexts or dependencies with other nodes, and handles
+     * various metadata emissions and context updates during the scheduling process.
      *
-     * @param {Task} task - The task to decouple from the current task.
-     * @return {void} This method does not return a value.
+     * @param {GraphLayer} layer - The graph layer on which the current task should be scheduled.
+     * @returns {void} Does not return a value.
      */
-    decouple(task: Task): void;
+    scheduleOn(layer: GraphLayer): void;
     /**
-     * Updates the progress weights for tasks within each layer of the subgraph.
-     * The progress weight for each task is calculated based on the inverse proportion
-     * of the number of layers and the number of tasks in each layer. This ensures an
-     * even distribution of progress weight across the tasks in the layers.
+     * Starts the execution process by initializing the execution start timestamp,
+     * emitting relevant metadata, and logging debug information if applicable.
      *
-     * @return {void} Does not return a value.
-     */
-    updateProgressWeights(): void;
-    /**
-     * Retrieves a mapping of layer indices to sets of tasks within each layer of a subgraph.
-     * This method traverses the task dependencies and organizes tasks by their respective layer indices.
+     * The method performs the following actions:
+     * 1. Sets the execution start timestamp if it's not already initialized.
+     * 2. Emits metrics with metadata about the routine execution starting, including additional data if there are no previous nodes.
+     * 3. Optionally logs debug or verbose information based on the current settings.
+     * 4. Emits additional metrics to indicate that the execution has started.
      *
-     * @return {Map<number, Set<Task>>} A map where the key is the layer index (number) and the value is a set of tasks (Set<Task>) belonging to that layer.
+     * @return {number} The timestamp indicating when the execution started.
      */
-    getSubgraphLayers(): Map<number, Set<Task>>;
+    start(): number;
     /**
-     * Updates the `layerIndex` of the current task based on the maximum layer index of its predecessors
-     * and propagates the update recursively to all subsequent tasks. If the `layerIndex` changes,
-     * emits a metric event with metadata about the change.
+     * Marks the end of an execution process, performs necessary cleanup, emits
+     * metrics with associated metadata, and signals the completion of execution.
+     * Also handles specific cases when the graph completes.
      *
-     * @return {void} This method does not return a value.
+     * @return {number} The timestamp corresponding to the end of execution. If execution
+     * was not started, it returns 0.
      */
-    updateLayerFromPredecessors(): void;
+    end(): number;
     /**
-     * Determines whether there is a cycle in the tasks graph.
-     * This method performs a depth-first search (DFS) to detect cycles.
+     * Executes the main logic of the task, including input validation, processing, and post-processing.
+     * Handles both synchronous and asynchronous workflows.
      *
-     * @return {boolean} - Returns true if a cycle is found in the graph, otherwise false.
+     * @return {Array|Promise|undefined} Returns the next nodes to process if available.
+     * If asynchronous processing is required, it returns a Promise that resolves to the next nodes.
+     * Returns undefined in case of an error during input validation or preconditions that prevent processing.
      */
-    hasCycle(): boolean;
+    execute(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * Maps over the next set of tasks or failed tasks if specified, applying the provided callback function.
+     * Executes an asynchronous workflow that processes a result and retries on errors.
+     * The method handles different result states, checks for error properties, and invokes
+     * error handling when necessary.
      *
-     * @param {Function} callback A function that will be called with each task, transforming the task as needed. It receives a single parameter of type Task.
-     * @return {any[]} An array of transformed tasks resulting from applying the callback function.
+     * @return {Promise<void>} A promise that resolves when the operation completes successfully,
+     * or rejects if an unhandled error occurs.
      */
-    mapNext(callback: (task: Task) => any): any[];
+    workAsync(): Promise<void>;
     /**
-     * Maps through each task in the set of predecessor tasks and applies the provided callback function.
+     * Executes an asynchronous operation, processes the result, and determines the next nodes to execute.
+     * This method will manage asynchronous work, handle post-processing of results, and ensure proper handling of both synchronous and asynchronous next node configurations.
      *
-     * @param {function} callback - A function to execute on each task in the predecessor tasks. The function receives a `Task` object as its argument and returns any value.
-     * @return {any[]} An array containing the results of applying the callback function to each predecessor task.
+     * @return {Promise<any>} A promise resolving to the next nodes to be executed. Can be the result of post-processing or a directly resolved next nodes object.
      */
-    mapPrevious(callback: (task: Task) => any): any[];
-    makeRoutine(name: string, description: string): this;
+    executeAsync(): Promise<GraphNode[]>;
     /**
-     * Adds the specified signals to the current instance, making it observe them.
-     * If the instance is already observing a signal, it will be skipped.
-     * The method also emits metadata information if the `register` property is set.
+     * Executes the task associated with the current instance, using the given context,
+     * progress callback, and metadata. If the task fails or an error occurs, it attempts
+     * to retry the execution. If the retry is not successful, it propagates the error and
+     * returns the result.
      *
-     * @param {...string[]} signals - The array of signal names to observe.
-     * @return {this} The current instance after adding the specified signals.
+     * @return {TaskResult | Promise<TaskResult>} The result of the task execution, or a
+     * promise that resolves to the task result. This includes handling for retries on
+     * failure and error propagation.
      */
-    doOn(...signals: SignalDefinitionInput[]): this;
+    work(): TaskResult | Promise<TaskResult>;
+    inquire(inquiry: string, context: AnyObject, options: InquiryOptions): Promise<any>;
     /**
-     * Registers the specified signals to be emitted after the Task executes successfully and attaches them for further processing.
+     * Emits a signal along with its associated metadata. The metadata includes
+     * task-specific information such as task name, version, execution ID, and
+     * additional context metadata like routine execution ID and execution trace ID.
+     * This method is designed to enrich emitted signals with relevant details
+     * before broadcasting them.
      *
-     * @param {...string} signals - The list of signals to be registered for emission.
-     * @return {this} The current instance for method chaining.
+     * @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.
      */
-    emits(...signals: SignalDefinitionInput[]): this;
+    emitWithMetadata(signal: string, data: AnyObject, options?: EmitOptions): void;
     /**
-     * Configures the instance to emit specified signals when the task execution fails.
-     * A failure is defined as anything that does not return a successful result.
+     * Emits metrics with additional metadata describing the task execution and context.
      *
-     * @param {...string} signals - The names of the signals to emit upon failure.
-     * @return {this} Returns the current instance for chaining.
+     * @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.
      */
-    emitsOnFail(...signals: SignalDefinitionInput[]): this;
+    emitMetricsWithMetadata(signal: string, data: AnyObject, options?: EmitOptions): void;
     /**
-     * Attaches a signal to the current context and emits metadata if the register flag is set.
+     * Updates the progress of a task and emits metrics with associated metadata.
      *
-     * @param {...string} signals - The names of the signals to attach.
+     * @param {number} progress - A number representing the progress value, which will be clamped between 0 and 1.
      * @return {void} This method does not return a value.
      */
-    attachSignal(...signals: SignalDefinitionInput[]): Task;
+    onProgress(progress: number): void;
     /**
-     * Unsubscribes the current instance from the specified signals.
-     * This method removes the signals from the observedSignals set, unsubscribes
-     * from the underlying broker, and emits metadata for the unsubscription if applicable.
+     * Processes the result of the current operation, validates it, and determines the next set of nodes.
      *
-     * @param {string[]} signals - The list of signal names to unsubscribe from.
-     * @return {this} Returns the current instance for method chaining.
+     * This method ensures that results of certain types such as strings or arrays
+     * are flagged as errors. It divides the current context into subsequent nodes
+     * for further processing. If the division returns a promise, it delegates the
+     * processing to `postProcessAsync`. For synchronous division, it sets the
+     * `nextNodes` and finalizes the operation.
+     *
+     * @return {(Array|undefined)} Returns an array of next nodes for further processing,
+     * or undefined if no further processing is required.
      */
-    unsubscribe(...signals: string[]): this;
+    postProcess(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * Unsubscribes from all currently observed signals and clears the list of observed signals.
+     * Asynchronously processes and finalizes the provided graph nodes.
      *
-     * @return {this} The instance of the class to allow method chaining.
+     * @param {Promise<GraphNode[]>} nextNodes A promise that resolves to an array of graph nodes to be processed.
+     * @return {Promise<GraphNode[]>} A promise that resolves to the processed array of graph nodes.
      */
-    unsubscribeAll(): this;
+    postProcessAsync(nextNodes: Promise<GraphNode[]>): Promise<GraphNode[]>;
     /**
-     * Detaches the specified signals from being emitted after execution and optionally emits metadata for each detached signal.
+     * Finalizes the current task execution by determining if the task is complete, handles any errors or failures,
+     * emits relevant signals based on the task outcomes, and ensures proper end of the task lifecycle.
      *
-     * @param {...string} signals - The list of signal names to be detached. Signals can be in the format "namespace:signalName".
-     * @return {this} Returns the current instance of the object for method chaining.
+     * @return {void} Does not return a value.
      */
-    detachSignals(...signals: string[]): this;
+    finalize(): void;
     /**
-     * Detaches all signals associated with the object by invoking the `detachSignals` method
-     * and clearing the `signalsToEmitAfter` collection.
+     * Handles an error event, processes the error, and updates the state accordingly.
      *
-     * @return {this} Returns the current instance to allow method chaining.
+     * @param {unknown} error - The error object or message that occurred.
+     * @param {AnyObject} [errorData={}] - Additional error data to include in the result.
+     * @return {void} This method does not return any value.
      */
-    detachAllSignals(): this;
-    respondsTo(...inquires: string[]): this;
-    attachIntents(...intentNames: string[]): this;
-    detachIntents(...intentNames: string[]): this;
-    detachAllIntents(): this;
+    onError(error: unknown, errorData?: AnyObject): void;
     /**
-     * Maps over the signals in the `signalsToEmitAfter` set and applies a callback function to each signal.
+     * Retries a task based on the defined retry count and delay time. If the retry count is 0, it immediately resolves with the provided previous result.
      *
-     * @param {function(string): void} callback - A function that is called with each signal
-     *   in the `signalsToEmitAfter` set, providing the signal as an argument.
-     * @return {Array<any>} An array containing the results of applying the callback
-     *   function to each signal.
+     * @param {any} [prevResult] - The result from a previous attempt, if any, to return when no retries are performed.
+     * @return {Promise<TaskResult>} - A promise that resolves with the result of the retried task or the previous result if no retries occur.
      */
-    mapSignals(callback: (signal: string) => void): void[];
+    retry(prevResult?: any): Promise<TaskResult>;
     /**
-     * Maps over the signals in `signalsToEmitOnFail` and applies the provided callback to each signal.
+     * Retries an asynchronous operation and returns its result.
+     * If the retry count is zero, the method immediately returns the provided previous result.
      *
-     * @param {function(string): void} callback - A function that receives each signal as a string and performs an operation or transformation on it.
-     * @return {Array} The array resulting from applying the callback to each signal in `signalsToEmitOnFail`.
+     * @param {any} [prevResult] - The optional result from a previous operation attempt, if applicable.
+     * @return {Promise<TaskResult>} A promise that resolves to the result of the retried operation.
      */
-    mapOnFailSignals(callback: (signal: string) => void): void[];
+    retryAsync(prevResult?: any): Promise<TaskResult>;
+    delayRetry(): Promise<void>;
     /**
-     * Maps over the observed signals with the provided callback function.
+     * Processes the result of a task by generating new nodes based on the task output.
+     * The method handles synchronous and asynchronous generators, validates task output,
+     * and creates new nodes accordingly. If errors occur, the method attempts to handle them
+     * by generating alternative task nodes.
      *
-     * @param {function(string): void} callback - A function to execute on each signal in the observed signals array.
-     * @return {Array} A new array containing the results of calling the callback function on each observed signal.
+     * @return {GraphNode[] | Promise<GraphNode[]>} Returns an array of generated GraphNode objects
+     * (synchronously or wrapped in a Promise) based on the task result, or propagates errors if validation fails.
      */
-    mapObservedSignals(callback: (signal: string) => void): void[];
+    divide(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * Emits a collection of signals stored in the `signalsToEmitAfter` array.
+     * Processes an asynchronous iterator result, validates its output, and generates new graph nodes accordingly.
+     * Additionally, continues to process and validate results from an asynchronous generator.
      *
-     * @param {GraphContext} context - The context object containing data or state to be passed to the emitted signals.
-     * @return {void} This method does not return a value.
+     * @param {Promise<IteratorResult<any>>} current - A promise resolving to the current step result from an asynchronous iterator.
+     * @return {Promise<GraphNode[]>} A promise resolving to an array of generated GraphNode objects based on validated outputs.
      */
-    emitSignals(context: GraphContext): void;
+    divideAsync(current: Promise<IteratorResult<any>>): Promise<GraphNode[]>;
     /**
-     * Emits registered signals when an operation fails.
+     * Generates new nodes based on the provided result and task configuration.
      *
-     * @param {GraphContext} context - The context from which the full context is derived and passed to the signals being emitted.
-     * @return {void} This method does not return any value.
+     * @param {any} result - The result of the previous operation, which determines the configuration and context for new nodes. It can be a boolean or an object containing details like failure, errors, or metadata.
+     * @return {GraphNode[]} An array of newly generated graph nodes configured based on the task and context.
      */
-    emitOnFailSignals(context: GraphContext): void;
+    generateNewNodes(result: any): GraphNode[];
     /**
-     * Cleans up and destroys the task instance, detaching it from other tasks and
-     * performing necessary cleanup operations.
+     * Executes the differentiation process based on a given task and updates the instance properties accordingly.
      *
-     * This method:
-     * - Unsubscribes from all signals and events.
-     * - Detaches all associated signal handlers.
-     * - Removes the task from successor and predecessor task mappings.
-     * - Clears all task relationships and marks the task as destroyed.
-     * - Emits destruction metrics, if applicable.
+     * @param {Task} task - The task object containing information such as retry count, retry delay, and metadata status.
+     * @return {GraphNode} The updated instance after processing the task.
+     */
+    differentiate(task: Task): GraphNode;
+    /**
+     * Migrates the current instance to a new context and returns the updated instance.
      *
-     * @return {void} No value is returned because the function performs clean-up operations.
+     * @param {any} ctx - The context data to be used for migration.
+     * @return {GraphNode} The updated instance after migration.
      */
-    destroy(): void;
+    migrate(ctx: any): GraphNode;
     /**
-     * Exports the current state of the object as a structured plain object.
+     * Splits the current node into a new group identified by the provided ID.
      *
-     * @return {AnyObject} An object containing the serialized properties of the current instance. The exported object includes various metadata, schema information, task attributes, and related tasks, such as:
-     * - Name and description of the task.
-     * - Layer index, uniqueness, meta, and signal-related flags.
-     * - Event triggers and attached signals.
-     * - Throttling, concurrency, timeout settings, and ephemeral flag.
-     * - Task function as a string.
-     * - Serialization of getter callbacks and schemas for input/output validation.
-     * - Relationships such as next tasks, failure tasks, and predecessor tasks.
+     * @param {string} id - The unique identifier for the new split group.
+     * @return {GraphNode} The current instance of the GraphNode with the updated split group ID.
      */
-    export(): AnyObject;
+    split(id: string): GraphNode;
     /**
-     * Returns an iterator for iterating over tasks associated with this instance.
+     * Creates a new instance of the GraphNode with the current node's properties.
+     * This method allows for duplicating the existing graph node.
      *
-     * @return {TaskIterator} An iterator instance for tasks.
+     * @return {GraphNode} A new instance of GraphNode that is a copy of the current node.
      */
-    getIterator(): TaskIterator;
+    clone(): GraphNode;
     /**
-     * Accepts a visitor object to perform operations on the current instance.
+     * Consumes the given graph node by combining contexts, merging previous nodes,
+     * and performing associated operations on the provided node.
      *
-     * @param {GraphVisitor} visitor - The visitor object implementing operations for this instance.
+     * @param {GraphNode} node - The graph node to be consumed.
      * @return {void} This method does not return a value.
      */
-    accept(visitor: GraphVisitor): void;
-    log(): void;
-}
-
-/**
- * Represents a synchronous graph layer derived from the GraphLayer base class.
- * This class is designed to execute graph nodes in a strictly synchronous manner.
- * Asynchronous functions are explicitly disallowed, ensuring consistency and predictability.
- */
-declare class SyncGraphLayer extends GraphLayer {
+    consume(node: GraphNode): void;
     /**
-     * Executes the processing logic of the current set of graph nodes. Iterates through all
-     * nodes, skipping any that have already been processed, and executes their respective
-     * logic to generate new nodes. Asynchronous functions are not supported and will
-     * trigger an error log.
+     * Changes the identity of the current instance by updating the `id` property.
      *
-     * @return {GraphNode[]} An array of newly generated graph nodes after executing the logic of each unprocessed node.
+     * @param {string} id - The new identity value to be assigned.
+     * @return {void} Does not return a value.
      */
-    execute(): GraphNode[];
-}
-
-/**
- * An abstract class representing a GraphExporter.
- * This class defines a structure for exporting graph data in different formats,
- * depending on the implementations provided by subclasses.
- */
-declare abstract class GraphExporter {
-    abstract exportGraph(graph: SyncGraphLayer): any;
-    abstract exportStaticGraph(graph: Task[]): any;
-}
-
-/**
- * GraphBuilder is an abstract base class designed to construct and manage a graph structure
- * composed of multiple layers. Subclasses are expected to implement the `compose` method
- * based on specific requirements. This class provides methods for adding nodes, managing
- * layers, and resetting the graph construction process.
- *
- * This class supports creating layered graph structures, dynamically adding layers and nodes,
- * and debugging graph-building operations.
- */
-declare abstract class GraphBuilder {
-    graph: GraphLayer | undefined;
-    topLayerIndex: number;
-    layers: GraphLayer[];
-    debug: boolean;
-    setDebug(value: boolean): void;
-    getResult(): GraphLayer;
+    changeIdentity(id: string): void;
     /**
-     * Composes a series of functions or operations.
-     * This method should be implemented in the child class
-     * to define custom composition logic.
+     * Completes the subgraph for the current node and recursively for its previous nodes
+     * once all next nodes have their subgraphs marked as done. If there are no previous nodes,
+     * it completes the entire graph.
      *
-     * @return {any} The result of the composed operations or functions
-     * when implemented in the child class.
+     * @return {void} Does not return a value.
      */
-    compose(): void;
+    completeSubgraph(): void;
     /**
-     * Adds a node to the appropriate layer of the graph.
+     * Completes the current graph by setting a flag indicating the graph has been completed
+     * and recursively completes all subsequent nodes in the graph.
      *
-     * @param {GraphNode} node - The node to be added to the graph. The node contains
-     *                           layer information that determines which layer it belongs to.
      * @return {void} Does not return a value.
      */
-    addNode(node: GraphNode): void;
+    completeGraph(): void;
     /**
-     * Adds multiple nodes to the graph.
+     * Destroys the current instance by releasing resources, breaking references,
+     * and resetting properties to ensure proper cleanup.
      *
-     * @param {GraphNode[]} nodes - An array of nodes to be added to the graph.
-     * @return {void} This method does not return a value.
+     * @return {void} No return value.
      */
-    addNodes(nodes: GraphNode[]): void;
+    destroy(): void;
     /**
-     * Adds a new layer to the graph at the specified index. If the graph does not exist,
-     * it creates the graph using the specified index. Updates the graph's top layer index
-     * and maintains the order of layers.
+     * Retrieves an iterator for traversing through the graph nodes.
+     *
+     * @return {GraphNodeIterator} An iterator instance specific to this graph node.
+     */
+    getIterator(): GraphNodeIterator;
+    /**
+     * Applies a callback function to each node in the `nextNodes` array and returns
+     * the resulting array from the map operation.
      *
-     * @param {number} index - The index at which the new layer should be added to the graph.
-     * @return {void} This method does not return a value.
+     * @param {function} callback - A function to execute on each `GraphNode` in the `nextNodes` array.
+     * The function receives a `GraphNode` as its argument.
+     * @return {Array} The resulting array after applying the callback function to each node in `nextNodes`.
      */
-    addLayer(index: number): void;
+    mapNext(callback: (node: GraphNode) => any): any[];
     /**
-     * Creates a new layer for the graph at the specified index.
+     * Accepts a visitor object and calls its visitNode method with the current instance.
      *
-     * @param {number} index - The index of the layer to be created.
-     * @return {GraphLayer} A new instance of the graph layer corresponding to the provided index.
+     * @param {GraphVisitor} visitor - The visitor instance implementing the GraphVisitor interface.
+     * @return {void} This method does not return a value.
      */
-    createLayer(index: number): GraphLayer;
+    accept(visitor: GraphVisitor): void;
     /**
-     * Retrieves a specific layer from the current set of layers.
+     * Exports the current object's state and returns it in a serialized format.
+     * The exported object contains metadata, task details, context information, execution times, node relationships, routine execution status, and other state information.
      *
-     * @param {number} layerIndex - The index of the layer to retrieve.
-     * @return {*} The layer corresponding to the given index.
+     * @return {Object} An object representing the current state.
      */
-    getLayer(layerIndex: number): GraphLayer;
-    reset(): void;
+    export(): {
+        __id: string;
+        __task: AnyObject;
+        __context: {
+            id: string;
+            context: AnyObject;
+        };
+        __result: TaskResult;
+        __executionTime: number;
+        __executionStart: number;
+        __executionEnd: number;
+        __nextNodes: string[];
+        __previousNodes: string[];
+        __routineExecId: string;
+        __isProcessing: boolean;
+        __isMeta: boolean;
+        __graphComplete: boolean;
+        __failed: boolean;
+        __errored: boolean;
+        __isUnique: boolean;
+        __splitGroupId: string;
+        __tag: string;
+    };
+    lightExport(): {
+        __id: string;
+        __task: {
+            __name: string;
+            __version: number;
+        };
+        __context: {
+            id: string;
+            context: AnyObject;
+        };
+        __executionTime: number;
+        __executionStart: number;
+        __nextNodes: string[];
+        __previousNodes: string[];
+        __routineExecId: string;
+        __isProcessing: boolean;
+        __graphComplete: boolean;
+        __isMeta: boolean;
+        __failed: boolean;
+        __errored: boolean;
+        __isUnique: boolean;
+        __splitGroupId: string;
+        __tag: string;
+    };
+    log(): void;
+}
+
+declare abstract class GraphVisitor {
+    abstract visitLayer(layer: GraphLayer): any;
+    abstract visitNode(node: GraphNode): any;
+    abstract visitTask(task: Task): any;
 }
 
 /**
- * Abstract class representing a strategy for configuring and executing graph operations.
- * Provides a structure for managing graph builders, altering strategies, and updating the execution context.
- *
- * This class cannot be instantiated directly and must be extended by concrete implementations.
+ * TaskIterator is a custom iterator for traversing over a set of tasks.
+ * It provides mechanisms to iterate through tasks in a layered manner,
+ * where each task can branch out to other tasks forming multiple layers.
  */
-declare abstract class GraphRunStrategy {
-    graphBuilder: GraphBuilder;
-    runInstance?: GraphRun;
-    constructor();
-    setRunInstance(runInstance: GraphRun): void;
-    changeStrategy(builder: GraphBuilder): void;
-    reset(): void;
-    addNode(node: GraphNode): void;
-    updateRunInstance(): void;
-    abstract run(): void;
-    abstract export(): any;
+declare class TaskIterator implements Iterator {
+    currentTask: Task | undefined;
+    currentLayer: Set<Task>;
+    nextLayer: Set<Task>;
+    iterator: {
+        next: () => {
+            value: Task | undefined;
+        };
+    };
+    constructor(task: Task);
+    hasNext(): boolean;
+    next(): Task | undefined;
 }
 
-interface RunJson {
-    __id: string;
-    __label: string;
-    __graph: any;
-    __data: any;
+interface RuntimeTools {
+    helpers: Record<string, HelperInvoker>;
+    globals: Record<string, unknown>;
 }
-/**
- * Represents a GraphRun instance which manages the execution of a graph-based workflow.
- * It utilizes a specific strategy and export mechanism to manage, execute, and export the graph data.
- */
-declare class GraphRun {
-    readonly id: string;
-    graph: GraphLayer | undefined;
-    strategy: GraphRunStrategy;
-    exporter: GraphExporter | undefined;
-    constructor(strategy: GraphRunStrategy);
-    setGraph(graph: GraphLayer): void;
-    addNode(node: GraphNode): void;
-    run(): void | Promise<void>;
+type HelperFunction = (context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, tools: RuntimeTools, progressCallback: (progress: number) => void) => TaskResult;
+type HelperInvoker = (context?: AnyObject) => TaskResult | Promise<TaskResult>;
+interface ToolDependencyOwner {
+    readonly isMeta: boolean;
+    helperAliases: Map<string, string>;
+    globalAliases: Map<string, string>;
+}
+declare class GlobalDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly version: number;
+    readonly isMeta: boolean;
+    readonly value: unknown;
+    destroyed: boolean;
+    constructor(name: string, value: unknown, description?: string, isMeta?: boolean);
     destroy(): void;
-    log(): void;
-    export(): RunJson;
-    setExporter(exporter: GraphExporter): void;
+    export(): Record<string, unknown>;
+}
+declare class HelperDefinition implements ToolDependencyOwner {
+    readonly name: string;
+    readonly description: string;
+    readonly version: number;
+    readonly isMeta: boolean;
+    readonly helperFunction: HelperFunction;
+    readonly helperAliases: Map<string, string>;
+    readonly globalAliases: Map<string, string>;
+    destroyed: boolean;
+    constructor(name: string, helperFunction: HelperFunction, description?: string, isMeta?: boolean);
+    usesHelpers(helpers: Record<string, HelperDefinition | undefined>): this;
+    usesGlobals(globals: Record<string, GlobalDefinition | undefined>): this;
+    execute(context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void): TaskResult;
+    destroy(): void;
+    export(): Record<string, unknown>;
 }
 
+type TaskFunction = (context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, tools: RuntimeTools, progressCallback: (progress: number) => void) => TaskResult;
+type TaskResult = boolean | AnyObject | Generator | Promise<any> | void;
+type ThrottleTagGetter = (context?: AnyObject, task?: Task) => string;
 /**
- * Represents a routine in a graph structure with tasks and signal observation capabilities.
- * Routines are named entrypoint for a sub-graph, describing the purpose for the subsequent flow.
- * Since Task names are specific to the task it performs, it doesn't describe the overall flow.
- * Routines, therefore are used to assign names to sub-flows that can be referenced using that name instead of the name of the task(s).
- * Extends SignalEmitter to emit and handle signals related to the routine's lifecycle and tasks.
+ * Represents a task with a specific behavior, configuration, and lifecycle management.
+ * Tasks are used to define units of work that can be executed and orchestrated.
+ * Tasks can specify input/output validation, concurrency, retry policies, and more.
+ * This class extends SignalEmitter and implements Graph, allowing tasks to emit and observe signals.
  */
-declare class GraphRoutine extends SignalEmitter {
+declare class Task extends SignalEmitter implements Graph, ToolDependencyOwner {
     readonly name: string;
-    version: number;
     readonly description: string;
+    version: number;
+    concurrency: number;
+    timeout: number;
     readonly isMeta: boolean;
-    tasks: Set<Task>;
+    readonly isSubMeta: boolean;
+    readonly isHidden: boolean;
+    readonly isUnique: boolean;
+    readonly throttled: boolean;
+    readonly isSignal: boolean;
+    readonly isDeputy: boolean;
+    readonly isEphemeral: boolean;
+    readonly isDebounce: boolean;
+    inputContextSchema: Schema;
+    hasExplicitInputContextSchema: boolean;
+    validateInputContext: boolean;
+    outputContextSchema: Schema;
+    hasExplicitOutputContextSchema: boolean;
+    validateOutputContext: boolean;
+    readonly retryCount: number;
+    readonly retryDelay: number;
+    readonly retryDelayMax: number;
+    readonly retryDelayFactor: number;
+    layerIndex: number;
+    progressWeight: number;
+    nextTasks: Set<Task>;
+    predecessorTasks: Set<Task>;
+    destroyed: boolean;
+    register: boolean;
     registered: boolean;
-    registeredTasks: Set<Task>;
+    registeredSignals: Set<string>;
+    taskMapRegistration: Set<string>;
+    emitsSignals: Set<string>;
+    signalsToEmitAfter: Set<string>;
+    signalsToEmitOnFail: Set<string>;
     observedSignals: Set<string>;
-    constructor(name: string, tasks: Task[], description: string, isMeta?: boolean);
+    handlesIntents: Set<string>;
+    inquiresIntents: Set<string>;
+    helperAliases: Map<string, string>;
+    globalAliases: Map<string, string>;
+    readonly taskFunction: TaskFunction;
+    /**
+     * Constructs an instance of the task with the specified properties and configuration options.
+     *
+     * @param {string} name - The name of the task.
+     * @param {TaskFunction} task - The function that represents the task logic.
+     * @param {string} [description=""] - A description of the task.
+     * @param {number} [concurrency=0] - The number of concurrent executions allowed for the task.
+     * @param {number} [timeout=0] - The maximum execution time for the task in milliseconds.
+     * @param {boolean} [register=true] - Indicates if the task should be registered or not.
+     * @param {boolean} [isUnique=false] - Specifies if the task should only allow one instance to exist at any time.
+     * @param {boolean} [isMeta=false] - Indicates if the task is a meta-task.
+     * @param {boolean} [isSubMeta=false] - Indicates if the task is a sub-meta-task.
+     * @param {boolean} [isHidden=false] - Determines if the task is hidden and not exposed publicly.
+     * @param {ThrottleTagGetter} [getTagCallback=undefined] - A callback to generate a throttle tag for the task.
+     * @param {Schema} [inputSchema=undefined] - The input schema for validating the task's input context.
+     * @param {boolean} [validateInputContext=false] - Specifies if the input context should be validated against the input schema.
+     * @param {Schema} [outputSchema=undefined] - The output schema for validating the task's output context.
+     * @param {boolean} [validateOutputContext=false] - Specifies if the output context should be validated against the output schema.
+     * @param {number} [retryCount=0] - The number of retry attempts allowed for the task in case of failure.
+     * @param {number} [retryDelay=0] - The initial delay (in milliseconds) between retry attempts.
+     * @param {number} [retryDelayMax=0] - The maximum delay (in milliseconds) allowed between retries.
+     * @param {number} [retryDelayFactor=1] - The factor by which the retry delay increases after each attempt.
+     */
+    constructor(name: string, task: TaskFunction, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: Schema, validateInputContext?: boolean, outputSchema?: Schema, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    clone(traverse?: boolean, includeSignals?: boolean): Task;
+    /**
+     * Retrieves the tag associated with the instance.
+     * Can be overridden by subclasses.
+     *
+     * @param {AnyObject} [context] - Optional context parameter that can be provided.
+     * @return {string} The tag value of the instance.
+     */
+    getTag(context?: AnyObject): string;
+    setVersion(version: number): void;
+    setTimeout(timeout: number): void;
+    setConcurrency(concurrency: number): void;
+    setProgressWeight(weight: number): void;
+    setInputContextSchema(schema: Schema): void;
+    setOutputContextSchema(schema: Schema): void;
+    setValidateInputContext(value: boolean): void;
+    setValidateOutputContext(value: boolean): void;
+    /**
+     * Emits a signal along with metadata if certain conditions are met.
+     *
+     * This method sends a signal with optional context data and adds metadata
+     * to the emitted data if the instance is not hidden and not a subordinate metadata object.
+     *
+     * @param {string} signal - The name of the signal to emit.
+     * @param {AnyObject} [ctx={}] - Additional context data to include with the emitted signal.
+     * @return {void} Does not return a value.
+     */
+    emitWithMetadata(signal: string, ctx?: AnyObject): void;
+    /**
+     * Emits metrics with additional metadata enhancement based on the context and the state of the instance.
+     * This is used to prevent loops on the meta layer in debug mode.
+     *
+     * @param {string} signal - The signal identifier for the metric being emitted.
+     * @param {AnyObject} [ctx={}] - Optional context object to provide additional information with the metric.
+     * @return {void} This method does not return any value.
+     */
+    emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
+    private isSchemaDefinition;
+    private isDefaultAnyObjectSchema;
+    private mergeSchemaVariant;
+    private validateValueAgainstSchema;
     /**
-     * Iterates over each task in the `tasks` collection and applies the provided callback function.
-     * If the callback returns a Promise, resolves all Promises concurrently.
+     * Validates a data object against a specified schema definition and returns validation results.
      *
-     * @param {function} callBack - A function to be executed on each task from the `tasks` collection.
-     *                              The callback receives the current task as its argument.
-     * @return {Promise<void>} A Promise that resolves once all callback executions, including asynchronous ones, are complete.
+     * @param {any} data - The target object to validate against the schema.
+     * @param {Schema | undefined} schema - The schema definition describing the expected structure and constraints of the data.
+     * @param {string} [path="context"] - The base path or context for traversing the data, used in generating error messages.
+     * @return {{ valid: boolean, errors: Record<string, string> }} - An object containing a validity flag (`valid`)
+     * and a map (`errors`) of validation error messages keyed by property paths.
      */
-    forEachTask(callBack: (task: Task) => any): Promise<void>;
+    validateSchema(data: any, schema: Schema | undefined, path?: string): {
+        valid: boolean;
+        errors: Record<string, string>;
+    };
+    validateProp(prop: SchemaDefinition, key: string, value?: any, path?: string): Record<string, string>;
     /**
-     * Sets global Version.
-     * @param version The Version.
+     * Validates the input context against the predefined schema and emits metadata if validation fails.
+     *
+     * @param {AnyObject} context - The input context to validate.
+     * @return {true | AnyObject} - Returns `true` if validation succeeds, otherwise returns an error object containing details of the validation failure.
      */
-    setVersion(version: number): void;
+    private getEffectiveValidationMode;
+    private warnMissingSchema;
+    private logValidationFailure;
+    validateInput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
     /**
-     * Subscribes the current instance to the specified signals, enabling it to observe them.
+     * Validates the output context using the provided schema and emits metadata if validation fails.
      *
-     * @param {...string} signals - The names of the signals to observe.
-     * @return {this} Returns the instance to allow for method chaining.
+     * @param {AnyObject} context - The output context to validate.
+     * @return {true | AnyObject} Returns `true` if the output context is valid; otherwise, returns an object
+     * containing error information when validation fails.
      */
-    doOn(...signals: string[]): this;
+    validateOutput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
     /**
-     * Unsubscribes from all observed signals and clears the internal collection
-     * of observed signals. This ensures that the instance is no longer listening
-     * or reacting to any previously subscribed signals.
+     * Executes a task within a given context, optionally emitting signals and reporting progress.
      *
-     * @return {this} Returns the current instance for chaining purposes.
+     * @param {GraphContext} context The execution context which provides data and functions necessary for the task.
+     * @param {function(string, AnyObject): void} emit A function to emit signals and communicate intermediate results or states.
+     * @param {function(string, AnyObject, InquiryOptions): Promise<AnyObject>} inquire A function to inquire something from another task.
+     * @param {function(number): void} progressCallback A callback function used to report task progress as a percentage (0 to 100).
+     * @param {{ nodeId: string; routineExecId: string }} nodeData An object containing identifiers related to the node and execution routine.
+     * @return {TaskResult} The result of the executed task.
      */
-    unsubscribeAll(): this;
+    execute(context: GraphContext, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
     /**
-     * Unsubscribes the current instance from the specified signals.
+     * Adds tasks as predecessors to the current task and establishes dependencies between them.
+     * Ensures that adding predecessors does not create cyclic dependencies.
+     * Updates task relationships, progress weights, and emits relevant metrics after operations.
      *
-     * @param {...string} signals - The signals to unsubscribe from.
-     * @return {this} The current instance for method chaining.
+     * @param {Task[]} tasks - An array of tasks to be added as predecessors to the current task.
+     * @return {this} The current task instance for method chaining.
+     * @throws {Error} Throws an error if adding a predecessor creates a cycle in the task structure.
      */
-    unsubscribe(...signals: string[]): this;
+    doAfter(...tasks: (Task | undefined)[]): this;
     /**
-     * Cleans up resources and emits an event indicating the destruction of the routine.
+     * Adds a sequence of tasks as successors to the current task, ensuring no cyclic dependencies are introduced.
+     * Metrics are emitted when a relationship is successfully added.
      *
-     * This method unsubscribes from all events, clears the tasks list,
-     * and emits a "meta.routine.destroyed" event with details of the destruction.
+     * @param {...Task} tasks - The tasks to be added as successors to the current task.
+     * @return {this} Returns the current task instance for method chaining.
+     * @throws {Error} Throws an error if adding a task causes a cyclic dependency.
+     */
+    then(...tasks: (Task | undefined)[]): this;
+    /**
+     * Decouples the current task from the provided task by removing mutual references.
      *
-     * @return {void}
+     * @param {Task} task - The task to decouple from the current task.
+     * @return {void} This method does not return a value.
      */
-    destroy(): void;
-}
-
-/**
- * Represents a runner for managing and executing tasks or routines within a graph.
- * The `GraphRunner` extends `SignalEmitter` to include signal-based event-driven mechanisms.
- */
-declare class GraphRunner extends SignalEmitter {
-    currentRun: GraphRun;
-    debug: boolean;
-    verbose: boolean;
-    isRunning: boolean;
-    readonly isMeta: boolean;
-    strategy: GraphRunStrategy;
+    decouple(task: Task): void;
     /**
-     * Constructs a runner.
-     * @param isMeta Meta flag (default false).
-     * @edge Creates 'Start run' meta-task chained to registry gets.
+     * Updates the progress weights for tasks within each layer of the subgraph.
+     * The progress weight for each task is calculated based on the inverse proportion
+     * of the number of layers and the number of tasks in each layer. This ensures an
+     * even distribution of progress weight across the tasks in the layers.
+     *
+     * @return {void} Does not return a value.
      */
-    constructor(isMeta?: boolean);
+    updateProgressWeights(): void;
     /**
-     * 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.
+     * Retrieves a mapping of layer indices to sets of tasks within each layer of a subgraph.
+     * This method traverses the task dependencies and organizes tasks by their respective layer indices.
      *
-     * @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.
+     * @return {Map<number, Set<Task>>} A map where the key is the layer index (number) and the value is a set of tasks (Set<Task>) belonging to that layer.
      */
-    addTasks(tasks: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): void;
+    getSubgraphLayers(): Map<number, Set<Task>>;
     /**
-     * Executes the provided tasks or routines. Maintains the execution state
-     * and handles synchronous or asynchronous processing.
+     * Updates the `layerIndex` of the current task based on the maximum layer index of its predecessors
+     * and propagates the update recursively to all subsequent tasks. If the `layerIndex` changes,
+     * emits a metric event with metadata about the change.
      *
-     * @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.
+     * @return {void} This method does not return a value.
      */
-    run(tasks?: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): GraphRun | Promise<GraphRun>;
+    updateLayerFromPredecessors(): void;
     /**
-     * Executes the provided asynchronous operation and resets the state afterwards.
+     * Determines whether there is a cycle in the tasks graph.
+     * This method performs a depth-first search (DFS) to detect cycles.
      *
-     * @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.
+     * @return {boolean} - Returns true if a cycle is found in the graph, otherwise false.
      */
-    runAsync(run: Promise<void>): Promise<GraphRun>;
+    hasCycle(): boolean;
     /**
-     * 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.
+     * Maps over the next set of tasks or failed tasks if specified, applying the provided callback function.
      *
-     * @return {GraphRun} The last GraphRun instance before the reset.
+     * @param {Function} callback A function that will be called with each task, transforming the task as needed. It receives a single parameter of type Task.
+     * @return {any[]} An array of transformed tasks resulting from applying the callback function.
      */
-    reset(): GraphRun;
-    setDebug(value: boolean): void;
-    setVerbose(value: boolean): void;
-    destroy(): void;
+    mapNext(callback: (task: Task) => any): any[];
     /**
-     * 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.
+     * Maps through each task in the set of predecessor tasks and applies the provided callback function.
      *
-     * @param {GraphRunStrategy} strategy - The strategy to use for running the graph.
-     * @return {void}
+     * @param {function} callback - A function to execute on each task in the predecessor tasks. The function receives a `Task` object as its argument and returns any value.
+     * @return {any[]} An array containing the results of applying the callback function to each predecessor task.
      */
-    setStrategy(strategy: GraphRunStrategy): void;
-}
-
-interface EmitOptions {
-    squash?: boolean;
-    squashId?: string | null;
-    groupId?: string | null;
-    mergeFunction?: ((oldContext: AnyObject, ...newContext: AnyObject[]) => AnyObject) | null;
-    debounce?: boolean;
-    throttle?: boolean;
-    delayMs?: number;
-    schedule?: boolean;
-    exactDateTime?: Date | null;
-    throttleBatch?: number;
-    flushStrategy?: string;
-}
-type SignalDeliveryMode = "single" | "broadcast";
-type SignalReceiverFilter = {
-    serviceNames?: string[];
-    serviceInstanceIds?: string[];
-    origins?: string[];
-    roles?: string[];
-    protocols?: string[];
-    runtimeStates?: string[];
-};
-type SignalMetadata = {
-    deliveryMode?: SignalDeliveryMode;
-    broadcastFilter?: SignalReceiverFilter | null;
-};
-type SignalDefinitionInput = string | ({
-    name: string;
-} & SignalMetadata);
-type FlushStrategyName = string;
-interface FlushStrategy {
-    intervalMs: number;
-    maxBatchSize: number;
-}
-/**
- * This class manages signals and observers, enabling communication across different parts of an application.
- * It follows a singleton design pattern, allowing for centralized signal management.
- */
-declare class SignalBroker {
-    static instance_: SignalBroker;
-    static get instance(): SignalBroker;
-    debug: boolean;
-    verbose: boolean;
-    setDebug(value: boolean): void;
-    setVerbose(value: boolean): void;
-    runner: GraphRunner | undefined;
-    metaRunner: GraphRunner | undefined;
-    throttleEmitters: Map<string, any>;
-    throttleQueues: Map<string, any>;
-    getSignalsTask: Task | undefined;
-    registerSignalTask: Task | undefined;
-    signalObservers: Map<string, {
-        fn: (runner: GraphRunner, tasks: (Task | GraphRoutine)[], context: AnyObject) => void;
-        tasks: Set<Task | GraphRoutine>;
-        registered: boolean;
-    }>;
-    emittedSignalsRegistry: Set<string>;
-    signalMetadataRegistry: Map<string, SignalMetadata>;
-    private flushStrategies;
-    private strategyData;
-    private strategyTimers;
-    private isStrategyFlushing;
-    private readonly defaultStrategyName;
-    constructor();
-    private resolveSignalMetadataKey;
-    private normalizeSignalMetadata;
-    setSignalMetadata(signal: string, metadata?: SignalMetadata | null): void;
-    getSignalMetadata(signal: string): SignalMetadata | undefined;
-    logMemoryFootprint(label?: string): void;
+    mapPrevious(callback: (task: Task) => any): any[];
+    makeRoutine(name: string, description: string): 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.
+     * The method also emits metadata information if the `register` property is set.
+     *
+     * @param {...string[]} signals - The array of signal names to observe.
+     * @return {this} The current instance after adding the specified signals.
+     */
+    doOn(...signals: SignalDefinitionInput[]): this;
+    /**
+     * Registers the specified signals to be emitted after the Task executes successfully and attaches them for further processing.
+     *
+     * @param {...string} signals - The list of signals to be registered for emission.
+     * @return {this} The current instance for method chaining.
+     */
+    emits(...signals: SignalDefinitionInput[]): this;
+    /**
+     * Configures the instance to emit specified signals when the task execution fails.
+     * A failure is defined as anything that does not return a successful result.
+     *
+     * @param {...string} signals - The names of the signals to emit upon failure.
+     * @return {this} Returns the current instance for chaining.
+     */
+    emitsOnFail(...signals: SignalDefinitionInput[]): this;
+    /**
+     * Attaches a signal to the current context and emits metadata if the register flag is set.
+     *
+     * @param {...string} signals - The names of the signals to attach.
+     * @return {void} This method does not return a value.
+     */
+    attachSignal(...signals: SignalDefinitionInput[]): Task;
     /**
-     * Validates the provided signal name string to ensure it adheres to specific formatting rules.
-     * Throws an error if any of the validation checks fail.
+     * Unsubscribes the current instance from the specified signals.
+     * This method removes the signals from the observedSignals set, unsubscribes
+     * from the underlying broker, and emits metadata for the unsubscription if applicable.
      *
-     * @param {string} signalName - The signal name to be validated.
-     * @return {void} - Returns nothing if the signal name is valid.
-     * @throws {Error} - Throws an error if the signal name is longer than 100 characters, contains spaces,
-     *                   contains backslashes, or contains uppercase letters in restricted parts of the name.
+     * @param {string[]} signals - The list of signal names to unsubscribe from.
+     * @return {this} Returns the current instance for method chaining.
      */
-    validateSignalName(signalName: string): void;
+    unsubscribe(...signals: string[]): this;
     /**
-     * Initializes with runners.
-     * @param runner Standard runner for user signals.
-     * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
+     * Unsubscribes from all currently observed signals and clears the list of observed signals.
+     *
+     * @return {this} The instance of the class to allow method chaining.
      */
-    bootstrap(runner: GraphRunner, metaRunner: GraphRunner): void;
+    unsubscribeAll(): this;
     /**
-     * Initializes and sets up the various tasks for managing and processing signals.
+     * Detaches the specified signals from being emitted after execution and optionally emits metadata for each detached signal.
      *
-     * @return {void} This method does not return a value.
+     * @param {...string} signals - The list of signal names to be detached. Signals can be in the format "namespace:signalName".
+     * @return {this} Returns the current instance of the object for method chaining.
      */
-    init(): void;
-    setFlushStrategy(name: FlushStrategyName, config: {
-        intervalMs: number;
-        maxBatchSize?: number;
-    }): void;
-    updateFlushStrategy(name: FlushStrategyName, config: FlushStrategy): void;
-    removeFlushStrategy(name: FlushStrategyName): void;
-    getFlushStrategies(): Record<FlushStrategyName, FlushStrategy>;
-    private readonly MAX_FLUSH_DURATION_MS;
-    squash(signal: string, context: AnyObject, options?: EmitOptions): void;
-    private flushGroup;
-    private flushStrategy;
-    clearSquashState(): void;
-    private clearScheduledState;
-    private scheduledBuckets;
-    private scheduleTimer;
-    schedule(signal: string, context: AnyObject, options?: EmitOptions): AbortController;
-    private flushScheduled;
-    private debouncedEmitters;
-    private readonly MAX_DEBOUNCERS;
-    private clearDebounceState;
-    private clearThrottleState;
-    debounce(signal: string, context: any, options?: {
-        delayMs: number;
-    }): void;
-    throttle(signal: string, context: any, options?: EmitOptions): void;
+    detachSignals(...signals: string[]): this;
     /**
-     * Emits `signal` repeatedly with a fixed interval.
+     * Detaches all signals associated with the object by invoking the `detachSignals` method
+     * and clearing the `signalsToEmitAfter` collection.
      *
-     * @param signal
-     * @param context
-     * @param intervalMs
-     * @param leading  If true, emits immediately (unless a startDateTime is given and we are before it).
-     * @param startDateTime  Optional absolute Date when the *first* emission after `leading` should occur.
-     * @returns a handle with `clear()` to stop the loop.
+     * @return {this} Returns the current instance to allow method chaining.
      */
-    interval(signal: string, context: AnyObject, intervalMs?: number, leading?: boolean, startDateTime?: Date): ThrottleHandle;
+    detachAllSignals(): this;
+    respondsTo(...inquires: string[]): this;
+    usesHelpers(helpers: Record<string, HelperDefinition | undefined>): this;
+    usesGlobals(globals: Record<string, GlobalDefinition | undefined>): this;
+    attachIntents(...intentNames: string[]): this;
+    detachIntents(...intentNames: string[]): this;
+    detachAllIntents(): this;
     /**
-     * Emits a signal with the specified context, triggering any associated handlers for that signal.
+     * Maps over the signals in the `signalsToEmitAfter` set and applies a callback function to each 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.
+     * @param {function(string): void} callback - A function that is called with each signal
+     *   in the `signalsToEmitAfter` set, providing the signal as an argument.
+     * @return {Array<any>} An array containing the results of applying the callback
+     *   function to each signal.
      */
-    emit(signal: string, context?: AnyObject, options?: EmitOptions): void;
+    mapSignals(callback: (signal: string) => void): void[];
     /**
-     * Executes a signal by emitting events, updating context, and invoking listeners.
-     * Creates a new execution trace if necessary and updates the context with relevant metadata.
-     * Handles specific, hierarchy-based, and wildcard signals.
+     * Maps over the signals in `signalsToEmitOnFail` and applies the provided callback to each signal.
      *
-     * @param {string} signal - The signal name to be executed, potentially including namespaces or tags (e.g., "meta.*" or "signal:type").
-     * @param {AnyObject} context - An object containing relevant metadata and execution details used for handling the signal.
-     * @return {boolean} Returns true if any listeners were successfully executed, otherwise false.
+     * @param {function(string): void} callback - A function that receives each signal as a string and performs an operation or transformation on it.
+     * @return {Array} The array resulting from applying the callback to each signal in `signalsToEmitOnFail`.
      */
-    execute(signal: string, context: AnyObject): boolean;
+    mapOnFailSignals(callback: (signal: string) => void): void[];
     /**
-     * Executes the tasks associated with a given signal and context.
-     * It processes both normal and meta tasks depending on the signal type
-     * and the availability of the appropriate runner.
+     * Maps over the observed signals with the provided callback function.
      *
-     * @param {string} signal - The signal identifier that determines which tasks to execute.
-     * @param {AnyObject} context - The context object passed to the task execution function.
-     * @return {boolean} - Returns true if tasks were executed; otherwise, false.
+     * @param {function(string): void} callback - A function to execute on each signal in the observed signals array.
+     * @return {Array} A new array containing the results of calling the callback function on each observed signal.
      */
-    executeListener(signal: string, context: AnyObject): boolean;
+    mapObservedSignals(callback: (signal: string) => void): void[];
     /**
-     * Adds a signal to the signalObservers for tracking and execution.
-     * Performs validation on the signal name and emits a meta signal event when added.
-     * If the signal contains a namespace (denoted by a colon ":"), its base signal is
-     * also added if it doesn't already exist.
+     * Emits a collection of signals stored in the `signalsToEmitAfter` array.
      *
-     * @param {string} signal - The name of the signal to be added.
+     * @param {GraphContext} context - The context object containing data or state to be passed to the emitted signals.
+     * @return {void} This method does not return a value.
+     */
+    emitSignals(context: GraphContext): void;
+    /**
+     * Emits registered signals when an operation fails.
+     *
+     * @param {GraphContext} context - The context from which the full context is derived and passed to the signals being emitted.
      * @return {void} This method does not return any value.
      */
-    addSignal(signal: string, metadata?: SignalMetadata | null): void;
+    emitOnFailSignals(context: GraphContext): void;
     /**
-     * Observes a signal with a routine/task.
-     * @param signal The signal (e.g., 'domain.action', 'domain.*' for wildcards).
-     * @param routineOrTask The observer.
-     * @edge Duplicates ignored; supports wildcards for broad listening.
+     * Cleans up and destroys the task instance, detaching it from other tasks and
+     * performing necessary cleanup operations.
+     *
+     * This method:
+     * - Unsubscribes from all signals and events.
+     * - Detaches all associated signal handlers.
+     * - Removes the task from successor and predecessor task mappings.
+     * - Clears all task relationships and marks the task as destroyed.
+     * - Emits destruction metrics, if applicable.
+     *
+     * @return {void} No value is returned because the function performs clean-up operations.
      */
-    observe(signal: string, routineOrTask: Task | GraphRoutine, metadata?: SignalMetadata | null): void;
-    registerEmittedSignal(signal: string, metadata?: SignalMetadata | null): void;
+    destroy(): void;
     /**
-     * Unsubscribes a routine/task from a signal.
-     * @param signal The signal.
-     * @param routineOrTask The observer.
-     * @edge Removes all instances if duplicate; deletes if empty.
+     * Exports the current state of the object as a structured plain object.
+     *
+     * @return {AnyObject} An object containing the serialized properties of the current instance. The exported object includes various metadata, schema information, task attributes, and related tasks, such as:
+     * - Name and description of the task.
+     * - Layer index, uniqueness, meta, and signal-related flags.
+     * - Event triggers and attached signals.
+     * - Throttling, concurrency, timeout settings, and ephemeral flag.
+     * - Task function as a string.
+     * - Serialization of getter callbacks and schemas for input/output validation.
+     * - Relationships such as next tasks, failure tasks, and predecessor tasks.
      */
-    unsubscribe(signal: string, routineOrTask: Task | GraphRoutine): void;
+    export(): AnyObject;
     /**
-     * Lists all observed signals.
-     * @returns Array of signals.
+     * Returns an iterator for iterating over tasks associated with this instance.
+     *
+     * @return {TaskIterator} An iterator instance for tasks.
      */
-    listObservedSignals(): string[];
-    listEmittedSignals(): string[];
-    reset(): void;
-    shutdown(): void;
+    getIterator(): TaskIterator;
+    /**
+     * Accepts a visitor object to perform operations on the current instance.
+     *
+     * @param {GraphVisitor} visitor - The visitor object implementing operations for this instance.
+     * @return {void} This method does not return a value.
+     */
+    accept(visitor: GraphVisitor): void;
+    log(): void;
 }
 
 /**
@@ -1794,7 +1844,7 @@ declare class EphemeralTask extends Task {
     execute(context: any, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void, nodeData: {
         nodeId: string;
         routineExecId: string;
-    }): TaskResult;
+    }): boolean | void | AnyObject | Generator<unknown, any, any> | Promise<any>;
 }
 
 /**
@@ -2071,11 +2121,12 @@ interface ActorTaskContext<D extends Record<string, any>, R = AnyObject> {
     reduceRuntimeState: (reducer: ActorStateReducer<R>) => void;
     emit: (signal: string, payload?: AnyObject) => void;
     inquire: (inquiry: string, context?: AnyObject, options?: InquiryOptions) => Promise<AnyObject>;
+    tools: RuntimeTools;
 }
 /**
  * Handler signature used by `actor.task(...)`.
  */
-type ActorTaskHandler<D extends Record<string, any>, R = AnyObject> = (context: ActorTaskContext<D, R>) => TaskResult | ActorStateReducer<D> | Promise<TaskResult | ActorStateReducer<D>>;
+type ActorTaskHandler<D extends Record<string, any>, R = AnyObject> = (context: ActorTaskContext<D, R>, emit: (signal: string, payload?: AnyObject) => void, inquire: (inquiry: string, context?: AnyObject, options?: InquiryOptions) => Promise<AnyObject>, tools: RuntimeTools, progressCallback: (progress: number) => void) => TaskResult | ActorStateReducer<D> | Promise<TaskResult | ActorStateReducer<D>>;
 interface ActorDurableStateHydration<D extends Record<string, any>> {
     durableState: D;
     durableVersion: number;
@@ -2133,6 +2184,10 @@ declare class Actor<D extends Record<string, any> = AnyObject, R = AnyObject> {
      * Returns runtime state reference for the resolved key.
      */
     getRuntimeState(actorKey?: string): R;
+    /**
+     * Lists all currently materialized actor keys.
+     */
+    listActorKeys(): string[];
     /**
      * Alias of `getDurableVersion`.
      */
@@ -2172,6 +2227,250 @@ declare class Actor<D extends Record<string, any> = AnyObject, R = AnyObject> {
     private emitActorCreatedSignal;
 }
 
+type RuntimeHandlerLanguage = "js" | "ts";
+type RuntimeTaskDefinitionKind = "task" | "metaTask";
+type RuntimeHelperDefinitionKind = "helper" | "metaHelper";
+type RuntimeGlobalDefinitionKind = "global" | "metaGlobal";
+type RuntimeSignalEmissionMode = "attach" | "after" | "onFail";
+type RuntimeSharingMode = "isolated" | "shared";
+type RuntimeSessionRole = "owner" | "writer" | "observer";
+type RuntimeTaskOptions = Omit<TaskOptions, "getTagCallback">;
+interface RuntimeTaskDefinition {
+    name: string;
+    description?: string;
+    handlerSource: string;
+    language: RuntimeHandlerLanguage;
+    kind?: RuntimeTaskDefinitionKind;
+    options?: RuntimeTaskOptions;
+}
+interface RuntimeHelperDefinition {
+    name: string;
+    description?: string;
+    handlerSource: string;
+    language: RuntimeHandlerLanguage;
+    kind?: RuntimeHelperDefinitionKind;
+}
+interface RuntimeGlobalDefinition {
+    name: string;
+    description?: string;
+    value: unknown;
+    kind?: RuntimeGlobalDefinitionKind;
+}
+interface RuntimeRoutineDefinition {
+    name: string;
+    description?: string;
+    startTaskNames: string[];
+    isMeta?: boolean;
+}
+interface RuntimeActorTaskDefinition {
+    actorName: string;
+    taskName: string;
+    description?: string;
+    mode?: ActorTaskMode;
+    handlerSource: string;
+    language: RuntimeHandlerLanguage;
+    options?: RuntimeTaskOptions;
+}
+interface RuntimeTaskLinkDefinition {
+    predecessorTaskName: string;
+    successorTaskName: string;
+}
+interface RuntimeSnapshotTask {
+    name: string;
+    version: number;
+    description: string;
+    kind: "task" | "metaTask" | "actorTask";
+    runtimeOwned: boolean;
+    language: RuntimeHandlerLanguage | null;
+    handlerSource: string | null;
+    concurrency: number;
+    timeout: number;
+    retryCount: number;
+    retryDelay: number;
+    retryDelayMax: number;
+    retryDelayFactor: number;
+    validateInputContext: boolean;
+    validateOutputContext: boolean;
+    inputContextSchema: Record<string, unknown>;
+    outputContextSchema: Record<string, unknown>;
+    nextTaskNames: string[];
+    predecessorTaskNames: string[];
+    signals: {
+        emits: string[];
+        emitsAfter: string[];
+        emitsOnFail: string[];
+        observed: string[];
+    };
+    intents: {
+        handles: string[];
+        inquires: string[];
+    };
+    tools: {
+        helpers: Record<string, string>;
+        globals: Record<string, string>;
+    };
+    actorName: string | null;
+    actorMode: ActorTaskMode | null;
+}
+interface RuntimeSnapshotHelper {
+    name: string;
+    version: number;
+    description: string;
+    kind: "helper" | "metaHelper";
+    runtimeOwned: boolean;
+    language: RuntimeHandlerLanguage | null;
+    handlerSource: string | null;
+    tools: {
+        helpers: Record<string, string>;
+        globals: Record<string, string>;
+    };
+}
+interface RuntimeSnapshotGlobal {
+    name: string;
+    version: number;
+    description: string;
+    kind: "global" | "metaGlobal";
+    runtimeOwned: boolean;
+    value: unknown;
+}
+interface RuntimeSnapshotRoutine {
+    name: string;
+    version: number;
+    description: string;
+    isMeta: boolean;
+    runtimeOwned: boolean;
+    startTaskNames: string[];
+    observedSignals: string[];
+}
+interface RuntimeSnapshotIntent extends Intent {
+    runtimeOwned: boolean;
+}
+interface RuntimeSnapshotSignal {
+    name: string;
+    metadata: SignalMetadata | null;
+}
+interface RuntimeSnapshotActorKeyState {
+    actorKey: string;
+    durableState: unknown;
+    runtimeState: unknown;
+    durableVersion: number;
+    runtimeVersion: number;
+}
+interface RuntimeSnapshotActor {
+    name: string;
+    description: string;
+    runtimeOwned: boolean;
+    definition: ActorDefinition<Record<string, any>, AnyObject>;
+    actorKeys: RuntimeSnapshotActorKeyState[];
+}
+interface RuntimeSnapshotActorTask {
+    actorName: string;
+    taskName: string;
+    description: string;
+    mode: ActorTaskMode;
+    language: RuntimeHandlerLanguage;
+    handlerSource: string;
+    runtimeOwned: boolean;
+}
+interface RuntimeSnapshot {
+    runtimeMode: "core";
+    bootstrapped: boolean;
+    mode: string;
+    tasks: RuntimeSnapshotTask[];
+    helpers: RuntimeSnapshotHelper[];
+    globals: RuntimeSnapshotGlobal[];
+    routines: RuntimeSnapshotRoutine[];
+    intents: RuntimeSnapshotIntent[];
+    signals: RuntimeSnapshotSignal[];
+    actors: RuntimeSnapshotActor[];
+    actorTasks: RuntimeSnapshotActorTask[];
+    links: RuntimeTaskLinkDefinition[];
+}
+interface RuntimeSubscription {
+    subscriptionId: string;
+    signalPatterns: string[];
+    maxQueueSize: number;
+    createdAt: string;
+    pendingEvents: number;
+}
+interface RuntimeSignalEventSource {
+    taskName: string | null;
+    taskVersion: number | null;
+    taskExecutionId: string | null;
+    routineName: string | null;
+    routineVersion: number | null;
+    routineExecutionId: string | null;
+    executionTraceId: string | null;
+    consumed: boolean;
+    consumedBy: string | null;
+}
+interface RuntimeSignalEvent {
+    id: string;
+    subscriptionId: string;
+    sequence: number;
+    type: "signal";
+    signal: string;
+    signalName: string;
+    signalTag: string | null;
+    emittedAt: string | null;
+    isMeta: boolean;
+    isSubMeta: boolean;
+    metadata: SignalMetadata | null;
+    source: RuntimeSignalEventSource;
+    context: Record<string, unknown>;
+}
+interface RuntimeNextEventResult {
+    subscriptionId: string;
+    event: RuntimeSignalEvent | null;
+    timedOut: boolean;
+    pendingEvents: number;
+}
+interface RuntimePollEventsResult {
+    subscriptionId: string;
+    events: RuntimeSignalEvent[];
+    pendingEvents: number;
+}
+interface RuntimeInfo {
+    runtimeMode: "core";
+    runtimeSharing: RuntimeSharingMode;
+    runtimeName: string | null;
+    sessionId: string | null;
+    sessionRole: RuntimeSessionRole | null;
+    activeSessionCount: number;
+    daemonProcessId: number | null;
+    bootstrapped: boolean;
+    mode: string;
+}
+type RuntimeProtocolOperation = "runtime.bootstrap" | "runtime.info" | "runtime.detach" | "runtime.shutdown" | "runtime.reset" | "runtime.snapshot" | "runtime.subscribe" | "runtime.unsubscribe" | "runtime.nextEvent" | "runtime.pollEvents" | "task.upsert" | "helper.upsert" | "global.upsert" | "task.link" | "task.observeSignal" | "task.emitSignal" | "task.respondToIntent" | "task.useHelper" | "task.useGlobal" | "helper.useHelper" | "helper.useGlobal" | "routine.upsert" | "routine.observeSignal" | "intent.upsert" | "actor.upsert" | "actorTask.upsert" | "run" | "emit" | "inquire";
+interface RuntimeProtocolRequest<TPayload = AnyObject> {
+    id?: string | number;
+    operation: RuntimeProtocolOperation;
+    payload?: TPayload;
+}
+interface RuntimeProtocolError {
+    code: string;
+    message: string;
+    details?: AnyObject;
+}
+interface RuntimeProtocolResponse<TResult = unknown> {
+    id?: string | number;
+    operation: RuntimeProtocolOperation;
+    ok: boolean;
+    result?: TResult;
+    error?: RuntimeProtocolError;
+}
+interface RuntimeProtocolHandshake {
+    ready: true;
+    protocol: "cadenza-runtime-jsonl";
+    protocolVersion: "1";
+    runtimeMode: "core";
+    runtimeSharing: RuntimeSharingMode;
+    runtimeName: string | null;
+    sessionId: string | null;
+    sessionRole: RuntimeSessionRole | null;
+    supportedOperations: RuntimeProtocolOperation[];
+}
+
 interface TaskOptions {
     concurrency?: number;
     timeout?: number;
@@ -2230,11 +2529,15 @@ declare class Cadenza {
     static metaRunner: GraphRunner;
     static registry: GraphRegistry;
     private static taskCache;
+    private static routineCache;
     private static actorCache;
+    private static helperCache;
+    private static globalCache;
     private static runtimeInquiryDelegate;
     private static runtimeValidationPolicy;
     private static runtimeValidationScopes;
     private static emittedMissingSchemaWarnings;
+    private static helperExecutionDepth;
     static isBootstrapped: boolean;
     static mode: CadenzaMode;
     /**
@@ -2274,8 +2577,15 @@ declare class Cadenza {
      * @throws {Error} If the name is not a non-empty string.
      */
     static validateName(name: string): void;
+    static assertGraphMutationAllowed(operationName: string): void;
+    static executeHelper(helper: HelperDefinition, context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void): TaskResult;
+    static resolveToolsForOwner(owner: ToolDependencyOwner, context: AnyObject, emit: (signal: string, context: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void): RuntimeTools;
     private static resolveTaskOptionsForActorTask;
     private static registerActor;
+    static getHelper(name: string): HelperDefinition | undefined;
+    static getAllHelpers(): HelperDefinition[];
+    static getGlobal(name: string): GlobalDefinition | undefined;
+    static getAllGlobals(): GlobalDefinition[];
     /**
      * Executes the specified task or GraphRoutine with the given context using an internal runner.
      *
@@ -2317,6 +2627,7 @@ declare class Cadenza {
     static interval(taskName: string, context: AnyObject, intervalMs: number, leading?: boolean, startDateTime?: Date): void;
     static debounce(signalName: string, context: any, delayMs: number): void;
     static get(taskName: string): Task | undefined;
+    static forgetTask(taskName: string): void;
     static getActor<D extends Record<string, any> = AnyObject, R = AnyObject>(actorName: string): Actor<D, R> | undefined;
     static getAllActors<D extends Record<string, any> = AnyObject, R = AnyObject>(): Actor<D, R>[];
     static getRoutine(routineName: string): GraphRoutine | undefined;
@@ -2422,6 +2733,13 @@ declare class Cadenza {
      * ```
      */
     static createTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
+    static createTaskFromDefinition(definition: RuntimeTaskDefinition): Task;
+    static createHelper(name: string, func: HelperFunction, description?: string): HelperDefinition;
+    static createMetaHelper(name: string, func: HelperFunction, description?: string): HelperDefinition;
+    static createHelperFromDefinition(definition: RuntimeHelperDefinition): HelperDefinition;
+    static createGlobal(name: string, value: unknown, description?: string): GlobalDefinition;
+    static createMetaGlobal(name: string, value: unknown, description?: string): GlobalDefinition;
+    static createGlobalFromDefinition(definition: RuntimeGlobalDefinition): GlobalDefinition;
     /**
      * Creates a meta task with the specified name, functionality, description, and options.
      * This is used for creating tasks that lives on the meta layer.
@@ -2684,6 +3002,7 @@ declare class Cadenza {
      * ```
      */
     static createRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
+    static createRoutineFromDefinition(definition: RuntimeRoutineDefinition): GraphRoutine;
     /**
      * Creates a meta routine with a given name, tasks, and optional description.
      * Routines are named entry points to starting tasks and are registered in the GraphRegistry.
@@ -2697,7 +3016,83 @@ declare class Cadenza {
      * @throws {Error} If no starting tasks are provided.
      */
     static createMetaRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
+    static snapshotRuntime(): RuntimeSnapshot;
     static reset(): void;
 }
 
-export { Actor, type ActorConsistencyProfileName, type ActorDefinition, type ActorFactoryOptions, type ActorInvocationOptions, type ActorKeyDefinition, type ActorKind, type ActorLoadPolicy, type ActorRuntimeReadGuard, type ActorSpec, type ActorStateDefinition, type ActorStateReducer, type ActorStateStore, type ActorTaskBindingDefinition, type ActorTaskBindingOptions, type ActorTaskContext, type ActorTaskHandler, type ActorTaskMode, type ActorTaskRuntimeMetadata, type ActorWriteContract, type AnyObject, type CadenzaMode, type DebounceOptions, DebounceTask, type EmitOptions, EphemeralTask, type EphemeralTaskOptions, GraphContext, GraphRegistry, GraphRoutine, GraphRun, GraphRunner, type IdempotencyPolicy, InquiryBroker, type InquiryOptions, type Intent, META_ACTOR_SESSION_STATE_PERSIST_INTENT, type ResolvedRuntimeValidationPolicy, type RetryPolicy, type RuntimeValidationMode, type RuntimeValidationPolicy, type RuntimeValidationScope, type Schema, type SchemaConstraints, type SchemaDefinition, type SchemaType, type SessionPolicy, SignalBroker, type SignalDefinitionInput, type SignalDeliveryMode, SignalEmitter, type SignalMetadata, type SignalReceiverFilter, Task, type TaskFunction, type TaskOptions, type TaskResult, type ThrottleTagGetter, Cadenza as default, getActorTaskRuntimeMetadata };
+type RuntimeControlAction = "detach" | "shutdown";
+interface RuntimeHostOptions {
+    runtimeSharing?: RuntimeSharingMode;
+    runtimeName?: string | null;
+    sessionId?: string | null;
+    sessionRole?: RuntimeSessionRole | null;
+    activeSessionCountProvider?: () => number;
+    daemonProcessId?: number | null;
+    onResetRuntime?: () => void;
+}
+declare class RuntimeHost {
+    private readonly subscriptionManager;
+    private readonly runtimeSharing;
+    private readonly runtimeName;
+    private readonly sessionId;
+    private readonly sessionRole;
+    private readonly activeSessionCountProvider;
+    private readonly daemonProcessId;
+    private readonly onResetRuntime;
+    private pendingControlAction;
+    constructor(options?: RuntimeHostOptions);
+    dispose(): void;
+    resetSubscriptions(): void;
+    consumeControlAction(): RuntimeControlAction | null;
+    handshake(): RuntimeProtocolHandshake;
+    handle(request: RuntimeProtocolRequest): Promise<RuntimeProtocolResponse>;
+    private normalizeError;
+    private dispatch;
+    private assertOperationAllowed;
+    private bootstrapRuntime;
+    private runtimeInfo;
+    private detachRuntime;
+    private shutdownRuntime;
+    private resetRuntime;
+    private subscribe;
+    private unsubscribe;
+    private nextEvent;
+    private pollEvents;
+    private upsertTask;
+    private upsertHelper;
+    private upsertGlobal;
+    private linkTasks;
+    private observeTaskSignal;
+    private emitTaskSignal;
+    private bindTaskIntent;
+    private bindTaskHelper;
+    private bindTaskGlobal;
+    private bindHelperHelper;
+    private bindHelperGlobal;
+    private upsertRoutine;
+    private observeRoutineSignal;
+    private upsertIntent;
+    private upsertActor;
+    private upsertActorTask;
+    private runTarget;
+    private emitSignal;
+    private inquireIntent;
+    private requireTask;
+    private requireRoutine;
+    private applyTaskDecorations;
+    private applyHelperDecorations;
+    private applyAllTaskLinks;
+    private applyRoutineDecorations;
+    private rematerializeRoutinesStartingWith;
+    private rematerializeActorTasksFor;
+    private materializeActorTask;
+    private snapshotTask;
+    private snapshotHelper;
+    private snapshotGlobal;
+    private snapshotRoutine;
+    private parseSignalPatterns;
+    private parsePositiveInteger;
+    private parseNonNegativeInteger;
+}
+
+export { Actor, type ActorConsistencyProfileName, type ActorDefinition, type ActorFactoryOptions, type ActorInvocationOptions, type ActorKeyDefinition, type ActorKind, type ActorLoadPolicy, type ActorRuntimeReadGuard, type ActorSpec, type ActorStateDefinition, type ActorStateReducer, type ActorStateStore, type ActorTaskBindingDefinition, type ActorTaskBindingOptions, type ActorTaskContext, type ActorTaskHandler, type ActorTaskMode, type ActorTaskRuntimeMetadata, type ActorWriteContract, type AnyObject, type CadenzaMode, type DebounceOptions, DebounceTask, type EmitOptions, EphemeralTask, type EphemeralTaskOptions, GlobalDefinition, GraphContext, GraphRegistry, GraphRoutine, GraphRun, GraphRunner, HelperDefinition, type HelperFunction, type IdempotencyPolicy, InquiryBroker, type InquiryOptions, type Intent, META_ACTOR_SESSION_STATE_PERSIST_INTENT, type ResolvedRuntimeValidationPolicy, type RetryPolicy, type RuntimeActorTaskDefinition, type RuntimeGlobalDefinition, type RuntimeHandlerLanguage, type RuntimeHelperDefinition, RuntimeHost, type RuntimeInfo, type RuntimeNextEventResult, type RuntimePollEventsResult, type RuntimeProtocolError, type RuntimeProtocolHandshake, type RuntimeProtocolOperation, type RuntimeProtocolRequest, type RuntimeProtocolResponse, type RuntimeRoutineDefinition, type RuntimeSessionRole, type RuntimeSharingMode, type RuntimeSignalEmissionMode, type RuntimeSignalEvent, type RuntimeSnapshot, type RuntimeSubscription, type RuntimeTaskDefinition, type RuntimeTaskOptions, type RuntimeTools, type RuntimeValidationMode, type RuntimeValidationPolicy, type RuntimeValidationScope, type Schema, type SchemaConstraints, type SchemaDefinition, type SchemaType, type SessionPolicy, SignalBroker, type SignalDefinitionInput, type SignalDeliveryMode, SignalEmitter, type SignalMetadata, type SignalReceiverFilter, Task, type TaskFunction, type TaskOptions, type TaskResult, type ThrottleTagGetter, Cadenza as default, getActorTaskRuntimeMetadata };