yaml-flow 2.1.0 → 2.3.0

package/README.md

@@ -748,6 +748,116 @@ See the [examples/graph-of-graphs/](./examples/graph-of-graphs/) directory for c
 
 ---
 
+## Execution Plan (Dry Run)
+
+Compute the full execution plan from a graph config without running anything — like `terraform plan` for workflows.
+
+```typescript
+import { planExecution } from 'yaml-flow/event-graph';
+
+const plan = planExecution(graph);
+
+plan.phases;          // [['prep'], ['copy'], ['evidence'], ['synthesis'], ['analyze'], ['health', 'report'], ['archive']]
+plan.depth;           // 7
+plan.maxParallelism;  // 2
+plan.entryPoints;     // ['prep']
+plan.leafTasks;       // ['archive']
+plan.conflicts;       // { 'output-token': ['task-a', 'task-b'] }  — multiple producers
+plan.unreachableTokens; // ['human-approval']  — required but no task produces it
+plan.blockedTasks;    // ['approve']  — blocked by unreachable tokens
+plan.dependencies;    // { 'copy': ['prep'], 'evidence': ['copy'], ... }
+```
+
+---
+
+## Mermaid Diagrams
+
+Generate Mermaid syntax from any config — useful for docs, debugging, and CI reports.
+
+```typescript
+import { graphToMermaid, flowToMermaid } from 'yaml-flow/event-graph';
+
+// Event graph → dependency diagram
+console.log(graphToMermaid(graph));
+// graph TD
+//   build([build])
+//   test[test]
+//   deploy[[deploy]]
+//   build -->|artifact| test
+//   test -->|tested| deploy
+
+// Step machine → flowchart
+console.log(flowToMermaid(flow));
+// graph TD
+//   START(( ))
+//   START --> classify
+//   classify -->|billing| handle
+//   handle -->|resolved| done
+//   done([done: resolved])
+```
+
+Options: `{ direction: 'LR' | 'TD', showTokens: boolean, title: string }`.  
+Entry points (no requires) get rounded shapes, leaf tasks get double-bracketed shapes, unreachable deps get warning markers.
+
+---
+
+## Graph Validation (Semantic)
+
+Validate the logical correctness of a graph — catches issues that structural validation (`validateGraphConfig`) can't.
+
+```typescript
+import { validateGraph } from 'yaml-flow/event-graph';
+
+const result = validateGraph(graph);
+
+result.valid;     // true if no errors (warnings/info allowed)
+result.errors;    // issues that will break execution
+result.warnings;  // issues that may cause unexpected behavior
+result.issues;    // all issues (errors + warnings + info)
+
+// Each issue
+result.issues[0].severity; // 'error' | 'warning' | 'info'
+result.issues[0].code;     // e.g. 'CIRCULAR_DEPENDENCY'
+result.issues[0].message;  // human-readable description
+result.issues[0].tasks;    // affected task names
+result.issues[0].tokens;   // affected tokens
+```
+
+| Issue Code | Severity | Description |
+|---|---|---|
+| `EMPTY_GRAPH` | error | Graph has no tasks |
+| `DANGLING_REQUIRES` | error | Task requires a token that no task produces |
+| `CIRCULAR_DEPENDENCY` | error | Cycle detected in task dependencies |
+| `SELF_DEPENDENCY` | error | Task requires a token it provides itself |
+| `UNREACHABLE_GOAL` | error | Goal token cannot be produced by any task |
+| `MISSING_GOAL` | error | `goal-reached` strategy without goal array |
+| `PROVIDE_CONFLICT` | warning | Multiple tasks produce the same token |
+| `DEAD_END_TASK` | warning | Task has no provides — can't unblock downstream |
+| `ISOLATED_TASK` | info | Disconnected task with no requires or dependents |
+
+Use `validateGraphConfig()` for structural checks (JSON shape) and `validateGraph()` for semantic checks (logical correctness). Both are pure functions.
+
+---
+
+## Loading & Exporting Graph Configs
+
+```typescript
+import { loadGraphConfig, exportGraphConfig, exportGraphConfigToFile } from 'yaml-flow/event-graph';
+
+// Load from file, URL, JSON string, or object (validates automatically)
+const graph = await loadGraphConfig('./pipeline.yaml');
+const graph2 = await loadGraphConfig('https://example.com/graph.json');
+
+// Export to string
+const json = exportGraphConfig(graph);                         // JSON (default)
+const yaml = exportGraphConfig(graph, { format: 'yaml' });     // YAML
+
+// Export to file (format auto-detected from extension)
+await exportGraphConfigToFile(graph, './output/pipeline.yaml');
+```
+
+---
+
 ## Package Exports
 
 ```typescript
@@ -761,6 +871,9 @@ import { applyStepResult, checkCircuitBreaker, createInitialState } from 'yaml-f
 // Event Graph only
 import { next, apply, applyAll, getCandidateTasks } from 'yaml-flow/event-graph';
 import { createInitialExecutionState, isExecutionComplete, detectStuckState } from 'yaml-flow/event-graph';
+import { planExecution, graphToMermaid, flowToMermaid } from 'yaml-flow/event-graph';
+import { loadGraphConfig, validateGraphConfig, exportGraphConfig } from 'yaml-flow/event-graph';
+import { validateGraph } from 'yaml-flow/event-graph';
 import { TASK_STATUS, COMPLETION_STRATEGIES, CONFLICT_STRATEGIES } from 'yaml-flow/event-graph';
 
 // Stores
@@ -808,6 +921,14 @@ import { FlowEngine, createEngine } from 'yaml-flow';  // aliases for StepMachin
 | `isExecutionComplete(graph, state)` | Check completion against configured strategy |
 | `detectStuckState({graph, state, ...})` | Check if execution is stuck |
 | `addDynamicTask(graph, name, config)` | Immutably add a task to a graph config |
+| `planExecution(graph)` | Dry-run: compute phases, parallelism, conflicts, unreachable tokens |
+| `graphToMermaid(graph, options?)` | Generate Mermaid dependency diagram from an event-graph |
+| `flowToMermaid(flow, options?)` | Generate Mermaid flowchart from a step-machine |
+| `loadGraphConfig(source)` | Load + validate a YAML/JSON/URL graph config |
+| `validateGraphConfig(config)` | Validate a GraphConfig, returns error strings |
+| `exportGraphConfig(config, options?)` | Export a GraphConfig to JSON or YAML string |
+| `exportGraphConfigToFile(config, path)` | Export a GraphConfig to a file |
+| `validateGraph(graph)` | Semantic validation: cycles, dangling requires, unreachable goals, conflicts |
 
 ### Event Types (for `apply()`)
 

package/dist/{constants-D1fTEbbM.d.ts → constants-BftTHiuV.d.cts}

@@ -1,3 +1,5 @@
+import { e as StepFlowConfig } from './types-FZ_eyErS.cjs';
+
 /**
  * Event Graph — Core Types
  *
@@ -311,6 +313,181 @@ declare function detectStuckState(params: {
     completionResult?: CompletionResult;
 }): StuckDetection;
 
+/**
+ * Event Graph — Execution Plan (Dry Run)
+ *
+ * Compute the full execution plan from a GraphConfig without running anything.
+ * Shows phases (what runs in parallel), dependency edges, and potential issues.
+ *
+ * Pure function — no I/O, no side effects.
+ */
+
+interface ExecutionPlan {
+    /** Ordered phases — tasks within a phase can run in parallel */
+    phases: string[][];
+    /** Dependency edges: taskName → tasks it depends on */
+    dependencies: Record<string, string[]>;
+    /** Tasks that provide conflicts (same output from multiple tasks) */
+    conflicts: Record<string, string[]>;
+    /** Tasks that have no requires (entry points) */
+    entryPoints: string[];
+    /** Tasks that nothing depends on (leaf nodes) */
+    leafTasks: string[];
+    /** Tokens required but not produced by any task */
+    unreachableTokens: string[];
+    /** Tasks blocked by unreachable tokens */
+    blockedTasks: string[];
+    /** Total number of phases (depth of the graph) */
+    depth: number;
+    /** Max parallelism (widest phase) */
+    maxParallelism: number;
+}
+/**
+ * Compute a full execution plan from a graph config.
+ *
+ * Shows the order tasks would execute, what can run in parallel,
+ * where conflicts exist, and what's unreachable — all without
+ * actually running anything.
+ *
+ * @param graph - The event-graph configuration
+ * @returns ExecutionPlan with phases, dependencies, conflicts, and diagnostics
+ */
+declare function planExecution(graph: GraphConfig): ExecutionPlan;
+
+/**
+ * Mermaid Diagram Export
+ *
+ * Generate Mermaid diagram strings from GraphConfig (event-graph)
+ * and StepFlowConfig (step-machine). Useful for documentation,
+ * debugging, and CI reports.
+ *
+ * Pure functions — no I/O, no side effects.
+ */
+
+interface MermaidOptions {
+    /** Diagram direction: TB (top-bottom), LR (left-right), etc. Default: 'TD' */
+    direction?: 'TD' | 'TB' | 'LR' | 'RL' | 'BT';
+    /** Show token labels on edges. Default: true */
+    showTokens?: boolean;
+    /** Title comment at top. Default: graph.id or 'Event Graph' */
+    title?: string;
+}
+/**
+ * Generate a Mermaid dependency graph from an event-graph config.
+ *
+ * Tasks are nodes. Edges represent token dependencies:
+ * if task B requires token X and task A provides X, then A --> B.
+ *
+ * @param graph - Event graph configuration
+ * @param options - Diagram options
+ * @returns Mermaid diagram string
+ */
+declare function graphToMermaid(graph: GraphConfig, options?: MermaidOptions): string;
+/**
+ * Generate a Mermaid flowchart from a step-machine config.
+ *
+ * Steps are nodes. Transitions are labeled edges.
+ * Terminal states are shown as filled/rounded nodes.
+ *
+ * @param flow - Step machine flow configuration
+ * @param options - Diagram options
+ * @returns Mermaid diagram string
+ */
+declare function flowToMermaid(flow: StepFlowConfig, options?: MermaidOptions): string;
+
+/**
+ * Event Graph — Loader & Exporter
+ *
+ * Load GraphConfig from YAML/JSON files or strings, and export back.
+ * Mirrors the step-machine's loadStepFlow/validateStepFlowConfig pattern.
+ */
+
+/**
+ * Validate a GraphConfig object. Returns an array of error strings.
+ * Empty array = valid config.
+ */
+declare function validateGraphConfig(config: unknown): string[];
+/**
+ * Load a GraphConfig from a file path, URL, JSON string, or object.
+ * Validates the config and throws if invalid.
+ *
+ * @param source - File path (.yaml/.yml/.json), URL, JSON string, or GraphConfig object
+ * @returns Validated GraphConfig
+ */
+declare function loadGraphConfig(source: string | GraphConfig): Promise<GraphConfig>;
+interface ExportOptions {
+    /** Output format. Default: 'json' */
+    format?: 'json' | 'yaml';
+    /** Indentation for JSON (default: 2) or YAML */
+    indent?: number;
+}
+/**
+ * Export a GraphConfig to a JSON or YAML string.
+ *
+ * @param config - The graph configuration to export
+ * @param options - Export format options
+ * @returns Serialized config string
+ */
+declare function exportGraphConfig(config: GraphConfig, options?: ExportOptions): string;
+/**
+ * Export a GraphConfig to a file.
+ *
+ * @param config - The graph configuration to export
+ * @param filePath - Output file path (.json or .yaml/.yml)
+ * @param options - Export format options (format auto-detected from extension if not specified)
+ */
+declare function exportGraphConfigToFile(config: GraphConfig, filePath: string, options?: ExportOptions): Promise<void>;
+
+/**
+ * Event Graph — Semantic Graph Validation
+ *
+ * Validates the logical correctness of a static graph configuration.
+ * Unlike validateGraphConfig() which checks JSON structure, this checks:
+ *   - Dangling requires (tokens no task produces)
+ *   - Circular dependencies
+ *   - Provide conflicts (multiple tasks producing same token)
+ *   - Unreachable goal tokens
+ *   - Dead-end tasks (no provides)
+ *   - Self-dependencies
+ *   - Orphaned tasks (disconnected from the graph)
+ *
+ * Pure function — config in, diagnostics out.
+ */
+
+type IssueSeverity = 'error' | 'warning' | 'info';
+interface GraphIssue {
+    /** Severity: error = will break execution, warning = may cause problems, info = notable */
+    severity: IssueSeverity;
+    /** Machine-readable issue code */
+    code: string;
+    /** Human-readable description */
+    message: string;
+    /** Affected task names (if applicable) */
+    tasks?: string[];
+    /** Affected tokens (if applicable) */
+    tokens?: string[];
+}
+interface GraphValidationResult {
+    /** true if no errors (warnings/info are allowed) */
+    valid: boolean;
+    /** All issues found */
+    issues: GraphIssue[];
+    /** Just the errors */
+    errors: GraphIssue[];
+    /** Just the warnings */
+    warnings: GraphIssue[];
+}
+/**
+ * Validate the semantic correctness of a static event-graph configuration.
+ *
+ * Checks for logical issues that would cause execution failures, stuck states,
+ * or unexpected behavior. Does NOT check JSON structure (use validateGraphConfig for that).
+ *
+ * @param graph - The event-graph configuration to validate
+ * @returns Validation result with categorized issues
+ */
+declare function validateGraph(graph: GraphConfig): GraphValidationResult;
+
 /**
  * Event Graph — Constants
  */
@@ -327,4 +504,4 @@ declare const DEFAULTS: {
     readonly MAX_ITERATIONS: 1000;
 };
 
-export { getRepeatableMax as $, type AgentActionEvent as A, getAllTasks as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, getCandidateTasks as F, type GraphConfig as G, getProvides as H, type InjectTokensEvent as I, getRequires as J, getTask as K, hasTask as L, isExecutionComplete as M, isNonActiveTask as N, isRepeatableTask as O, isTaskCompleted as P, isTaskRunning as Q, next as R, type SchedulerResult as S, type TaskConfig as T, type RepeatableConfig as U, type TaskCircuitBreakerConfig as V, type TaskMessage as W, type TaskProgressEvent as X, type TaskRetryConfig as Y, addKeyToProvides as Z, addKeyToRequires as _, CONFLICT_STRATEGIES as a, groupTasksByProvides as a0, hasOutputConflict as a1, removeKeyFromProvides as a2, removeKeyFromRequires as a3, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionState as h, type ExecutionStatus as i, type GraphEvent as j, type GraphSettings as k, type StuckDetection as l, TASK_STATUS as m, type TaskCompletedEvent as n, type TaskCreationEvent as o, type TaskFailedEvent as p, type TaskStartedEvent as q, type TaskState as r, type TaskStatus as s, addDynamicTask as t, apply as u, applyAll as v, computeAvailableOutputs as w, createDefaultTaskState as x, createInitialExecutionState as y, detectStuckState as z };
+export { isTaskCompleted as $, type AgentActionEvent as A, applyAll as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, computeAvailableOutputs as F, type GraphConfig as G, createDefaultTaskState as H, type InjectTokensEvent as I, createInitialExecutionState as J, detectStuckState as K, exportGraphConfig as L, type MermaidOptions as M, exportGraphConfigToFile as N, flowToMermaid as O, getAllTasks as P, getCandidateTasks as Q, getProvides as R, type SchedulerResult as S, type TaskConfig as T, getRequires as U, getTask as V, graphToMermaid as W, hasTask as X, isExecutionComplete as Y, isNonActiveTask as Z, isRepeatableTask as _, CONFLICT_STRATEGIES as a, isTaskRunning as a0, loadGraphConfig as a1, next as a2, planExecution as a3, validateGraph as a4, validateGraphConfig as a5, type RepeatableConfig as a6, type TaskCircuitBreakerConfig as a7, type TaskMessage as a8, type TaskProgressEvent as a9, type TaskRetryConfig as aa, addKeyToProvides as ab, addKeyToRequires as ac, getRepeatableMax as ad, groupTasksByProvides as ae, hasOutputConflict as af, removeKeyFromProvides as ag, removeKeyFromRequires as ah, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionPlan as h, type ExecutionState as i, type ExecutionStatus as j, type ExportOptions as k, type GraphEvent as l, type GraphIssue as m, type GraphSettings as n, type GraphValidationResult as o, type IssueSeverity as p, type StuckDetection as q, TASK_STATUS as r, type TaskCompletedEvent as s, type TaskCreationEvent as t, type TaskFailedEvent as u, type TaskStartedEvent as v, type TaskState as w, type TaskStatus as x, addDynamicTask as y, apply as z };

package/dist/{constants-D1fTEbbM.d.cts → constants-DMbnp--H.d.ts}

@@ -1,3 +1,5 @@
+import { e as StepFlowConfig } from './types-FZ_eyErS.js';
+
 /**
  * Event Graph — Core Types
  *
@@ -311,6 +313,181 @@ declare function detectStuckState(params: {
     completionResult?: CompletionResult;
 }): StuckDetection;
 
+/**
+ * Event Graph — Execution Plan (Dry Run)
+ *
+ * Compute the full execution plan from a GraphConfig without running anything.
+ * Shows phases (what runs in parallel), dependency edges, and potential issues.
+ *
+ * Pure function — no I/O, no side effects.
+ */
+
+interface ExecutionPlan {
+    /** Ordered phases — tasks within a phase can run in parallel */
+    phases: string[][];
+    /** Dependency edges: taskName → tasks it depends on */
+    dependencies: Record<string, string[]>;
+    /** Tasks that provide conflicts (same output from multiple tasks) */
+    conflicts: Record<string, string[]>;
+    /** Tasks that have no requires (entry points) */
+    entryPoints: string[];
+    /** Tasks that nothing depends on (leaf nodes) */
+    leafTasks: string[];
+    /** Tokens required but not produced by any task */
+    unreachableTokens: string[];
+    /** Tasks blocked by unreachable tokens */
+    blockedTasks: string[];
+    /** Total number of phases (depth of the graph) */
+    depth: number;
+    /** Max parallelism (widest phase) */
+    maxParallelism: number;
+}
+/**
+ * Compute a full execution plan from a graph config.
+ *
+ * Shows the order tasks would execute, what can run in parallel,
+ * where conflicts exist, and what's unreachable — all without
+ * actually running anything.
+ *
+ * @param graph - The event-graph configuration
+ * @returns ExecutionPlan with phases, dependencies, conflicts, and diagnostics
+ */
+declare function planExecution(graph: GraphConfig): ExecutionPlan;
+
+/**
+ * Mermaid Diagram Export
+ *
+ * Generate Mermaid diagram strings from GraphConfig (event-graph)
+ * and StepFlowConfig (step-machine). Useful for documentation,
+ * debugging, and CI reports.
+ *
+ * Pure functions — no I/O, no side effects.
+ */
+
+interface MermaidOptions {
+    /** Diagram direction: TB (top-bottom), LR (left-right), etc. Default: 'TD' */
+    direction?: 'TD' | 'TB' | 'LR' | 'RL' | 'BT';
+    /** Show token labels on edges. Default: true */
+    showTokens?: boolean;
+    /** Title comment at top. Default: graph.id or 'Event Graph' */
+    title?: string;
+}
+/**
+ * Generate a Mermaid dependency graph from an event-graph config.
+ *
+ * Tasks are nodes. Edges represent token dependencies:
+ * if task B requires token X and task A provides X, then A --> B.
+ *
+ * @param graph - Event graph configuration
+ * @param options - Diagram options
+ * @returns Mermaid diagram string
+ */
+declare function graphToMermaid(graph: GraphConfig, options?: MermaidOptions): string;
+/**
+ * Generate a Mermaid flowchart from a step-machine config.
+ *
+ * Steps are nodes. Transitions are labeled edges.
+ * Terminal states are shown as filled/rounded nodes.
+ *
+ * @param flow - Step machine flow configuration
+ * @param options - Diagram options
+ * @returns Mermaid diagram string
+ */
+declare function flowToMermaid(flow: StepFlowConfig, options?: MermaidOptions): string;
+
+/**
+ * Event Graph — Loader & Exporter
+ *
+ * Load GraphConfig from YAML/JSON files or strings, and export back.
+ * Mirrors the step-machine's loadStepFlow/validateStepFlowConfig pattern.
+ */
+
+/**
+ * Validate a GraphConfig object. Returns an array of error strings.
+ * Empty array = valid config.
+ */
+declare function validateGraphConfig(config: unknown): string[];
+/**
+ * Load a GraphConfig from a file path, URL, JSON string, or object.
+ * Validates the config and throws if invalid.
+ *
+ * @param source - File path (.yaml/.yml/.json), URL, JSON string, or GraphConfig object
+ * @returns Validated GraphConfig
+ */
+declare function loadGraphConfig(source: string | GraphConfig): Promise<GraphConfig>;
+interface ExportOptions {
+    /** Output format. Default: 'json' */
+    format?: 'json' | 'yaml';
+    /** Indentation for JSON (default: 2) or YAML */
+    indent?: number;
+}
+/**
+ * Export a GraphConfig to a JSON or YAML string.
+ *
+ * @param config - The graph configuration to export
+ * @param options - Export format options
+ * @returns Serialized config string
+ */
+declare function exportGraphConfig(config: GraphConfig, options?: ExportOptions): string;
+/**
+ * Export a GraphConfig to a file.
+ *
+ * @param config - The graph configuration to export
+ * @param filePath - Output file path (.json or .yaml/.yml)
+ * @param options - Export format options (format auto-detected from extension if not specified)
+ */
+declare function exportGraphConfigToFile(config: GraphConfig, filePath: string, options?: ExportOptions): Promise<void>;
+
+/**
+ * Event Graph — Semantic Graph Validation
+ *
+ * Validates the logical correctness of a static graph configuration.
+ * Unlike validateGraphConfig() which checks JSON structure, this checks:
+ *   - Dangling requires (tokens no task produces)
+ *   - Circular dependencies
+ *   - Provide conflicts (multiple tasks producing same token)
+ *   - Unreachable goal tokens
+ *   - Dead-end tasks (no provides)
+ *   - Self-dependencies
+ *   - Orphaned tasks (disconnected from the graph)
+ *
+ * Pure function — config in, diagnostics out.
+ */
+
+type IssueSeverity = 'error' | 'warning' | 'info';
+interface GraphIssue {
+    /** Severity: error = will break execution, warning = may cause problems, info = notable */
+    severity: IssueSeverity;
+    /** Machine-readable issue code */
+    code: string;
+    /** Human-readable description */
+    message: string;
+    /** Affected task names (if applicable) */
+    tasks?: string[];
+    /** Affected tokens (if applicable) */
+    tokens?: string[];
+}
+interface GraphValidationResult {
+    /** true if no errors (warnings/info are allowed) */
+    valid: boolean;
+    /** All issues found */
+    issues: GraphIssue[];
+    /** Just the errors */
+    errors: GraphIssue[];
+    /** Just the warnings */
+    warnings: GraphIssue[];
+}
+/**
+ * Validate the semantic correctness of a static event-graph configuration.
+ *
+ * Checks for logical issues that would cause execution failures, stuck states,
+ * or unexpected behavior. Does NOT check JSON structure (use validateGraphConfig for that).
+ *
+ * @param graph - The event-graph configuration to validate
+ * @returns Validation result with categorized issues
+ */
+declare function validateGraph(graph: GraphConfig): GraphValidationResult;
+
 /**
  * Event Graph — Constants
  */
@@ -327,4 +504,4 @@ declare const DEFAULTS: {
     readonly MAX_ITERATIONS: 1000;
 };
 
-export { getRepeatableMax as $, type AgentActionEvent as A, getAllTasks as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, getCandidateTasks as F, type GraphConfig as G, getProvides as H, type InjectTokensEvent as I, getRequires as J, getTask as K, hasTask as L, isExecutionComplete as M, isNonActiveTask as N, isRepeatableTask as O, isTaskCompleted as P, isTaskRunning as Q, next as R, type SchedulerResult as S, type TaskConfig as T, type RepeatableConfig as U, type TaskCircuitBreakerConfig as V, type TaskMessage as W, type TaskProgressEvent as X, type TaskRetryConfig as Y, addKeyToProvides as Z, addKeyToRequires as _, CONFLICT_STRATEGIES as a, groupTasksByProvides as a0, hasOutputConflict as a1, removeKeyFromProvides as a2, removeKeyFromRequires as a3, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionState as h, type ExecutionStatus as i, type GraphEvent as j, type GraphSettings as k, type StuckDetection as l, TASK_STATUS as m, type TaskCompletedEvent as n, type TaskCreationEvent as o, type TaskFailedEvent as p, type TaskStartedEvent as q, type TaskState as r, type TaskStatus as s, addDynamicTask as t, apply as u, applyAll as v, computeAvailableOutputs as w, createDefaultTaskState as x, createInitialExecutionState as y, detectStuckState as z };
+export { isTaskCompleted as $, type AgentActionEvent as A, applyAll as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, computeAvailableOutputs as F, type GraphConfig as G, createDefaultTaskState as H, type InjectTokensEvent as I, createInitialExecutionState as J, detectStuckState as K, exportGraphConfig as L, type MermaidOptions as M, exportGraphConfigToFile as N, flowToMermaid as O, getAllTasks as P, getCandidateTasks as Q, getProvides as R, type SchedulerResult as S, type TaskConfig as T, getRequires as U, getTask as V, graphToMermaid as W, hasTask as X, isExecutionComplete as Y, isNonActiveTask as Z, isRepeatableTask as _, CONFLICT_STRATEGIES as a, isTaskRunning as a0, loadGraphConfig as a1, next as a2, planExecution as a3, validateGraph as a4, validateGraphConfig as a5, type RepeatableConfig as a6, type TaskCircuitBreakerConfig as a7, type TaskMessage as a8, type TaskProgressEvent as a9, type TaskRetryConfig as aa, addKeyToProvides as ab, addKeyToRequires as ac, getRepeatableMax as ad, groupTasksByProvides as ae, hasOutputConflict as af, removeKeyFromProvides as ag, removeKeyFromRequires as ah, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionPlan as h, type ExecutionState as i, type ExecutionStatus as j, type ExportOptions as k, type GraphEvent as l, type GraphIssue as m, type GraphSettings as n, type GraphValidationResult as o, type IssueSeverity as p, type StuckDetection as q, TASK_STATUS as r, type TaskCompletedEvent as s, type TaskCreationEvent as t, type TaskFailedEvent as u, type TaskStartedEvent as v, type TaskState as w, type TaskStatus as x, addDynamicTask as y, apply as z };