@cadenza.io/core 1.11.12 → 1.11.14

package/dist/index.d.mts

@@ -4,9 +4,9 @@ type AnyObject = {
 
 declare class GraphContext {
     readonly id: string;
-    private readonly fullContext;
-    private readonly userData;
-    private readonly metaData;
+    readonly fullContext: AnyObject;
+    readonly userData: AnyObject;
+    readonly metadata: AnyObject;
     constructor(context: AnyObject);
     /**
      * Gets frozen user data (read-only, no clone).
@@ -24,7 +24,7 @@ declare class GraphContext {
      * Gets frozen metadata (read-only).
      * @returns Frozen metadata object.
      */
-    getMetaData(): AnyObject;
+    getMetadata(): AnyObject;
     /**
      * Clones this context (new instance).
      * @returns New GraphContext.
@@ -107,7 +107,7 @@ declare class GraphNodeIterator implements Iterator {
 }
 
 declare abstract class SignalEmitter {
-    protected silent: boolean;
+    silent: boolean;
     /**
      * Constructor for signal emitters.
      * @param silent If true, suppresses all emissions (e.g., for meta-runners to avoid loops; affects all emits).
@@ -118,18 +118,18 @@ declare abstract class SignalEmitter {
      * @param signal The signal name.
      * @param data Optional payload (defaults to empty object).
      */
-    protected emit(signal: string, data?: AnyObject): void;
+    emit(signal: string, data?: AnyObject): void;
     /**
      * Emits a signal via the broker if not silent.
      * @param signal The signal name.
      * @param data Optional payload (defaults to empty object).
      */
-    protected emitMetrics(signal: string, data?: AnyObject): void;
+    emitMetrics(signal: string, data?: AnyObject): void;
 }
 
 declare abstract class ExecutionChain {
-    protected next: ExecutionChain | undefined;
-    protected previous: ExecutionChain | undefined;
+    next: ExecutionChain | undefined;
+    previous: ExecutionChain | undefined;
     setNext(next: ExecutionChain): void;
     get hasNext(): boolean;
     get hasPreceding(): boolean;
@@ -151,11 +151,11 @@ declare class GraphLayerIterator implements Iterator {
 }
 
 declare abstract class GraphLayer extends ExecutionChain implements Graph {
-    protected readonly index: number;
-    protected nodes: GraphNode[];
-    private executionTime;
-    private executionStart;
-    protected debug: boolean;
+    readonly index: number;
+    nodes: GraphNode[];
+    executionTime: number;
+    executionStart: number;
+    debug: boolean;
     constructor(index: number);
     setDebug(value: boolean): void;
     abstract execute(context?: GraphContext): unknown;
@@ -186,27 +186,27 @@ declare abstract class GraphLayer extends ExecutionChain implements Graph {
 declare class GraphNode extends SignalEmitter implements Graph {
     id: string;
     routineExecId: string;
-    private task;
-    private context;
-    private layer;
-    private divided;
-    private splitGroupId;
-    private processing;
-    private subgraphComplete;
-    private graphComplete;
-    private result;
-    private retryCount;
-    private retryDelay;
-    private retries;
-    private previousNodes;
-    private nextNodes;
-    private executionTime;
-    private executionStart;
-    private failed;
-    private errored;
+    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;
-    protected debug: boolean;
-    protected verbose: boolean;
+    debug: boolean;
+    verbose: boolean;
     constructor(task: Task, context: GraphContext, routineExecId: string, prevNodes?: GraphNode[], debug?: boolean, verbose?: boolean);
     setDebug(value: boolean): void;
     isUnique(): boolean;
@@ -226,27 +226,27 @@ declare class GraphNode extends SignalEmitter implements Graph {
     start(): number;
     end(): number;
     execute(): GraphNode[] | Promise<GraphNode[]>;
-    private workAsync;
-    private executeAsync;
-    private work;
-    protected emitWithMetadata(signal: string, ctx: AnyObject): void;
-    protected emitMetricsWithMetadata(signal: string, ctx: AnyObject): void;
-    private onProgress;
-    private postProcess;
-    private onError;
-    private retry;
-    private retryAsync;
-    private delayRetry;
-    private divide;
-    private generateNewNodes;
-    private differentiate;
-    private migrate;
-    private split;
+    workAsync(): Promise<void>;
+    executeAsync(): Promise<GraphNode[]>;
+    work(): TaskResult | Promise<TaskResult>;
+    emitWithMetadata(signal: string, ctx: AnyObject): void;
+    emitMetricsWithMetadata(signal: string, ctx: AnyObject): void;
+    onProgress(progress: number): void;
+    postProcess(): void;
+    onError(error: unknown, errorData?: AnyObject): void;
+    retry(prevResult?: any): Promise<TaskResult>;
+    retryAsync(prevResult?: any): Promise<TaskResult>;
+    delayRetry(): Promise<void>;
+    divide(): GraphNode[];
+    generateNewNodes(result: any): GraphNode[];
+    differentiate(task: Task): GraphNode;
+    migrate(ctx: any): GraphNode;
+    split(id: string): GraphNode;
     clone(): GraphNode;
     consume(node: GraphNode): void;
-    private changeIdentity;
-    private completeSubgraph;
-    private completeGraph;
+    changeIdentity(id: string): void;
+    completeSubgraph(): void;
+    completeGraph(): void;
     destroy(): void;
     getIterator(): GraphNodeIterator;
     mapNext(callback: (node: GraphNode) => any): any[];
@@ -308,20 +308,24 @@ declare abstract class GraphVisitor {
 }
 
 declare class TaskIterator implements Iterator {
-    private currentTask;
-    private currentLayer;
-    private nextLayer;
-    private iterator;
+    currentTask: Task | undefined;
+    currentLayer: Set<Task>;
+    nextLayer: Set<Task>;
+    iterator: {
+        next: () => {
+            value: Task | undefined;
+        };
+    };
     constructor(task: Task);
     hasNext(): boolean;
     next(): Task | undefined;
 }
 
 declare class SignalParticipant extends SignalEmitter {
-    protected emitsSignals: Set<string>;
-    protected signalsToEmitAfter: Set<string>;
-    protected signalsToEmitOnFail: Set<string>;
-    protected observedSignals: Set<string>;
+    emitsSignals: Set<string>;
+    signalsToEmitAfter: Set<string>;
+    signalsToEmitOnFail: Set<string>;
+    observedSignals: Set<string>;
     /**
      * Subscribes to signals (chainable).
      * @param signals The signal names.
@@ -421,21 +425,21 @@ declare class Task extends SignalParticipant implements Graph {
     readonly isDeputy: boolean;
     readonly isEphemeral: boolean;
     readonly isDebounce: boolean;
-    protected inputContextSchema: SchemaDefinition | undefined;
-    protected validateInputContext: boolean;
-    protected outputContextSchema: SchemaDefinition | undefined;
-    protected validateOutputContext: boolean;
+    inputContextSchema: SchemaDefinition | undefined;
+    validateInputContext: boolean;
+    outputContextSchema: SchemaDefinition | undefined;
+    validateOutputContext: boolean;
     readonly retryCount: number;
     readonly retryDelay: number;
     readonly retryDelayMax: number;
     readonly retryDelayFactor: number;
     layerIndex: number;
     progressWeight: number;
-    private nextTasks;
-    private onFailTasks;
-    private predecessorTasks;
+    nextTasks: Set<Task>;
+    onFailTasks: Set<Task>;
+    predecessorTasks: Set<Task>;
     destroyed: boolean;
-    protected readonly taskFunction: TaskFunction;
+    readonly taskFunction: TaskFunction;
     /**
      * Constructs a Task (static definition).
      * @param name Name.
@@ -469,8 +473,8 @@ declare class Task extends SignalParticipant implements Graph {
     setOutputContextSchema(schema: SchemaDefinition): void;
     setValidateInputContext(value: boolean): void;
     setValidateOutputContext(value: boolean): void;
-    private emitWithMetadata;
-    private emitMetricsWithMetadata;
+    emitWithMetadata(signal: string, ctx?: AnyObject): void;
+    emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
     /**
      * Validates a context deeply against a schema.
      * @param data - The data to validate (input context or output result).
@@ -479,7 +483,7 @@ declare class Task extends SignalParticipant implements Graph {
      * @returns { { valid: boolean, errors: Record<string, string> } } - Validation result with detailed errors if invalid.
      * @description Recursively checks types, required fields, and constraints; allows extra properties not in schema.
      */
-    protected validateSchema(data: any, schema: SchemaDefinition | undefined, path?: string): {
+    validateSchema(data: any, schema: SchemaDefinition | undefined, path?: string): {
         valid: boolean;
         errors: Record<string, string>;
     };
@@ -499,10 +503,10 @@ declare class Task extends SignalParticipant implements Graph {
     then(...tasks: Task[]): this;
     decouple(task: Task): void;
     doOnFail(...tasks: Task[]): this;
-    private updateProgressWeights;
-    private getSubgraphLayers;
-    private updateLayerFromPredecessors;
-    private hasCycle;
+    updateProgressWeights(): void;
+    getSubgraphLayers(): Map<number, Set<Task>>;
+    updateLayerFromPredecessors(): void;
+    hasCycle(): boolean;
     mapNext(callback: (task: Task) => any, failed?: boolean): any[];
     mapPrevious(callback: (task: Task) => any): any[];
     destroy(): void;
@@ -530,20 +534,20 @@ declare abstract class GraphBuilder {
     getResult(): GraphLayer;
     compose(): void;
     addNode(node: GraphNode): void;
-    protected addNodes(nodes: GraphNode[]): void;
-    protected addLayer(index: number): void;
-    protected createLayer(index: number): GraphLayer;
-    protected getLayer(layerIndex: number): GraphLayer;
+    addNodes(nodes: GraphNode[]): void;
+    addLayer(index: number): void;
+    createLayer(index: number): GraphLayer;
+    getLayer(layerIndex: number): GraphLayer;
     reset(): void;
 }
 
 declare abstract class GraphRunStrategy {
-    protected graphBuilder: GraphBuilder;
-    protected runInstance?: GraphRun;
+    graphBuilder: GraphBuilder;
+    runInstance?: GraphRun;
     constructor();
     setRunInstance(runInstance: GraphRun): void;
     changeStrategy(builder: GraphBuilder): void;
-    protected reset(): void;
+    reset(): void;
     addNode(node: GraphNode): void;
     updateRunInstance(): void;
     abstract run(): void;
@@ -558,9 +562,9 @@ interface RunJson {
 }
 declare class GraphRun {
     readonly id: string;
-    private graph;
-    private strategy;
-    private exporter;
+    graph: GraphLayer | undefined;
+    strategy: GraphRunStrategy;
+    exporter: GraphExporter | undefined;
     constructor(strategy: GraphRunStrategy);
     setGraph(graph: GraphLayer): void;
     addNode(node: GraphNode): void;
@@ -576,7 +580,7 @@ declare class GraphRoutine extends SignalParticipant {
     readonly name: string;
     readonly description: string;
     readonly isMeta: boolean;
-    private tasks;
+    tasks: Set<Task>;
     constructor(name: string, tasks: Task[], description: string, isMeta?: boolean);
     /**
      * Applies callback to starting tasks.
@@ -597,12 +601,12 @@ declare class GraphRoutine extends SignalParticipant {
 
 declare class GraphRunner extends SignalEmitter {
     readonly id: string;
-    protected currentRun: GraphRun;
-    private debug;
-    private verbose;
-    protected isRunning: boolean;
-    private readonly isMeta;
-    protected strategy: GraphRunStrategy;
+    currentRun: GraphRun;
+    debug: boolean;
+    verbose: boolean;
+    isRunning: boolean;
+    readonly isMeta: boolean;
+    strategy: GraphRunStrategy;
     /**
      * Constructs a runner.
      * @param isMeta Meta flag (default false).
@@ -618,7 +622,7 @@ declare class GraphRunner extends SignalEmitter {
      * @edge Emits 'meta.runner.added_tasks' with metadata.
      * @edge Empty tasks warns no-op.
      */
-    protected addTasks(tasks: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): void;
+    addTasks(tasks: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): void;
     /**
      * Runs tasks/routines.
      * @param tasks Optional tasks/routines.
@@ -627,36 +631,36 @@ declare class GraphRunner extends SignalEmitter {
      * @edge If running, returns current; else runs and resets.
      */
     run(tasks?: Task | GraphRoutine | (Task | GraphRoutine)[], context?: AnyObject): GraphRun | Promise<GraphRun>;
-    private runAsync;
-    protected reset(): GraphRun;
+    runAsync(run: Promise<void>): Promise<GraphRun>;
+    reset(): GraphRun;
     setDebug(value: boolean): void;
     setVerbose(value: boolean): void;
     destroy(): void;
     setStrategy(strategy: GraphRunStrategy): void;
-    private startRun;
+    startRun(context: AnyObject): boolean;
 }
 
 declare class SignalBroker {
-    private static instance_;
+    static instance_: SignalBroker;
     /**
      * Singleton instance for signal management.
      * @returns The broker instance.
      */
     static get instance(): SignalBroker;
-    private debug;
-    private verbose;
+    debug: boolean;
+    verbose: boolean;
     setDebug(value: boolean): void;
     setVerbose(value: boolean): void;
-    protected validateSignalName(signalName: string): void;
-    protected runner: GraphRunner | undefined;
-    protected metaRunner: GraphRunner | undefined;
+    validateSignalName(signalName: string): void;
+    runner: GraphRunner | undefined;
+    metaRunner: GraphRunner | undefined;
     getSignalsTask: Task | undefined;
-    protected signalObservers: Map<string, {
+    signalObservers: Map<string, {
         fn: (runner: GraphRunner, tasks: (Task | GraphRoutine)[], context: AnyObject) => void;
         tasks: Set<Task | GraphRoutine>;
     }>;
-    protected emitStacks: Map<string, Map<string, AnyObject>>;
-    protected constructor();
+    emitStacks: Map<string, Map<string, AnyObject>>;
+    constructor();
     /**
      * Initializes with runners.
      * @param runner Standard runner for user signals.
@@ -687,8 +691,8 @@ declare class SignalBroker {
      */
     emit(signal: string, context?: AnyObject): void;
     execute(signal: string, context: AnyObject): boolean;
-    private executeListener;
-    private addSignal;
+    executeListener(signal: string, context: AnyObject): boolean;
+    addSignal(signal: string): void;
     /**
      * Lists all observed signals.
      * @returns Array of signals.
@@ -698,10 +702,10 @@ declare class SignalBroker {
 }
 
 declare class GraphRegistry {
-    private static _instance;
+    static _instance: GraphRegistry;
     static get instance(): GraphRegistry;
-    private tasks;
-    private routines;
+    tasks: Map<string, Task>;
+    routines: Map<string, GraphRoutine>;
     registerTask: Task;
     updateTaskId: Task;
     updateTaskInputSchema: Task;
@@ -719,7 +723,7 @@ declare class GraphRegistry {
     getAllRoutines: Task;
     doForEachRoutine: Task;
     deleteRoutine: Task;
-    private constructor();
+    constructor();
     reset(): void;
 }
 
@@ -729,22 +733,22 @@ interface DebounceOptions {
     maxWait?: number;
 }
 declare class DebounceTask extends Task {
-    private readonly debounceTime;
-    private leading;
-    private trailing;
-    private maxWait;
-    private timer;
-    private maxTimer;
-    private hasLaterCall;
-    private lastResolve;
-    private lastReject;
-    private lastContext;
-    private lastTimeout;
-    private lastProgressCallback;
-    private lastEmitFunction;
+    readonly debounceTime: number;
+    leading: boolean;
+    trailing: boolean;
+    maxWait: number;
+    timer: NodeJS.Timeout | null;
+    maxTimer: NodeJS.Timeout | null;
+    hasLaterCall: boolean;
+    lastResolve: ((value: unknown) => void) | null;
+    lastReject: ((reason?: any) => void) | null;
+    lastContext: GraphContext | null;
+    lastTimeout: NodeJS.Timeout | null;
+    lastProgressCallback: ((progress: number) => void) | null;
+    lastEmitFunction: ((signal: string, context: any) => void) | null;
     constructor(name: string, task: TaskFunction, description?: string, debounceTime?: number, leading?: boolean, trailing?: boolean, maxWait?: number, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, inputSchema?: SchemaDefinition | undefined, validateInputSchema?: boolean, outputSchema?: SchemaDefinition | undefined, validateOutputSchema?: boolean);
-    private executeFunction;
-    private debouncedTrigger;
+    executeFunction(): void;
+    debouncedTrigger(resolve: (value: unknown) => void, reject: (reason?: any) => void, context: GraphContext, timeout: NodeJS.Timeout, emit: (signal: string, context: any) => void, progressCallback: (progress: number) => void): void;
     execute(context: GraphContext, emit: (signal: string, context: any) => void, progressCallback: (progress: number) => void): TaskResult;
 }
 
@@ -753,8 +757,8 @@ type EphemeralTaskOptions = {
     destroyCondition?: (context: any) => boolean;
 };
 declare class EphemeralTask extends Task {
-    private readonly once;
-    private readonly condition;
+    readonly once: boolean;
+    readonly condition: (context: any) => boolean;
     readonly isEphemeral: boolean;
     constructor(name: string, task: TaskFunction, description?: string, once?: boolean, condition?: (context: any) => boolean, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: SchemaDefinition | undefined, validateInputContext?: boolean, outputSchema?: SchemaDefinition | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
     execute(context: any, emit: (signal: string, context: AnyObject) => void, progressCallback: (progress: number) => void): TaskResult;
@@ -763,7 +767,7 @@ declare class EphemeralTask extends Task {
 declare class GraphAsyncRun extends GraphRunStrategy {
     constructor();
     run(): Promise<void>;
-    protected reset(): void;
+    reset(): void;
     export(): any;
 }
 
@@ -796,8 +800,8 @@ declare class Cadenza {
     static runner: GraphRunner;
     static metaRunner: GraphRunner;
     static registry: GraphRegistry;
-    protected static isBootstrapped: boolean;
-    protected static mode: CadenzaMode;
+    static isBootstrapped: boolean;
+    static mode: CadenzaMode;
     static bootstrap(): void;
     static get runStrategy(): {
         PARALLEL: GraphAsyncRun;