@flow-scanner/lightning-flow-scanner-core 6.11.4 → 6.11.5

package/README.md

@@ -54,110 +54,137 @@
 
 ### Action Calls In 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`  
 **Severity:** 🔴 *Error*
 
-### Outdated API Version  
+### 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*
 
-### 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.  
-**Severity:** 🔵 *Note*
-
-### Copy API Name  
+### 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`  
 **Severity:** 🟡 *Warning*
 
-### Cyclomatic Complexity  
+### 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`  
 **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`  
 **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`  
 **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`  
 **Severity:** 🔴 *Error*
 
-### Get Record All Fields  
+### 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 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`  
 **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  
 _[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`  
 **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`  
+**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`  
 **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`  
 **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`  
 **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`  
 **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`  
 **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`  
+**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`  
 **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*
 
 ### 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`  
 **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`  
 **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`  
 **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`  
 **Severity:** 🔵 *Note*
 
-### 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.  
-**Severity:** 🔵 *Note*
-
-### Unconnected Element  
+### 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`  
 **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`  
 **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`  
 **Severity:** 🟡 *Warning*
 
 ---

package/main/interfaces/IRuleConfig.d.ts

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

package/main/interfaces/IRuleDefinition.d.ts

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

package/main/libs/GetRuleDefinitions.js

@@ -16,80 +16,43 @@ _export(exports, {
         return getRules;
     }
 });
