@flow-scanner/lightning-flow-scanner-core 6.10.5 → 6.10.6

package/main/libs/ExportSarif.js

@@ -74,7 +74,7 @@ function exportSarif(results) {
                     }))),
             tool: {
                 driver: {
-                    informationUri: "https://github.com/Flow-Scanner/lightning-flow-scanner-core",
+                    informationUri: "https://github.com/Flow-Scanner/lightning-flow-scanner",
                     name: "Lightning Flow Scanner",
                     rules: result.ruleResults.filter((r)=>r.occurs).map((r)=>({
                             defaultConfiguration: {

package/main/models/Flow.d.ts

@@ -1,4 +1,5 @@
 import { FlowElement } from "./FlowElement";
+import { FlowNode } from "./FlowNode";
 export declare class Flow {
     /**
      * Metadata Tags of Salesforce Flow Attributes
@@ -7,32 +8,54 @@ export declare class Flow {
     /**
      * Metadata Tags of Salesforce Flow Nodes
      */
-    static readonly NODE_TAGS: readonly ["actionCalls", "apexPluginCalls", "assignments", "collectionProcessors", "decisions", "loops", "orchestratedStages", "recordCreates", "recordDeletes", "recordLookups", "recordUpdates", "recordRollbacks", "screens", "start", "steps", "subflows", "waits", "transforms", "customErrors"];
+    static readonly NODE_TAGS: readonly ["actionCalls", "apexPluginCalls", "assignments", "collectionProcessors", "decisions", "loops", "orchestratedStages", "recordCreates", "recordDeletes", "recordLookups", "recordUpdates", "recordRollbacks", "screens", "steps", "subflows", "waits", "transforms", "customErrors"];
     static readonly RESOURCE_TAGS: readonly ["textTemplates", "stages"];
     static readonly VARIABLE_TAGS: readonly ["choices", "constants", "dynamicChoiceSets", "formulas", "variables"];
-    elements?: FlowElement[];
+    elements: FlowElement[];
     fsPath?: string;
     uri?: string;
-    interviewLabel?: string;
     label: string;
-    name?: string;
+    interviewLabel?: string;
+    name: string;
     processMetadataValues?: any;
-    processType?: string;
-    root?: any;
+    processType: string;
+    type: string;
+    status: string;
+    triggerOrder?: number;
+    /**
+     * @deprecated Use startNode.element instead. Kept for backward compatibility.
+     */
     start?: any;
+    /**
+     * Direct reference to first element (from XML attribute).
+     * Used in newer flows as an alternative to the start element.
+     */
     startElementReference?: string;
+    /**
+     * Computed reference to the first element to execute.
+     * This is what rules should use for traversal.
+     */
     startReference?: string;
-    status?: string;
-    triggerOrder?: number;
-    type?: string;
     /**
-     * XML to JSON conversion in raw format
+     * Parsed FlowNode object of the start element.
+     * Contains trigger information and connectors.
+     * Access start element data via startNode.element
      */
+    startNode?: FlowNode;
+    root?: any;
     xmldata: any;
     constructor(path?: string, data?: unknown);
     static from(obj: Partial<Flow>): Flow;
     preProcessNodes(): void;
-    toXMLString(): string;
+    private processNodeType;
+    /**
+     * Find the name of the first element to execute.
+     * Priority order:
+     * 1. startElementReference (newer flows, direct XML attribute)
+     * 2. Start node connector (older flows, points to first element)
+     * 3. Start node scheduledPaths (async flows)
+     */
     private findStart;
+    toXMLString(): string;
     private generateDoc;
 }

package/main/models/Flow.js

@@ -96,14 +96,17 @@ let Flow = class Flow {
         return flow;
     }
     preProcessNodes() {
-        this.label = this.xmldata.label;
+        if (!this.xmldata) {
+            return;
+        }
+        // Extract top-level attributes
+        this.label = this.xmldata.label || "";
         this.interviewLabel = this.xmldata.interviewLabel;
-        this.processType = this.xmldata.processType;
+        this.processType = this.xmldata.processType || "AutoLaunchedFlow";
+        this.type = this.processType;
         this.processMetadataValues = this.xmldata.processMetadataValues;
         this.startElementReference = this.xmldata.startElementReference;
-        this.start = this.xmldata.start;
-        this.status = this.xmldata.status;
-        this.type = this.xmldata.processType;
+        this.status = this.xmldata.status || "Draft";
         this.triggerOrder = this.xmldata.triggerOrder;
         const allNodes = [];
         for(const nodeType in this.xmldata){
@@ -112,129 +115,160 @@ let Flow = class Flow {
                 continue;
             }
             const data = this.xmldata[nodeType];
-            if (Flow.ATTRIBUTE_TAGS.includes(nodeType)) {
-                if (Array.isArray(data)) {
-                    for (const node of data){
-                        allNodes.push(new _FlowMetadata.FlowMetadata(node.name, nodeType, node));
-                    }
-                } else {
-                    allNodes.push(new _FlowMetadata.FlowMetadata(data.name, nodeType, data));
+            // Handle start nodes separately - store in startNode, don't add to elements
+            if (nodeType === "start") {
+                if (Array.isArray(data) && data.length > 0) {
+                    this.startNode = new _FlowNode.FlowNode(data[0].name || "start", "start", data[0]);
+                } else if (!Array.isArray(data)) {
+                    this.startNode = new _FlowNode.FlowNode(data.name || "start", "start", data);
                 }
+                continue; // Don't add to elements array
+            }
+            // Process other node types
+            if (Flow.ATTRIBUTE_TAGS.includes(nodeType)) {
+                this.processNodeType(data, nodeType, allNodes, _FlowMetadata.FlowMetadata);
             } else if (Flow.VARIABLE_TAGS.includes(nodeType)) {
-                if (Array.isArray(data)) {
-                    for (const node of data){
-                        allNodes.push(new _FlowVariable.FlowVariable(node.name, nodeType, node));
-                    }
-                } else {
-                    allNodes.push(new _FlowVariable.FlowVariable(data.name, nodeType, data));
-                }
+                this.processNodeType(data, nodeType, allNodes, _FlowVariable.FlowVariable);
             } else if (Flow.NODE_TAGS.includes(nodeType)) {
-                if (Array.isArray(data)) {
-                    for (const node of data){
-                        allNodes.push(new _FlowNode.FlowNode(node.name, nodeType, node));
-                    }
-                } else {
-                    allNodes.push(new _FlowNode.FlowNode(data.name, nodeType, data));
-                }
+                this.processNodeType(data, nodeType, allNodes, _FlowNode.FlowNode);
             } else if (Flow.RESOURCE_TAGS.includes(nodeType)) {
-                if (Array.isArray(data)) {
-                    for (const node of data){
-                        allNodes.push(new _FlowResource.FlowResource(node.name, nodeType, node));
-                    }
-                } else {
-                    allNodes.push(new _FlowResource.FlowResource(data.name, nodeType, data));
-                }
+                this.processNodeType(data, nodeType, allNodes, _FlowResource.FlowResource);
             }
         }
         this.elements = allNodes;
         this.startReference = this.findStart();
     }
+    processNodeType(data, nodeType, allNodes, NodeClass) {
+        if (Array.isArray(data)) {
+            for (const node of data){
+                allNodes.push(new NodeClass(node.name, nodeType, node));
+            }
+        } else {
+            allNodes.push(new NodeClass(data.name, nodeType, data));
+        }
+    }
+    /**
+   * Find the name of the first element to execute.
+   * Priority order:
+   * 1. startElementReference (newer flows, direct XML attribute)
+   * 2. Start node connector (older flows, points to first element)
+   * 3. Start node scheduledPaths (async flows)
+   */ findStart() {
+        var _this_startNode;
+        // Priority 1: Explicit startElementReference
+        if (this.startElementReference) {
+            return this.startElementReference;
+        }
+        // Priority 2: Start node with regular connector
+        if (this.startNode && this.startNode.connectors && this.startNode.connectors.length > 0) {
+            const connector = this.startNode.connectors[0];
+            if (connector.reference) {
+                return connector.reference;
+            }
+        }
+        // Priority 3: Start node with scheduledPaths (async flows)
+        if ((_this_startNode = this.startNode) === null || _this_startNode === void 0 ? void 0 : _this_startNode.element) {
+            const scheduledPaths = this.startNode.element['scheduledPaths'];
+            if (scheduledPaths) {
+                var _paths_;
+                const paths = Array.isArray(scheduledPaths) ? scheduledPaths : [
+                    scheduledPaths
+                ];
+                if (paths.length > 0 && ((_paths_ = paths[0]) === null || _paths_ === void 0 ? void 0 : _paths_.connector)) {
+                    const targetRef = paths[0].connector.targetReference;
+                    if (targetRef) {
+                        return targetRef;
+                    }
+                }
+            }
+        }
+        // No valid start found
+        return "";
+    }
     toXMLString() {
         try {
             return this.generateDoc();
         } catch (exception) {
-            console.warn(`Unable to write xml, caught an error ${exception.toString()}`);
+            const errorMsg = exception instanceof Error ? exception.message : String(exception);
+            console.warn(`Unable to write xml, caught an error: ${errorMsg}`);
             return "";
         }
     }
-    findStart() {
-        let start = "";
-        const flowElements = this.elements.filter((node)=>node instanceof _FlowNode.FlowNode);
-        if (this.startElementReference) {
-            start = this.startElementReference;
-        } else if (flowElements.find((n)=>{
-            return n.subtype === "start";
-        })) {
-            const startElement = flowElements.find((n)=>{
-                return n.subtype === "start";
-            });
-            start = startElement.connectors[0]["reference"];
-        }
-        return start;
-    }
     generateDoc() {
-        // eslint-disable-next-line sonarjs/no-clear-text-protocols
         const flowXmlNamespace = "http://soap.sforce.com/2006/04/metadata";
         const builderOptions = {
             attributeNamePrefix: "@_",
             format: true,
             ignoreAttributes: false,
             suppressBooleanAttributes: false,
-            suppressEmptyNode: false // Keep empty tags (but doesn't force self-closing in pretty)
+            suppressEmptyNode: false
         };
         const builder = new _fastxmlparser.XMLBuilder(builderOptions);
-        // Fallback: Inject xmlns as attribute if missing
         const xmldataWithNs = _object_spread({}, this.xmldata);
         if (!xmldataWithNs["@_xmlns"]) {
             xmldataWithNs["@_xmlns"] = flowXmlNamespace;
         }
-        // Optional: Add xsi if needed (often in parsed data; test has it in root)
         if (!xmldataWithNs["@_xmlns:xsi"]) {
             xmldataWithNs["@_xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance";
         }
-        // Build: Wrap in { Flow: ... }
         const rootObj = {
             Flow: xmldataWithNs
         };
         return builder.build(rootObj);
     }
     constructor(path, data){
-        _define_property(this, "elements", void 0);
-        _define_property(this, "fsPath", void 0); //  This is only set in Node.js environments and is the resolved absolute path. In browser environments, it stays undefined.
-        _define_property(this, "uri", void 0); // This is always set from the constructor's path parameter and represents the input path (could be relative, absolute, or virtual)
+        // Flow elements (excludes legacy start nodes)
+        _define_property(this, "elements", []);
+        // Path properties
+        _define_property(this, "fsPath", void 0); // Resolved absolute path (Node.js only)
+        _define_property(this, "uri", void 0); // Input path (could be relative, absolute, or virtual)
+        // Flow metadata
+        _define_property(this, "label", "");
         _define_property(this, "interviewLabel", void 0);
-        _define_property(this, "label", void 0);
-        _define_property(this, "name", void 0);
+        _define_property(this, "name", "unnamed");
         _define_property(this, "processMetadataValues", void 0);
-        _define_property(this, "processType", void 0);
-        _define_property(this, "root", void 0);
-        _define_property(this, "start", void 0);
-        _define_property(this, "startElementReference", void 0);
-        _define_property(this, "startReference", void 0);
-        _define_property(this, "status", void 0);
+        _define_property(this, "processType", "AutoLaunchedFlow");
+        _define_property(this, "type", ""); // Alias for processType (backward compatibility)
+        _define_property(this, "status", "");
         _define_property(this, "triggerOrder", void 0);
-        _define_property(this, "type", void 0);
+        // Start-related properties
+        /**
+   * @deprecated Use startNode.element instead. Kept for backward compatibility.
+   */ _define_property(this, "start", void 0);
+        /**
+   * Direct reference to first element (from XML attribute).
+   * Used in newer flows as an alternative to the start element.
+   */ _define_property(this, "startElementReference", void 0);
         /**
-   * XML to JSON conversion in raw format
-   */ _define_property(this, "xmldata", void 0);
+   * Computed reference to the first element to execute.
+   * This is what rules should use for traversal.
+   */ _define_property(this, "startReference", void 0);
+        /**
+   * Parsed FlowNode object of the start element.
+   * Contains trigger information and connectors.
+   * Access start element data via startNode.element
+   */ _define_property(this, "startNode", void 0);
+        // Legacy/internal
+        _define_property(this, "root", void 0);
+        _define_property(this, "xmldata", void 0);
         if (path) {
-            this.uri = path; // Always set general URI from input (file path or virtual)
-            // Only resolve fsPath in Node.js environments
-            // In browser with polyfills, fsPath stays undefined
-            if (typeof process !== 'undefined' && process.cwd) {
+            this.uri = path;
+            if (typeof process !== 'undefined' && typeof process.cwd === 'function') {
                 this.fsPath = _path.resolve(path);
             }
             let flowName = _path.basename(_path.basename(path), _path.extname(path));
             if (flowName.includes(".")) {
                 flowName = flowName.split(".")[0];
             }
-            this.name = flowName;
+            this.name = flowName || "unnamed";
         }
         if (data) {
-            const hasFlowElement = typeof data === "object" && "Flow" in data;
+            const hasFlowElement = typeof data === "object" && data !== null && "Flow" in data;
             if (hasFlowElement) {
                 this.xmldata = data.Flow;
-            } else this.xmldata = data;
+            } else {
+                this.xmldata = data;
+            }
             this.preProcessNodes();
         }
     }
@@ -276,7 +310,6 @@ let Flow = class Flow {
     "recordUpdates",
     "recordRollbacks",
     "screens",
-    "start",
     "steps",
     "subflows",
     "waits",

package/main/models/ParsedFlow.d.ts

@@ -3,5 +3,5 @@ export declare class ParsedFlow {
     uri: string;
     flow: Flow | undefined;
     errorMessage?: string;
-    constructor(uri: string, flow: Flow, errorMessage?: string);
+    constructor(uri: string, flow?: Flow, errorMessage?: string);
 }

package/main/models/RuleCommon.d.ts

@@ -16,17 +16,40 @@ export declare abstract class RuleCommon {
     constructor(info: RuleInfo, optional?: {
         severity?: string;
     });
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected abstract check(flow: core.Flow, options: object | undefined, suppressions: Set<string>): core.Violation[];
+    protected isSuppressed(name: string, suppressions: Set<string>): boolean;
     /**
-     * execute() – automatic suppression
+     * Get the start node (the special <start> element).
+     * This is now stored separately in flow.startNode, not in flow.elements.
+     *
+     * @param flow - The Flow instance
+     * @returns The start FlowNode or undefined if not found
      */
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected getStartNode(flow: core.Flow): core.FlowNode | undefined;
     /**
-     * Rules implement this. They should return *all* violations,
-     * NOT pre-filter suppressed ones (unless they need early-exit performance).
+     * Get the reference name of the first actual element (what the flow starts at).
+     * This is the element that comes AFTER the start node.
+     *
+     * @param flow - The Flow instance
+     * @returns The start reference name or undefined
      */
-    protected abstract check(flow: core.Flow, options: object | undefined, suppressions: Set<string>): core.Violation[];
+    protected getStartReference(flow: core.Flow): string | undefined;
     /**
-     * Legacy/manual suppression helper (still available for early exits)
+     * Find the INDEX of the first actual element in a FlowNode array.
+     * Useful for rules that need to iterate by index.
+     *
+     * @param flow - The Flow instance
+     * @param flowElements - Array of FlowNodes (typically from flow.elements)
+     * @returns The index of the starting element, or -1 if not found
      */
-    protected isSuppressed(name: string, suppressions: Set<string>): boolean;
+    protected findStartIndex(flow: core.Flow, flowElements: core.FlowNode[]): number;
+    /**
+     * Safely get a property from the start element.
+     *
+     * @param flow - The Flow instance
+     * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
+     * @returns The property value or undefined
+     */
+    protected getStartProperty(flow: core.Flow, propertyName: string): any;
 }

package/main/models/RuleCommon.js

@@ -64,31 +64,69 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let RuleCommon = class RuleCommon {
-    /**
-   * execute() – automatic suppression
-   */ execute(flow, options, suppressions = []) {
+    execute(flow, options, suppressions = []) {
         // Wildcard suppression disables entire rule
         if (suppressions.includes("*")) {
             return new _internals.RuleResult(this, []);
         }
-        // Convert to Set for fast lookup
         const suppSet = new Set(suppressions);
-        // Raw violations from rule
         let violations = this.check(flow, options, suppSet);
-        // Automatically filter suppressed violations by their .name
         violations = violations.filter((v)=>!suppSet.has(v.name));
-        // Wrap into RuleResult
         return new _internals.RuleResult(this, violations);
     }
-    /**
-   * Legacy/manual suppression helper (still available for early exits)
-   */ isSuppressed(name, suppressions) {
+    isSuppressed(name, suppressions) {
         return suppressions.has(name);
     }
+    /**
+   * Get the start node (the special <start> element).
+   * This is now stored separately in flow.startNode, not in flow.elements.
+   * 
+   * @param flow - The Flow instance
+   * @returns The start FlowNode or undefined if not found
+   */ getStartNode(flow) {
+        return flow.startNode;
+    }
+    /**
+   * Get the reference name of the first actual element (what the flow starts at).
+   * This is the element that comes AFTER the start node.
+   * 
+   * @param flow - The Flow instance
+   * @returns The start reference name or undefined
+   */ getStartReference(flow) {
+        return flow.startReference || undefined;
+    }
+    /**
+   * Find the INDEX of the first actual element in a FlowNode array.
+   * Useful for rules that need to iterate by index.
+   * 
+   * @param flow - The Flow instance
+   * @param flowElements - Array of FlowNodes (typically from flow.elements)
+   * @returns The index of the starting element, or -1 if not found
+   */ findStartIndex(flow, flowElements) {
+        const startRef = this.getStartReference(flow);
+        if (!startRef) {
+            return -1;
+        }
+        return flowElements.findIndex((n)=>n.name === startRef);
+    }
+    /**
+   * Safely get a property from the start element.
+   * 
+   * @param flow - The Flow instance
+   * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
+   * @returns The property value or undefined
+   */ getStartProperty(flow, propertyName) {
+        var _flow_startNode;
+        if ((_flow_startNode = flow.startNode) === null || _flow_startNode === void 0 ? void 0 : _flow_startNode.element) {
+            var _flow_startNode_element;
+            return (_flow_startNode_element = flow.startNode.element) === null || _flow_startNode_element === void 0 ? void 0 : _flow_startNode_element[propertyName];
+        }
+        return undefined;
+    }
     constructor(info, optional){
         _define_property(this, "description", void 0);
         _define_property(this, "docRefs", []);
-        _define_property(this, "isConfigurable", void 0); // Auto-detected by checking if the implemented check() method actually uses "options."
+        _define_property(this, "isConfigurable", void 0);
         _define_property(this, "label", void 0);
         _define_property(this, "name", void 0);
         _define_property(this, "severity", void 0);

package/main/rules/APIVersion.js

@@ -65,7 +65,37 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
         }
         // Custom logic
         if (options === null || options === void 0 ? void 0 : options.expression) {
-            const isValid = new Function(`return ${flowAPIVersionNumber}${options.expression};`)();
+            // Match something like: >= 58
+            const match = options.expression.match(/^\s*(>=|<=|>|<|===|!==)\s*(\d+)\s*$/);
+            if (!match) {
+                // Invalid expression format
+                return [
+                    new _internals.Violation(new _internals.FlowAttribute("Invalid API rule expression", "apiVersion", options.expression))
+                ];
+            }
+            const [, operator, versionStr] = match;
+            const target = parseFloat(versionStr);
+            let isValid = true;
+            switch(operator){
+                case ">":
+                    isValid = flowAPIVersionNumber > target;
+                    break;
+                case "<":
+                    isValid = flowAPIVersionNumber < target;
+                    break;
+                case ">=":
+                    isValid = flowAPIVersionNumber >= target;
+                    break;
+                case "<=":
+                    isValid = flowAPIVersionNumber <= target;
+                    break;
+                case "===":
+                    isValid = flowAPIVersionNumber === target;
+                    break;
+                case "!==":
+                    isValid = flowAPIVersionNumber !== target;
+                    break;
+            }
             if (!isValid) {
                 return [
                     new _internals.Violation(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression))

package/main/rules/DuplicateDMLOperation.d.ts

@@ -4,6 +4,5 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
-    private findStart;
     private flagDML;
 }

package/main/rules/DuplicateDMLOperation.js

@@ -54,13 +54,14 @@ function _interop_require_wildcard(obj, nodeInterop) {
 let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
         const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        const processedElementIndexes = [];
-        const unconnectedElementIndexes = [];
-        const DuplicateDMLOperations = [];
-        const startingNode = this.findStart(flow);
+        // Use the helper to find the starting element index
+        const startingNode = this.findStartIndex(flow, flowElements);
         if (startingNode === -1) {
             return [];
         }
+        const processedElementIndexes = [];
+        const unconnectedElementIndexes = [];
+        const DuplicateDMLOperations = [];
         let dmlFlag = false;
         let indexesToProcess = [
             startingNode
@@ -108,14 +109,6 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
         }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
         return DuplicateDMLOperations.map((det)=>new _internals.Violation(det));
     }
-    findStart(flow) {
-        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        if (flow.startElementReference) {
-            return flowElements.findIndex((n)=>n.name === flow.startElementReference);
-        } else {
-            return flowElements.findIndex((n)=>n.subtype === "start");
-        }
-    }
     flagDML(element, dmlFlag) {
         const dmlStatementTypes = [
             "recordDeletes",

package/main/rules/MissingFaultPath.d.ts

@@ -6,5 +6,9 @@ export declare class MissingFaultPath extends RuleCommon implements IRuleDefinit
     constructor();
     private isValidSubtype;
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
+    /**
+     *  Determine if this is a RecordBeforeSave flow.
+     */
+    private isRecordBeforeSaveFlow;
     private isPartOfFaultHandlingFlow;
 }

package/main/rules/MissingFaultPath.js

@@ -82,14 +82,14 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         return true;
     }
     check(flow, _options, suppressions) {
-        var _flow_elements;
         const compiler = new _internals.Compiler();
         const results = [];
-        const elementsWhereFaultPathIsApplicable = ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>{
+        const elementsWhereFaultPathIsApplicable = flow.elements.filter((node)=>{
             const proxyNode = node;
             return this.isValidSubtype(proxyNode);
-        })).map((e)=>e.name);
-        const isRecordBeforeSave = flow.start.triggerType === "RecordBeforeSave";
+        }).map((e)=>e.name);
+        // Check if this is a RecordBeforeSave flow
+        const isRecordBeforeSave = this.isRecordBeforeSaveFlow(flow);
         const visitCallback = (element)=>{
             var _element_connectors;
             if (!(element === null || element === void 0 ? void 0 : (_element_connectors = element.connectors) === null || _element_connectors === void 0 ? void 0 : _element_connectors.find((connector)=>connector.type === "faultConnector")) && elementsWhereFaultPathIsApplicable.includes(element.name)) {
@@ -104,16 +104,30 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
                 }
             }
         };
-        compiler.traverseFlow(flow, flow.startReference, visitCallback);
+        if (flow.startReference) {
+            compiler.traverseFlow(flow, flow.startReference, visitCallback);
+        }
         return results;
     }
+    /**
+   *  Determine if this is a RecordBeforeSave flow.
+   */ isRecordBeforeSaveFlow(flow) {
+        var _flow_startNode;
+        if ((_flow_startNode = flow.startNode) === null || _flow_startNode === void 0 ? void 0 : _flow_startNode.element) {
+            var _flow_startNode_element;
+            const triggerType = (_flow_startNode_element = flow.startNode.element) === null || _flow_startNode_element === void 0 ? void 0 : _flow_startNode_element["triggerType"];
+            if (triggerType === "RecordBeforeSave") {
+                return true;
+            }
+        }
+        return false;
+    }
     isPartOfFaultHandlingFlow(element, flow) {
-        var _flow_elements;
-        const flowelements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((el)=>el instanceof _internals.FlowNode);
+        const flowelements = flow.elements.filter((el)=>el instanceof _internals.FlowNode);
         for (const otherElement of flowelements){
             if (otherElement !== element) {
                 var _otherElement_connectors;
-                if ((_otherElement_connectors = otherElement.connectors) === null || _otherElement_connectors === void 0 ? void 0 : _otherElement_connectors.find((connector)=>connector.type === "faultConnector" && connector.reference === element.name)) {
+                if ((_otherElement_connectors = otherElement.connectors) === null || _otherElement_connectors === void 0 ? void 0 : _otherElement_connectors.find((connector)=>connector.type === "faultConnector" && connector.reference && connector.reference === element.name)) {
                     return true;
                 }
             }

package/main/rules/MissingFilterRecordTrigger.js

@@ -53,10 +53,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_xmldata_start, _flow_xmldata, _flow_xmldata_start1, _flow_xmldata1, _flow_xmldata_start2, _flow_xmldata2;
+        var _flow_xmldata_start, _flow_xmldata;
         const violations = [];
         // Check if this is a record-triggered flow
-        const triggerType = (_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : (_flow_xmldata_start = _flow_xmldata.start) === null || _flow_xmldata_start === void 0 ? void 0 : _flow_xmldata_start.triggerType;
+        const triggerType = this.getStartProperty(flow, 'triggerType');
         // Only check flows with record trigger types
         if (!triggerType || ![
             "RecordAfterSave",
@@ -65,9 +65,9 @@ let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleC
             return violations;
         }
         // Check if the flow has filters or entry conditions at the flow level
-        const filters = (_flow_xmldata1 = flow.xmldata) === null || _flow_xmldata1 === void 0 ? void 0 : (_flow_xmldata_start1 = _flow_xmldata1.start) === null || _flow_xmldata_start1 === void 0 ? void 0 : _flow_xmldata_start1.filters;
+        const filters = this.getStartProperty(flow, 'filters');
         const hasFilters = !!filters;
-        const scheduledPaths = (_flow_xmldata2 = flow.xmldata) === null || _flow_xmldata2 === void 0 ? void 0 : (_flow_xmldata_start2 = _flow_xmldata2.start) === null || _flow_xmldata_start2 === void 0 ? void 0 : _flow_xmldata_start2.scheduledPaths;
+        const scheduledPaths = (_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : (_flow_xmldata_start = _flow_xmldata.start) === null || _flow_xmldata_start === void 0 ? void 0 : _flow_xmldata_start.scheduledPaths;
         const hasScheduledPaths = !!scheduledPaths;
         // If no filters or scheduled paths (which have their own conditions), flag as violation
         if (!hasFilters && !hasScheduledPaths) {

package/main/rules/RecordIdAsString.js

@@ -53,10 +53,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let RecordIdAsString = class RecordIdAsString extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_start, _flow_start1, _flow_elements;
+        var _flow_elements;
         const violations = [];
         // Skip record-triggered flows - they don't support this pattern
-        const isRecordTriggered = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordAfterSave" || ((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.triggerType) === "RecordBeforeSave";
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const isRecordTriggered = triggerType === "RecordAfterSave" || triggerType === "RecordBeforeDelete" || triggerType === "RecordBeforeSave";
         if (isRecordTriggered) {
             return violations;
         }

package/main/rules/RecursiveAfterUpdate.js

@@ -66,10 +66,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        var _flow_start, _flow_start1, _flow_elements, _flow_elements_filter, _flow_elements1;
+        var _flow_elements, _flow_elements_filter, _flow_elements1;
         const results = [];
-        const isAfterSave = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordAfterSave";
-        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
+        const isAfterSave = triggerType === "RecordAfterSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
         if (!isAfterSave || !isQualifiedTriggerTypes) {
             return results;
         }
@@ -86,7 +88,8 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
             }
         }
         // === Lookup → same object type updates ===
-        const lookupElementsWithTheSameObjectType = (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : (_flow_elements_filter = _flow_elements1.filter((node)=>node.subtype === "recordLookups" && typeof node.element === "object" && "object" in node.element && flow.start.object === node.element["object"])) === null || _flow_elements_filter === void 0 ? void 0 : _flow_elements_filter.map((node)=>node.name);
+        const flowObject = this.getStartProperty(flow, 'object');
+        const lookupElementsWithTheSameObjectType = (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : (_flow_elements_filter = _flow_elements1.filter((node)=>node.subtype === "recordLookups" && typeof node.element === "object" && "object" in node.element && flowObject === node.element["object"])) === null || _flow_elements_filter === void 0 ? void 0 : _flow_elements_filter.map((node)=>node.name);
         if (lookupElementsWithTheSameObjectType == null || typeof lookupElementsWithTheSameObjectType[Symbol.iterator] !== "function") {
             return results;
         }

package/main/rules/SameRecordFieldUpdates.js

@@ -66,10 +66,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_start, _flow_start1, _flow_elements;
+        var _flow_elements;
         const results = [];
-        const isBeforeSaveType = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordBeforeSave";
-        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
+        const isBeforeSaveType = triggerType === "RecordBeforeSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
         if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
             return results;
         }

package/main/rules/TriggerOrder.d.ts

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

package/main/rules/TriggerOrder.js

@@ -10,19 +10,6 @@ Object.defineProperty(exports, "TriggerOrder", {
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
 const _RuleCommon = require("../models/RuleCommon");
-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 _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -66,7 +53,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        if (!("object" in flow.start)) return [];
+        const startObject = this.getStartProperty(flow, "object");
+        // If there's no `object` on the start node, this is NOT a record-triggered flow
+        if (!startObject) {
+            return [];
+        }
+        // This *is* a record-triggered flow → should have triggerOrder
         if (!flow.triggerOrder) {
             return [
                 new _internals.Violation(new _internals.FlowAttribute("TriggerOrder", "TriggerOrder", "10, 20, 30 ..."))
@@ -78,7 +70,7 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
         super({
             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.",
+            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.",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],
@@ -90,9 +82,6 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
             ]
         }, {
             severity: "note"
-        }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([
-            "Create",
-            "Update"
-        ]));
+        });
     }
 };

package/main/rules/UnconnectedElement.d.ts

@@ -4,5 +4,4 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class UnconnectedElement extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
-    private findStart;
 }

package/main/rules/UnconnectedElement.js

@@ -58,18 +58,14 @@ let UnconnectedElement = class UnconnectedElement extends _RuleCommon.RuleCommon
             connectedElements.add(element.name);
         };
         const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        const startIndex = this.findStart(flowElements);
-        if (startIndex !== -1) {
-            new _internals.Compiler().traverseFlow(flow, flowElements[startIndex].name, logConnected);
+        // Use the helper to get the start reference
+        const startRef = this.getStartReference(flow);
+        if (startRef) {
+            new _internals.Compiler().traverseFlow(flow, startRef, logConnected);
         }
         const unconnectedElements = flowElements.filter((element)=>!connectedElements.has(element.name) && !suppressions.has(element.name));
         return unconnectedElements.map((det)=>new _internals.Violation(det));
     }
-    findStart(nodes) {
-        return nodes.findIndex((n)=>{
-            return n.subtype === "start";
-        });
-    }
     constructor(){
         super({
             description: "To maintain the efficiency and manageability of your Flow, it's best to avoid including unconnected elements that are not in use.",

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