@memberjunction/react-test-harness 2.94.0 → 2.95.0

package/dist/lib/component-linter.js

@@ -91,7 +91,8 @@ function getLineNumber(code, index) {
 // These will be evaluated at TypeScript compile time and become static arrays
 const runQueryResultProps = [
     'QueryID', 'QueryName', 'Success', 'Results', 'RowCount',
-    'TotalRowCount', 'ExecutionTime', 'ErrorMessage'
+    'TotalRowCount', 'ExecutionTime', 'ErrorMessage', 'AppliedParameters',
+    'CacheHit', 'CacheKey', 'CacheTTLRemaining'
 ];
 const runViewResultProps = [
     'Success', 'Results', 'UserViewRunID', 'RowCount',
@@ -152,13 +153,78 @@ class ComponentLinter {
         }
         return isFromMethod;
     }
+    static async validateComponentSyntax(code, componentName) {
+        try {
+            const parseResult = parser.parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                errorRecovery: true,
+                ranges: true
+            });
+            if (parseResult.errors && parseResult.errors.length > 0) {
+                const errors = parseResult.errors.map((error) => {
+                    const location = error.loc ? `Line ${error.loc.line}, Column ${error.loc.column}` : 'Unknown location';
+                    return `${location}: ${error.message || error.toString()}`;
+                });
+                return {
+                    valid: false,
+                    errors
+                };
+            }
+            return {
+                valid: true,
+                errors: []
+            };
+        }
+        catch (error) {
+            // Handle catastrophic parse failures
+            const errorMessage = error instanceof Error ? error.message : 'Unknown parsing error';
+            return {
+                valid: false,
+                errors: [`Failed to parse component: ${errorMessage}`]
+            };
+        }
+    }
     static async lintComponent(code, componentName, componentSpec, isRootComponent, contextUser, debugMode, options) {
         try {
-            const ast = parser.parse(code, {
+            // Parse with error recovery to get both AST and errors
+            const parseResult = parser.parse(code, {
                 sourceType: 'module',
                 plugins: ['jsx', 'typescript'],
-                errorRecovery: true
+                errorRecovery: true,
+                attachComment: false,
+                ranges: true,
+                tokens: false
             });
+            // Check for syntax errors from parser
+            const syntaxViolations = [];
+            if (parseResult.errors && parseResult.errors.length > 0) {
+                for (const error of parseResult.errors) {
+                    const err = error; // Babel parser errors don't have proper types
+                    syntaxViolations.push({
+                        rule: 'syntax-error',
+                        severity: 'critical',
+                        line: err.loc?.line || 0,
+                        column: err.loc?.column || 0,
+                        message: `Syntax error in component "${componentName}": ${err.message || err.toString()}`,
+                        code: err.code || 'BABEL_PARSER_ERROR'
+                    });
+                }
+            }
+            // If we have critical syntax errors, return immediately with those
+            if (syntaxViolations.length > 0) {
+                return {
+                    success: false,
+                    violations: syntaxViolations,
+                    suggestions: this.generateSyntaxErrorSuggestions(syntaxViolations),
+                    criticalCount: syntaxViolations.length,
+                    highCount: 0,
+                    mediumCount: 0,
+                    lowCount: 0
+                };
+            }
+            // Continue with existing linting logic
+            const ast = parseResult;
             // Use universal rules for all components in the new pattern
             let rules = this.universalComponentRules;
             // Filter rules based on component type and appliesTo property
@@ -1027,6 +1093,32 @@ const { ModelTreeView, PromptTable, FilterPanel } = components;
 // All these will be available`
                     });
                     break;
+                case 'component-usage-without-destructuring':
+                    suggestions.push({
+                        violation: violation.rule,
+                        suggestion: 'Components must be properly accessed - either destructure from components prop or use dot notation',
+                        example: `// ❌ WRONG - Using component without destructuring:
+function MyComponent({ components }) {
+  return <AccountList />; // Error: AccountList not destructured
+}
+
+// ✅ CORRECT - Option 1: Destructure from components
+function MyComponent({ components }) {
+  const { AccountList } = components;
+  return <AccountList />;
+}
+
+// ✅ CORRECT - Option 2: Use dot notation
+function MyComponent({ components }) {
+  return <components.AccountList />;
+}
+
+// ✅ CORRECT - Option 3: Destructure in function parameters
+function MyComponent({ components: { AccountList } }) {
+  return <AccountList />;
+}`
+                    });
+                    break;
                 case 'unsafe-array-access':
                     suggestions.push({
                         violation: violation.rule,
@@ -1595,6 +1687,40 @@ setData(queryResult.Results || []);  // NOT queryResult directly!
         }
         return suggestions;
     }
+    static generateSyntaxErrorSuggestions(violations) {
+        const suggestions = [];
+        for (const violation of violations) {
+            if (violation.message.includes('Unterminated string')) {
+                suggestions.push({
+                    violation: violation.rule,
+                    suggestion: 'Check that all string literals are properly closed with matching quotes',
+                    example: 'Template literals with interpolation must use backticks: `text ${variable} text`'
+                });
+            }
+            else if (violation.message.includes('Unexpected token') || violation.message.includes('export')) {
+                suggestions.push({
+                    violation: violation.rule,
+                    suggestion: 'Ensure all code is within the component function body',
+                    example: 'Remove any export statements or code outside the function definition'
+                });
+            }
+            else if (violation.message.includes('import') && violation.message.includes('top level')) {
+                suggestions.push({
+                    violation: violation.rule,
+                    suggestion: 'Import statements are not allowed in components - use props instead',
+                    example: 'Access libraries through props: const { React, MaterialUI } = props.components'
+                });
+            }
+            else {
+                suggestions.push({
+                    violation: violation.rule,
+                    suggestion: 'Fix the syntax error before the component can be compiled',
+                    example: 'Review the code at the specified line and column for syntax issues'
+                });
+            }
+        }
+        return suggestions;
+    }
     /**
      * Apply library-specific lint rules based on ComponentLibrary LintRules field
      */
@@ -2028,34 +2154,69 @@ ComponentLinter.universalComponentRules = [
         appliesTo: 'all',
         test: (ast, componentName, componentSpec) => {
             const violations = [];
+            // Track if we're inside the main function and where it ends
+            let mainFunctionEnd = 0;
+            // First pass: find the main component function
+            (0, traverse_1.default)(ast, {
+                FunctionDeclaration(path) {
+                    if (path.node.id?.name === componentName) {
+                        mainFunctionEnd = path.node.loc?.end.line || 0;
+                        path.stop(); // Stop traversing once we find it
+                    }
+                },
+                FunctionExpression(path) {
+                    // Check for function expressions assigned to const/let/var
+                    const parent = path.parent;
+                    if (t.isVariableDeclarator(parent) &&
+                        t.isIdentifier(parent.id) &&
+                        parent.id.name === componentName) {
+                        mainFunctionEnd = path.node.loc?.end.line || 0;
+                        path.stop();
+                    }
+                },
+                ArrowFunctionExpression(path) {
+                    // Check for arrow functions assigned to const/let/var
+                    const parent = path.parent;
+                    if (t.isVariableDeclarator(parent) &&
+                        t.isIdentifier(parent.id) &&
+                        parent.id.name === componentName) {
+                        mainFunctionEnd = path.node.loc?.end.line || 0;
+                        path.stop();
+                    }
+                }
+            });
+            // Second pass: check for export statements
             (0, traverse_1.default)(ast, {
                 ExportNamedDeclaration(path) {
+                    const line = path.node.loc?.start.line || 0;
                     violations.push({
                         rule: 'no-export-statements',
                         severity: 'critical',
-                        line: path.node.loc?.start.line || 0,
+                        line: line,
                         column: path.node.loc?.start.column || 0,
-                        message: `Component "${componentName}" contains an export statement. Interactive components are self-contained and cannot export values.`,
+                        message: `Component "${componentName}" contains an export statement${mainFunctionEnd > 0 && line > mainFunctionEnd ? ' after the component function' : ''}. Interactive components are self-contained and cannot export values.`,
                         code: path.toString().substring(0, 100)
                     });
                 },
                 ExportDefaultDeclaration(path) {
+                    const line = path.node.loc?.start.line || 0;
                     violations.push({
                         rule: 'no-export-statements',
                         severity: 'critical',
-                        line: path.node.loc?.start.line || 0,
+                        line: line,
                         column: path.node.loc?.start.column || 0,
-                        message: `Component "${componentName}" contains an export default statement. Interactive components are self-contained and cannot export values.`,
+                        message: `Component "${componentName}" contains an export default statement${mainFunctionEnd > 0 && line > mainFunctionEnd ? ' after the component function' : ''}. Interactive components are self-contained and cannot export values.`,
                         code: path.toString().substring(0, 100)
                     });
                 },
                 ExportAllDeclaration(path) {
+                    const line = path.node.loc?.start.line || 0;
                     violations.push({
                         rule: 'no-export-statements',
                         severity: 'critical',
-                        line: path.node.loc?.start.line || 0,
+                        line: line,
                         column: path.node.loc?.start.column || 0,
-                        message: `Component "${componentName}" contains an export * statement. Interactive components are self-contained and cannot export values.`,
+                        message: `Component "${componentName}" contains an export * statement${mainFunctionEnd > 0 && line > mainFunctionEnd ? ' after the component function' : ''}. Interactive components are self-contained and cannot export values.`,
                         code: path.toString().substring(0, 100)
                     });
                 }
@@ -2394,7 +2555,8 @@ ComponentLinter.universalComponentRules = [
             const libraryMap = new Map();
             if (componentSpec?.libraries) {
                 for (const lib of componentSpec.libraries) {
-                    if (lib.globalVariable) {
+                    // Skip empty library objects or those without required fields
+                    if (lib.globalVariable && lib.name) {
                         // Store both the library name and globalVariable for lookup
                         libraryMap.set(lib.name.toLowerCase(), lib.globalVariable);
                         libraryMap.set(lib.globalVariable.toLowerCase(), lib.globalVariable);
@@ -2695,8 +2857,11 @@ ComponentLinter.universalComponentRules = [
             const libraryGlobals = new Map();
             if (componentSpec?.libraries) {
                 for (const lib of componentSpec.libraries) {
-                    // Store both the exact name and lowercase for comparison
-                    libraryGlobals.set(lib.name.toLowerCase(), lib.globalVariable);
+                    // Skip empty library objects or those without required fields
+                    if (lib.name && lib.globalVariable) {
+                        // Store both the exact name and lowercase for comparison
+                        libraryGlobals.set(lib.name.toLowerCase(), lib.globalVariable);
+                    }
                 }
             }
             (0, traverse_1.default)(ast, {
@@ -2879,6 +3044,7 @@ ComponentLinter.universalComponentRules = [
                 // Track JSX element usage
                 JSXElement(path) {
                     const openingElement = path.node.openingElement;
+                    // Check for direct usage (e.g., <ComponentName>)
                     if (t.isJSXIdentifier(openingElement.name) && /^[A-Z]/.test(openingElement.name.name)) {
                         const componentName = openingElement.name.name;
                         // Only track if it's from our destructured components
@@ -2886,6 +3052,18 @@ ComponentLinter.universalComponentRules = [
                             componentsUsedInJSX.add(componentName);
                         }
                     }
+                    // Also check for components.X pattern (e.g., <components.ComponentName>)
+                    if (t.isJSXMemberExpression(openingElement.name)) {
+                        if (t.isJSXIdentifier(openingElement.name.object) &&
+                            openingElement.name.object.name === 'components' &&
+                            t.isJSXIdentifier(openingElement.name.property)) {
+                            const componentName = openingElement.name.property.name;
+                            // Track usage of components accessed via dot notation
+                            if (componentsFromProps.has(componentName)) {
+                                componentsUsedInJSX.add(componentName);
+                            }
+                        }
+                    }
                 }
             });
             // Only check if we found a components prop
@@ -2905,6 +3083,75 @@ ComponentLinter.universalComponentRules = [
             return violations;
         }
     },
+    {
+        name: 'component-not-in-dependencies',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Get the list of available component names from dependencies
+            const availableComponents = new Set();
+            if (componentSpec?.dependencies) {
+                for (const dep of componentSpec.dependencies) {
+                    if (dep.name) {
+                        availableComponents.add(dep.name);
+                    }
+                }
+            }
+            (0, traverse_1.default)(ast, {
+                // Check for components.X usage in JSX
+                JSXElement(path) {
+                    const openingElement = path.node.openingElement;
+                    // Check for components.X pattern (e.g., <components.Loading>)
+                    if (t.isJSXMemberExpression(openingElement.name)) {
+                        if (t.isJSXIdentifier(openingElement.name.object) &&
+                            openingElement.name.object.name === 'components' &&
+                            t.isJSXIdentifier(openingElement.name.property)) {
+                            const componentName = openingElement.name.property.name;
+                            // Check if this component is NOT in the dependencies
+                            if (!availableComponents.has(componentName)) {
+                                violations.push({
+                                    rule: 'component-not-in-dependencies',
+                                    severity: 'critical',
+                                    line: openingElement.loc?.start.line || 0,
+                                    column: openingElement.loc?.start.column || 0,
+                                    message: `Component "${componentName}" is used via components.${componentName} but is not defined in the component spec's dependencies array. This will cause a runtime error.`,
+                                    code: `<components.${componentName}>`
+                                });
+                            }
+                        }
+                    }
+                },
+                // Also check for components.X usage in JavaScript expressions
+                MemberExpression(path) {
+                    if (t.isIdentifier(path.node.object) &&
+                        path.node.object.name === 'components' &&
+                        t.isIdentifier(path.node.property)) {
+                        const componentName = path.node.property.name;
+                        // Skip if this is a method call like components.hasOwnProperty
+                        const parent = path.parent;
+                        if (t.isCallExpression(parent) && parent.callee === path.node) {
+                            // Check if it looks like a component (starts with uppercase)
+                            if (!/^[A-Z]/.test(componentName)) {
+                                return; // Skip built-in methods
+                            }
+                        }
+                        // Check if this component is NOT in the dependencies
+                        if (/^[A-Z]/.test(componentName) && !availableComponents.has(componentName)) {
+                            violations.push({
+                                rule: 'component-not-in-dependencies',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Component "${componentName}" is accessed via components.${componentName} but is not defined in the component spec's dependencies array. This will cause a runtime error.`,
+                                code: `components.${componentName}`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
     // DISABLED: Consolidated into unsafe-array-operations rule
     // {
     //   name: 'unsafe-array-access',
@@ -3697,7 +3944,23 @@ ComponentLinter.universalComponentRules = [
                                         severity: 'critical',
                                         line: path.node.arguments[0].loc?.start.line || 0,
                                         column: path.node.arguments[0].loc?.start.column || 0,
-                                        message: `RunViews expects an array of RunViewParams objects, not a ${t.isObjectExpression(path.node.arguments[0]) ? 'single object' : 'non-array'}. Use: RunViews([{ EntityName: 'Entity1' }, { EntityName: 'Entity2' }])`,
+                                        message: `RunViews expects an array of RunViewParams objects, not a ${t.isObjectExpression(path.node.arguments[0]) ? 'single object' : 'non-array'}.
+Use: RunViews([
+  { 
+    EntityName: 'Entity1',
+    ExtraFilter: 'IsActive = 1',
+    Fields: 'ID, Name',
+    StartRow: 0,
+    MaxRows: 50
+  },
+  { 
+    EntityName: 'Entity2',
+    OrderBy: 'CreatedAt DESC',
+    StartRow: 0,
+    MaxRows: 100
+  }
+])
+Each object supports: EntityName, ExtraFilter, Fields, OrderBy, MaxRows, StartRow, ResultType`,
                                         code: path.toString().substring(0, 100)
                                     });
                                 }
@@ -3718,7 +3981,16 @@ ComponentLinter.universalComponentRules = [
                                         severity: 'critical',
                                         line: path.node.arguments[0].loc?.start.line || 0,
                                         column: path.node.arguments[0].loc?.start.column || 0,
-                                        message: `RunView expects a RunViewParams object, not ${argType === 'array' ? 'an' : 'a'} ${argType}. Use: RunView({ EntityName: 'YourEntity' }) or for multiple use RunViews([...])`,
+                                        message: `RunView expects a RunViewParams object, not ${argType === 'array' ? 'an' : 'a'} ${argType}.
+Use: RunView({ 
+  EntityName: 'YourEntity',
+  ExtraFilter: 'Status = "Active"',  // Optional WHERE clause
+  Fields: 'ID, Name, Status',        // Optional columns to return
+  OrderBy: 'Name ASC',                // Optional sort
+  StartRow: 0,                        // Optional offset (0-based)
+  MaxRows: 100                        // Optional limit
+})
+Valid properties: EntityName, ExtraFilter, Fields, OrderBy, MaxRows, StartRow, ResultType`,
                                         code: path.toString().substring(0, 100)
                                     });
                                 }
@@ -3804,7 +4076,15 @@ ComponentLinter.universalComponentRules = [
                                 severity: 'critical',
                                 line: path.node.loc?.start.line || 0,
                                 column: path.node.loc?.start.column || 0,
-                                message: `RunQuery requires a RunQueryParams object as the first parameter. Must provide an object with either QueryID or QueryName.`,
+                                message: `RunQuery requires a RunQueryParams object as the first parameter.
+Use: RunQuery({ 
+  QueryName: 'YourQuery',             // Or use QueryID: 'uuid'
+  Parameters: {                       // Optional query parameters
+    param1: 'value1'
+  },
+  StartRow: 0,                        // Optional offset (0-based)
+  MaxRows: 100                        // Optional limit
+})`,
                                 code: `RunQuery()`
                             });
                         }
@@ -3818,7 +4098,17 @@ ComponentLinter.universalComponentRules = [
                                 severity: 'critical',
                                 line: path.node.arguments[0].loc?.start.line || 0,
                                 column: path.node.arguments[0].loc?.start.column || 0,
-                                message: `RunQuery expects a RunQueryParams object, not a ${argType}. Use: RunQuery({ QueryName: 'YourQuery' }) or RunQuery({ QueryID: 'id' })`,
+                                message: `RunQuery expects a RunQueryParams object, not a ${argType}.
+Use: RunQuery({ 
+  QueryName: 'YourQuery',             // Or use QueryID: 'uuid'
+  Parameters: {                       // Optional query parameters
+    startDate: '2024-01-01',
+    endDate: '2024-12-31'
+  },
+  StartRow: 0,                        // Optional offset (0-based)
+  MaxRows: 100                        // Optional limit
+})
+Valid properties: QueryID, QueryName, CategoryID, CategoryPath, Parameters, MaxRows, StartRow, ForceAuditLog, AuditLogDescription`,
                                 code: path.toString().substring(0, 100)
                             });
                         }
@@ -4776,13 +5066,12 @@ ComponentLinter.universalComponentRules = [
           }
         }
         
-        // Track dependency components (these are now auto-destructured in the wrapper)
+        // Track dependency components (NOT auto-destructured - must be manually destructured or accessed via components.X)
         if (componentSpec?.dependencies) {
           for (const dep of componentSpec.dependencies) {
             if (dep.name) {
               componentsFromProp.add(dep.name);
-              // Mark as available since they're auto-destructured
-              availableIdentifiers.add(dep.name);
+              // DO NOT add to availableIdentifiers - components must be destructured first
             }
           }
         }
@@ -5132,88 +5421,56 @@ ComponentLinter.universalComponentRules = [
         appliesTo: 'all',
         test: (ast, componentName, componentSpec) => {
             const violations = [];
-            // Track variables that hold RunView/RunQuery results
-            const resultVariables = new Map();
-            (0, traverse_1.default)(ast, {
-                // First pass: identify RunView/RunQuery calls and their assigned variables
-                AwaitExpression(path) {
-                    const callExpr = path.node.argument;
-                    if (t.isCallExpression(callExpr) && t.isMemberExpression(callExpr.callee)) {
-                        const callee = callExpr.callee;
-                        // Check for utilities.rv.RunView or utilities.rq.RunQuery pattern
-                        if (t.isMemberExpression(callee.object) &&
-                            t.isIdentifier(callee.object.object) &&
-                            callee.object.object.name === 'utilities') {
-                            const method = t.isIdentifier(callee.property) ? callee.property.name : '';
-                            const isRunView = method === 'RunView' || method === 'RunViews';
-                            const isRunQuery = method === 'RunQuery';
-                            if (isRunView || isRunQuery) {
-                                // Check if this is being assigned to a variable
-                                const parent = path.parent;
-                                if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
-                                    // const result = await utilities.rv.RunView(...)
-                                    resultVariables.set(parent.id.name, {
-                                        line: parent.id.loc?.start.line || 0,
-                                        column: parent.id.loc?.start.column || 0,
-                                        method: isRunView ? 'RunView' : 'RunQuery'
-                                    });
-                                }
-                                else if (t.isAssignmentExpression(parent) && t.isIdentifier(parent.left)) {
-                                    // result = await utilities.rv.RunView(...)
-                                    resultVariables.set(parent.left.name, {
-                                        line: parent.left.loc?.start.line || 0,
-                                        column: parent.left.loc?.start.column || 0,
-                                        method: isRunView ? 'RunView' : 'RunQuery'
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-            // Second pass: check for misuse of these result variables
+            // Array methods that would fail on a result object - keep for smart error detection
+            const arrayMethods = ['map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every', 'sort', 'concat'];
             (0, traverse_1.default)(ast, {
-                // Check for direct array operations
+                // Check for direct array operations on RunView/RunQuery results
                 CallExpression(path) {
-                    // Check for array methods being called on result objects
                     if (t.isMemberExpression(path.node.callee) &&
                         t.isIdentifier(path.node.callee.object) &&
                         t.isIdentifier(path.node.callee.property)) {
                         const objName = path.node.callee.object.name;
                         const methodName = path.node.callee.property.name;
-                        // Array methods that would fail on a result object
-                        const arrayMethods = ['map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every', 'sort', 'concat'];
-                        if (resultVariables.has(objName) && arrayMethods.includes(methodName)) {
-                            const resultInfo = resultVariables.get(objName);
-                            violations.push({
-                                rule: 'runview-runquery-result-direct-usage',
-                                severity: 'critical',
-                                line: path.node.loc?.start.line || 0,
-                                column: path.node.loc?.start.column || 0,
-                                message: `Cannot call array method "${methodName}" directly on ${resultInfo.method} result. Use "${objName}.Results.${methodName}(...)" instead. ${resultInfo.method} returns an object with { Success, Results, ... }, not an array.`,
-                                code: `${objName}.${methodName}(...)`
-                            });
+                        if (arrayMethods.includes(methodName)) {
+                            // Use proper variable tracing instead of naive name matching
+                            const isFromRunView = ComponentLinter.isVariableFromRunQueryOrView(path, objName, 'RunView');
+                            const isFromRunQuery = ComponentLinter.isVariableFromRunQueryOrView(path, objName, 'RunQuery');
+                            if (isFromRunView || isFromRunQuery) {
+                                const methodType = isFromRunView ? 'RunView' : 'RunQuery';
+                                const ruleName = isFromRunView ? 'runview-result-invalid-usage' : 'runquery-result-invalid-usage';
+                                violations.push({
+                                    rule: ruleName,
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Cannot call array method "${methodName}" directly on ${methodType} result. Use "${objName}.Results.${methodName}(...)" instead. ${methodType} returns an object with { Success, Results, ... }, not an array.`,
+                                    code: `${objName}.${methodName}(...)`
+                                });
+                            }
                         }
                     }
                 },
                 // Check for direct usage in setState or as function arguments
                 Identifier(path) {
                     const varName = path.node.name;
-                    if (resultVariables.has(varName)) {
-                        const resultInfo = resultVariables.get(varName);
-                        const parent = path.parent;
+                    const parent = path.parent;
+                    // Use proper variable tracing
+                    const isFromRunView = ComponentLinter.isVariableFromRunQueryOrView(path, varName, 'RunView');
+                    const isFromRunQuery = ComponentLinter.isVariableFromRunQueryOrView(path, varName, 'RunQuery');
+                    if (isFromRunView || isFromRunQuery) {
+                        const methodType = isFromRunView ? 'RunView' : 'RunQuery';
+                        const ruleName = isFromRunView ? 'runview-result-invalid-usage' : 'runquery-result-invalid-usage';
                         // Check if being passed to setState-like functions
                         if (t.isCallExpression(parent) && path.node === parent.arguments[0]) {
                             const callee = parent.callee;
                             // Check for setState patterns
                             if (t.isIdentifier(callee) && /^set[A-Z]/.test(callee.name)) {
-                                // Likely a setState function
                                 violations.push({
-                                    rule: 'runview-runquery-result-direct-usage',
+                                    rule: ruleName,
                                     severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
-                                    message: `Passing ${resultInfo.method} result directly to setState. Use "${varName}.Results" or check "${varName}.Success" first. ${resultInfo.method} returns { Success, Results, ErrorMessage }, not the data array.`,
+                                    message: `Passing ${methodType} result directly to setState. Use "${varName}.Results" or check "${varName}.Success" first. ${methodType} returns { Success, Results, ErrorMessage }, not the data array.`,
                                     code: `${callee.name}(${varName})`
                                 });
                             }
@@ -5222,11 +5479,11 @@ ComponentLinter.universalComponentRules = [
                                 const methodName = callee.property.name;
                                 if (methodName === 'concat' || methodName === 'push' || methodName === 'unshift') {
                                     violations.push({
-                                        rule: 'runview-runquery-result-direct-usage',
+                                        rule: ruleName,
                                         severity: 'critical',
                                         line: path.node.loc?.start.line || 0,
                                         column: path.node.loc?.start.column || 0,
-                                        message: `Passing ${resultInfo.method} result to array method. Use "${varName}.Results" instead of "${varName}".`,
+                                        message: `Passing ${methodType} result to array method. Use "${varName}.Results" instead of "${varName}".`,
                                         code: `...${methodName}(${varName})`
                                     });
                                 }
@@ -5243,16 +5500,50 @@ ComponentLinter.universalComponentRules = [
                             // Pattern: Array.isArray(result) ? result : []
                             if (parent.test.arguments[0] === path.node && parent.consequent === path.node) {
                                 violations.push({
-                                    rule: 'runview-runquery-result-direct-usage',
+                                    rule: ruleName,
                                     severity: 'high',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
-                                    message: `${resultInfo.method} result is never an array. Use "${varName}.Results || []" instead of "Array.isArray(${varName}) ? ${varName} : []".`,
+                                    message: `${methodType} result is never an array. Use "${varName}.Results || []" instead of "Array.isArray(${varName}) ? ${varName} : []".`,
                                     code: `Array.isArray(${varName}) ? ${varName} : []`
                                 });
                             }
                         }
                     }
+                },
+                // Check for invalid property access on RunView/RunQuery results
+                MemberExpression(path) {
+                    if (t.isIdentifier(path.node.object) && t.isIdentifier(path.node.property)) {
+                        const objName = path.node.object.name;
+                        const propName = path.node.property.name;
+                        // Use proper variable tracing
+                        const isFromRunView = ComponentLinter.isVariableFromRunQueryOrView(path, objName, 'RunView');
+                        const isFromRunQuery = ComponentLinter.isVariableFromRunQueryOrView(path, objName, 'RunQuery');
+                        if (isFromRunView || isFromRunQuery) {
+                            const isValidViewProp = runViewResultProps.includes(propName);
+                            const isValidQueryProp = runQueryResultProps.includes(propName);
+                            if (isFromRunQuery && !isValidQueryProp) {
+                                violations.push({
+                                    rule: 'runquery-result-invalid-property',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid property "${propName}" on RunQuery result. Valid properties: ${runQueryResultProps.join(', ')}.`,
+                                    code: `${objName}.${propName}`
+                                });
+                            }
+                            else if (isFromRunView && !isValidViewProp) {
+                                violations.push({
+                                    rule: 'runview-result-invalid-property',
+                                    severity: 'critical',
+                                    line: path.node.loc?.start.line || 0,
+                                    column: path.node.loc?.start.column || 0,
+                                    message: `Invalid property "${propName}" on RunView result. Valid properties: ${runViewResultProps.join(', ')}.`,
+                                    code: `${objName}.${propName}`
+                                });
+                            }
+                        }
+                    }
                 }
             });
             return violations;
@@ -5263,31 +5554,9 @@ ComponentLinter.universalComponentRules = [
         appliesTo: 'all',
         test: (ast, componentName, componentSpec) => {
             const violations = [];
-            // Valid properties for RunQueryResult based on MJCore type definition
-            const validRunQueryResultProps = new Set([
-                'QueryID', // string
-                'QueryName', // string
-                'Success', // boolean
-                'Results', // any[]
-                'RowCount', // number
-                'TotalRowCount', // number
-                'ExecutionTime', // number
-                'ErrorMessage', // string
-                'AppliedParameters', // Record<string, any> (optional)
-                'CacheHit', // boolean (optional)
-                'CacheKey', // string (optional)
-                'CacheTTLRemaining' // number (optional)
-            ]);
-            // Valid properties for RunViewResult based on MJCore type definition
-            const validRunViewResultProps = new Set([
-                'Success', // boolean
-                'Results', // Array<T>
-                'UserViewRunID', // string (optional)
-                'RowCount', // number
-                'TotalRowCount', // number
-                'ExecutionTime', // number
-                'ErrorMessage' // string
-            ]);
+            // Use shared property arrays from top of file - ensures consistency
+            const validRunQueryResultProps = new Set(runQueryResultProps);
+            const validRunViewResultProps = new Set(runViewResultProps);
             // Map of common incorrect properties to the correct property
             const incorrectToCorrectMap = {
                 'data': 'Results',
@@ -5494,66 +5763,257 @@ ComponentLinter.universalComponentRules = [
         }
     },
     {
-        name: 'dependency-prop-validation',
+        name: 'validate-runview-runquery-result-access',
         appliesTo: 'all',
         test: (ast, componentName, componentSpec) => {
             const violations = [];
-            // Skip if no dependencies
-            if (!componentSpec?.dependencies || componentSpec.dependencies.length === 0) {
-                return violations;
-            }
-            // Build a map of dependency components and their expected props
-            const dependencyPropsMap = new Map();
-            for (const dep of componentSpec.dependencies) {
-                const requiredProps = dep.properties
-                    ?.filter(p => p.required)
-                    ?.map(p => p.name) || [];
-                const allProps = dep.properties?.map(p => p.name) || [];
-                dependencyPropsMap.set(dep.name, {
-                    required: requiredProps,
-                    all: allProps,
-                    location: dep.location || 'embedded'
-                });
-            }
-            // Helper function to find closest matching prop name
-            function findClosestMatch(target, candidates) {
-                if (candidates.length === 0)
-                    return null;
-                // Simple Levenshtein distance implementation
-                function levenshtein(a, b) {
-                    const matrix = [];
-                    for (let i = 0; i <= b.length; i++) {
-                        matrix[i] = [i];
-                    }
-                    for (let j = 0; j <= a.length; j++) {
-                        matrix[0][j] = j;
-                    }
-                    for (let i = 1; i <= b.length; i++) {
-                        for (let j = 1; j <= a.length; j++) {
-                            if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                                matrix[i][j] = matrix[i - 1][j - 1];
+            // Track variables that hold RunView/RunQuery results with their actual names
+            const resultVariables = new Map();
+            // First pass: identify all RunView/RunQuery calls and their assigned variables
+            (0, traverse_1.default)(ast, {
+                AwaitExpression(path) {
+                    const callExpr = path.node.argument;
+                    if (t.isCallExpression(callExpr) && t.isMemberExpression(callExpr.callee)) {
+                        const callee = callExpr.callee;
+                        // Check for utilities.rv.RunView/RunViews or utilities.rq.RunQuery pattern
+                        if (t.isMemberExpression(callee.object) &&
+                            t.isIdentifier(callee.object.object) &&
+                            callee.object.object.name === 'utilities' &&
+                            t.isIdentifier(callee.object.property)) {
+                            const subObject = callee.object.property.name;
+                            const method = t.isIdentifier(callee.property) ? callee.property.name : '';
+                            let methodType = null;
+                            if (subObject === 'rv' && (method === 'RunView' || method === 'RunViews')) {
+                                methodType = method;
                             }
-                            else {
-                                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                            else if (subObject === 'rq' && method === 'RunQuery') {
+                                methodType = 'RunQuery';
+                            }
+                            if (methodType) {
+                                // Check if this is being assigned to a variable
+                                const parent = path.parent;
+                                if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+                                    // const result = await utilities.rv.RunView(...)
+                                    resultVariables.set(parent.id.name, {
+                                        line: parent.id.loc?.start.line || 0,
+                                        column: parent.id.loc?.start.column || 0,
+                                        method: methodType,
+                                        varName: parent.id.name
+                                    });
+                                }
+                                else if (t.isAssignmentExpression(parent) && t.isIdentifier(parent.left)) {
+                                    // result = await utilities.rv.RunView(...)
+                                    resultVariables.set(parent.left.name, {
+                                        line: parent.left.loc?.start.line || 0,
+                                        column: parent.left.loc?.start.column || 0,
+                                        method: methodType,
+                                        varName: parent.left.name
+                                    });
+                                }
                             }
                         }
                     }
-                    return matrix[b.length][a.length];
-                }
-                // Find the closest match
-                let bestMatch = '';
-                let bestDistance = Infinity;
-                for (const candidate of candidates) {
-                    const distance = levenshtein(target.toLowerCase(), candidate.toLowerCase());
-                    if (distance < bestDistance && distance <= 3) { // Max distance of 3 for suggestions
-                        bestDistance = distance;
-                        bestMatch = candidate;
-                    }
                 }
-                return bestMatch || null;
-            }
-            // Standard props that are always valid (passed by the runtime)
-            const standardProps = new Set([
+            });
+            // Second pass: check for incorrect usage patterns
+            (0, traverse_1.default)(ast, {
+                // Check for .length property access on result objects
+                MemberExpression(path) {
+                    if (t.isIdentifier(path.node.object) &&
+                        t.isIdentifier(path.node.property) &&
+                        path.node.property.name === 'length') {
+                        const objName = path.node.object.name;
+                        if (resultVariables.has(objName)) {
+                            const resultInfo = resultVariables.get(objName);
+                            violations.push({
+                                rule: 'validate-runview-runquery-result-access',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Cannot check .length on ${resultInfo.method} result directly. ${resultInfo.method} returns an object with Success and Results properties.
+Correct pattern:
+  if (${resultInfo.varName}?.Success && ${resultInfo.varName}?.Results?.length > 0) {
+    // Process ${resultInfo.varName}.Results array
+  }`,
+                                code: `${objName}.length`
+                            });
+                        }
+                    }
+                },
+                // Check for incorrect conditional checks
+                IfStatement(path) {
+                    const test = path.node.test;
+                    // Pattern: if (result) or if (result.length)
+                    if (t.isIdentifier(test)) {
+                        const varName = test.name;
+                        if (resultVariables.has(varName)) {
+                            const resultInfo = resultVariables.get(varName);
+                            // Check if they're ONLY checking the result object without .Success
+                            let checksSuccess = false;
+                            let checksResults = false;
+                            // Scan the if block to see what they're doing with the result
+                            path.traverse({
+                                MemberExpression(innerPath) {
+                                    if (t.isIdentifier(innerPath.node.object) &&
+                                        innerPath.node.object.name === varName) {
+                                        const prop = t.isIdentifier(innerPath.node.property) ? innerPath.node.property.name : '';
+                                        if (prop === 'Success')
+                                            checksSuccess = true;
+                                        if (prop === 'Results')
+                                            checksResults = true;
+                                    }
+                                }
+                            });
+                            // If they're accessing Results without checking Success, flag it
+                            if (checksResults && !checksSuccess) {
+                                violations.push({
+                                    rule: 'validate-runview-runquery-result-access',
+                                    severity: 'high',
+                                    line: test.loc?.start.line || 0,
+                                    column: test.loc?.start.column || 0,
+                                    message: `Checking ${resultInfo.method} result without verifying Success property.
+Correct pattern:
+  if (${resultInfo.varName}?.Success) {
+    const data = ${resultInfo.varName}.Results;
+    // Process data
+  } else {
+    // Handle error: ${resultInfo.varName}.ErrorMessage
+  }`,
+                                    code: `if (${varName})`
+                                });
+                            }
+                        }
+                    }
+                    // Pattern: if (result?.length)
+                    if (t.isOptionalMemberExpression(test) &&
+                        t.isIdentifier(test.object) &&
+                        t.isIdentifier(test.property) &&
+                        test.property.name === 'length') {
+                        const varName = test.object.name;
+                        if (resultVariables.has(varName)) {
+                            const resultInfo = resultVariables.get(varName);
+                            violations.push({
+                                rule: 'validate-runview-runquery-result-access',
+                                severity: 'critical',
+                                line: test.loc?.start.line || 0,
+                                column: test.loc?.start.column || 0,
+                                message: `Incorrect check: "${varName}?.length" on ${resultInfo.method} result.
+Correct pattern:
+  if (${resultInfo.varName}?.Success && ${resultInfo.varName}?.Results?.length > 0) {
+    const processedData = processChartData(${resultInfo.varName}.Results);
+    // Use processedData
+  }`,
+                                code: `if (${varName}?.length)`
+                            });
+                        }
+                    }
+                },
+                // Check for passing result directly to functions expecting arrays
+                CallExpression(path) {
+                    const args = path.node.arguments;
+                    for (let i = 0; i < args.length; i++) {
+                        const arg = args[i];
+                        if (t.isIdentifier(arg) && resultVariables.has(arg.name)) {
+                            const resultInfo = resultVariables.get(arg.name);
+                            // Check if the function being called looks like it expects an array
+                            let funcName = '';
+                            if (t.isIdentifier(path.node.callee)) {
+                                funcName = path.node.callee.name;
+                            }
+                            else if (t.isMemberExpression(path.node.callee) && t.isIdentifier(path.node.callee.property)) {
+                                funcName = path.node.callee.property.name;
+                            }
+                            // Common functions that expect arrays
+                            const arrayExpectingFuncs = [
+                                'map', 'filter', 'forEach', 'reduce', 'sort', 'concat',
+                                'processChartData', 'processData', 'transformData',
+                                'setData', 'setItems', 'setResults', 'setRows'
+                            ];
+                            if (arrayExpectingFuncs.some(f => funcName.toLowerCase().includes(f.toLowerCase()))) {
+                                violations.push({
+                                    rule: 'validate-runview-runquery-result-access',
+                                    severity: 'critical',
+                                    line: arg.loc?.start.line || 0,
+                                    column: arg.loc?.start.column || 0,
+                                    message: `Passing ${resultInfo.method} result object directly to ${funcName}() which expects an array.
+Correct pattern:
+  if (${resultInfo.varName}?.Success) {
+    ${funcName}(${resultInfo.varName}.Results);
+  } else {
+    console.error('${resultInfo.method} failed:', ${resultInfo.varName}?.ErrorMessage);
+    ${funcName}([]); // Provide empty array as fallback
+  }`,
+                                    code: `${funcName}(${arg.name})`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'dependency-prop-validation',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Skip if no dependencies
+            if (!componentSpec?.dependencies || componentSpec.dependencies.length === 0) {
+                return violations;
+            }
+            // Build a map of dependency components and their expected props
+            const dependencyPropsMap = new Map();
+            for (const dep of componentSpec.dependencies) {
+                const requiredProps = dep.properties
+                    ?.filter(p => p.required)
+                    ?.map(p => p.name) || [];
+                const allProps = dep.properties?.map(p => p.name) || [];
+                dependencyPropsMap.set(dep.name, {
+                    required: requiredProps,
+                    all: allProps,
+                    location: dep.location || 'embedded'
+                });
+            }
+            // Helper function to find closest matching prop name
+            function findClosestMatch(target, candidates) {
+                if (candidates.length === 0)
+                    return null;
+                // Simple Levenshtein distance implementation
+                function levenshtein(a, b) {
+                    const matrix = [];
+                    for (let i = 0; i <= b.length; i++) {
+                        matrix[i] = [i];
+                    }
+                    for (let j = 0; j <= a.length; j++) {
+                        matrix[0][j] = j;
+                    }
+                    for (let i = 1; i <= b.length; i++) {
+                        for (let j = 1; j <= a.length; j++) {
+                            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                                matrix[i][j] = matrix[i - 1][j - 1];
+                            }
+                            else {
+                                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                            }
+                        }
+                    }
+                    return matrix[b.length][a.length];
+                }
+                // Find the closest match
+                let bestMatch = '';
+                let bestDistance = Infinity;
+                for (const candidate of candidates) {
+                    const distance = levenshtein(target.toLowerCase(), candidate.toLowerCase());
+                    if (distance < bestDistance && distance <= 3) { // Max distance of 3 for suggestions
+                        bestDistance = distance;
+                        bestMatch = candidate;
+                    }
+                }
+                return bestMatch || null;
+            }
+            // Standard props that are always valid (passed by the runtime)
+            const standardProps = new Set([
                 'styles', 'utilities', 'components', 'callbacks',
                 'savedUserSettings', 'onSaveUserSettings'
             ]);
@@ -6074,6 +6534,611 @@ ComponentLinter.universalComponentRules = [
             });
             return violations;
         }
+    },
+    {
+        name: 'validate-component-references',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Skip if no spec or no dependencies
+            if (!componentSpec?.dependencies || componentSpec.dependencies.length === 0) {
+                return violations;
+            }
+            // Build a set of available component names from dependencies
+            const availableComponents = new Set();
+            for (const dep of componentSpec.dependencies) {
+                if (dep.location === 'embedded' && dep.name) {
+                    availableComponents.add(dep.name);
+                }
+            }
+            // If no embedded dependencies, nothing to validate
+            if (availableComponents.size === 0) {
+                return violations;
+            }
+            // Track ALL defined variables in scope (from destructuring, imports, declarations, etc.)
+            const definedVariables = new Set();
+            const referencedComponents = new Set();
+            // First pass: collect all variable declarations and destructuring
+            (0, traverse_1.default)(ast, {
+                // Track variable declarations (const x = ...)
+                VariableDeclarator(path) {
+                    if (t.isIdentifier(path.node.id)) {
+                        definedVariables.add(path.node.id.name);
+                    }
+                    else if (t.isObjectPattern(path.node.id)) {
+                        // Track all destructured variables
+                        const collectDestructured = (pattern) => {
+                            for (const prop of pattern.properties) {
+                                if (t.isObjectProperty(prop)) {
+                                    if (t.isIdentifier(prop.value)) {
+                                        definedVariables.add(prop.value.name);
+                                    }
+                                    else if (t.isObjectPattern(prop.value)) {
+                                        collectDestructured(prop.value);
+                                    }
+                                }
+                                else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                                    definedVariables.add(prop.argument.name);
+                                }
+                            }
+                        };
+                        collectDestructured(path.node.id);
+                    }
+                    else if (t.isArrayPattern(path.node.id)) {
+                        // Track array destructuring
+                        for (const elem of path.node.id.elements) {
+                            if (t.isIdentifier(elem)) {
+                                definedVariables.add(elem.name);
+                            }
+                        }
+                    }
+                },
+                // Track function declarations
+                FunctionDeclaration(path) {
+                    if (path.node.id) {
+                        definedVariables.add(path.node.id.name);
+                    }
+                },
+                // Track class declarations
+                ClassDeclaration(path) {
+                    if (path.node.id) {
+                        definedVariables.add(path.node.id.name);
+                    }
+                },
+                // Track function parameters
+                Function(path) {
+                    for (const param of path.node.params) {
+                        if (t.isIdentifier(param)) {
+                            definedVariables.add(param.name);
+                        }
+                        else if (t.isObjectPattern(param)) {
+                            // Track destructured parameters
+                            const collectParams = (pattern) => {
+                                for (const prop of pattern.properties) {
+                                    if (t.isObjectProperty(prop)) {
+                                        if (t.isIdentifier(prop.value)) {
+                                            definedVariables.add(prop.value.name);
+                                        }
+                                        else if (t.isObjectPattern(prop.value)) {
+                                            collectParams(prop.value);
+                                        }
+                                    }
+                                }
+                            };
+                            collectParams(param);
+                        }
+                    }
+                }
+            });
+            // Second pass: check component usage
+            (0, traverse_1.default)(ast, {
+                // Look for React.createElement calls
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check for React.createElement(ComponentName, ...)
+                    if (t.isMemberExpression(callee) &&
+                        t.isIdentifier(callee.object) &&
+                        callee.object.name === 'React' &&
+                        t.isIdentifier(callee.property) &&
+                        callee.property.name === 'createElement') {
+                        const firstArg = path.node.arguments[0];
+                        // If first argument is an identifier (component reference)
+                        if (t.isIdentifier(firstArg)) {
+                            const componentRef = firstArg.name;
+                            // Skip HTML elements and React built-ins
+                            if (!componentRef.match(/^[a-z]/) && componentRef !== 'Fragment') {
+                                // Only check if it's supposed to be a component dependency
+                                // and it's not defined elsewhere in the code
+                                if (availableComponents.has(componentRef)) {
+                                    referencedComponents.add(componentRef);
+                                }
+                                else if (!definedVariables.has(componentRef)) {
+                                    // Only complain if it's not defined anywhere
+                                    const availableList = Array.from(availableComponents).sort().join(', ');
+                                    const availableLibs = componentSpec?.libraries?.map(lib => lib.globalVariable).filter(Boolean).join(', ') || '';
+                                    let message = `Component "${componentRef}" is not defined. Available component dependencies: ${availableList}`;
+                                    if (availableLibs) {
+                                        message += `. Available libraries: ${availableLibs}`;
+                                    }
+                                    violations.push({
+                                        rule: 'validate-component-references',
+                                        severity: 'critical',
+                                        line: firstArg.loc?.start.line || 0,
+                                        column: firstArg.loc?.start.column || 0,
+                                        message: message,
+                                        code: `React.createElement(${componentRef}, ...)`
+                                    });
+                                }
+                            }
+                        }
+                    }
+                },
+                // Look for JSX elements
+                JSXElement(path) {
+                    const openingElement = path.node.openingElement;
+                    const elementName = openingElement.name;
+                    if (t.isJSXIdentifier(elementName)) {
+                        const componentRef = elementName.name;
+                        // Skip HTML elements and fragments
+                        if (!componentRef.match(/^[a-z]/) && componentRef !== 'Fragment') {
+                            // Track if it's a known component dependency
+                            if (availableComponents.has(componentRef)) {
+                                referencedComponents.add(componentRef);
+                            }
+                            else if (!definedVariables.has(componentRef)) {
+                                // Only complain if it's not defined anywhere (not from libraries, not from declarations)
+                                const availableList = Array.from(availableComponents).sort().join(', ');
+                                const availableLibs = componentSpec?.libraries?.map(lib => lib.globalVariable).filter(Boolean).join(', ') || '';
+                                let message = `Component "${componentRef}" is not defined. Available component dependencies: ${availableList}`;
+                                if (availableLibs) {
+                                    message += `. Available libraries: ${availableLibs}`;
+                                }
+                                violations.push({
+                                    rule: 'validate-component-references',
+                                    severity: 'critical',
+                                    line: elementName.loc?.start.line || 0,
+                                    column: elementName.loc?.start.column || 0,
+                                    message: message,
+                                    code: `<${componentRef} ... />`
+                                });
+                            }
+                        }
+                    }
+                },
+                // Look for destructuring from components prop specifically
+                ObjectPattern(path) {
+                    // Check if this is destructuring from a 'components' parameter
+                    const parent = path.parent;
+                    // Check if it's a function parameter with components
+                    if ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent) ||
+                        t.isArrowFunctionExpression(parent)) && parent.params.includes(path.node)) {
+                        // Look for components property
+                        for (const prop of path.node.properties) {
+                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) &&
+                                prop.key.name === 'components' && t.isObjectPattern(prop.value)) {
+                                // Check each destructured component
+                                for (const componentProp of prop.value.properties) {
+                                    if (t.isObjectProperty(componentProp) && t.isIdentifier(componentProp.key)) {
+                                        const componentRef = componentProp.key.name;
+                                        referencedComponents.add(componentRef);
+                                        if (!availableComponents.has(componentRef)) {
+                                            const availableList = Array.from(availableComponents).sort().join(', ');
+                                            // Try to find similar names for suggestions
+                                            const suggestions = Array.from(availableComponents).filter(name => name.toLowerCase().includes(componentRef.toLowerCase()) ||
+                                                componentRef.toLowerCase().includes(name.toLowerCase()));
+                                            let message = `Destructured component "${componentRef}" is not found in dependencies. Available components: ${availableList}`;
+                                            if (suggestions.length > 0) {
+                                                message += `. Did you mean: ${suggestions.join(' or ')}?`;
+                                            }
+                                            violations.push({
+                                                rule: 'validate-component-references',
+                                                severity: 'critical',
+                                                line: componentProp.key.loc?.start.line || 0,
+                                                column: componentProp.key.loc?.start.column || 0,
+                                                message: message,
+                                                code: `{ components: { ${componentRef}, ... } }`
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Also warn about unused dependencies
+            for (const depName of availableComponents) {
+                if (!referencedComponents.has(depName)) {
+                    violations.push({
+                        rule: 'validate-component-references',
+                        severity: 'low',
+                        line: 1,
+                        column: 0,
+                        message: `Component dependency "${depName}" is defined but never used in the code.`,
+                        code: `dependencies: [..., { name: "${depName}", ... }, ...]`
+                    });
+                }
+            }
+            return violations;
+        }
+    },
+    {
+        name: 'unused-libraries',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Skip if no libraries declared
+            if (!componentSpec?.libraries || componentSpec.libraries.length === 0) {
+                return violations;
+            }
+            // Get the function body to search within
+            let functionBody = '';
+            (0, traverse_1.default)(ast, {
+                FunctionDeclaration(path) {
+                    if (path.node.id && path.node.id.name === componentName) {
+                        functionBody = path.toString();
+                    }
+                }
+            });
+            // If we couldn't find the function body, use the whole code
+            if (!functionBody) {
+                functionBody = ast.toString ? ast.toString() : '';
+            }
+            // Track which libraries are used and unused
+            const unusedLibraries = [];
+            const usedLibraries = [];
+            // Check each library for usage
+            for (const lib of componentSpec.libraries) {
+                const globalVar = lib.globalVariable;
+                if (!globalVar)
+                    continue;
+                // Check for various usage patterns
+                const usagePatterns = [
+                    globalVar + '.', // Direct property access: Chart.defaults
+                    globalVar + '(', // Direct call: dayjs()
+                    'new ' + globalVar + '(', // Constructor: new Chart()
+                    globalVar + '[', // Array/property access: XLSX['utils']
+                    '= ' + globalVar, // Assignment: const myChart = Chart
+                    ', ' + globalVar, // In parameter list
+                    '(' + globalVar, // Start of expression
+                    '{' + globalVar, // In object literal
+                    '<' + globalVar, // JSX component
+                    globalVar + ' ', // Followed by space (various uses)
+                ];
+                const isUsed = usagePatterns.some(pattern => functionBody.includes(pattern));
+                if (isUsed) {
+                    usedLibraries.push({ name: lib.name, globalVariable: globalVar });
+                }
+                else {
+                    unusedLibraries.push({ name: lib.name, globalVariable: globalVar });
+                }
+            }
+            // Determine severity based on usage patterns
+            const totalLibraries = componentSpec.libraries.length;
+            const usedCount = usedLibraries.length;
+            if (usedCount === 0 && totalLibraries > 0) {
+                // CRITICAL: No libraries used at all
+                violations.push({
+                    rule: 'unused-libraries',
+                    severity: 'critical',
+                    line: 1,
+                    column: 0,
+                    message: `CRITICAL: None of the ${totalLibraries} declared libraries are used. This indicates missing core functionality.`,
+                    code: `Unused libraries: ${unusedLibraries.map(l => l.name).join(', ')}`
+                });
+            }
+            else if (unusedLibraries.length > 0) {
+                // Some libraries unused, severity depends on ratio
+                for (const lib of unusedLibraries) {
+                    const severity = totalLibraries === 1 ? 'high' : 'low';
+                    const contextMessage = totalLibraries === 1
+                        ? 'This is the only declared library and it\'s not being used.'
+                        : `${usedCount} of ${totalLibraries} libraries are being used. This might be an alternative/optional library.`;
+                    violations.push({
+                        rule: 'unused-libraries',
+                        severity: severity,
+                        line: 1,
+                        column: 0,
+                        message: `Library "${lib.name}" (${lib.globalVariable}) is declared but not used. ${contextMessage}`,
+                        code: `Consider removing if not needed: { name: "${lib.name}", globalVariable: "${lib.globalVariable}" }`
+                    });
+                }
+            }
+            return violations;
+        }
+    },
+    {
+        name: 'unused-component-dependencies',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Skip if no dependencies declared
+            if (!componentSpec?.dependencies || componentSpec.dependencies.length === 0) {
+                return violations;
+            }
+            // Filter to only embedded components
+            const embeddedDeps = componentSpec.dependencies.filter(dep => dep.location === 'embedded' && dep.name);
+            if (embeddedDeps.length === 0) {
+                return violations;
+            }
+            // Get the function body to search within
+            let functionBody = '';
+            (0, traverse_1.default)(ast, {
+                FunctionDeclaration(path) {
+                    if (path.node.id && path.node.id.name === componentName) {
+                        functionBody = path.toString();
+                    }
+                }
+            });
+            // If we couldn't find the function body, use the whole code
+            if (!functionBody) {
+                functionBody = ast.toString ? ast.toString() : '';
+            }
+            // Check each component dependency for usage
+            for (const dep of embeddedDeps) {
+                const depName = dep.name;
+                // Check for various usage patterns
+                // Components can be used directly (if destructured) or via components object
+                const usagePatterns = [
+                    // Direct usage (after destructuring)
+                    '<' + depName + ' ', // JSX: <AccountList />
+                    '<' + depName + '>', // JSX: <AccountList>
+                    '<' + depName + '/', // JSX self-closing: <AccountList/>
+                    depName + '(', // Direct call: AccountList()
+                    '= ' + depName, // Assignment: const List = AccountList
+                    depName + ' ||', // Fallback: AccountList || DefaultComponent
+                    depName + ' &&', // Conditional: AccountList && ...
+                    depName + ' ?', // Ternary: AccountList ? ... : ...
+                    ', ' + depName, // In parameter/array list
+                    '(' + depName, // Start of expression
+                    '{' + depName, // In object literal
+                    // Via components object
+                    'components.' + depName, // Dot notation: components.AccountList
+                    "components['" + depName + "']", // Bracket notation single quotes
+                    'components["' + depName + '"]', // Bracket notation double quotes
+                    'components[`' + depName + '`]', // Bracket notation template literal
+                    '<components.' + depName, // JSX via components: <components.AccountList
+                ];
+                const isUsed = usagePatterns.some(pattern => functionBody.includes(pattern));
+                if (!isUsed) {
+                    violations.push({
+                        rule: 'unused-component-dependencies',
+                        severity: 'high',
+                        line: 1,
+                        column: 0,
+                        message: `Component dependency "${depName}" is declared but never used. This likely means missing functionality.`,
+                        code: `Expected usage: <${depName} /> or <components.${depName} />`
+                    });
+                }
+            }
+            return violations;
+        }
+    },
+    {
+        name: 'component-usage-without-destructuring',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Skip if no dependencies
+            if (!componentSpec?.dependencies || componentSpec.dependencies.length === 0) {
+                return violations;
+            }
+            // Track dependency names
+            const dependencyNames = new Set(componentSpec.dependencies.map(d => d.name).filter(Boolean));
+            // Track what's been destructured from components prop
+            const destructuredComponents = new Set();
+            (0, traverse_1.default)(ast, {
+                // Track destructuring from components
+                VariableDeclarator(path) {
+                    if (t.isObjectPattern(path.node.id) && t.isIdentifier(path.node.init)) {
+                        // Check if destructuring from 'components'
+                        if (path.node.init.name === 'components') {
+                            for (const prop of path.node.id.properties) {
+                                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                    const name = prop.key.name;
+                                    if (dependencyNames.has(name)) {
+                                        destructuredComponents.add(name);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                // Also check function parameter destructuring
+                FunctionDeclaration(path) {
+                    if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
+                        const param = path.node.params[0];
+                        if (t.isObjectPattern(param)) {
+                            for (const prop of param.properties) {
+                                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'components') {
+                                    // Check for nested destructuring like { components: { A, B } }
+                                    if (t.isObjectPattern(prop.value)) {
+                                        for (const innerProp of prop.value.properties) {
+                                            if (t.isObjectProperty(innerProp) && t.isIdentifier(innerProp.key)) {
+                                                const name = innerProp.key.name;
+                                                if (dependencyNames.has(name)) {
+                                                    destructuredComponents.add(name);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                // Check JSX usage
+                JSXElement(path) {
+                    const openingElement = path.node.openingElement;
+                    // Check for direct component usage (e.g., <ComponentName>)
+                    if (t.isJSXIdentifier(openingElement.name)) {
+                        const name = openingElement.name.name;
+                        // Check if this is one of our dependencies being used directly
+                        if (dependencyNames.has(name) && !destructuredComponents.has(name)) {
+                            violations.push({
+                                rule: 'component-usage-without-destructuring',
+                                severity: 'critical',
+                                line: openingElement.loc?.start.line || 0,
+                                column: openingElement.loc?.start.column || 0,
+                                message: `Component "${name}" used without destructuring. Either destructure it from components prop (const { ${name} } = components;) or use <components.${name} />`,
+                                code: `<${name}>`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'prefer-jsx-syntax',
+        appliesTo: 'all',
+        test: (ast, componentName) => {
+            const violations = [];
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check for React.createElement
+                    if (t.isMemberExpression(callee) &&
+                        t.isIdentifier(callee.object) &&
+                        callee.object.name === 'React' &&
+                        t.isIdentifier(callee.property) &&
+                        callee.property.name === 'createElement') {
+                        violations.push({
+                            rule: 'prefer-jsx-syntax',
+                            severity: 'low',
+                            line: callee.loc?.start.line || 0,
+                            column: callee.loc?.start.column || 0,
+                            message: 'Prefer JSX syntax over React.createElement for better readability',
+                            code: 'React.createElement(...) → <ComponentName ... />'
+                        });
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'prefer-async-await',
+        appliesTo: 'all',
+        test: (ast, componentName) => {
+            const violations = [];
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check for .then() chains
+                    if (t.isMemberExpression(callee) &&
+                        t.isIdentifier(callee.property) &&
+                        callee.property.name === 'then') {
+                        // Try to get the context of what's being chained
+                        let context = '';
+                        if (t.isMemberExpression(callee.object)) {
+                            context = ' Consider using async/await for cleaner code.';
+                        }
+                        violations.push({
+                            rule: 'prefer-async-await',
+                            severity: 'low',
+                            line: callee.property.loc?.start.line || 0,
+                            column: callee.property.loc?.start.column || 0,
+                            message: `Prefer async/await over .then() chains for better readability.${context}`,
+                            code: '.then(result => ...) → const result = await ...'
+                        });
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'single-function-only',
+        appliesTo: 'all',
+        test: (ast, componentName) => {
+            const violations = [];
+            // Count all function declarations and expressions at the top level
+            const functionDeclarations = [];
+            const functionExpressions = [];
+            (0, traverse_1.default)(ast, {
+                FunctionDeclaration(path) {
+                    // Only check top-level functions (not nested inside other functions)
+                    const parent = path.getFunctionParent();
+                    if (!parent) {
+                        const funcName = path.node.id?.name || 'anonymous';
+                        functionDeclarations.push({
+                            name: funcName,
+                            line: path.node.loc?.start.line || 0,
+                            column: path.node.loc?.start.column || 0
+                        });
+                    }
+                },
+                VariableDeclaration(path) {
+                    // Check for const/let/var func = function() or arrow functions at top level
+                    const parent = path.getFunctionParent();
+                    if (!parent) {
+                        for (const declarator of path.node.declarations) {
+                            if (t.isVariableDeclarator(declarator) &&
+                                (t.isFunctionExpression(declarator.init) ||
+                                    t.isArrowFunctionExpression(declarator.init))) {
+                                const funcName = t.isIdentifier(declarator.id) ? declarator.id.name : 'anonymous';
+                                functionExpressions.push({
+                                    name: funcName,
+                                    line: declarator.loc?.start.line || 0,
+                                    column: declarator.loc?.start.column || 0
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            const allFunctions = [...functionDeclarations, ...functionExpressions];
+            // Check if we have more than one function
+            if (allFunctions.length > 1) {
+                // Find which one is the main component
+                const mainComponentIndex = allFunctions.findIndex(f => f.name === componentName);
+                const otherFunctions = allFunctions.filter((_, index) => index !== mainComponentIndex);
+                violations.push({
+                    rule: 'single-function-only',
+                    severity: 'critical',
+                    line: otherFunctions[0].line,
+                    column: otherFunctions[0].column,
+                    message: `Component code must contain ONLY the main component function "${componentName}". Found ${allFunctions.length} functions: ${allFunctions.map(f => f.name).join(', ')}. Move other functions to separate component dependencies.`,
+                    code: `Remove functions: ${otherFunctions.map(f => f.name).join(', ')}`
+                });
+                // Add a violation for each extra function
+                for (const func of otherFunctions) {
+                    violations.push({
+                        rule: 'single-function-only',
+                        severity: 'critical',
+                        line: func.line,
+                        column: func.column,
+                        message: `Extra function "${func.name}" not allowed. Each component must be a single function. Move this to a separate component dependency.`,
+                        code: `function ${func.name} should be a separate component`
+                    });
+                }
+            }
+            // Also check that the single function matches the component name
+            if (allFunctions.length === 1 && allFunctions[0].name !== componentName) {
+                violations.push({
+                    rule: 'single-function-only',
+                    severity: 'critical',
+                    line: allFunctions[0].line,
+                    column: allFunctions[0].column,
+                    message: `Component function name "${allFunctions[0].name}" does not match component name "${componentName}". The function must be named exactly as specified.`,
+                    code: `Rename function to: function ${componentName}(...)`
+                });
+            }
+            // Check for no function at all
+            if (allFunctions.length === 0) {
+                violations.push({
+                    rule: 'single-function-only',
+                    severity: 'critical',
+                    line: 1,
+                    column: 0,
+                    message: `Component code must contain exactly one function named "${componentName}". No functions found.`,
+                    code: `Add: function ${componentName}({ utilities, styles, components, callbacks, savedUserSettings, onSaveUserSettings }) { ... }`
+                });
+            }
+            return violations;
+        }
     }
 ];
 //# sourceMappingURL=component-linter.js.map