-const _DefaultRuleStore = require("../store/DefaultRuleStore");
-const _DynamicRule = require("./DynamicRule");
+const _RuleRegistry = require("../store/RuleRegistry");
 function GetRuleDefinitions(ruleConfig, options) {
-    const selectedRules = [];
     const includeBeta = (options === null || options === void 0 ? void 0 : options.betaMode) === true || (options === null || options === void 0 ? void 0 : options.betamode) === true;
-    // Default to "merged" mode for backward compatibility
     const rulesMode = (options === null || options === void 0 ? void 0 : options.ruleMode) || "merged";
-    // In "isolated" mode, only load rules that are explicitly configured
+    const selectedRules = [];
+    const ruleIds = _RuleRegistry.ruleRegistry.getAllRuleIds(includeBeta);
+    // ISOLATED MODE
     if (rulesMode === "isolated" && ruleConfig && ruleConfig.size > 0) {
-        for (const ruleName of ruleConfig.keys()){
-            try {
-                const customConfig = ruleConfig.get(ruleName);
-                // Skip if explicitly disabled
-                if (customConfig && customConfig["enabled"] === false) {
-                    continue;
-                }
-                // Create the rule instance
-                const matchedRule = new _DynamicRule.DynamicRule(ruleName, includeBeta);
-                // Apply custom severity if provided
-                const configuredSeverity = customConfig === null || customConfig === void 0 ? void 0 : customConfig["severity"];
-                if (configuredSeverity && (configuredSeverity === "error" || configuredSeverity === "warning" || configuredSeverity === "note")) {
-                    matchedRule.severity = configuredSeverity;
-                }
-                selectedRules.push(matchedRule);
-            } catch (error) {
-                console.log(error.message);
+        for (const key of ruleConfig.keys()){
+            // key can now be either ruleId (new) or legacyName (old config compatibility)
+            const entry = _RuleRegistry.ruleRegistry.get(key);
+            if (!entry) continue;
+            const config = ruleConfig.get(key);
+            if ((config === null || config === void 0 ? void 0 : config.enabled) === false) continue;
+            const rule = _RuleRegistry.ruleRegistry.createInstance(entry.ruleId); // Always use ruleId to instantiate
+            if (config === null || config === void 0 ? void 0 : config.severity) {
+                rule.severity = config.severity;
             }
+            selectedRules.push(rule);
         }
         return selectedRules;
     }
-    // In "merged" mode (default), start with all default rules and merge with config
-    const allRuleNames = new Set();
-    // Add all default rules
-    for(const ruleName in _DefaultRuleStore.DefaultRuleStore){
-        allRuleNames.add(ruleName);
-    }
-    // Add beta rules if beta mode is enabled
-    if (includeBeta) {
-        for(const ruleName in _DefaultRuleStore.BetaRuleStore){
-            allRuleNames.add(ruleName);
-        }
-    }
-    // Process each rule
-    for (const ruleName of allRuleNames){
-        try {
-            // Check if there's a custom config for this rule
-            const customConfig = ruleConfig === null || ruleConfig === void 0 ? void 0 : ruleConfig.get(ruleName);
-            // Skip if explicitly disabled
-            if (customConfig && customConfig["enabled"] === false) {
-                continue;
-            }
-            // Create the rule instance
-            const matchedRule = new _DynamicRule.DynamicRule(ruleName, includeBeta);
-            // Apply custom severity if provided
-            const configuredSeverity = customConfig === null || customConfig === void 0 ? void 0 : customConfig["severity"];
-            if (configuredSeverity && (configuredSeverity === "error" || configuredSeverity === "warning" || configuredSeverity === "note")) {
-                matchedRule.severity = configuredSeverity;
-            }
-            selectedRules.push(matchedRule);
-        } catch (error) {
-            console.log(error.message);
+    // MERGED MODE (default)
+    for (const ruleId of ruleIds){
+        const rule = _RuleRegistry.ruleRegistry.createInstance(ruleId);
+        var _ruleConfig_get;
+        // Try to find config by ruleId first, then fall back to legacy name
+        const config = (_ruleConfig_get = ruleConfig === null || ruleConfig === void 0 ? void 0 : ruleConfig.get(rule.ruleId)) !== null && _ruleConfig_get !== void 0 ? _ruleConfig_get : ruleConfig === null || ruleConfig === void 0 ? void 0 : ruleConfig.get(rule.name) // rule.name is the legacy camelCase name (e.g. "ActionCallsInLoop")
+        ;
+        if ((config === null || config === void 0 ? void 0 : config.enabled) === false) continue;
+        if (config === null || config === void 0 ? void 0 : config.severity) {
+            rule.severity = config.severity;
         }
+        selectedRules.push(rule);
     }
     return selectedRules;
 }
 function getRules(ruleNames, options) {
-    if (ruleNames && ruleNames.length > 0) {
-        const ruleSeverityMap = new Map(ruleNames.map((name)=>[
-                name,
-                {
-                    severity: "error"
-                }
-            ]));
-        return GetRuleDefinitions(ruleSeverityMap, options);
-    }
-    return GetRuleDefinitions(undefined, options);
+    return _RuleRegistry.ruleRegistry.getRulesByNames(ruleNames, options);
 }

package/main/libs/ScanFlows.js

@@ -20,6 +20,21 @@ const _internals = require("../../main/internals/internals");
 const _IRulesConfig = require("../interfaces/IRulesConfig");
 const _Violation = require("../models/Violation");
 const _GetRuleDefinitions = require("./GetRuleDefinitions");
+function getRuleConfigByIdOrName(rule, rulesConfig) {
+    if (!rulesConfig) return undefined;
+    // Try ruleId first, then fall back to name
+    return rulesConfig[rule.ruleId] || rulesConfig[rule.name];
+}
+function getSuppressionsForRule(rule, flowName, exceptions) {
+    if (!(exceptions === null || exceptions === void 0 ? void 0 : exceptions[flowName])) return [];
+    const flowExceptions = exceptions[flowName];
+    // Try ruleId first, then fall back to name
+    const rawSuppressions = flowExceptions[rule.ruleId] || flowExceptions[rule.name];
+    // If wildcard exists, return only wildcard; otherwise return array or empty
+    return (rawSuppressions === null || rawSuppressions === void 0 ? void 0 : rawSuppressions.includes("*")) ? [
+        "*"
+    ] : rawSuppressions !== null && rawSuppressions !== void 0 ? rawSuppressions : [];
+}
 function scan(parsedFlows, ruleOptions) {
     const flows = [];
     for (const flow of parsedFlows){
@@ -49,19 +64,12 @@ function ScanFlows(flows, ruleOptions) {
         const ruleResults = [];
         for (const rule of selectedRules){
             try {
-                var _ruleOptions_rules, _ruleOptions_exceptions_flow_name, _ruleOptions_exceptions;
                 if (!rule.supportedTypes.includes(flow.type)) {
                     ruleResults.push(new _internals.RuleResult(rule, []));
                     continue;
                 }
-                let config = undefined;
-                if (ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_rules = ruleOptions.rules) === null || _ruleOptions_rules === void 0 ? void 0 : _ruleOptions_rules[rule.name]) {
-                    config = ruleOptions.rules[rule.name];
-                }
-                const rawSuppressions = ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_exceptions = ruleOptions.exceptions) === null || _ruleOptions_exceptions === void 0 ? void 0 : (_ruleOptions_exceptions_flow_name = _ruleOptions_exceptions[flow.name]) === null || _ruleOptions_exceptions_flow_name === void 0 ? void 0 : _ruleOptions_exceptions_flow_name[rule.name];
-                const suppressions = (rawSuppressions === null || rawSuppressions === void 0 ? void 0 : rawSuppressions.includes("*")) ? [
-                    "*"
-                ] : rawSuppressions !== null && rawSuppressions !== void 0 ? rawSuppressions : [];
+                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);
                 if (result.severity !== rule.severity) {
                     result.severity = rule.severity;

package/main/models/RuleCommon.d.ts

@@ -11,8 +11,8 @@ export declare abstract class RuleCommon {
     name: string;
     severity?: string;
     supportedTypes: string[];
-    suppressionElement?: string;
     uri?: string;
+    readonly ruleId: string;
     constructor(info: RuleInfo, optional?: {
         severity?: string;
     });

package/main/models/RuleCommon.js

@@ -69,6 +69,9 @@ let RuleCommon = class RuleCommon {
         if (suppressions.includes("*")) {
             return new _internals.RuleResult(this, []);
         }
+        if (suppressions.includes(this.ruleId) || suppressions.includes(this.name)) {
+            return new _internals.RuleResult(this, []);
+        }
         const suppSet = new Set(suppressions);
         let violations = this.check(flow, options, suppSet);
         violations = violations.filter((v)=>!suppSet.has(v.name));
@@ -131,8 +134,9 @@ let RuleCommon = class RuleCommon {
         _define_property(this, "name", void 0);
         _define_property(this, "severity", void 0);
         _define_property(this, "supportedTypes", void 0);
-        _define_property(this, "suppressionElement", void 0);
         _define_property(this, "uri", void 0);
+        _define_property(this, "ruleId", void 0);
+        this.ruleId = info.ruleId;
         this.name = info.name;
         this.supportedTypes = info.supportedTypes;
         this.label = info.label;
@@ -148,6 +152,5 @@ let RuleCommon = class RuleCommon {
         }
         var _optional_severity;
         this.severity = (_optional_severity = optional === null || optional === void 0 ? void 0 : optional.severity) !== null && _optional_severity !== void 0 ? _optional_severity : "error";
-        this.suppressionElement = info.suppressionElement;
     }
 };

package/main/models/RuleInfo.d.ts

@@ -24,7 +24,12 @@ export declare class RuleInfo {
      */
     label: string;
     /**
-     * The unique name identifier for the rule.
+     * Stable public identifier used for config, suppression, and reporting.
+     */
+    ruleId: string;
+    /**
+     * Legacy rule name (class-based identifier).
+     * Kept for backward compatibility.
      */
     name: string;
     /**
@@ -32,9 +37,4 @@ export declare class RuleInfo {
      * Use defined types in @see FlowType
      */
     supportedTypes: string[];
-    /**
-     * (Optional) The element that can be used to suppress this rule.
-     * @see AdvancedSuppression
-     */
-    suppressionElement?: string;
 }

package/main/models/RuleInfo.js

@@ -34,15 +34,15 @@ let RuleInfo = class RuleInfo {
    * This property is being displayed on sf cli and on vsce
    */ _define_property(this, "label", void 0);
         /**
-   * The unique name identifier for the rule.
+   * Stable public identifier used for config, suppression, and reporting.
+   */ _define_property(this, "ruleId", void 0);
+        /**
+   * Legacy rule name (class-based identifier).
+   * Kept for backward compatibility.
    */ _define_property(this, "name", void 0);
         /**
    * The types supported by this rule (e.g., Flow, Process).
    * Use defined types in @see FlowType
    */ _define_property(this, "supportedTypes", void 0);
-        /**
-   * (Optional) The element that can be used to suppress this rule.
-   * @see AdvancedSuppression
-   */ _define_property(this, "suppressionElement", void 0);
     }
 };

package/main/rules/APIVersion.js

@@ -106,8 +106,9 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            ruleId: "invalid-api-version",
             name: "APIVersion",
-            label: "Outdated API Version",
+            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.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []

package/main/rules/ActionCallsInLoop.js

@@ -19,6 +19,7 @@ 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.",
             docRefs: [
                 {

package/main/rules/AutoLayout.js

@@ -65,6 +65,7 @@ let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
     }
     constructor(){
         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.",

package/main/rules/CopyAPIName.js

@@ -59,8 +59,9 @@ let CopyAPIName = class CopyAPIName extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            ruleId: "unclear-api-naming",
             name: "CopyAPIName",
-            label: "Copy API Name",
+            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.",
             supportedTypes: _internals.FlowType.allTypes(),
             docRefs: []

package/main/rules/CyclomaticComplexity.js

@@ -87,8 +87,9 @@ let CyclomaticComplexity = class CyclomaticComplexity extends _RuleCommon.RuleCo
     }
     constructor(){
         super({
+            ruleId: "excessive-cyclomatic-complexity",
             name: "CyclomaticComplexity",
-            label: "Cyclomatic Complexity",
+            label: "Excessive Cyclomatic Complexity",
             description: `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.`,
             supportedTypes: _internals.FlowType.backEndTypes,
             docRefs: [

package/main/rules/DMLStatementInLoop.js

@@ -20,6 +20,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.",
             docRefs: [
                 {

package/main/rules/DuplicateDMLOperation.js

@@ -94,6 +94,7 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
     }
     constructor(){
         super({
+            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.",

package/main/rules/FlowDescription.js

@@ -63,6 +63,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.",
             docRefs: [],
             label: "Missing Flow Description",

package/main/rules/FlowName.js

@@ -66,6 +66,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'.",
             docRefs: [
                 {

package/main/rules/GetRecordAllFields.js

@@ -66,6 +66,7 @@ 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.",
             docRefs: [
                 {

package/main/rules/HardcodedId.js

@@ -58,6 +58,7 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            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.",

package/main/rules/HardcodedUrl.js

@@ -18,6 +18,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.",
             docRefs: [
                 {

package/main/rules/InactiveFlow.js

@@ -62,6 +62,7 @@ let InactiveFlow = class InactiveFlow extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            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.",

package/main/rules/MissingFaultPath.js

@@ -126,6 +126,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.",
             docRefs: [
                 {

package/main/rules/MissingMetadataDescription.js

@@ -65,6 +65,7 @@ let MissingMetadataDescription = class MissingMetadataDescription extends _RuleC
     }
     constructor(){
         super({
+            ruleId: "missing-metadata-description",
             description: "Every element must have a meaningful description",
             docRefs: [],
             label: "Missing Metadata Description",

package/main/rules/MissingNullHandler.js

@@ -130,6 +130,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.",
             docRefs: [],
             label: "Missing Null Handler",

package/main/rules/{MissingFilterRecordTrigger.d.ts → MissingRecordTriggerFilter.d.ts}

@@ -1,7 +1,7 @@
 import * as core from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export declare class MissingFilterRecordTrigger extends RuleCommon implements IRuleDefinition {
+export declare class MissingRecordTriggerFilter extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/{MissingFilterRecordTrigger.js → MissingRecordTriggerFilter.js}

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "MissingFilterRecordTrigger", {
+Object.defineProperty(exports, "MissingRecordTriggerFilter", {
     enumerable: true,
     get: function() {
-        return MissingFilterRecordTrigger;
+        return MissingRecordTriggerFilter;
     }
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
@@ -51,7 +51,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleCommon.RuleCommon {
+let MissingRecordTriggerFilter = class MissingRecordTriggerFilter extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
         var _flow_xmldata_start, _flow_xmldata;
         const violations = [];
@@ -77,7 +77,8 @@ let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleC
     }
     constructor(){
         super({
-            name: "MissingFilterRecordTrigger",
+            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.",
             supportedTypes: [

package/main/rules/ProcessBuilder.js

@@ -59,8 +59,9 @@ let ProcessBuilder = class ProcessBuilder extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            ruleId: "process-builder-usage",
             name: "ProcessBuilder",
-            label: "No Process Builder",
+            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.",
             supportedTypes: _internals.FlowType.processBuilder,
             docRefs: [

package/main/rules/RecordIdAsString.js

@@ -73,6 +73,7 @@ let RecordIdAsString = class RecordIdAsString extends _RuleCommon.RuleCommon {
     }
     constructor(){
         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.",

package/main/rules/RecursiveAfterUpdate.js

@@ -104,6 +104,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.",
             docRefs: [
                 {

package/main/rules/SOQLQueryInLoop.js

@@ -18,6 +18,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.",
             docRefs: [
                 {

package/main/rules/SameRecordFieldUpdates.js

@@ -86,6 +86,7 @@ let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.Ru
     }
     constructor(){
         super({
+            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",

package/main/rules/TransformInsteadOfLoop.js

@@ -76,6 +76,7 @@ let TransformInsteadOfLoop = class TransformInsteadOfLoop extends _RuleCommon.Ru
     }
     constructor(){
         super({
+            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.",

package/main/rules/TriggerOrder.js

@@ -68,6 +68,7 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
     }
     constructor(){
         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.",

package/main/rules/UnconnectedElement.js

@@ -61,9 +61,10 @@ 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.",
             docRefs: [],
-            label: "Unconnected Element",
+            label: "Unreachable Element",
             name: "UnconnectedElement",
             supportedTypes: [
                 ..._internals.FlowType.backEndTypes,

package/main/rules/UnsafeRunningContext.js

@@ -67,6 +67,7 @@ let UnsafeRunningContext = class UnsafeRunningContext extends _RuleCommon.RuleCo
     }
     constructor(){
         super({
+            ruleId: "unsafe-running-context",
             name: "UnsafeRunningContext",
             label: "Unsafe Running Context",
             description: `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.`,

package/main/rules/UnusedVariable.js

@@ -79,6 +79,7 @@ let UnusedVariable = class UnusedVariable extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
+            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.",

package/main/store/RuleRegistry.d.ts

@@ -0,0 +1,22 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { IRulesConfig } from "../interfaces/IRulesConfig";
+type RuleConstructor = new () => IRuleDefinition;
+interface RuleRegistryEntry {
+    ruleId: string;
+    ruleClass: RuleConstructor;
+    legacyName: string;
+    isBeta: boolean;
+}
+declare class RuleRegistry {
+    private rules;
+    private legacyNameMap;
+    register(ruleId: string, ruleClass: RuleConstructor, legacyName: string, isBeta?: boolean): void;
+    get(idOrLegacyName: string): RuleRegistryEntry | undefined;
+    getAllRuleIds(includeBeta?: boolean): string[];
+    has(idOrLegacyName: string): boolean;
+    createInstance(idOrLegacyName: string): IRuleDefinition;
+    getRules(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[];
+    getRulesByNames(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[];
+}
+export declare const ruleRegistry: RuleRegistry;
+export {};

package/main/store/RuleRegistry.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ruleRegistry", {
+    enumerable: true,
+    get: function() {
+        return ruleRegistry;
+    }
+});
+const _ActionCallsInLoop = require("../rules/ActionCallsInLoop");
+const _APIVersion = require("../rules/APIVersion");
+const _AutoLayout = require("../rules/AutoLayout");
+const _CopyAPIName = require("../rules/CopyAPIName");
+const _CyclomaticComplexity = require("../rules/CyclomaticComplexity");
+const _DMLStatementInLoop = require("../rules/DMLStatementInLoop");
+const _DuplicateDMLOperation = require("../rules/DuplicateDMLOperation");
+const _FlowDescription = require("../rules/FlowDescription");
+const _FlowName = require("../rules/FlowName");
+const _GetRecordAllFields = require("../rules/GetRecordAllFields");
+const _HardcodedId = require("../rules/HardcodedId");
+const _HardcodedUrl = require("../rules/HardcodedUrl");
+const _InactiveFlow = require("../rules/InactiveFlow");
+const _MissingFaultPath = require("../rules/MissingFaultPath");
+const _MissingNullHandler = require("../rules/MissingNullHandler");
+const _ProcessBuilder = require("../rules/ProcessBuilder");
+const _RecursiveAfterUpdate = require("../rules/RecursiveAfterUpdate");
+const _SameRecordFieldUpdates = require("../rules/SameRecordFieldUpdates");
+const _SOQLQueryInLoop = require("../rules/SOQLQueryInLoop");
+const _TriggerOrder = require("../rules/TriggerOrder");
+const _UnconnectedElement = require("../rules/UnconnectedElement");
+const _UnsafeRunningContext = require("../rules/UnsafeRunningContext");
+const _UnusedVariable = require("../rules/UnusedVariable");
+const _MissingMetadataDescription = require("../rules/MissingMetadataDescription");
+const _MissingRecordTriggerFilter = require("../rules/MissingRecordTriggerFilter");
+const _TransformInsteadOfLoop = require("../rules/TransformInsteadOfLoop");
+const _RecordIdAsString = require("../rules/RecordIdAsString");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+let RuleRegistry = class RuleRegistry {
+    register(ruleId, ruleClass, legacyName, isBeta = false) {
+        const entry = {
+            ruleId,
+            ruleClass,
+            legacyName,
+            isBeta
+        };
+        this.rules.set(ruleId, entry);
+        this.legacyNameMap.set(legacyName, ruleId);
+    }
+    get(idOrLegacyName) {
+        let entry = this.rules.get(idOrLegacyName);
+        if (!entry) {
+            const ruleId = this.legacyNameMap.get(idOrLegacyName);
+            if (ruleId) {
+                entry = this.rules.get(ruleId);
+            }
+        }
+        return entry;
+    }
+    getAllRuleIds(includeBeta = false) {
+        return Array.from(this.rules.values()).filter((entry)=>includeBeta || !entry.isBeta).map((entry)=>entry.ruleId);
+    }
+    has(idOrLegacyName) {
+        return this.get(idOrLegacyName) !== undefined;
+    }
+    createInstance(idOrLegacyName) {
+        const entry = this.get(idOrLegacyName);
+        if (!entry) {
+            throw new Error(`Rule not found: ${idOrLegacyName}`);
+        }
+        return new entry.ruleClass();
+    }
+    getRules(ruleConfig, options) {
+        const includeBeta = (options === null || options === void 0 ? void 0 : options.betaMode) === true || (options === null || options === void 0 ? void 0 : options.betamode) === true;
+        const rulesMode = (options === null || options === void 0 ? void 0 : options.ruleMode) || "merged";
+        const selectedRules = [];
+        if (rulesMode === "isolated" && ruleConfig && ruleConfig.size > 0) {
+            for (const key of ruleConfig.keys()){
+                const entry = this.get(key);
+                if (!entry) continue;
+                const config = ruleConfig.get(key);
+                if ((config === null || config === void 0 ? void 0 : config.enabled) === false) continue;
+                const rule = this.createInstance(entry.ruleId);
+                if (config === null || config === void 0 ? void 0 : config.severity) {
+                    rule.severity = config.severity;
+                }
+                selectedRules.push(rule);
+            }
+            return selectedRules;
+        }
+        const allRuleIds = this.getAllRuleIds(includeBeta);
+        for (const ruleId of allRuleIds){
+            const rule = this.createInstance(ruleId);
+            var _ruleConfig_get;
+            const config = (_ruleConfig_get = ruleConfig === null || ruleConfig === void 0 ? void 0 : ruleConfig.get(rule.ruleId)) !== null && _ruleConfig_get !== void 0 ? _ruleConfig_get : ruleConfig === null || ruleConfig === void 0 ? void 0 : ruleConfig.get(rule.name);
+            if ((config === null || config === void 0 ? void 0 : config.enabled) === false) continue;
+            if (config === null || config === void 0 ? void 0 : config.severity) {
+                rule.severity = config.severity;
+            }
+            selectedRules.push(rule);
+        }
+        return selectedRules;
+    }
+    getRulesByNames(ruleNames, options) {
+        if (!ruleNames || ruleNames.length === 0) {
+            return this.getRules(undefined, options);
+        }
+        const config = new Map();
+        for (const identifier of ruleNames){
+            const entry = this.get(identifier);
+            if (entry) {
+                config.set(entry.ruleId, {
+                    enabled: true
+                });
+            }
+        }
+        return this.getRules(config, _object_spread_props(_object_spread({}, options), {
+            ruleMode: "isolated"
+        }));
+    }
+    constructor(){
+        _define_property(this, "rules", new Map());
+        _define_property(this, "legacyNameMap", new Map());
+    }
+};
+const registry = new RuleRegistry();
+registry.register("action-call-in-loop", _ActionCallsInLoop.ActionCallsInLoop, "ActionCallsInLoop");
+registry.register("invalid-api-version", _APIVersion.APIVersion, "APIVersion");
+registry.register("missing-auto-layout", _AutoLayout.AutoLayout, "AutoLayout");
+registry.register("unclear-api-naming", _CopyAPIName.CopyAPIName, "CopyAPIName");
+registry.register("excessive-cyclomatic-complexity", _CyclomaticComplexity.CyclomaticComplexity, "CyclomaticComplexity");
+registry.register("dml-in-loop", _DMLStatementInLoop.DMLStatementInLoop, "DMLStatementInLoop");
+registry.register("duplicate-dml", _DuplicateDMLOperation.DuplicateDMLOperation, "DuplicateDMLOperation");
+registry.register("missing-flow-description", _FlowDescription.FlowDescription, "FlowDescription");
+registry.register("invalid-naming-convention", _FlowName.FlowName, "FlowName");
+registry.register("get-record-all-fields", _GetRecordAllFields.GetRecordAllFields, "GetRecordAllFields");
+registry.register("hardcoded-id", _HardcodedId.HardcodedId, "HardcodedId");
+registry.register("hardcoded-url", _HardcodedUrl.HardcodedUrl, "HardcodedUrl");
+registry.register("inactive-flow", _InactiveFlow.InactiveFlow, "InactiveFlow");
+registry.register("missing-fault-path", _MissingFaultPath.MissingFaultPath, "MissingFaultPath");
+registry.register("missing-null-handler", _MissingNullHandler.MissingNullHandler, "MissingNullHandler");
+registry.register("process-builder-usage", _ProcessBuilder.ProcessBuilder, "ProcessBuilder");
+registry.register("recursive-record-update", _RecursiveAfterUpdate.RecursiveAfterUpdate, "RecursiveAfterUpdate");
+registry.register("same-record-field-updates", _SameRecordFieldUpdates.SameRecordFieldUpdates, "SameRecordFieldUpdates");
+registry.register("soql-in-loop", _SOQLQueryInLoop.SOQLQueryInLoop, "SOQLQueryInLoop");
+registry.register("unspecified-trigger-order", _TriggerOrder.TriggerOrder, "TriggerOrder");
+registry.register("unreachable-element", _UnconnectedElement.UnconnectedElement, "UnconnectedElement");
+registry.register("unsafe-running-context", _UnsafeRunningContext.UnsafeRunningContext, "UnsafeRunningContext");
+registry.register("unused-variable", _UnusedVariable.UnusedVariable, "UnusedVariable");
+registry.register("missing-metadata-description", _MissingMetadataDescription.MissingMetadataDescription, "MissingMetadataDescription", true);
+registry.register("missing-record-trigger-filter", _MissingRecordTriggerFilter.MissingRecordTriggerFilter, "MissingFilterRecordTrigger", true);
+registry.register("transform-instead-of-loop", _TransformInsteadOfLoop.TransformInsteadOfLoop, "TransformInsteadOfLoop", true);
+registry.register("record-id-as-string", _RecordIdAsString.RecordIdAsString, "RecordIdAsString", true);
+const ruleRegistry = registry;

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.11.4",
+  "version": "6.11.5",
   "main": "index.js",
   "exports": {
     ".": {

package/main/libs/DynamicRule.d.ts

@@ -1,4 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export declare class DynamicRule<T extends IRuleDefinition> {
-    constructor(className: string, betaMode?: boolean);
-}

package/main/libs/DynamicRule.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DynamicRule", {
-    enumerable: true,
-    get: function() {
-        return DynamicRule;
-    }
-});
-const _DefaultRuleStore = require("../store/DefaultRuleStore");
-let DynamicRule = class DynamicRule {
-    constructor(className, betaMode = false){
-        if (betaMode && _DefaultRuleStore.BetaRuleStore.hasOwnProperty(className)) {
-            return new _DefaultRuleStore.BetaRuleStore[className]();
-        }
-        return new _DefaultRuleStore.DefaultRuleStore[className]();
-    }
-};

package/main/store/DefaultRuleStore.d.ts

@@ -1,2 +0,0 @@
-export declare const DefaultRuleStore: object;
-export declare const BetaRuleStore: object;

package/main/store/DefaultRuleStore.js

@@ -1,76 +0,0 @@
-"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 BetaRuleStore () {
-        return BetaRuleStore;
-    },
-    get DefaultRuleStore () {
-        return DefaultRuleStore;
-    }
-});
-const _ActionCallsInLoop = require("../rules/ActionCallsInLoop");
-const _APIVersion = require("../rules/APIVersion");
-const _AutoLayout = require("../rules/AutoLayout");
-const _CopyAPIName = require("../rules/CopyAPIName");
-const _CyclomaticComplexity = require("../rules/CyclomaticComplexity");
-const _DMLStatementInLoop = require("../rules/DMLStatementInLoop");
-const _DuplicateDMLOperation = require("../rules/DuplicateDMLOperation");
-const _FlowDescription = require("../rules/FlowDescription");
-const _FlowName = require("../rules/FlowName");
-const _GetRecordAllFields = require("../rules/GetRecordAllFields");
-const _HardcodedId = require("../rules/HardcodedId");
-const _HardcodedUrl = require("../rules/HardcodedUrl");
-const _InactiveFlow = require("../rules/InactiveFlow");
-const _MissingFaultPath = require("../rules/MissingFaultPath");
-const _MissingNullHandler = require("../rules/MissingNullHandler");
-const _ProcessBuilder = require("../rules/ProcessBuilder");
-const _RecursiveAfterUpdate = require("../rules/RecursiveAfterUpdate");
-const _SameRecordFieldUpdates = require("../rules/SameRecordFieldUpdates");
-const _SOQLQueryInLoop = require("../rules/SOQLQueryInLoop");
-const _TriggerOrder = require("../rules/TriggerOrder");
-const _UnconnectedElement = require("../rules/UnconnectedElement");
-const _UnsafeRunningContext = require("../rules/UnsafeRunningContext");
-const _UnusedVariable = require("../rules/UnusedVariable");
-const _MissingMetadataDescription = require("../rules/MissingMetadataDescription");
-const _MissingFilterRecordTrigger = require("../rules/MissingFilterRecordTrigger");
-const _TransformInsteadOfLoop = require("../rules/TransformInsteadOfLoop");
-const _RecordIdAsString = require("../rules/RecordIdAsString");
-const DefaultRuleStore = {
-    ActionCallsInLoop: _ActionCallsInLoop.ActionCallsInLoop,
-    APIVersion: _APIVersion.APIVersion,
-    AutoLayout: _AutoLayout.AutoLayout,
-    CopyAPIName: _CopyAPIName.CopyAPIName,
-    CyclomaticComplexity: _CyclomaticComplexity.CyclomaticComplexity,
-    DMLStatementInLoop: _DMLStatementInLoop.DMLStatementInLoop,
-    DuplicateDMLOperation: _DuplicateDMLOperation.DuplicateDMLOperation,
-    FlowDescription: _FlowDescription.FlowDescription,
-    FlowName: _FlowName.FlowName,
-    GetRecordAllFields: _GetRecordAllFields.GetRecordAllFields,
-    HardcodedId: _HardcodedId.HardcodedId,
-    HardcodedUrl: _HardcodedUrl.HardcodedUrl,
-    InactiveFlow: _InactiveFlow.InactiveFlow,
-    MissingFaultPath: _MissingFaultPath.MissingFaultPath,
-    MissingNullHandler: _MissingNullHandler.MissingNullHandler,
-    ProcessBuilder: _ProcessBuilder.ProcessBuilder,
-    RecursiveAfterUpdate: _RecursiveAfterUpdate.RecursiveAfterUpdate,
-    SameRecordFieldUpdates: _SameRecordFieldUpdates.SameRecordFieldUpdates,
-    SOQLQueryInLoop: _SOQLQueryInLoop.SOQLQueryInLoop,
-    TriggerOrder: _TriggerOrder.TriggerOrder,
-    UnconnectedElement: _UnconnectedElement.UnconnectedElement,
-    UnsafeRunningContext: _UnsafeRunningContext.UnsafeRunningContext,
-    UnusedVariable: _UnusedVariable.UnusedVariable
-};
-const BetaRuleStore = {
-    MissingMetadataDescription: _MissingMetadataDescription.MissingMetadataDescription,
-    MissingFilterRecordTrigger: _MissingFilterRecordTrigger.MissingFilterRecordTrigger,
-    TransformInsteadOfLoop: _TransformInsteadOfLoop.TransformInsteadOfLoop,
-    RecordIdAsString: _RecordIdAsString.RecordIdAsString
-};