@cadenza.io/core 3.26.1 → 3.28.0

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,1424 @@ 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;
+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>;
     /**
-     * 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.
+     * Initializes with runners.
+     * @param runner Standard runner for user signals.
+     * @param metaRunner Meta runner for 'meta.' signals (suppresses further meta-emits).
      */
-    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;
+    bootstrap(runner: GraphRunner, metaRunner: GraphRunner): void;
+    init(): void;
     /**
-     * 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.
+     * 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.
      */
-    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;
+    observe(inquiry: string, task: Task): 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.
+     * Unsubscribes a routine/task from an inquiry.
+     * @param inquiry The inquiry.
+     * @param task The observer.
+     * @edge Removes all instances if duplicate; deletes if empty.
      */
-    emitWithMetadata(signal: string, ctx?: AnyObject): void;
+    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;
     /**
-     * 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.
+     * Compares the current GraphNode instance with another GraphNode to determine if they are considered equal.
      *
-     * @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.
+     * @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.
      */
-    emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
-    private isSchemaDefinition;
-    private isDefaultAnyObjectSchema;
-    private mergeSchemaVariant;
-    private validateValueAgainstSchema;
+    isEqualTo(node: GraphNode): boolean;
     /**
-     * Validates a data object against a specified schema definition and returns validation results.
+     * Determines if the given node is part of the same graph as the current node.
      *
-     * @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 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.
      */
-    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>;
+    isPartOfSameGraph(node: GraphNode): boolean;
     /**
-     * Validates the input context against the predefined schema and emits metadata if validation fails.
+     * Determines whether the current instance shares a task with the provided 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 graph node to compare with the current instance.
+     * @return {boolean} Returns true if the task names of both nodes match, otherwise false.
      */
-    private getEffectiveValidationMode;
-    private warnMissingSchema;
-    private logValidationFailure;
-    validateInput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
+    sharesTaskWith(node: GraphNode): boolean;
     /**
-     * Validates the output context using the provided schema and emits metadata if validation fails.
+     * Determines whether the current node shares the same context as the specified 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 node's context.
+     * @return {boolean} True if both nodes share the same context; otherwise, false.
      */
-    validateOutput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
+    sharesContextWith(node: GraphNode): boolean;
+    getLayerIndex(): number;
+    getConcurrency(): number;
     /**
-     * Executes a task within a given context, optionally emitting signals and reporting progress.
+     * Retrieves the tag associated with the current task and context.
      *
-     * @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.
+     * @return {string} The tag retrieved from the task within the given context.
      */
-    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;
+    getTag(): string;
     /**
-     * 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.
+     * Schedules the current node/task on the specified graph layer if applicable.
      *
-     * @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.
-     */
-    doAfter(...tasks: (Task | undefined)[]): this;
-    /**
-     * 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 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} 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.
+     * @param {GraphLayer} layer - The graph layer on which the current task should be scheduled.
+     * @returns {void} Does not return a value.
      */
-    then(...tasks: (Task | undefined)[]): this;
+    scheduleOn(layer: GraphLayer): void;
     /**
-     * Decouples the current task from the provided task by removing mutual references.
+     * Starts the execution process by initializing the execution start timestamp,
+     * emitting relevant metadata, and logging debug information if applicable.
      *
-     * @param {Task} task - The task to decouple from the current task.
-     * @return {void} This method does not return a value.
-     */
-    decouple(task: Task): 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.
+     * 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 {void} Does not return a value.
+     * @return {number} The timestamp indicating when the execution started.
      */
-    updateProgressWeights(): void;
+    start(): number;
     /**
-     * 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.
+     * 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 {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 corresponding to the end of execution. If execution
+     * was not started, it returns 0.
      */
-    getSubgraphLayers(): Map<number, Set<Task>>;
+    end(): 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.
+     * Executes the main logic of the task, including input validation, processing, and post-processing.
+     * Handles both synchronous and asynchronous workflows.
      *
-     * @return {void} This method does not return a value.
+     * @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.
      */
