@flow-scanner/lightning-flow-scanner-core 6.15.0 → 6.15.1

package/README.md

@@ -53,195 +53,195 @@
 
 > 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
-Repeatedly invoking Apex actions inside a loop can exhaust governor limits and lead to performance issues. Where possible, bulkify your logic by moving the action call outside the loop and passing a collection variable instead.
-
-**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:** 🟡 *Warning*
-
-### DML Statement In A Loop
-Executing DML operations (insert, update, delete) inside a loop is a high-risk anti-pattern that frequently causes governor limit exceptions. All database operations should be collected and executed once, outside the loop.
-
-**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*
-
-### Duplicate DML Operation
-When a Flow performs database operations across multiple screens, users navigating backward can cause the same actions to run multiple times. To prevent unintended changes, either restrict backward navigation or redesign the Flow so database operations execute in a single, forward-moving step.
-
-**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
-High numbers of loops and decision elements increase a Flow’s cyclomatic complexity. To maintain simplicity and readability, consider using subflows or splitting a Flow into smaller, ordered Flows.
-
-**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*
-
-### Flow Naming Convention
-Using clear and consistent Flow names improves readability, discoverability, and maintainability. A good naming convention helps team members quickly understand a Flow’s purpose—for example, including a domain and brief description like Service_OrderFulfillment. Adopt a naming pattern that aligns with your organization’s standards.
-
-**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*
-
-### Get Record All Fields
-Avoid using Get Records to retrieve all fields unless necessary. This improves performance, reduces processing time, and limits exposure of unnecessary data.
-
-**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*
-
-### Hardcoded Id
-Avoid hard-coding record IDs, as they are unique to a specific org and will not work in other environments. Instead, store IDs in variables—such as merge-field URL parameters or a **Get Records** element—to make the Flow portable, maintainable, and flexible.
-
-**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*
-
-### Hardcoded Url
-Avoid hard-coding URLs, as they may change between environments or over time. Instead, store URLs in variables or custom settings to make the Flow adaptable, maintainable, and environment-independent.
-
-**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*
-
-### Inactive Flow
-Inactive Flows should be deleted or archived to reduce risk. Even when inactive, they can cause unintended record changes during testing or be activated as subflows. Keeping only active, relevant Flows improves safety and maintainability.
-
-**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
-Flows running on outdated API versions may behave inconsistently when newer platform features or components are used. From API version 50.0 onward, the API Version attribute explicitly controls Flow runtime behavior. Keeping Flows aligned with a supported API version helps prevent compatibility issues and ensures predictable execution.
-
-**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
-Auto-Layout automatically arranges and aligns Flow elements, keeping the canvas organized and easier to maintain. Enabling it saves time and improves readability.
-
-**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
-Elements that can fail should include a Fault Path to handle errors gracefully. Without it, failures show generic errors to users. Fault Paths improve reliability and user experience.
-
-**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)
-Record-triggered Flows without filters on changed fields or entry conditions execute on every record change. Adding filters ensures the Flow runs only when needed, improving performance.
-
-**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
-Flow descriptions are essential for documentation and maintainability. Include a description for each Flow, explaining its purpose and where it’s used.
-
-**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)
-Elements and metadata without a description reduce clarity and maintainability. Adding descriptions improves readability and makes your automation easier to understand.
-
-**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:** 🟡 *Warning*
-
-### Missing Null Handler
-Get Records operations return null when no data is found. Without handling these null values, Flows can fail or produce unintended results. Adding a null check improves reliability and ensures the Flow behaves as expected.
-
-**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
-Record-triggered Flows without a specified Trigger Order may execute in an unpredictable sequence. Setting a Trigger Order ensures your Flows run in the intended order.
-
-**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
-Process Builder is retired. Continuing to use it increases maintenance overhead and risks future compatibility issues. Migrating automation to Flow reduces risk and improves maintainability.
-
-**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:** 🔴 *Error*
-
-### Record ID as String ![Beta](https://img.shields.io/badge/status-beta-yellow)
-Flows that use a String variable for a record ID instead of receiving the full record introduce unnecessary complexity and additional Get Records queries. Using the complete record simplifies the Flow and improves 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:** 🔵 *Note*
-
-### Recursive After Update
-After-save Flows that update the same record can trigger recursion, causing unintended behavior or performance issues. Avoid updating the triggering record in after-save Flows; use before-save Flows instead to prevent recursion.
-
-**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
-Before-save Flows can safely update the triggering record directly via $Record, applying changes efficiently without extra DML operations. Using before-save updates improves performance
-
-**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
-Running SOQL queries inside a loop can rapidly exceed query limits and severely degrade performance. Queries should be executed once, with results reused throughout the loop.
-
-**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)
-Loop elements that perform direct Assignments on each item can slow down Flows. Using Transform elements allows bulk operations on collections, improving performance and reducing complexity.
-
-**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*
-
-### Unclear API Name
-Elements with unclear or duplicated API names, like Copy_X_Of_Element, reduce Flow readability. Make sure to update the API name when copying elements to keep your Flow organized.
-
-**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*
-
-### Unreachable Element
-Unconnected elements never execute and add unnecessary clutter. Remove or connect unused Flow elements to keep Flows clean and efficient.
-
-**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
-Flows configured to run in System Mode without Sharing grant access to all data, bypassing user permissions. Avoid this setting to prevent security risks and protect sensitive data.
-
-**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
-Unused variables are never referenced and add unnecessary clutter. Remove them to keep Flows efficient and easy to maintain.
-
-**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*
+<!-- START GENERATED_RULES -->
+### Action Call In A Loop
+Repeatedly invoking Apex actions inside a loop can exhaust governor limits and lead to performance issues. Where possible, bulkify your logic by moving the action call outside the loop and passing a collection variable instead.
+
+**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:** 🟡 *Warning*
+
+### DML Statement In A Loop
+Executing DML operations (insert, update, delete) inside a loop is a high-risk anti-pattern that frequently causes governor limit exceptions. All database operations should be collected and executed once, outside the loop.
+
+**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*
+
+### Duplicate DML Operation
+When a Flow performs database operations across multiple screens, users navigating backward can cause the same actions to run multiple times. To prevent unintended changes, either restrict backward navigation or redesign the Flow so database operations execute in a single, forward-moving step.
+
+**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
+High numbers of loops and decision elements increase a Flow’s cyclomatic complexity. To maintain simplicity and readability, consider using subflows or splitting a Flow into smaller, ordered Flows.
+
+**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*
+
+### Flow Naming Convention
+Using clear and consistent Flow names improves readability, discoverability, and maintainability. A good naming convention helps team members quickly understand a Flow’s purpose—for example, including a domain and brief description like Service_OrderFulfillment. Adopt a naming pattern that aligns with your organization’s standards.
+
+**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*
+
+### Get Record All Fields
+Avoid using Get Records to retrieve all fields unless necessary. This improves performance, reduces processing time, and limits exposure of unnecessary data.
+
+**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*
+
+### Hardcoded Id
+Avoid hard-coding record IDs, as they are unique to a specific org and will not work in other environments. Instead, store IDs in variables—such as merge-field URL parameters or a **Get Records** element—to make the Flow portable, maintainable, and flexible.
+
+**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*
+
+### Hardcoded Url
+Avoid hard-coding URLs, as they may change between environments or over time. Instead, store URLs in variables or custom settings to make the Flow adaptable, maintainable, and environment-independent.
+
+**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*
+
+### Inactive Flow
+Inactive Flows should be deleted or archived to reduce risk. Even when inactive, they can cause unintended record changes during testing or be activated as subflows. Keeping only active, relevant Flows improves safety and maintainability.
+
+**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
+Flows running on outdated API versions may behave inconsistently when newer platform features or components are used. From API version 50.0 onward, the API Version attribute explicitly controls Flow runtime behavior. Keeping Flows aligned with a supported API version helps prevent compatibility issues and ensures predictable execution.
+
+**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
+Auto-Layout automatically arranges and aligns Flow elements, keeping the canvas organized and easier to maintain. Enabling it saves time and improves readability.
+
+**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
+Elements that can fail should include a Fault Path to handle errors gracefully. Without it, failures show generic errors to users. Fault Paths improve reliability and user experience.
+
+**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)
+Record-triggered Flows without filters on changed fields or entry conditions execute on every record change. Adding filters ensures the Flow runs only when needed, improving performance.
+
+**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
+Flow descriptions are essential for documentation and maintainability. Include a description for each Flow, explaining its purpose and where it’s used.
+
+**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)
+Elements and metadata without a description reduce clarity and maintainability. Adding descriptions improves readability and makes your automation easier to understand.
+
+**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:** 🟡 *Warning*
+
+### Missing Null Handler
+Get Records operations return null when no data is found. Without handling these null values, Flows can fail or produce unintended results. Adding a null check improves reliability and ensures the Flow behaves as expected.
+
+**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
+Record-triggered Flows without a specified Trigger Order may execute in an unpredictable sequence. Setting a Trigger Order ensures your Flows run in the intended order.
+
+**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
+Process Builder is retired. Continuing to use it increases maintenance overhead and risks future compatibility issues. Migrating automation to Flow reduces risk and improves maintainability.
+
+**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:** 🔴 *Error*
+
+### Record ID as String ![Beta](https://img.shields.io/badge/status-beta-yellow)
+Flows that use a String variable for a record ID instead of receiving the full record introduce unnecessary complexity and additional Get Records queries. Using the complete record simplifies the Flow and improves 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:** 🔵 *Note*
+
+### Recursive After Update
+After-save Flows that update the same record can trigger recursion, causing unintended behavior or performance issues. Avoid updating the triggering record in after-save Flows; use before-save Flows instead to prevent recursion.
+
+**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
+Before-save Flows can safely update the triggering record directly via $Record, applying changes efficiently without extra DML operations. Using before-save updates improves performance
+
+**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
+Running SOQL queries inside a loop can rapidly exceed query limits and severely degrade performance. Queries should be executed once, with results reused throughout the loop.
+
+**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)
+Loop elements that perform direct Assignments on each item can slow down Flows. Using Transform elements allows bulk operations on collections, improving performance and reducing complexity.
+
+**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*
+
+### Unclear API Name
+Elements with unclear or duplicated API names, like Copy_X_Of_Element, reduce Flow readability. Make sure to update the API name when copying elements to keep your Flow organized.
+
+**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*
+
+### Unreachable Element
+Unconnected elements never execute and add unnecessary clutter. Remove or connect unused Flow elements to keep Flows clean and efficient.
+
+**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
+Flows configured to run in System Mode without Sharing grant access to all data, bypassing user permissions. Avoid this setting to prevent security risks and protect sensitive data.
+
+**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
+Unused variables are never referenced and add unnecessary clutter. Remove them to keep Flows efficient and easy to maintain.
+
+**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 -->
 
 ---
