@flow-scanner/lightning-flow-scanner-core 6.13.1 → 6.14.0

package/README.md

@@ -36,6 +36,7 @@
   - [Configure Severity Levels](#configure-severity-levels)
   - [Overwrite Expressions](#overwrite-expressions)
   - [Define Exceptions](#define-exceptions)
+  - [Exclude Flows from Scanning](#exclude-flows-from-scanning)
   - [Scan Modes](#scan-modes)
 - **[Installation](#installation)**
   - [Distributions](#distributions)
@@ -52,140 +53,196 @@
 
 > Want to code a new rule? → See [How to Write a Rule](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/docs/write-a-rule.md)
 
+<!-- START GENERATED_RULES -->
 ### Action Call In A Loop
-_[ActionCallsInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/ActionCallsInLoop.ts)_ – To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.  
-**Rule ID:** `action-call-in-loop`  
+To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.
+
+**Rule ID:** `action-call-in-loop`
+**Class Name:** _[ActionCallsInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/ActionCallsInLoop.ts)_
 **Severity:** 🔴 *Error*
 
-### Invalid API Version  
-_[APIVersion](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/APIVersion.ts)_ – Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the **Api Version** attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.  
-**Rule ID:** `invalid-api-version`  
-**Severity:** 🟡 *Warning*
+### DML Statement In A Loop
+To prevent exceeding Apex governor limits, consolidate all your database operations—record creation, updates, or deletions—at the conclusion of the flow.
+
+**Rule ID:** `dml-in-loop`
+**Class Name:** _[DMLStatementInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/DMLStatementInLoop.ts)_
+**Severity:** 🔴 *Error*
 
-### Unclear API Name  
-_[CopyAPIName](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/CopyAPIName.ts)_ – Maintaining multiple elements with a similar name, like `Copy_X_Of_Element`, can diminish the overall readability of your Flow. When copying and pasting these elements, remember to update the API name of the newly created copy.  
-**Rule ID:** `unclear-api-naming`  
+### Duplicate DML Operation
+When a flow executes database changes or actions between two screens, prevent users from navigating backward between screens; otherwise, duplicate database operations may be performed.
+
+**Rule ID:** `duplicate-dml`
+**Class Name:** _[DuplicateDMLOperation](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/DuplicateDMLOperation.ts)_
 **Severity:** 🟡 *Warning*
 
-### Excessive Cyclomatic Complexity  
-_[CyclomaticComplexity](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/CyclomaticComplexity.ts)_ – The number of loops and decision rules, plus the number of decisions. Use a combination of 1) subflows and 2) breaking flows into multiple concise trigger-ordered flows to reduce cyclomatic complexity within a single flow, ensuring maintainability and simplicity.  
-**Rule ID:** `excessive-cyclomatic-complexity`  
+### Excessive Cyclomatic Complexity
+The number of loops and decision rules, plus the number of decisions. Use a combination of 1) subflows and 2) breaking flows into multiple concise trigger ordered flows, to reduce the cyclomatic complexity within a single flow, ensuring maintainability and simplicity.
+
+**Rule ID:** `excessive-cyclomatic-complexity`
+**Class Name:** _[CyclomaticComplexity](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/CyclomaticComplexity.ts)_
 **Severity:** 🔵 *Note*
 
-### DML Statement In A Loop  
-_[DMLStatementInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/DMLStatementInLoop.ts)_ – To prevent exceeding Apex governor limits, consolidate all your database operations—record creation, updates, or deletions—at the conclusion of the flow.  
-**Rule ID:** `dml-in-loop`  
+### Flow Naming Convention
+The readability of a flow is paramount. Establishing a naming convention significantly enhances findability, searchability, and overall consistency. Include at least a domain and a brief description of the flow’s actions, for example `Service_OrderFulfillment`.
+
+**Rule ID:** `invalid-naming-convention`
+**Class Name:** _[FlowName](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/FlowName.ts)_
 **Severity:** 🔴 *Error*
 
-### Duplicate DML Operation  
-_[DuplicateDMLOperation](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/DuplicateDMLOperation.ts)_ – When a flow executes database changes or actions between two screens, prevent users from navigating backward between screens; otherwise, duplicate database operations may be performed.  
-**Rule ID:** `duplicate-dml`  
+### Get Record All Fields
+Following the principle of least privilege (PoLP), avoid using **Get Records** with “Automatically store all fields” unless necessary.
+
+**Rule ID:** `get-record-all-fields`
+**Class Name:** _[GetRecordAllFields](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/GetRecordAllFields.ts)_
 **Severity:** 🟡 *Warning*
 
-### Flow Naming Convention  
-_[FlowName](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/FlowName.ts)_ – The readability of a flow is paramount. Establishing a naming convention significantly enhances findability, searchability, and overall consistency. Include at least a domain and a brief description of the flow’s actions, for example `Service_OrderFulfillment`.  
-**Rule ID:** `invalid-naming-convention`  
+### Hardcoded Id
+Avoid hard-coding IDs because they are org specific. Instead, pass them into variables at the start of the flow—via merge-field URL parameters or a **Get Records** element.
+
+**Rule ID:** `hardcoded-id`
+**Class Name:** _[HardcodedId](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/HardcodedId.ts)_
 **Severity:** 🔴 *Error*
 
-### Get Records Stores All Fields 
-_[GetRecordAllFields](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/GetRecordAllFields.ts)_ – Following the principle of least privilege (PoLP), avoid using **Get Records** with “Automatically store all fields” unless necessary.  
-**Rule ID:** `get-record-all-fields`  
-**Severity:** 🟡 *Warning*
+### Hardcoded Url
+Avoid hard-coding URLs because they are environment specific. Use an `$API` formula (preferred) or environment-specific sources like custom labels, metadata, or settings.
 
-### Hardcoded Id  
-_[HardcodedId](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/HardcodedId.ts)_ – Avoid hard-coding IDs because they are org specific. Instead, pass them into variables at the start of the flow—via merge-field URL parameters or a **Get Records** element.  
-**Rule ID:** `hardcoded-id`  
+**Rule ID:** `hardcoded-url`
+**Class Name:** _[HardcodedUrl](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/HardcodedUrl.ts)_
 **Severity:** 🔴 *Error*
 
-### Hardcoded Url  
-_[HardcodedUrl](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/HardcodedUrl.ts)_ – Avoid hard-coding URLs because they are environment specific. Use an `$API` formula (preferred) or environment-specific sources like custom labels, metadata, or settings.  
-**Rule ID:** `hardcoded-url`  
-**Severity:** 🔴 *Error*
+### Inactive Flow
+Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble—such as accidentally deleting records during testing, or being activated as subflows.
+
+**Rule ID:** `inactive-flow`
+**Class Name:** _[InactiveFlow](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/InactiveFlow.ts)_
+**Severity:** 🟡 *Warning*
+
+### Invalid API Version
+Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the **Api Version** attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.
 
-### Inactive Flow  
-_[InactiveFlow](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/InactiveFlow.ts)_ – Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble—such as accidentally deleting records during testing, or being activated as subflows.  
-**Rule ID:** `inactive-flow`  
+**Rule ID:** `invalid-api-version`
+**Class Name:** _[APIVersion](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/APIVersion.ts)_
 **Severity:** 🟡 *Warning*
 
-### Missing Auto Layout  
-_[AutoLayout](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/AutoLayout.ts)_ – With Canvas Mode set to Auto-Layout, elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized—saving you time.  
-**Rule ID:** `missing-auto-layout`  
+### Missing Auto Layout
+With Canvas Mode set to Auto-Layout, elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized—saving you time.
+
+**Rule ID:** `missing-auto-layout`
+**Class Name:** _[AutoLayout](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/AutoLayout.ts)_
 **Severity:** 🔵 *Note*
 
-### Missing Fault Path  
-_[MissingFaultPath](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingFaultPath.ts)_ – A flow may fail to execute an operation as intended. By default, the flow displays an error to the user and emails the creator. Customize this behavior by incorporating a Fault Path.  
-**Rule ID:** `missing-fault-path`  
+### Missing Fault Path
+A flow may fail to execute an operation as intended. By default, the flow displays an error to the user and emails the creator. Customize this behavior by incorporating a Fault Path.
+
+**Rule ID:** `missing-fault-path`
+**Class Name:** _[MissingFaultPath](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingFaultPath.ts)_
 **Severity:** 🟡 *Warning*
 
 ### Missing Filter Record Trigger ![Beta](https://img.shields.io/badge/status-beta-yellow)
-_[MissingFilterRecordTrigger](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingFilterRecordTrigger.ts)_ – Record-triggered flows that lack filters on changed fields or entry conditions can lead to unnecessary executions on every record change. This may degrade system performance, hit governor limits faster, and increase resource consumption in high-volume orgs. 
-**Rule ID:** `missing-record-trigger-filter`  
+Record-triggered flows that lack filters on changed fields or entry conditions can lead to unnecessary executions on every record change. This may degrade system performance, hit governor limits faster, and increase resource consumption in high-volume orgs.
+
+**Rule ID:** `missing-record-trigger-filter`
+**Class Name:** _[MissingFilterRecordTrigger](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingFilterRecordTrigger.ts)_
 **Severity:** 🟡 *Warning*
 
-### Missing Flow Description  
-_[FlowDescription](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/FlowDescription.ts)_ – Descriptions play a vital role in documentation. It is highly recommended to include details about where a flow is used and its intended purpose.  
-**Rule ID:** `missing-flow-description`  
+### Missing Flow Description
+Descriptions play a vital role in documentation. It is highly recommended to include details about where a flow is used and its intended purpose.
+
+**Rule ID:** `missing-flow-description`
+**Class Name:** _[FlowDescription](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/FlowDescription.ts)_
 **Severity:** 🔴 *Error*
 
 ### Missing Metadata Description ![Beta](https://img.shields.io/badge/status-beta-yellow)
-_[MissingMetadataDescription](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingMetadataDescription.ts)_ – Flags Flow elements (Get Records, Assignments, Decisions, Actions, etc.) and metadata components (Variables, Formulas, Constants, Text Templates) that lack a description. Adding concise descriptions greatly improves readability, maintainability, and helps AI tools understand your automation intent.  
-**Rule ID:** `missing-metadata-description`  
+Flags Flow elements (Get Records, Assignments, Decisions, Actions, etc.) and metadata components (Variables, Formulas, Constants, Text Templates) that lack a description. Adding concise descriptions greatly improves readability, maintainability, and helps AI tools understand your automation intent.
+
+**Rule ID:** `missing-metadata-description`
+**Class Name:** _[MissingMetadataDescription](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingMetadataDescription.ts)_
 **Severity:** 🔴 *Error*
 
-### Missing Null Handler  
-_[MissingNullHandler](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingNullHandler.ts)_ – When a **Get Records** operation finds no data, it returns `null`. Validate data by using a Decision element to check for a non-null result.  
-**Rule ID:** `missing-null-handler`  
+### Missing Null Handler
+When a **Get Records** operation finds no data, it returns `null`. Validate data by using a Decision element to check for a non-null result.
+
+**Rule ID:** `missing-null-handler`
+**Class Name:** _[MissingNullHandler](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/MissingNullHandler.ts)_
 **Severity:** 🟡 *Warning*
 
-### Missing Trigger Order  
-_[TriggerOrder](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/TriggerOrder.ts)_ – Guarantee your flow execution order with the **Trigger Order** property introduced in Spring ’22.  
-**Rule ID:** `missing-trigger-order`  
+### Missing Trigger Order
+Guarantee your flow execution order with the **Trigger Order** property introduced in Spring '22.value to their flows and guarantee their execution order. This priority value is not an absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.
+
+**Rule ID:** `unspecified-trigger-order`
+**Class Name:** _[TriggerOrder](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/TriggerOrder.ts)_
 **Severity:** 🔵 *Note*
 
-### Process Builder  
-_[ProcessBuilder](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/ProcessBuilder.ts)_ – Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Begin migrating your organization’s automation to Flow.  
-**Rule ID:** `process-builder-usage`  
+### Process Builder
+Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Begin migrating your organization’s automation to Flow.
+
+**Rule ID:** `process-builder-usage`
+**Class Name:** _[ProcessBuilder](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/ProcessBuilder.ts)_
 **Severity:** 🟡 *Warning*
 
 ### Record ID as String ![Beta](https://img.shields.io/badge/status-beta-yellow)
-_[RecordIdAsString](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/RecordIdAsString.ts)_ – Detects flows using a String variable named `recordId` as input when they could receive the entire record object instead. Since recent Salesforce releases, record pages and quick actions can pass the complete record, eliminating the need for an additional Get Records query and improving performance.  
-**Rule ID:** `record-id-as-string`  
-**Severity:** 🔵 *Note*
+Detects flows using a String variable named `recordId` as input when they could receive the entire record object instead. Since recent Salesforce releases, record pages and quick actions can pass the complete record, eliminating the need for an additional Get Records query and improving performance.
+
+**Rule ID:** `record-id-as-string`
+**Class Name:** _[RecordIdAsString](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/RecordIdAsString.ts)_
+**Severity:** 🔴 *Error*
 
-### Recursive After Update  
-_[RecursiveAfterUpdate](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/RecursiveAfterUpdate.ts)_ – After-update flows are meant for modifying **other** records. Using them on the same record can cause recursion. Consider **before-save** flows for same-record updates.  
-**Rule ID:** `recursive-record-update`  
+### Recursive After Update
+After-update flows are meant for modifying **other** records. Using them on the same record can cause recursion. Consider **before-save** flows for same-record updates.
+
+**Rule ID:** `recursive-record-update`
+**Class Name:** _[RecursiveAfterUpdate](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/RecursiveAfterUpdate.ts)_
 **Severity:** 🟡 *Warning*
 
-### Same Record Field Updates  
-_[SameRecordFieldUpdates](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/SameRecordFieldUpdates.ts)_ – Similar to triggers, **before-save** contexts can update the same record via `$Record` without invoking DML.  
-**Rule ID:** `same-record-field-updates`  
+### Same Record Field Updates
+Similar to triggers, **before-save** contexts can update the same record via `$Record` without invoking DML.
+
+**Rule ID:** `same-record-field-updates`
+**Class Name:** _[SameRecordFieldUpdates](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/SameRecordFieldUpdates.ts)_
 **Severity:** 🟡 *Warning*
 
-### SOQL Query In A Loop  
-_[SOQLQueryInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/SOQLQueryInLoop.ts)_ – To prevent exceeding Apex governor limits, consolidate all SOQL queries at the end of the flow.  
-**Rule ID:** `soql-in-loop`  
+### SOQL Query In A Loop
+To prevent exceeding Apex governor limits, consolidate all SOQL queries at the end of the flow.
+
+**Rule ID:** `soql-in-loop`
+**Class Name:** _[SOQLQueryInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/SOQLQueryInLoop.ts)_
 **Severity:** 🔴 *Error*
 
 ### Transform Instead of Loop ![Beta](https://img.shields.io/badge/status-beta-yellow)
-_[TransformInsteadOfLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/TransformInsteadOfLoop.ts)_ – Detects Loop elements that directly connect to Assignment elements. Transform elements handle collection manipulation in bulk operations, providing significant performance improvements over iterative loop-assignment patterns.  
-**Rule ID:** `transform-instead-of-loop`  
+Detects Loop elements that directly connect to Assignment elements. Transform elements handle collection manipulation in bulk operations, providing significant performance improvements over iterative loop-assignment patterns.
+
+**Rule ID:** `transform-instead-of-loop`
+**Class Name:** _[TransformInsteadOfLoop](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/TransformInsteadOfLoop.ts)_
 **Severity:** 🔵 *Note*
 
-### Unreachable Element  
-_[UnconnectedElement](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnconnectedElement.ts)_ – Avoid unconnected elements that are not used by the flow to keep flows efficient and maintainable.  
-**Rule ID:** `unreachable-element`  
+### Unclear API Name
+Maintaining multiple elements with a similar name, like `Copy_X_Of_Element`, can diminish the overall readability of your Flow. When copying and pasting these elements, remember to update the API name of the newly created copy.
+
+**Rule ID:** `unclear-api-naming`
+**Class Name:** _[CopyAPIName](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/CopyAPIName.ts)_
 **Severity:** 🟡 *Warning*
 
-### Unsafe Running Context  
-_[UnsafeRunningContext](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnsafeRunningContext.ts)_ – This flow is configured to run in **System Mode without Sharing**, granting all users permission to view and edit all data. This can lead to unsafe data access.  
-**Rule ID:** `unsafe-running-context`  
+### Unreachable Element
+Avoid unconnected elements that are not used by the flow to keep flows efficient and maintainable.
+
+**Rule ID:** `unreachable-element`
+**Class Name:** _[UnconnectedElement](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnconnectedElement.ts)_
+**Severity:** 🟡 *Warning*
+
+### Unsafe Running Context
+This flow is configured to run in System Mode without Sharing. This system context grants all running users the permission to view and edit all data in your org. Running a flow in System Mode without Sharing can lead to unsafe data access.
+
+**Rule ID:** `unsafe-running-context`
+**Class Name:** _[UnsafeRunningContext](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnsafeRunningContext.ts)_
 **Severity:** 🔴 *Error*
 
-### Unused Variable  
-_[UnusedVariable](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnusedVariable.ts)_ – To maintain efficiency and manageability, avoid including variables that are never referenced.  
-**Rule ID:** `unused-variable`  
+### Unused Variable
+To maintain efficiency and manageability, avoid including variables that are never referenced.
+
+**Rule ID:** `unused-variable`
+**Class Name:** _[UnusedVariable](https://github.com/Flow-Scanner/lightning-flow-scanner/blob/main/packages/core/src/main/rules/UnusedVariable.ts)_
 **Severity:** 🟡 *Warning*
+<!-- END GENERATED_RULES -->
 
 ---
 
@@ -196,6 +253,7 @@ It is recommend to configure and define:
 - The severity of violating any specific rule.
 - Expressions used for rules, such as REGEX patterns and comparison operators.
 - Any known exceptions that should be ignored during scanning.
+- Flows or directories to exclude from scanning entirely.
 
 ```json
 {
@@ -290,6 +348,48 @@ _Example_
 }
 ```
 
+### Exclude Flows from Scanning
+
+Lightning Flow Scanner provides two complementary ways to exclude flows from scanning:
+
+#### Exclude by File Path (Node.js only)
+
+Use glob patterns to exclude flows based on their file system location. This is useful for excluding entire directories or specific file patterns during the flow discovery phase:
+
+```json
+{
+  "ignore": [
+    "**/testing/**",
+    "**/*_Deprecated.flow-meta.xml"
+  ]
+}
+```
+
+**Note**: The `ignore` option uses glob patterns and applies during file discovery before flows are parsed. This is the most efficient way to exclude large numbers of flows.
+
+**Environment compatibility**: `ignore` requires Node.js (file system access) and is available in CLI Plugin, VS Code Extension, and GitHub Action. It is **not** available when using the Core Library in browser/web environments.
+
+#### Exclude by Flow API Name (Browser-compatible)
+
+Exclude specific flows by their unique API names, regardless of their location. This is particularly useful for:
+- Excluding specific flows without knowing their exact file path
+- Working with metadata API deployments where directory structures may vary
+- More precise control than path-based patterns
+
+```json
+{
+  "ignoreFlows": [
+    "My_Legacy_Flow",
+    "Temporary_Test_Flow",
+    "Deprecated_Process_Builder"
+  ]
+}
+```
+
+**Note**: The `ignoreFlows` option applies after flows are parsed, using the flow's API name (the `<fullName>` element in the flow metadata). Flow names are unique identifiers and work regardless of the flow's file system location.
+
+**Environment compatibility**: `ignoreFlows` works in **all environments** including Node.js and browser/web distributions, as it operates on parsed flow data rather than file system paths.
+
 ### Scan Modes
 
 #### Beta Mode
@@ -326,7 +426,7 @@ By default, Lightning Flow Scanner runs **all** default rules and merges any cus
 **Privacy:** Zero user data collected. All processing is client-side. → See our [Security Policy](https://github.com/Flow-Scanner/lightning-flow-scanner?tab=security-ov-file).
 
 ### CICD Templates
-Ready-to-use CI/CD templates and a **Copado Plugin**.  
+Ready-to-use CI/CD templates and a **Copado Plugin**.
 
 | Platform       | Type                     | Link |
 |----------------|-----------------------------------|------|
@@ -369,6 +469,8 @@ Add a GitHub workflow file `.github/workflows/scan-flows.yml` to detect issues d
 - name: Lightning Flow Scan
   id: flowscanner
   uses: Flow-Scanner/lightning-flow-scanner@main
+  with:
+    sarif-only: true  # Strict mode for PRs
 
 - name: Upload SARIF to Code Scanning
   uses: github/codeql-action/upload-sarif@v3
@@ -388,12 +490,12 @@ parse("flows/*.xml").then(scan);
 
 // Get SARIF output (e.g. for GitHub Code Scanning)
 import { parse, scan, exportSarif } from "@flow-scanner/lightning-flow-scanner-core";
-parse("flows/**/*.flow-meta.xml").then(scan).then(exportSarif) 
+parse("flows/**/*.flow-meta.xml").then(scan).then(exportSarif)
   // .then(sarif => fs.writeFile("results.sarif", sarif))
 
 // Generate Markdown documentation with Mermaid flow diagrams
 import { parse, exportDiagram } from "@flow-scanner/lightning-flow-scanner-core";
-parse("flows/**/*.flow-meta.xml").then(exportDiagram) 
+parse("flows/**/*.flow-meta.xml").then(exportDiagram)
   // .then(md => fs.writeFile("flow-docs.md", md))
 
 // Browser Usage (Tooling API)
@@ -413,13 +515,13 @@ For more on Programmatic API, types, and advanced usage of `@flow-scanner/lightn
 
 > This project optionally uses [Volta](https://volta.sh) to guarantee the exact same Node.js and tool versions for every contributor.
 >
-> MacOs/Linux: 
+> MacOs/Linux:
 > ```sh
 > curl https://get.volta.sh | bash
 > ```
 > Windows:
 > ```sh
-> winget install Volta.Volta 
+> winget install Volta.Volta
 > ```
 > Volta will automatically install and lock the tool versions defined in `package.json`.
 
@@ -443,18 +545,18 @@ For more on Programmatic API, types, and advanced usage of `@flow-scanner/lightn
 
    To compile just the core package::
    ```bash
-   pnpm build:core 
+   pnpm build:core
    ```
 
 4. Run tests:
 
    ```bash
-   pnpm test 
+   pnpm test
    ```
 
     Or to test a new version of the core:
     ```bash
-    pnpm test:core 
+    pnpm test:core
     ```
 
 5. Linking the core module locally(Optional):

package/main/interfaces/IRulesConfig.d.ts

@@ -11,4 +11,5 @@ export interface IRulesConfig {
     exceptions?: IExceptions;
     rules?: IRuleOptions;
     ruleMode?: "merged" | "isolated";
+    ignoreFlows?: string[];
 }

package/main/libs/ScanFlows.js

@@ -37,8 +37,13 @@ function getSuppressionsForRule(rule, flowName, exceptions) {
 }
 function scan(parsedFlows, ruleOptions) {
     const flows = [];
+    const ignoreFlows = (ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.ignoreFlows) || [];
     for (const flow of parsedFlows){
         if (!flow.errorMessage && flow.flow) {
+            // Filter out flows whose names are in the ignore list
+            if (ignoreFlows.length > 0 && ignoreFlows.includes(flow.flow.name)) {
+                continue;
+            }
             flows.push(flow.flow);
         }
     }

package/main/rules/APIVersion.js

@@ -116,7 +116,7 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
             ruleId: "invalid-api-version",
             name: "APIVersion",
             label: "Invalid API Version",
-            description: "Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the 'Api Version' attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.",
+            description: "Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the **Api Version** attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/ActionCallsInLoop.js

@@ -20,14 +20,14 @@ let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRule
     constructor(){
         super({
             ruleId: "action-call-in-loop",
-            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilize a single action call containing a collection variable at the end of the loop.",
+            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.",
             docRefs: [
                 {
-                    label: "Invocable Method Considerations",
+                    label: "Action Call In A Loop",
                     path: "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableMethod.htm"
                 }
             ],
-            label: "Action Call In Loop",
+            label: "Action Call In A Loop",
             name: "ActionCallsInLoop",
             supportedTypes: _internals.FlowType.backEndTypes
         }, {

package/main/rules/AutoLayout.js

@@ -67,8 +67,8 @@ let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
         super({
             ruleId: "missing-auto-layout",
             name: "AutoLayout",
-            label: "Auto-Layout Mode",
-            description: "With Canvas Mode set to Auto-Layout, Elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized thus saving you time.",
+            label: "Missing Auto Layout",
+            description: "With Canvas Mode set to Auto-Layout, elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized—saving you time.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         }, {

package/main/rules/CopyAPIName.js

@@ -62,7 +62,7 @@ let CopyAPIName = class CopyAPIName extends _RuleCommon.RuleCommon {
             ruleId: "unclear-api-naming",
             name: "CopyAPIName",
             label: "Unclear API Name",
-            description: "Maintaining multiple elements with a similar name, like 'Copy_X_Of_Element,' can diminish the overall readability of your Flow. When copying and pasting these elements, it's crucial to remember to update the API name of the newly created copy.",
+            description: "Maintaining multiple elements with a similar name, like `Copy_X_Of_Element`, can diminish the overall readability of your Flow. When copying and pasting these elements, remember to update the API name of the newly created copy.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/DMLStatementInLoop.js

@@ -21,7 +21,7 @@ let DMLStatementInLoop = class DMLStatementInLoop extends _LoopRuleCommon.LoopRu
     constructor(){
         super({
             ruleId: "dml-in-loop",
-            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your database operations, including record creation, updates, or deletions, at the conclusion of the flow.",
+            description: "To prevent exceeding Apex governor limits, consolidate all your database operations—record creation, updates, or deletions—at the conclusion of the flow.",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/DuplicateDMLOperation.js

@@ -97,7 +97,7 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
             ruleId: "duplicate-dml",
             name: "DuplicateDMLOperation",
             label: "Duplicate DML Operation",
-            description: "When the flow executes database changes between screens, users must not be allowed to navigate back, or duplicate DML operations may occur.",
+            description: "When a flow executes database changes or actions between two screens, prevent users from navigating backward between screens; otherwise, duplicate database operations may be performed.",
             supportedTypes: _internals.FlowType.visualTypes,
             docRefs: []
         });

package/main/rules/FlowDescription.js

@@ -64,7 +64,7 @@ let FlowDescription = class FlowDescription extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "missing-flow-description",
-            description: "Descriptions play a vital role in documentation. We highly recommend including details about where they are used and their intended purpose.",
+            description: "Descriptions play a vital role in documentation. It is highly recommended to include details about where a flow is used and its intended purpose.",
             docRefs: [],
             label: "Missing Flow Description",
             name: "FlowDescription",

package/main/rules/FlowName.js

@@ -67,7 +67,7 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "invalid-naming-convention",
-            description: "The readability of a flow is of utmost importance. Establishing a naming convention for the Flow Name significantly enhances findability, searchability, and maintains overall consistency. It is advisable to include at least a domain and a brief description of the actions carried out in the flow, for instance, 'Service_OrderFulfillment'.",
+            description: "The readability of a flow is paramount. Establishing a naming convention significantly enhances findability, searchability, and overall consistency. Include at least a domain and a brief description of the flow’s actions, for example `Service_OrderFulfillment`.",
             docRefs: [
                 {
                     label: "Naming your Flows is more critical than ever. By Stephen Church",

package/main/rules/GetRecordAllFields.js

@@ -69,10 +69,10 @@ let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon
     constructor(){
         super({
             ruleId: "get-record-all-fields",
-            description: "Following the principle of least privilege (PoLP), avoid using Get Records with 'Automatically store all fields' unless necessary.",
+            description: "Following the principle of least privilege (PoLP), avoid using **Get Records** with “Automatically store all fields” unless necessary.",
             docRefs: [
                 {
-                    label: "SOQL and SOSL | Best Practices for Deployments with Large Data Volumes",
+                    label: "Get Records Stores All Fields",
                     path: "https://developer.salesforce.com/docs/atlas.en-us.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_best_practices_soql_and_sosl.htm"
                 },
                 {

package/main/rules/HardcodedId.js

@@ -61,7 +61,7 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
             ruleId: "hardcoded-id",
             name: "HardcodedId",
             label: "Hardcoded Id",
-            description: "Avoid hard-coding IDs as they are org-specific. Instead, pass them into variables at the start of the flow. You can achieve this by utilizing merge fields in URL parameters or employing a Get Records element.",
+            description: "Avoid hard-coding IDs because they are org specific. Instead, pass them into variables at the start of the flow—via merge-field URL parameters or a **Get Records** element.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: [
                 {

package/main/rules/HardcodedUrl.js

@@ -19,7 +19,7 @@ let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "hardcoded-url",
-            description: "Avoid hard-coding URLs as they are org-specific. Instead, use a $API formula (preferred) or you can use an environment-specific such as custom labels, custom metadata, or custom settings.",
+            description: "Avoid hard-coding URLs because they are environment specific. Use an `$API` formula (preferred) or environment-specific sources like custom labels, metadata, or settings.",
             docRefs: [
                 {
                     label: "The Ultimate Guide to Salesforce Flow Best Practices",

package/main/rules/InactiveFlow.js

@@ -65,7 +65,7 @@ let InactiveFlow = class InactiveFlow extends _RuleCommon.RuleCommon {
             ruleId: "inactive-flow",
             name: "InactiveFlow",
             label: "Inactive Flow",
-            description: "Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble, like accidentally deleting records during testing, or being activated as subflows within parent flows.",
+            description: "Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble—such as accidentally deleting records during testing, or being activated as subflows.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/MissingFaultPath.js

@@ -127,7 +127,7 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "missing-fault-path",
-            description: "At times, a flow may fail to execute a configured operation as intended. By default, the flow displays an error message to the user and notifies the admin who created the flow via email. However, you can customize this behavior by incorporating a Fault Path. This rule checks DML operations, actions (Send Email, Quick Actions), and Invocable Apex Actions for proper error handling.",
+            description: "A flow may fail to execute an operation as intended. By default, the flow displays an error to the user and emails the creator. Customize this behavior by incorporating a Fault Path.",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/MissingMetadataDescription.js

@@ -66,7 +66,7 @@ let MissingMetadataDescription = class MissingMetadataDescription extends _RuleC
     constructor(){
         super({
             ruleId: "missing-metadata-description",
-            description: "Every element must have a meaningful description",
+            description: "Flags Flow elements (Get Records, Assignments, Decisions, Actions, etc.) and metadata components (Variables, Formulas, Constants, Text Templates) that lack a description. Adding concise descriptions greatly improves readability, maintainability, and helps AI tools understand your automation intent.",
             docRefs: [],
             label: "Missing Metadata Description",
             name: "MissingMetadataDescription",

package/main/rules/MissingNullHandler.js

@@ -138,7 +138,7 @@ let MissingNullHandler = class MissingNullHandler extends _RuleCommon.RuleCommon
     constructor(){
         super({
             ruleId: "missing-null-handler",
-            description: "When a Get Records operation doesn't find any data, it returns null. To ensure data validation, utilize a decision element on the operation result variable to check for a non-null result.",
+            description: "When a **Get Records** operation finds no data, it returns `null`. Validate data by using a Decision element to check for a non-null result.",
             docRefs: [],
             label: "Missing Null Handler",
             name: "MissingNullHandler",

package/main/rules/MissingRecordTriggerFilter.js

@@ -79,12 +79,14 @@ let MissingRecordTriggerFilter = class MissingRecordTriggerFilter extends _RuleC
         super({
             ruleId: "missing-record-trigger-filter",
             name: "MissingRecordTriggerFilter",
-            label: "Missing Record Trigger Filter",
-            description: "Detects record-triggered flows that lack filters on changed fields or entry conditions, leading to unnecessary executions on every record change. This can degrade system performance, hit governor limits faster, and increase resource consumption in high-volume orgs.",
+            label: "Missing Filter Record Trigger",
+            description: "Record-triggered flows that lack filters on changed fields or entry conditions can lead to unnecessary executions on every record change. This may degrade system performance, hit governor limits faster, and increase resource consumption in high-volume orgs.",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],
             docRefs: []
+        }, {
+            severity: "warning"
         });
     }
 };

package/main/rules/ProcessBuilder.js

@@ -61,8 +61,8 @@ let ProcessBuilder = class ProcessBuilder extends _RuleCommon.RuleCommon {
         super({
             ruleId: "process-builder-usage",
             name: "ProcessBuilder",
-            label: "Process Builder Usage",
-            description: "Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Ensure you're prepared for this transition by migrating your organization's automation to Flow. Refer to official documentation for more information on the transition process and tools available.",
+            label: "Process Builder",
+            description: "Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Begin migrating your organization’s automation to Flow.",
             supportedTypes: _internals.FlowType.processBuilder,
             docRefs: [
                 {

package/main/rules/RecordIdAsString.js

@@ -75,8 +75,8 @@ let RecordIdAsString = class RecordIdAsString extends _RuleCommon.RuleCommon {
         super({
             ruleId: "record-id-as-string",
             name: "RecordIdAsString",
-            label: "Record ID as String Instead of Record",
-            description: "Detects flows using a String variable named 'recordId' as input when they could receive the entire record object instead. Since recent Salesforce releases, record pages and quick actions can pass the complete record, eliminating the need for an additional Get Records query and improving performance.",
+            label: "Record ID as String",
+            description: "Detects flows using a String variable named `recordId` as input when they could receive the entire record object instead. Since recent Salesforce releases, record pages and quick actions can pass the complete record, eliminating the need for an additional Get Records query and improving performance.",
             supportedTypes: [
                 ..._internals.FlowType.visualTypes,
                 _internals.FlowType.autolaunchedType

package/main/rules/RecursiveAfterUpdate.js

@@ -105,7 +105,7 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
     constructor(){
         super({
             ruleId: "recursive-record-update",
-            description: "After updates are meant to be used for record modifications that are not the same record that triggered the flow. Using after updates on the same record can lead to recursion and unexpected behavior. Consider using before save flows for same record updates.",
+            description: "After-update flows are meant for modifying **other** records. Using them on the same record can cause recursion. Consider **before-save** flows for same-record updates.",
             docRefs: [
                 {
                     label: "Learn about same record field updates",

package/main/rules/SOQLQueryInLoop.js

@@ -19,7 +19,7 @@ let SOQLQueryInLoop = class SOQLQueryInLoop extends _LoopRuleCommon.LoopRuleComm
     constructor(){
         super({
             ruleId: "soql-in-loop",
-            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your SOQL queries at the conclusion of the flow.",
+            description: "To prevent exceeding Apex governor limits, consolidate all SOQL queries at the end of the flow.",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/SameRecordFieldUpdates.js

@@ -89,7 +89,7 @@ let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.Ru
             ruleId: "same-record-field-updates",
             name: "SameRecordFieldUpdates",
             label: "Same Record Field Updates",
-            description: "Before-save same-record field updates allows you to update the record using variable assignments to `$Record`. This is significantly faster than doing another DML on the same-record that triggered the flow",
+            description: "Similar to triggers, **before-save** contexts can update the same record via `$Record` without invoking DML.",
             supportedTypes: [
                 ..._internals.FlowType.backEndTypes
             ],

package/main/rules/TransformInsteadOfLoop.js

@@ -79,7 +79,7 @@ let TransformInsteadOfLoop = class TransformInsteadOfLoop extends _RuleCommon.Ru
             ruleId: "transform-instead-of-loop",
             name: "TransformInsteadOfLoop",
             label: "Transform Instead of Loop",
-            description: "Detects Loop elements that directly connect to Assignment elements. This pattern can often be replaced with the Transform element, which is on average 10x more performant according to Salesforce documentation.",
+            description: "Detects Loop elements that directly connect to Assignment elements. Transform elements handle collection manipulation in bulk operations, providing significant performance improvements over iterative loop-assignment patterns.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: [
                 {

package/main/rules/TriggerOrder.js

@@ -70,8 +70,8 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
         super({
             ruleId: "unspecified-trigger-order",
             name: "TriggerOrder",
-            label: "Trigger Order",
-            description: "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority " + "value to their flows and guarantee their execution order. This priority value is not an " + "absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
+            label: "Missing Trigger Order",
+            description: "Guarantee your flow execution order with the **Trigger Order** property introduced in Spring '22." + "value to their flows and guarantee their execution order. This priority value is not an " + "absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],

package/main/rules/UnconnectedElement.js

@@ -62,7 +62,7 @@ let UnconnectedElement = class UnconnectedElement extends _RuleCommon.RuleCommon
     constructor(){
         super({
             ruleId: "unreachable-element",
-            description: "To maintain the efficiency and manageability of your Flow, it's best to avoid including unconnected elements that are not in use.",
+            description: "Avoid unconnected elements that are not used by the flow to keep flows efficient and maintainable.",
             docRefs: [],
             label: "Unreachable Element",
             name: "UnconnectedElement",

package/main/rules/UnusedVariable.js

@@ -82,7 +82,7 @@ let UnusedVariable = class UnusedVariable extends _RuleCommon.RuleCommon {
             ruleId: "unused-variable",
             name: "UnusedVariable",
             label: "Unused Variable",
-            description: "To maintain the efficiency and manageability of your Flow, it's advisable to avoid including unconnected variables that are not in use.",
+            description: "To maintain efficiency and manageability, avoid including variables that are never referenced.",
             supportedTypes: [
                 ..._internals.FlowType.backEndTypes,
                 ..._internals.FlowType.visualTypes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flow-scanner/lightning-flow-scanner-core",
   "description": "A lightweight engine for Flow metadata in Node.js, and browser environments. Assess and enhance Salesforce Flow automations for best practices, security, governor limits, and performance issues.",
-  "version": "6.13.1",
+  "version": "6.14.0",
   "main": "index.js",
   "exports": {
     ".": {