-    updateLayerFromPredecessors(): void;
+    execute(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * Determines whether there is a cycle in the tasks graph.
-     * This method performs a depth-first search (DFS) to detect cycles.
+     * 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 {boolean} - Returns true if a cycle is found in the graph, otherwise false.
+     * @return {Promise<void>} A promise that resolves when the operation completes successfully,
+     * or rejects if an unhandled error occurs.
      */
-    hasCycle(): boolean;
+    workAsync(): Promise<void>;
     /**
-     * Maps over the next set of tasks or failed tasks if specified, applying 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 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<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.
      */
-    mapNext(callback: (task: Task) => any): any[];
+    executeAsync(): Promise<GraphNode[]>;
     /**
-     * Maps through each task in the set of predecessor tasks and applies the provided callback function.
+     * 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 {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 {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.
      */
-    mapPrevious(callback: (task: Task) => any): any[];
-    makeRoutine(name: string, description: string): this;
+    work(): TaskResult | Promise<TaskResult>;
+    inquire(inquiry: string, context: AnyObject, options: InquiryOptions): Promise<any>;
     /**
-     * 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.
+     * 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 array of signal names to observe.
-     * @return {this} The current instance after adding the specified signals.
+     * @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.
      */
-    doOn(...signals: SignalDefinitionInput[]): this;
+    emitWithMetadata(signal: string, data: AnyObject, options?: EmitOptions): void;
     /**
-     * Registers the specified signals to be emitted after the Task executes successfully and attaches them for further processing.
+     * Emits metrics with additional metadata describing the task execution and context.
      *
-     * @param {...string} signals - The list of signals to be registered for emission.
-     * @return {this} The current instance for method 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.
      */
-    emits(...signals: SignalDefinitionInput[]): this;
+    emitMetricsWithMetadata(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.
+     * Updates the progress of a task and emits metrics with associated metadata.
      *
-     * @param {...string} signals - The names of the signals to emit upon failure.
-     * @return {this} Returns the current instance for chaining.
+     * @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.
      */
-    emitsOnFail(...signals: SignalDefinitionInput[]): this;
+    onProgress(progress: number): void;
     /**
-     * Attaches a signal to the current context and emits metadata if the register flag is set.
+     * Processes the result of the current operation, validates it, and determines the next set of nodes.
      *
-     * @param {...string} signals - The names of the signals to attach.
-     * @return {void} This method does not return a value.
+     * 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.
      */
-    attachSignal(...signals: SignalDefinitionInput[]): Task;
+    postProcess(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * 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.
+     * Asynchronously processes and finalizes the provided graph nodes.
      *
-     * @param {string[]} signals - The list of signal names to unsubscribe from.
-     * @return {this} Returns the current instance for 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.
      */
-    unsubscribe(...signals: string[]): this;
+    postProcessAsync(nextNodes: Promise<GraphNode[]>): Promise<GraphNode[]>;
     /**
-     * Unsubscribes from all currently observed signals and clears the list of observed signals.
+     * 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.
      *
-     * @return {this} The instance of the class to allow method chaining.
+     * @return {void} Does not return a value.
      */
-    unsubscribeAll(): this;
+    finalize(): void;
     /**
-     * Detaches the specified signals from being emitted after execution and optionally emits metadata for each detached signal.
+     * Handles an error event, processes the error, and updates the state accordingly.
      *
-     * @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.
+     * @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.
      */
-    detachSignals(...signals: string[]): this;
+    onError(error: unknown, errorData?: AnyObject): void;
     /**
-     * Detaches all signals associated with the object by invoking the `detachSignals` method
-     * and clearing the `signalsToEmitAfter` collection.
+     * 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.
      *
-     * @return {this} Returns the current instance to allow method chaining.
+     * @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.
      */
-    detachAllSignals(): this;
-    respondsTo(...inquires: string[]): this;
-    attachIntents(...intentNames: string[]): this;
-    detachIntents(...intentNames: string[]): this;
-    detachAllIntents(): this;
+    retry(prevResult?: any): Promise<TaskResult>;
     /**
-     * Maps over the signals in the `signalsToEmitAfter` set and applies a callback function 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 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 optional result from a previous operation attempt, if applicable.
+     * @return {Promise<TaskResult>} A promise that resolves to the result of the retried operation.
      */
-    mapSignals(callback: (signal: string) => void): void[];
+    retryAsync(prevResult?: any): Promise<TaskResult>;
+    delayRetry(): Promise<void>;
     /**
-     * Maps over the signals in `signalsToEmitOnFail` and applies the provided callback to each signal.
+     * 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 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`.
+     * @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.
      */
-    mapOnFailSignals(callback: (signal: string) => void): void[];
+    divide(): GraphNode[] | Promise<GraphNode[]>;
     /**
-     * Maps over the observed signals with the provided callback function.
+     * 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 {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.
+     * @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.
      */
-    mapObservedSignals(callback: (signal: string) => void): void[];
+    divideAsync(current: Promise<IteratorResult<any>>): Promise<GraphNode[]>;
     /**
-     * Emits a collection of signals stored in the `signalsToEmitAfter` array.
+     * Generates new nodes based on the provided result and task configuration.
      *
-     * @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 {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.
      */
-    emitSignals(context: GraphContext): void;
+    generateNewNodes(result: any): GraphNode[];
     /**
-     * Emits registered signals when an operation fails.
+     * Executes the differentiation process based on a given task and updates the instance properties accordingly.
      *
-     * @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 {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.
      */
-    emitOnFailSignals(context: GraphContext): void;
+    differentiate(task: Task): GraphNode;
     /**
-     * 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.
+     * 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.
      *
-     * @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.
+     * @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 {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;
+    /**
+     * Validates a data object against a specified schema definition and returns validation results.
+     *
+     * @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.
+     */
+    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>;
     /**
-     * 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 the input context against the predefined schema and emits metadata if validation fails.
      *
-     * @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 {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.
      */
-    forEachTask(callBack: (task: Task) => any): Promise<void>;
+    private getEffectiveValidationMode;
+    private warnMissingSchema;
+    private logValidationFailure;
+    validateInput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
     /**
-     * Sets global Version.
-     * @param version The Version.
+     * Validates the output context using the provided schema and emits metadata if validation fails.
+     *
+     * @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.
      */
-    setVersion(version: number): void;
+    validateOutput(context: AnyObject, metadata?: AnyObject): true | AnyObject;
     /**
-     * Subscribes the current instance to the specified signals, enabling it to observe them.
+     * Executes a task within a given context, optionally emitting signals and reporting progress.
      *
-     * @param {...string} signals - The names of the signals to observe.
-     * @return {this} Returns the instance to allow for method chaining.
+     * @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.
      */
-    doOn(...signals: string[]): 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 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.
+     * 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.
      *
-     * @return {this} Returns the current instance for chaining purposes.
+     * @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.
      */
-    unsubscribeAll(): this;
+    doAfter(...tasks: (Task | undefined)[]): this;
     /**
-     * Unsubscribes the current instance from the specified signals.
+     * 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.
      *
-     * @param {...string} signals - The signals to unsubscribe from.
-     * @return {this} The current instance for method chaining.
+     * @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.
      */
-    unsubscribe(...signals: string[]): this;
+    then(...tasks: (Task | undefined)[]): this;
     /**
-     * Cleans up resources and emits an event indicating the destruction of the routine.
+     * Decouples the current task from the provided task by removing mutual references.
      *
-     * This method unsubscribes from all events, clears the tasks list,
-     * and emits a "meta.routine.destroyed" event with details of the destruction.
+     * @param {Task} task - The task to decouple from the current task.
+     * @return {void} This method does not return a value.
+     */
+    decouple(task: Task): 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.
      *
-     * @return {void}
+     * @return {void} 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;
+    updateProgressWeights(): void;
     /**
-     * Constructs a runner.
-     * @param isMeta Meta flag (default false).
-     * @edge Creates 'Start run' meta-task chained to registry gets.
+     * 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.
+     *
+     * @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.
      */
-    constructor(isMeta?: boolean);
+    getSubgraphLayers(): Map<number, Set<Task>>;
     /**
-     * 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.
+     * 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 - 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 {void} This method does not return a value.
      */
-    addTasks(tasks: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): void;
+    updateLayerFromPredecessors(): void;
     /**
-     * Executes the provided tasks or routines. Maintains the execution state
-     * and handles synchronous or asynchronous processing.
+     * Determines whether there is a cycle in the tasks graph.
+     * This method performs a depth-first search (DFS) to detect cycles.
      *
-     * @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 {boolean} - Returns true if a cycle is found in the graph, otherwise false.
      */
-    run(tasks?: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): GraphRun | Promise<GraphRun>;
+    hasCycle(): boolean;
     /**
-     * Executes the provided asynchronous operation and resets the state afterwards.
+     * Maps over the next set of tasks or failed tasks if specified, applying the provided callback function.
      *
-     * @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.
+     * @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.
      */
-    runAsync(run: Promise<void>): Promise<GraphRun>;
+    mapNext(callback: (task: Task) => any): any[];
     /**
-     * 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 through each task in the set of predecessor tasks and applies the provided callback function.
      *
-     * @return {GraphRun} The last GraphRun instance before the reset.
+     * @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.
      */
-    reset(): GraphRun;
-    setDebug(value: boolean): void;
-    setVerbose(value: boolean): void;
-    destroy(): void;
+    mapPrevious(callback: (task: Task) => any): any[];
+    makeRoutine(name: string, description: string): this;
     /**
-     * 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.
+     * 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 {GraphRunStrategy} strategy - The strategy to use for running the graph.
-     * @return {void}
+     * @param {...string[]} signals - The array of signal names to observe.
+     * @return {this} The current instance after adding the specified signals.
      */
-    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;
+    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 +1841,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>;
 }
 
 /**
@@ -1993,6 +2040,7 @@ interface ActorSpec<D extends Record<string, any>, R = AnyObject> {
 interface ActorFactoryOptions<D extends Record<string, any> = Record<string, any>, R = AnyObject> {
     isMeta?: boolean;
     definitionSource?: ActorDefinition<D, R>;
+    hydrateDurableState?: (actorKey: string) => Promise<ActorDurableStateHydration<D> | null>;
 }
 /**
  * Optional per-binding behavior when wrapping actor handlers.
@@ -2070,11 +2118,16 @@ 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>>;
+interface ActorDurableStateHydration<D extends Record<string, any>> {
+    durableState: D;
+    durableVersion: number;
+}
 /**
  * Metadata attached to wrapped actor task functions.
  */
@@ -2101,9 +2154,11 @@ declare class Actor<D extends Record<string, any> = AnyObject, R = AnyObject> {
     readonly spec: ActorSpec<D, R>;
     readonly kind: ActorKind;
     private readonly sourceDefinition?;
+    private readonly hydrateDurableState?;
     private readonly stateByKey;
     private readonly sessionByKey;
     private readonly idempotencyByKey;
+    private readonly pendingHydrationByKey;
     private readonly writeQueueByKey;
     private nextTaskBindingIndex;
     /**
@@ -2126,6 +2181,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`.
      */
@@ -2154,6 +2213,7 @@ declare class Actor<D extends Record<string, any> = AnyObject, R = AnyObject> {
     private resolveInitialDurableState;
     private resolveInitialRuntimeState;
     private ensureStateRecord;
+    private maybeHydrateStateRecord;
     private touchSession;
     private pruneExpiredActorKeys;
     private isSessionExpired;
@@ -2164,6 +2224,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;
@@ -2222,11 +2526,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;
     /**
@@ -2266,8 +2574,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.
      *
@@ -2309,6 +2624,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;
@@ -2414,6 +2730,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.
@@ -2676,6 +2999,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.
@@ -2689,7 +3013,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 };