@@ -278,6 +278,7 @@ By default, all default rules are executed. You can customize individual rules a
       "severity": "<Severity>", // Override severity level
       "expression": "<Expression>", // Override rule expression
       "message": "<Message>", // Set custom message
+      "messageUrl": "<URL>", // Set custom documentation URL
       "enabled": false  // Disable this rule
     }
   }
@@ -299,6 +300,19 @@ When the severity is not provided it will be `warning` by default. Other availab
 }
 ```
 
+If not provided, `message` shows the standard rule summary and `messageUrl` links to the README; providing either overrides the default behavior.
+
+```json
+{
+  "rules": {
+    "dml-in-loop": {
+      "message": "Avoid DML inside loops. Bulkify operations instead.",
+      "messageUrl": "https://internal.docs.company.com/salesforce/flow-dml-best-practices"
+    }
+  }
+}
+```
+
 ### Overwrite Expressions
 
 Some rules are configurable and allow overriding their default expressions. You configure these overrides the same way as severity, as shown in the examples below.

package/main/interfaces/IRuleConfig.d.ts

@@ -1,4 +1,6 @@
 export interface IRuleConfig {
     enabled?: boolean;
     severity?: "error" | "warning" | "note";
+    message?: string;
+    messageUrl?: string;
 }

package/main/interfaces/IRuleDefinition.d.ts

@@ -2,6 +2,7 @@ import { Flow, RuleResult } from "../internals/internals";
 export interface IRuleDefinition {
     ruleId: string;
     description: string;
+    summary: string;
     docRefs: Array<{
         label: string;
         path: string;

package/main/libs/ExportDetails.js

@@ -106,9 +106,11 @@ function exportDetails(results, includeDetails = false) {
                 const exported = _object_spread_props(_object_spread({}, base), {
                     flowFile,
                     flowName,
+                    ruleId: rule.ruleId,
                     ruleName: rule.ruleName,
                     severity: (_rule_severity = rule.severity) !== null && _rule_severity !== void 0 ? _rule_severity : "warning",
-                    message: rule.message || rule.ruleDefinition.description
+                    message: rule.message || rule.ruleDefinition.description,
+                    messageUrl: rule.messageUrl
                 });
                 // Flatten details object into top-level properties if includeDetails is true
                 if (includeDetails && details) {

package/main/libs/ExportSarif.js

@@ -63,14 +63,14 @@ function exportSarif(results) {
                             }
                         ],
                         message: {
-                            text: r.errorMessage || (r.message || r.ruleDefinition.description ? `${r.message || r.ruleDefinition.description} (${d.name})` : `${r.ruleName} in ${d.name}`)
+                            text: r.errorMessage || (r.message || r.ruleDefinition.description ? `${r.message || r.ruleDefinition.description} (${d.name})` : `${r.ruleId} in ${d.name}`)
                         },
                         properties: _object_spread({
                             element: d.name,
                             flow: flow.name,
                             type: d.type
                         }, d.details),
-                        ruleId: r.ruleName
+                        ruleId: r.ruleId
                     }))),
             tool: {
                 driver: {
@@ -83,9 +83,9 @@ function exportSarif(results) {
                             fullDescription: {
                                 text: r.message || r.ruleDefinition.description || ""
                             },
-                            id: r.ruleName,
+                            id: r.ruleId,
                             shortDescription: {
-                                text: r.message || r.ruleDefinition.description || r.ruleName
+                                text: r.message || r.ruleDefinition.description || r.ruleId
                             }
                         })),
                     version: "1.0.0"

package/main/libs/RuleDocumentation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a rule label to a documentation URL anchor.
+ *
+ * Rules:
+ * - Lowercase
+ * - Spaces → hyphens
+ * - Remove special characters and badges
+ *
+ * @param label - The rule display label (e.g., "DML Statement In A Loop")
+ * @returns The anchor slug (e.g., "dml-statement-in-a-loop")
+ */
+export declare function labelToAnchor(label: string): string;
+/**
+ * Generates a documentation URL for a rule.
+ *
+ * @param label - The rule display label
+ * @param customUrl - Optional custom URL override
+ * @returns The documentation URL
+ */
+export declare function getRuleDocumentationUrl(label: string, customUrl?: string): string;

package/main/libs/RuleDocumentation.js

@@ -0,0 +1,41 @@
+/**
+ * Converts a rule label to a documentation URL anchor.
+ *
+ * Rules:
+ * - Lowercase
+ * - Spaces → hyphens
+ * - Remove special characters and badges
+ *
+ * @param label - The rule display label (e.g., "DML Statement In A Loop")
+ * @returns The anchor slug (e.g., "dml-statement-in-a-loop")
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getRuleDocumentationUrl () {
+        return getRuleDocumentationUrl;
+    },
+    get labelToAnchor () {
+        return labelToAnchor;
+    }
+});
+function labelToAnchor(label) {
+    return label.toLowerCase().replace(/\s+/g, '-') // Replace spaces with hyphens
+    .replace(/[^a-z0-9-]/g, '') // Remove non-alphanumeric except hyphens
+    .replace(/-+/g, '-') // Collapse multiple hyphens
+    .replace(/^-|-$/g, ''); // Trim leading/trailing hyphens
+}
+function getRuleDocumentationUrl(label, customUrl) {
+    if (customUrl) {
+        return customUrl;
+    }
+    const anchor = labelToAnchor(label);
+    return `https://flow-scanner.github.io/lightning-flow-scanner/#${anchor}`;
+}

