@flow-scanner/lightning-flow-scanner-core 6.4.2 → 6.5.0

package/README.md

@@ -15,6 +15,7 @@
   - [Defining Severity Levels](#defining-severity-levels)
   - [Configuring Expressions](#configuring-expressions)
   - [Specifying Exceptions](#specifying-exceptions)
+  - [Report Detail Level](#report-detail-level)
   - [Include Beta Rules](#include-beta-rules)
 - **[Usage](#Usage)**
   - [Examples](#examples)
@@ -27,7 +28,9 @@
 ## Default Rules
 
 <p>📌<strong>Tip:</strong> To link directly to a specific rule, use the full GitHub anchor link format. Example:</p>
-<p><em><a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context">https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context</a></em></i></p>
+<p><em><a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context">https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context</a></em></p>
+
+> Want to code a new rule? → See [How to Write a Rule](docs/write-a-new-rule.md)
 
 ### Action Calls In Loop(Beta)
 
@@ -125,7 +128,7 @@ _[UnusedVariable](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tr
 
 ## Configuration
 
-It is recommended to set up configuration and define:
+Lightning Flow Scanner is plug-and-play by default, but we recommend configuring and defining:
 
 - The rules to be executed.
 - The severity of violating any specific rule.
@@ -201,8 +204,10 @@ Specifying exceptions allows you to exclude specific scenarios from rule enforce
   "exceptions": {
     "<FlowName>": {
       "<RuleName>": [
-        "<ResultName>",   // Suppress specific result
-        "*",              // Suppress ALL results of this rule
+        // Suppress a specific result:
+        "<ResultName>",
+        // Suppress ALL results of rule:
+        "*",
         ...
       ]
     },
@@ -224,6 +229,22 @@ _Example_
 }
 ```
 
+### Report Detail Level
+
+Control the verbosity of violation reports via detailLevel. By default (`enriched`), outputs include element or flow-level details like variable data types, node connectors/locations, or attribute expressions for comprehensive reports. Set to `simple` for lighter output with only line and column numbers.
+
+```json
+{
+  "rules": {
+    ...
+  },
+  "exceptions": {
+    ...
+  },
+  "detailLevel": "simple"
+}
+```
+
 ### Include Beta Rules
 
 New rules are introduced in Beta mode before being added to the default ruleset. To include current Beta rules, enable the optional betamode parameter in your configuration:
@@ -236,15 +257,16 @@ New rules are introduced in Beta mode before being added to the default ruleset.
   "exceptions": {
     ...
   },
-  "betamode": true
+  "betaMode": true
 }
+
 ```
 
 ---
 
 ## Usage
 
-`lightning-flow-scanner-core` can be used as a dependency in Node.js and browser environments, or as a standalone UMD module.
+Use `lightning-flow-scanner-core` as a Node.js/browser dependency or standalone UMD module.
 
 ### Examples
 
@@ -282,7 +304,7 @@ _Retrieves rule definitions used in the scanner._
 
 #### [`parse(selectedUris: any): Promise<ParsedFlow[]>`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/ParseFlows.ts)
 
-_Loads Flow XML files into in-memory models._
+_Loads Flow XML files into in-memory models.(Node.js only)_
 
 #### [`scan(parsedFlows: ParsedFlow[], ruleOptions?: IRulesConfig): ScanResult[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/ScanFlows.ts)
 
@@ -348,14 +370,21 @@ npm install @flow-scanner/lightning-flow-scanner-core
    npm run test
    ```
 
-5. Test as local dependency(Optional):
-   a. run:
+5. Testing the module locally(Optional):
+
+   To link the module, run:
+
+   ```bash
+   npm run link
+   ```
+
+   a. Ad-Hoc Testing with node:
 
    ```bash
    npm run link
    ```
 
-   b. Go to the dependent project (e.g. VSX or CLI) and use:
+   b. Test in a dependent project (e.g. VSX or CLI):
 
    ```bash
    npm link @flow-scanner/lightning-flow-scanner-core
@@ -363,10 +392,18 @@ npm install @flow-scanner/lightning-flow-scanner-core
 
    Your local module will now replace any installed version and update on rebuild.
 
-6. Create a standalone UMD Module(Optional):
+6. Deploy Demo Flows (Optional):
 
-```bash
-  npm run vite:dist // creates UMD at`dist/lightning-flow-scanner-core.umd.js`.
-```
+   ```bash
+   cd assets/example-flows && sf project deploy start &&
+   ```
+
+   Navigate to the [Demo Readme](assets\example-flows\README.md) for full details
+
+7. Create a standalone UMD Module(Optional):
+
+   ```bash
+     npm run vite:dist // creates UMD at`dist/lightning-flow-scanner-core.umd.js`.
+   ```
 
 <p><strong>Want to help improve Lightning Flow Scanner? See our <a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core?tab=contributing-ov-file">Contributing Guidelines</a></strong></p>

package/index.d.ts

@@ -1,5 +1,6 @@
 import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
 import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
+import type { FlatViolation } from "./main/models/FlatViolation";
 import { Compiler } from "./main/libs/Compiler";
 import { exportDetails } from "./main/libs/exportAsDetails";
 import { exportSarif } from "./main/libs/exportAsSarif";
@@ -15,8 +16,8 @@ import { FlowResource } from "./main/models/FlowResource";
 import { FlowType } from "./main/models/FlowType";
 import { FlowVariable } from "./main/models/FlowVariable";
 import { ParsedFlow } from "./main/models/ParsedFlow";
-import { ResultDetails } from "./main/models/ResultDetails";
 import { RuleResult } from "./main/models/RuleResult";
 import { ScanResult } from "./main/models/ScanResult";
-export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, ResultDetails, RuleResult, scan, ScanResult, };
-export type { IRuleDefinition, IRulesConfig };
+import { Violation } from "./main/models/Violation";
+export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, Violation, RuleResult, scan, ScanResult, };
+export type { FlatViolation, IRuleDefinition, IRulesConfig };

package/index.js

@@ -36,15 +36,15 @@ _export(exports, {
     get ParsedFlow () {
         return _ParsedFlow.ParsedFlow;
     },
-    get ResultDetails () {
-        return _ResultDetails.ResultDetails;
-    },
     get RuleResult () {
         return _RuleResult.RuleResult;
     },
     get ScanResult () {
         return _ScanResult.ScanResult;
     },
+    get Violation () {
+        return _Violation.Violation;
+    },
     get exportDetails () {
         return _exportAsDetails.exportDetails;
     },
@@ -82,6 +82,6 @@ const _FlowResource = require("./main/models/FlowResource");
 const _FlowType = require("./main/models/FlowType");
 const _FlowVariable = require("./main/models/FlowVariable");
 const _ParsedFlow = require("./main/models/ParsedFlow");
-const _ResultDetails = require("./main/models/ResultDetails");
 const _RuleResult = require("./main/models/RuleResult");
 const _ScanResult = require("./main/models/ScanResult");
+const _Violation = require("./main/models/Violation");

package/main/interfaces/IRulesConfig.d.ts

@@ -1,7 +1,13 @@
 import { IExceptions } from "./IExceptions";
 import { IRuleOptions } from "./IRuleOptions";
+export declare enum DetailLevel {
+    ENRICHED = "enriched",
+    SIMPLE = "simple"
+}
 export interface IRulesConfig {
+    betaMode?: boolean;
     betamode?: boolean;
+    detailLevel?: 'enriched' | 'simple' | DetailLevel;
     exceptions?: IExceptions;
     rules?: IRuleOptions;
 }

package/main/interfaces/IRulesConfig.js

@@ -2,3 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "DetailLevel", {
+    enumerable: true,
+    get: function() {
+        return DetailLevel;
+    }
+});
+var DetailLevel = /*#__PURE__*/ function(DetailLevel) {
+    DetailLevel["ENRICHED"] = "enriched";
+    DetailLevel["SIMPLE"] = "simple";
+    return DetailLevel;
+}({});

package/main/internals/internals.d.ts

@@ -1,17 +1,18 @@
 import type { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import type { IRulesConfig } from "../interfaces/IRulesConfig";
 import { Compiler } from "../libs/Compiler";
+import { FlatViolation } from "../models/FlatViolation";
 import { Flow } from "../models/Flow";
 import { FlowAttribute } from "../models/FlowAttribute";
 import { FlowElement } from "../models/FlowElement";
-import { FlowType } from "../models/FlowType";
 import { FlowNode } from "../models/FlowNode";
 import { FlowResource } from "../models/FlowResource";
+import { FlowType } from "../models/FlowType";
 import { FlowVariable } from "../models/FlowVariable";
-import { ResultDetails } from "../models/ResultDetails";
+import { ParsedFlow } from "../models/ParsedFlow";
+import { RuleCommon } from "../models/RuleCommon";
 import { RuleResult } from "../models/RuleResult";
 import { ScanResult } from "../models/ScanResult";
-import { RuleCommon } from "../models/RuleCommon";
-import { ParsedFlow } from "../models/ParsedFlow";
-export { FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, ResultDetails, RuleCommon, ParsedFlow, };
+import { Violation } from "../models/Violation";
+export { FlatViolation, FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, Violation, RuleCommon, ParsedFlow, };
 export type { IRuleDefinition, IRulesConfig };

package/main/internals/internals.js

@@ -12,6 +12,9 @@ _export(exports, {
     get Compiler () {
         return _Compiler.Compiler;
     },
+    get FlatViolation () {
+        return _FlatViolation.FlatViolation;
+    },
     get Flow () {
         return _Flow.Flow;
     },
@@ -36,9 +39,6 @@ _export(exports, {
     get ParsedFlow () {
         return _ParsedFlow.ParsedFlow;
     },
-    get ResultDetails () {
-        return _ResultDetails.ResultDetails;
-    },
     get RuleCommon () {
         return _RuleCommon.RuleCommon;
     },
@@ -47,18 +47,22 @@ _export(exports, {
     },
     get ScanResult () {
         return _ScanResult.ScanResult;
+    },
+    get Violation () {
+        return _Violation.Violation;
     }
 });
 const _Compiler = require("../libs/Compiler");
+const _FlatViolation = require("../models/FlatViolation");
 const _Flow = require("../models/Flow");
 const _FlowAttribute = require("../models/FlowAttribute");
 const _FlowElement = require("../models/FlowElement");
-const _FlowType = require("../models/FlowType");
 const _FlowNode = require("../models/FlowNode");
 const _FlowResource = require("../models/FlowResource");
+const _FlowType = require("../models/FlowType");
 const _FlowVariable = require("../models/FlowVariable");
-const _ResultDetails = require("../models/ResultDetails");
+const _ParsedFlow = require("../models/ParsedFlow");
+const _RuleCommon = require("../models/RuleCommon");
 const _RuleResult = require("../models/RuleResult");
 const _ScanResult = require("../models/ScanResult");
-const _RuleCommon = require("../models/RuleCommon");
-const _ParsedFlow = require("../models/ParsedFlow");
+const _Violation = require("../models/Violation");

package/main/libs/GetRuleDefinitions.d.ts

@@ -1,5 +1,5 @@
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import { IRulesConfig } from "../interfaces/IRulesConfig";
+export declare function getBetaRules(): IRuleDefinition[];
 export declare function GetRuleDefinitions(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[];
 export declare function getRules(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[];
-export declare function getBetaRules(): IRuleDefinition[];

package/main/libs/GetRuleDefinitions.js

@@ -21,9 +21,12 @@ _export(exports, {
 });
 const _DefaultRuleStore = require("../store/DefaultRuleStore");
 const _DynamicRule = require("./DynamicRule");
+function getBetaRules() {
+    return getBetaDefinition();
+}
 function GetRuleDefinitions(ruleConfig, options) {
     const selectedRules = [];
-    const includeBeta = (options === null || options === void 0 ? void 0 : options.betamode) === true;
+    const includeBeta = (options === null || options === void 0 ? void 0 : options.betaMode) === true || (options === null || options === void 0 ? void 0 : options.betamode) === true;
     if (ruleConfig && ruleConfig instanceof Map) {
         for (const ruleName of ruleConfig.keys()){
             let severity = "warning";
@@ -49,8 +52,7 @@ function GetRuleDefinitions(ruleConfig, options) {
             selectedRules.push(matchedRule);
         }
     }
-    // Append all beta rules if opted in (skip if already included via config/default)
-    if (includeBeta) {
+    if (includeBeta && _DefaultRuleStore.BetaRuleStore && typeof _DefaultRuleStore.BetaRuleStore === 'object' && !Array.isArray(_DefaultRuleStore.BetaRuleStore)) {
         for(const betaRuleName in _DefaultRuleStore.BetaRuleStore){
             if (!selectedRules.some((r)=>r.name === betaRuleName)) {
                 const betaRule = new _DynamicRule.DynamicRule(betaRuleName);
@@ -73,9 +75,6 @@ function getRules(ruleNames, options) {
         return GetRuleDefinitions(undefined, options);
     }
 }
-function getBetaRules() {
-    return getBetaDefinition();
-}
 function getBetaDefinition() {
     return Object.values(_DefaultRuleStore.BetaRuleStore).map((rule)=>new rule());
 }

package/main/libs/ScanFlows.js

@@ -17,6 +17,8 @@ _export(exports, {
     }
 });
 const _internals = require("../../main/internals/internals");
+const _IRulesConfig = require("../interfaces/IRulesConfig");
+const _Violation = require("../models/Violation");
 const _GetRuleDefinitions = require("./GetRuleDefinitions");
 function scan(parsedFlows, ruleOptions) {
     const flows = [];
@@ -26,11 +28,13 @@ function scan(parsedFlows, ruleOptions) {
         }
     }
     const scanResults = ScanFlows(flows, ruleOptions);
-    return scanResults; // generalSuppressions removed — suppression now inline
+    return scanResults;
 }
 function ScanFlows(flows, ruleOptions) {
     const flowResults = [];
     let selectedRules = [];
+    const rawMode = ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.detailLevel;
+    const detailLevel = typeof rawMode === 'string' && rawMode.toLowerCase() === 'simple' ? _IRulesConfig.DetailLevel.SIMPLE : _IRulesConfig.DetailLevel.ENRICHED;
     if ((ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) && Object.keys(ruleOptions.rules).length > 0) {
         const ruleMap = new Map();
         for (const [ruleName, config] of Object.entries(ruleOptions.rules)){
@@ -40,7 +44,9 @@ function ScanFlows(flows, ruleOptions) {
     } else {
         selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)();
     }
-    for (const flow of flows){
+    const flowXmlCache = new Map();
+    for (const flowInput of flows){
+        const flow = flowInput instanceof _internals.Flow ? flowInput : _internals.Flow.from(flowInput);
         const ruleResults = [];
         for (const rule of selectedRules){
             try {
@@ -53,7 +59,6 @@ function ScanFlows(flows, ruleOptions) {
                 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];
                 }
-                // WILDCARD SUPPORT: "*" = suppress all
                 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("*")) ? [
                     "*"
@@ -62,6 +67,16 @@ function ScanFlows(flows, ruleOptions) {
                 if (result.severity !== rule.severity) {
                     result.severity = rule.severity;
                 }
+                if (result.details.length > 0) {
+                    let flowXml = flowXmlCache.get(flow.name);
+                    if (!flowXml) {
+                        flowXml = flow.toXMLString();
+                        flowXmlCache.set(flow.name, flowXml);
+                    }
+                    if (flowXml) {
+                        (0, _Violation.enrichViolationsWithLineNumbers)(result.details, flowXml);
+                    }
+                }
                 ruleResults.push(result);
             } catch (error) {
                 const message = `Something went wrong while executing ${rule.name} in the Flow: ${flow.name} with error ${error}`;
@@ -69,6 +84,17 @@ function ScanFlows(flows, ruleOptions) {
             }
         }
         flowResults.push(new _internals.ScanResult(flow, ruleResults));
+        flowXmlCache.delete(flow.name);
+    }
+    flowXmlCache.clear();
+    if (detailLevel === _IRulesConfig.DetailLevel.SIMPLE) {
+        flowResults.forEach((scanResult)=>{
+            scanResult.ruleResults.forEach((ruleResult)=>{
+                ruleResult.details.forEach((violation)=>{
+                    delete violation.details;
+                });
+            });
+        });
     }
     return flowResults;
 }

package/main/libs/exportAsDetails.d.ts

@@ -1,16 +1,3 @@
+import { FlatViolation } from "../models/FlatViolation";
 import { ScanResult } from "../models/ScanResult";
-export interface FlatViolation {
-    connectsTo?: string;
-    dataType?: string;
-    expression?: string;
-    flowFile: string;
-    flowName: string;
-    locationX?: string;
-    locationY?: string;
-    metaType: string;
-    name: string;
-    ruleName: string;
-    severity: string;
-    type: string;
-}
-export declare function exportDetails(results: ScanResult[]): FlatViolation[];
+export declare function exportDetails(results: ScanResult[], includeDetails?: boolean): FlatViolation[];

package/main/libs/exportAsDetails.js

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -8,36 +8,79 @@ Object.defineProperty(exports, "exportDetails", {
         return exportDetails;
     }
 });
-function exportDetails(results) {
-    const violations = [];
-    for (const result of results){
+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;
+}
+function exportDetails(results, includeDetails = false) {
+    return results.flatMap((result)=>{
         const flow = result.flow;
         const flowName = flow.label || flow.name;
         const flowFile = flow.fsPath ? flow.fsPath.replace(/\\/g, "/") : `${flow.name}.flow-meta.xml`;
-        for (const rule of result.ruleResults){
+        return result.ruleResults.filter((rule)=>{
             var _rule_details;
-            if (!rule.occurs || !((_rule_details = rule.details) === null || _rule_details === void 0 ? void 0 : _rule_details.length)) continue;
-            const ruleName = rule.ruleDefinition.label || rule.ruleName;
-            var _rule_severity;
-            const severity = (_rule_severity = rule.severity) !== null && _rule_severity !== void 0 ? _rule_severity : "error";
-            for (const detail of rule.details){
-                const d = detail.details || {};
-                violations.push({
-                    connectsTo: Array.isArray(d.connectsTo) ? d.connectsTo.join("; ") : d.connectsTo,
-                    dataType: d.dataType,
-                    expression: d.expression,
+            return rule.occurs && ((_rule_details = rule.details) === null || _rule_details === void 0 ? void 0 : _rule_details.length);
+        }).flatMap((rule)=>rule.details.map((detail)=>{
+                // Exclude details by default (via Omit), add conditionally
+                const base = detail;
+                var _rule_severity;
+                const exported = _object_spread_props(_object_spread({}, base, includeDetails && detail.details ? {
+                    details: detail.details
+                } : {}), {
                     flowFile,
                     flowName,
-                    locationX: d.locationX,
-                    locationY: d.locationY,
-                    metaType: detail.metaType,
-                    name: detail.name,
-                    ruleName,
-                    severity,
-                    type: detail.type
+                    ruleName: rule.ruleDefinition.label || rule.ruleName,
+                    severity: (_rule_severity = rule.severity) !== null && _rule_severity !== void 0 ? _rule_severity : "error"
                 });
-            }
-        }
-    }
-    return violations;
+                return exported;
+            }));
+    });
 }

package/main/libs/exportAsSarif.js

@@ -58,7 +58,7 @@ function exportSarif(results) {
                                         index: 0,
                                         uri
                                     },
-                                    region: mapRegion(d, result.flow.toXMLString() || "")
+                                    region: mapRegion(d)
                                 }
                             }
                         ],
@@ -100,26 +100,27 @@ function exportSarif(results) {
     }, null, 2);
 }
 function getUri(flow) {
-    return flow.fsPath ? flow.fsPath.replace(/\\/g, "/") : `flows/${flow.name}.flow-meta.xml`;
-}
-function mapRegion(detail, rawXml = "") {
-    if (!rawXml) return {
-        startLine: 1,
-        startColumn: 1
-    };
-    const lines = rawXml.split("\n");
-    const name = detail.name;
-    for(let i = 0; i < lines.length; i++){
-        if (lines[i].includes(`<name>${name}</name>`)) {
-            return {
-                startLine: i + 1,
-                startColumn: lines[i].indexOf(name) + 1
-            };
+    // Prefer uri (works in both browser and Node)
+    if (flow.uri) {
+        return flow.uri.replace(/\\/g, "/");
+    }
+    // Node only: fsPath is only set in Node environments
+    if (flow.fsPath) {
+        const match = flow.fsPath.match(/(?:force-app|src)\/.+$/);
+        if (match) {
+            return match[0].replace(/\\/g, "/");
         }
+        return flow.fsPath.replace(/\\/g, "/");
     }
+    return `flows/${flow.name}.flow-meta.xml`;
+}
+function mapRegion(detail) {
+    var _detail_columnNumber, _detail_lineNumber;
+    // Use pre-enriched line/column from Violation (added by enrichViolationsWithLineNumbers)
+    // Fallback if somehow missing (e.g., unenriched legacy data)
     return {
-        startLine: 1,
-        startColumn: 1
+        startColumn: (_detail_columnNumber = detail.columnNumber) !== null && _detail_columnNumber !== void 0 ? _detail_columnNumber : 1,
+        startLine: (_detail_lineNumber = detail.lineNumber) !== null && _detail_lineNumber !== void 0 ? _detail_lineNumber : 1
     };
 }
 function mapSeverity(sev) {

package/main/models/FlatViolation.d.ts

@@ -0,0 +1,7 @@
+import { Violation } from "./Violation";
+export interface FlatViolation extends Omit<Violation, 'details'> {
+    flowFile: string;
+    flowName: string;
+    ruleName: string;
+    severity: string;
+}

package/main/models/Flow.d.ts

@@ -1,31 +1,39 @@
 import { FlowElement } from "./FlowElement";
 export declare class Flow {
+    /**
+     * Metadata Tags of Salesforce Flow Elements
+     */
+    static readonly FLOW_METADATA_TAGS: readonly ["description", "apiVersion", "processMetadataValues", "processType", "interviewLabel", "label", "status", "runInMode", "startElementReference", "isTemplate", "fullName", "timeZoneSidKey", "isAdditionalPermissionRequiredToRun", "migratedFromWorkflowRuleName", "triggerOrder", "environments", "segment"];
+    /**
+     * Categorized flow contents that should be used in the rule implementation
+     */
+    static readonly FLOW_NODES: readonly ["actionCalls", "apexPluginCalls", "assignments", "collectionProcessors", "decisions", "loops", "orchestratedStages", "recordCreates", "recordDeletes", "recordLookups", "recordUpdates", "recordRollbacks", "screens", "start", "steps", "subflows", "waits", "transforms", "customErrors"];
+    static readonly FLOW_RESOURCES: readonly ["textTemplates", "stages"];
+    static readonly FLOW_VARIABLES: readonly ["choices", "constants", "dynamicChoiceSets", "formulas", "variables"];
     /**
      * Categorized flow contents that should be used in the rule implementation
      */
     elements?: FlowElement[];
-    fsPath: any;
+    fsPath?: string;
+    uri?: string;
     interviewLabel?: string;
     label: string;
     name?: string;
     processMetadataValues?: any;
-    processType?: any;
+    processType?: string;
     root?: any;
     start?: any;
-    startElementReference?: any;
-    startReference: any;
-    status?: any;
+    startElementReference?: string;
+    startReference?: string;
+    status?: string;
     triggerOrder?: number;
-    type?: any;
+    type?: string;
     /**
      * XML to JSON conversion in raw format
      */
     xmldata: any;
-    private flowMetadata;
-    private flowNodes;
-    private flowResources;
-    private flowVariables;
     constructor(path?: string, data?: unknown);
+    static from(obj: Partial<Flow>): Flow;
     preProcessNodes(): void;
     toXMLString(): string;
     private findStart;