package/main/libs/ScanFlows.js

@@ -20,6 +20,7 @@ const _internals = require("../../main/internals/internals");
 const _IRulesConfig = require("../interfaces/IRulesConfig");
 const _Violation = require("../models/Violation");
 const _GetRuleDefinitions = require("./GetRuleDefinitions");
+const _RuleDocumentation = require("./RuleDocumentation");
 function getRuleConfigByIdOrName(rule, rulesConfig) {
     if (!rulesConfig) return undefined;
     // Try ruleId first, then fall back to name
@@ -76,10 +77,16 @@ function ScanFlows(flows, ruleOptions) {
                 const config = getRuleConfigByIdOrName(rule, ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules);
                 const suppressions = getSuppressionsForRule(rule, flow.name, ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.exceptions);
                 const result = config && Object.keys(config).length > 0 ? rule.execute(flow, config, suppressions) : rule.execute(flow, undefined, suppressions);
-                // Apply custom message if provided in config
+                // Apply custom message if provided in config, otherwise use summary
                 if (config && typeof config === 'object' && 'message' in config && typeof config.message === 'string') {
                     result.message = config.message;
+                } else {
+                    // Use summary if available, otherwise fallback to description
+                    result.message = result.ruleDefinition.summary || result.ruleDefinition.description;
                 }
+                // Apply custom messageUrl if provided in config, otherwise auto-generate from rule label
+                const customUrl = config && typeof config === 'object' && 'messageUrl' in config && typeof config.messageUrl === 'string' ? config.messageUrl : undefined;
+                result.messageUrl = (0, _RuleDocumentation.getRuleDocumentationUrl)(result.ruleDefinition.label, customUrl);
                 if (result.details.length > 0) {
                     let flowXml = flowXmlCache.get(flow.name);
                     if (!flowXml) {

package/main/models/FlatViolation.d.ts

@@ -2,9 +2,11 @@ import { Violation } from "./Violation";
 export interface FlatViolation extends Omit<Violation, 'details'> {
     flowFile: string;
     flowName: string;
+    ruleId: string;
     ruleName: string;
     severity: string;
     message?: string;
+    messageUrl?: string;
     dataType?: string;
     locationX?: string;
     locationY?: string;

package/main/models/RuleCommon.d.ts

@@ -2,6 +2,7 @@ import { RuleInfo } from "./RuleInfo";
 import * as core from "../internals/internals";
 export declare abstract class RuleCommon {
     description: string;
+    summary: string;
     docRefs: Array<{
         label: string;
         path: string;

package/main/models/RuleCommon.js

@@ -128,6 +128,7 @@ let RuleCommon = class RuleCommon {
     }
     constructor(info, optional){
         _define_property(this, "description", void 0);
+        _define_property(this, "summary", void 0);
         _define_property(this, "docRefs", []);
         _define_property(this, "isConfigurable", void 0);
         _define_property(this, "label", void 0);
@@ -141,6 +142,7 @@ let RuleCommon = class RuleCommon {
         this.supportedTypes = info.supportedTypes;
         this.label = info.label;
         this.description = info.description;
+        this.summary = info.summary;
         this.uri = `https://github.com/Lightning-Flow-Scanner/lightning-flow-scanner/tree/main/src/main/rules/${info.name}.ts`;
         this.docRefs = info.docRefs;
         const checkImpl = this.check;

package/main/models/RuleInfo.d.ts

@@ -11,6 +11,10 @@ export declare class RuleInfo {
      * A human-readable description of the rule.
      */
     description: string;
+    /**
+     * A short summary (5-10 words) used when no custom message is provided.
+     */
+    summary: string;
     /**
      * An array of documentation references related to the rule.
      */

package/main/models/RuleInfo.js

@@ -27,6 +27,9 @@ let RuleInfo = class RuleInfo {
    * A human-readable description of the rule.
    */ _define_property(this, "description", void 0);
         /**
+   * A short summary (5-10 words) used when no custom message is provided.
+   */ _define_property(this, "summary", void 0);
+        /**
    * An array of documentation references related to the rule.
    */ _define_property(this, "docRefs", void 0);
         /**

package/main/models/RuleResult.d.ts

@@ -3,10 +3,12 @@ import { Violation } from "./Violation";
 export declare class RuleResult {
     occurs: boolean;
     ruleName: string;
+    ruleId: string;
     ruleDefinition: IRuleDefinition;
     severity: string;
     details: Violation[];
     errorMessage: string;
     message?: string;
+    messageUrl?: string;
     constructor(info: IRuleDefinition, details: Violation[], errorMessage?: string);
 }

package/main/models/RuleResult.js

@@ -25,13 +25,16 @@ let RuleResult = class RuleResult {
     constructor(info, details, errorMessage){
         _define_property(this, "occurs", void 0);
         _define_property(this, "ruleName", void 0);
+        _define_property(this, "ruleId", void 0);
         _define_property(this, "ruleDefinition", void 0);
         _define_property(this, "severity", void 0);
         _define_property(this, "details", []);
         _define_property(this, "errorMessage", void 0);
         _define_property(this, "message", void 0); // Custom message that overrides the default rule description
+        _define_property(this, "messageUrl", void 0); // URL to custom documentation (fallback to rule docs if not provided)
         this.ruleDefinition = info;
         this.ruleName = info.name;
+        this.ruleId = info.ruleId;
         this.severity = info.severity ? info.severity : "warning";
         this.occurs = false;
         this.details = details;

package/main/rules/APIVersion.js

@@ -117,6 +117,7 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
             name: "APIVersion",
             label: "Invalid API Version",
             description: "Flows running on outdated API versions may behave inconsistently when newer platform features or components are used. From API version 50.0 onward, the API Version attribute explicitly controls Flow runtime behavior. Keeping Flows aligned with a supported API version helps prevent compatibility issues and ensures predictable execution.",
+            summary: "Outdated API versions risk compatibility issues",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/ActionCallsInLoop.js

@@ -21,6 +21,7 @@ let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRule
         super({
             ruleId: "action-call-in-loop",
             description: "Repeatedly invoking Apex actions inside a loop can exhaust governor limits and lead to performance issues. Where possible, bulkify your logic by moving the action call outside the loop and passing a collection variable instead.",
+            summary: "Action calls inside loop risk governor limits",
             docRefs: [
                 {
                     label: "Action Call In A Loop",

package/main/rules/AutoLayout.js

@@ -69,6 +69,7 @@ let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
             name: "AutoLayout",
             label: "Missing Auto Layout",
             description: "Auto-Layout automatically arranges and aligns Flow elements, keeping the canvas organized and easier to maintain. Enabling it saves time and improves readability.",
+            summary: "Auto-Layout improves canvas organization and readability",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         }, {

package/main/rules/CopyAPIName.js

@@ -63,6 +63,7 @@ let CopyAPIName = class CopyAPIName extends _RuleCommon.RuleCommon {
             name: "CopyAPIName",
             label: "Unclear API Name",
             description: "Elements with unclear or duplicated API names, like Copy_X_Of_Element, reduce Flow readability. Make sure to update the API name when copying elements to keep your Flow organized.",
+            summary: "Duplicated API names reduce Flow readability",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/CyclomaticComplexity.js

@@ -90,7 +90,8 @@ let CyclomaticComplexity = class CyclomaticComplexity extends _RuleCommon.RuleCo
             ruleId: "excessive-cyclomatic-complexity",
             name: "CyclomaticComplexity",
             label: "Excessive Cyclomatic Complexity",
-            description: "High numbers of loops and decision elements increase a Flow’s cyclomatic complexity. To maintain simplicity and readability, consider using subflows or splitting a Flow into smaller, ordered Flows.",
+            description: "High numbers of loops and decision elements increase a Flow's cyclomatic complexity. To maintain simplicity and readability, consider using subflows or splitting a Flow into smaller, ordered Flows.",
+            summary: "Too many loops and decisions harm readability",
             supportedTypes: _internals.FlowType.backEndTypes,
             docRefs: [
                 {

package/main/rules/DMLStatementInLoop.js

@@ -22,6 +22,7 @@ let DMLStatementInLoop = class DMLStatementInLoop extends _LoopRuleCommon.LoopRu
         super({
             ruleId: "dml-in-loop",
             description: "Executing DML operations (insert, update, delete) inside a loop is a high-risk anti-pattern that frequently causes governor limit exceptions. All database operations should be collected and executed once, outside the loop.",
+            summary: "DML operations inside loop risk governor limits",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/DuplicateDMLOperation.js

@@ -98,6 +98,7 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
             name: "DuplicateDMLOperation",
             label: "Duplicate DML Operation",
             description: "When a Flow performs database operations across multiple screens, users navigating backward can cause the same actions to run multiple times. To prevent unintended changes, either restrict backward navigation or redesign the Flow so database operations execute in a single, forward-moving step.",
+            summary: "DML across screens may execute multiple times",
             supportedTypes: _internals.FlowType.visualTypes,
             docRefs: []
         });

package/main/rules/FlowDescription.js

@@ -64,7 +64,8 @@ let FlowDescription = class FlowDescription extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "missing-flow-description",
-            description: "Flow descriptions are essential for documentation and maintainability. Include a description for each Flow, explaining its purpose and where it’s used.",
+            description: "Flow descriptions are essential for documentation and maintainability. Include a description for each Flow, explaining its purpose and where it's used.",
+            summary: "Flow descriptions improve documentation and maintainability",
             docRefs: [],
             label: "Missing Flow Description",
             name: "FlowDescription",

package/main/rules/FlowName.js

@@ -67,7 +67,8 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
     constructor(){
         super({
             ruleId: "invalid-naming-convention",
-            description: "Using clear and consistent Flow names improves readability, discoverability, and maintainability. A good naming convention helps team members quickly understand a Flow’s purpose—for example, including a domain and brief description like Service_OrderFulfillment. Adopt a naming pattern that aligns with your organization’s standards.",
+            description: "Using clear and consistent Flow names improves readability, discoverability, and maintainability. A good naming convention helps team members quickly understand a Flow's purpose—for example, including a domain and brief description like Service_OrderFulfillment. Adopt a naming pattern that aligns with your organization's standards.",
+            summary: "Consistent naming improves Flow discoverability and maintainability",
             docRefs: [
                 {
                     label: "Naming your Flows is more critical than ever. By Stephen Church",

package/main/rules/GetRecordAllFields.js

@@ -70,6 +70,7 @@ let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon
         super({
             ruleId: "get-record-all-fields",
             description: "Avoid using Get Records to retrieve all fields unless necessary. This improves performance, reduces processing time, and limits exposure of unnecessary data.",
+            summary: "Retrieving all fields harms performance and security",
             docRefs: [
                 {
                     label: "Get Records Stores All Fields",

package/main/rules/HardcodedId.js

@@ -62,6 +62,7 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
             name: "HardcodedId",
             label: "Hardcoded Id",
             description: "Avoid hard-coding record IDs, as they are unique to a specific org and will not work in other environments. Instead, store IDs in variables—such as merge-field URL parameters or a **Get Records** element—to make the Flow portable, maintainable, and flexible.",
+            summary: "Hardcoded IDs break portability across environments",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: [
                 {

package/main/rules/HardcodedUrl.js

@@ -20,6 +20,7 @@ let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
         super({
             ruleId: "hardcoded-url",
             description: "Avoid hard-coding URLs, as they may change between environments or over time. Instead, store URLs in variables or custom settings to make the Flow adaptable, maintainable, and environment-independent.",
+            summary: "Hardcoded URLs break across different environments",
             docRefs: [
                 {
                     label: "The Ultimate Guide to Salesforce Flow Best Practices",

package/main/rules/InactiveFlow.js

@@ -66,6 +66,7 @@ let InactiveFlow = class InactiveFlow extends _RuleCommon.RuleCommon {
             name: "InactiveFlow",
             label: "Inactive Flow",
             description: "Inactive Flows should be deleted or archived to reduce risk. Even when inactive, they can cause unintended record changes during testing or be activated as subflows. Keeping only active, relevant Flows improves safety and maintainability.",
+            summary: "Inactive Flows should be deleted or archived",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []
         });

package/main/rules/MissingFaultPath.js

@@ -128,6 +128,7 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         super({
             ruleId: "missing-fault-path",
             description: "Elements that can fail should include a Fault Path to handle errors gracefully. Without it, failures show generic errors to users. Fault Paths improve reliability and user experience.",
+            summary: "Fault Paths enable graceful error handling",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/MissingMetadataDescription.js

@@ -67,6 +67,7 @@ let MissingMetadataDescription = class MissingMetadataDescription extends _RuleC
         super({
             ruleId: "missing-metadata-description",
             description: "Elements and metadata without a description reduce clarity and maintainability. Adding descriptions improves readability and makes your automation easier to understand.",
+            summary: "Element descriptions improve clarity and maintainability",
             docRefs: [],
             label: "Missing Metadata Description",
             name: "MissingMetadataDescription",

package/main/rules/MissingNullHandler.js

@@ -139,6 +139,7 @@ let MissingNullHandler = class MissingNullHandler extends _RuleCommon.RuleCommon
         super({
             ruleId: "missing-null-handler",
             description: "Get Records operations return null when no data is found. Without handling these null values, Flows can fail or produce unintended results. Adding a null check improves reliability and ensures the Flow behaves as expected.",
+            summary: "Null checks prevent failures from missing records",
             docRefs: [],
             label: "Missing Null Handler",
             name: "MissingNullHandler",

package/main/rules/MissingRecordTriggerFilter.js

@@ -81,6 +81,7 @@ let MissingRecordTriggerFilter = class MissingRecordTriggerFilter extends _RuleC
             name: "MissingRecordTriggerFilter",
             label: "Missing Filter Record Trigger",
             description: "Record-triggered Flows without filters on changed fields or entry conditions execute on every record change. Adding filters ensures the Flow runs only when needed, improving performance.",
+            summary: "Filters ensure Flows run only when needed",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],

package/main/rules/ProcessBuilder.js

@@ -63,6 +63,7 @@ let ProcessBuilder = class ProcessBuilder extends _RuleCommon.RuleCommon {
             name: "ProcessBuilder",
             label: "Process Builder",
             description: "Process Builder is retired. Continuing to use it increases maintenance overhead and risks future compatibility issues. Migrating automation to Flow reduces risk and improves maintainability.",
+            summary: "Process Builder is retired, migrate to Flow",
             supportedTypes: _internals.FlowType.processBuilder,
             docRefs: [
                 {

package/main/rules/RecordIdAsString.js

@@ -77,6 +77,7 @@ let RecordIdAsString = class RecordIdAsString extends _RuleCommon.RuleCommon {
             name: "RecordIdAsString",
             label: "Record ID as String",
             description: "Flows that use a String variable for a record ID instead of receiving the full record introduce unnecessary complexity and additional Get Records queries. Using the complete record simplifies the Flow and improves performance.",
+            summary: "String record IDs add complexity and queries",
             supportedTypes: [
                 ..._internals.FlowType.visualTypes,
                 _internals.FlowType.autolaunchedType

package/main/rules/RecursiveAfterUpdate.js

@@ -106,6 +106,7 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
         super({
             ruleId: "recursive-record-update",
             description: "After-save Flows that update the same record can trigger recursion, causing unintended behavior or performance issues. Avoid updating the triggering record in after-save Flows; use before-save Flows instead to prevent recursion.",
+            summary: "After-save updates to same record trigger recursion",
             docRefs: [
                 {
                     label: "Learn about same record field updates",

package/main/rules/SOQLQueryInLoop.js

@@ -20,6 +20,7 @@ let SOQLQueryInLoop = class SOQLQueryInLoop extends _LoopRuleCommon.LoopRuleComm
         super({
             ruleId: "soql-in-loop",
             description: "Running SOQL queries inside a loop can rapidly exceed query limits and severely degrade performance. Queries should be executed once, with results reused throughout the loop.",
+            summary: "SOQL queries inside loop risk governor limits",
             docRefs: [
                 {
                     label: "Flow Best Practices",

package/main/rules/SameRecordFieldUpdates.js

@@ -90,6 +90,7 @@ let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.Ru
             name: "SameRecordFieldUpdates",
             label: "Same Record Field Updates",
             description: "Before-save Flows can safely update the triggering record directly via $Record, applying changes efficiently without extra DML operations. Using before-save updates improves performance",
+            summary: "Before-save Flows can update $Record directly",
             supportedTypes: [
                 ..._internals.FlowType.backEndTypes
             ],

package/main/rules/TransformInsteadOfLoop.js

@@ -80,6 +80,7 @@ let TransformInsteadOfLoop = class TransformInsteadOfLoop extends _RuleCommon.Ru
             name: "TransformInsteadOfLoop",
             label: "Transform Instead of Loop",
             description: "Loop elements that perform direct Assignments on each item can slow down Flows. Using Transform elements allows bulk operations on collections, improving performance and reducing complexity.",
+            summary: "Transform elements enable faster bulk operations",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: [
                 {

package/main/rules/TriggerOrder.js

@@ -72,6 +72,7 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
             name: "TriggerOrder",
             label: "Missing Trigger Order",
             description: "Record-triggered Flows without a specified Trigger Order may execute in an unpredictable sequence. Setting a Trigger Order ensures your Flows run in the intended order.",
+            summary: "Trigger Order ensures predictable execution sequence",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],

package/main/rules/UnconnectedElement.js

@@ -63,6 +63,7 @@ let UnconnectedElement = class UnconnectedElement extends _RuleCommon.RuleCommon
         super({
             ruleId: "unreachable-element",
             description: "Unconnected elements never execute and add unnecessary clutter. Remove or connect unused Flow elements to keep Flows clean and efficient.",
+            summary: "Unconnected elements add clutter without executing",
             docRefs: [],
             label: "Unreachable Element",
             name: "UnconnectedElement",

package/main/rules/UnsafeRunningContext.js

@@ -71,6 +71,7 @@ let UnsafeRunningContext = class UnsafeRunningContext extends _RuleCommon.RuleCo
             name: "UnsafeRunningContext",
             label: "Unsafe Running Context",
             description: "Flows configured to run in System Mode without Sharing grant access to all data, bypassing user permissions. Avoid this setting to prevent security risks and protect sensitive data.",
+            summary: "System mode without sharing creates security risks",
             supportedTypes: [
                 ..._internals.FlowType.backEndTypes,
                 ..._internals.FlowType.visualTypes

package/main/rules/UnusedVariable.js

@@ -83,6 +83,7 @@ let UnusedVariable = class UnusedVariable extends _RuleCommon.RuleCommon {
             name: "UnusedVariable",
             label: "Unused Variable",
             description: "Unused variables are never referenced and add unnecessary clutter. Remove them to keep Flows efficient and easy to maintain.",
+            summary: "Unused variables add clutter and hurt maintainability",
             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.15.0",
+  "version": "6.15.1",
   "main": "index.js",
   "exports": {
     ".": {