@memberjunction/react-test-harness 2.94.0 → 2.96.0

package/dist/lib/component-linter.js

@@ -30,7 +30,9 @@ exports.ComponentLinter = void 0;
 const parser = __importStar(require("@babel/parser"));
 const traverse_1 = __importDefault(require("@babel/traverse"));
 const t = __importStar(require("@babel/types"));
+const core_entities_1 = require("@memberjunction/core-entities");
 const library_lint_cache_1 = require("./library-lint-cache");
+const styles_type_analyzer_1 = require("./styles-type-analyzer");
 // Standard HTML elements (lowercase)
 const HTML_ELEMENTS = new Set([
     // Main root
@@ -91,13 +93,21 @@ 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',
     'TotalRowCount', 'ExecutionTime', 'ErrorMessage'
 ];
 class ComponentLinter {
+    // Get or create the styles analyzer instance
+    static getStylesAnalyzer() {
+        if (!ComponentLinter.stylesAnalyzer) {
+            ComponentLinter.stylesAnalyzer = new styles_type_analyzer_1.StylesTypeAnalyzer();
+        }
+        return ComponentLinter.stylesAnalyzer;
+    }
     // Helper method to check if a statement contains a return
     static containsReturn(node) {
         let hasReturn = false;
@@ -152,13 +162,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 +1102,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,
@@ -1591,6 +1692,80 @@ setData(queryResult.Results || []);  // NOT queryResult directly!
 // }`
                     });
                     break;
+                case 'styles-invalid-path':
+                    suggestions.push({
+                        violation: violation.rule,
+                        suggestion: 'Fix invalid styles property paths. Use the correct ComponentStyles interface structure.',
+                        example: `// ❌ WRONG - Invalid property paths:
+styles.fontSize.small           // fontSize is not at root level
+styles.colors.background        // colors.background exists
+styles.spacing.small            // should be styles.spacing.sm
+
+// ✅ CORRECT - Valid property paths:
+styles.typography.fontSize.sm   // fontSize is under typography
+styles.colors.background        // correct path
+styles.spacing.sm               // correct size name
+
+// With safe access and fallbacks:
+styles?.typography?.fontSize?.sm || '14px'
+styles?.colors?.background || '#FFFFFF'
+styles?.spacing?.sm || '8px'`
+                    });
+                    break;
+                case 'styles-unsafe-access':
+                    suggestions.push({
+                        violation: violation.rule,
+                        suggestion: 'Use optional chaining for nested styles access to prevent runtime errors.',
+                        example: `// ❌ UNSAFE - Direct nested access:
+const fontSize = styles.typography.fontSize.md;
+const borderRadius = styles.borders.radius.sm;
+
+// ✅ SAFE - With optional chaining and fallbacks:
+const fontSize = styles?.typography?.fontSize?.md || '14px';
+const borderRadius = styles?.borders?.radius?.sm || '6px';
+
+// Even better - destructure with defaults:
+const {
+  typography: {
+    fontSize: { md: fontSize = '14px' } = {}
+  } = {}
+} = styles || {};`
+                    });
+                    break;
+            }
+        }
+        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;
@@ -2028,34 +2203,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 +2604,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 +2906,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 +3093,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 +3101,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 +3132,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 +3993,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 +4030,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)
                                     });
                                 }
@@ -3772,6 +4093,117 @@ ComponentLinter.universalComponentRules = [
                                                 code: `${propName}: ...`
                                             });
                                         }
+                                        else {
+                                            // Property name is valid, now check its type
+                                            const value = prop.value;
+                                            // Helper to check if a node is null or undefined
+                                            const isNullOrUndefined = (node) => {
+                                                return t.isNullLiteral(node) ||
+                                                    (t.isIdentifier(node) && node.name === 'undefined');
+                                            };
+                                            // Helper to check if a node could evaluate to a string
+                                            const isStringLike = (node, depth = 0) => {
+                                                // Prevent infinite recursion
+                                                if (depth > 3)
+                                                    return false;
+                                                // Special handling for ternary operators - check both branches
+                                                if (t.isConditionalExpression(node)) {
+                                                    const consequentOk = isStringLike(node.consequent, depth + 1) || isNullOrUndefined(node.consequent);
+                                                    const alternateOk = isStringLike(node.alternate, depth + 1) || isNullOrUndefined(node.alternate);
+                                                    return consequentOk && alternateOk;
+                                                }
+                                                // Explicitly reject object and array expressions
+                                                if (t.isObjectExpression(node) || t.isArrayExpression(node)) {
+                                                    return false;
+                                                }
+                                                return t.isStringLiteral(node) ||
+                                                    t.isTemplateLiteral(node) ||
+                                                    t.isBinaryExpression(node) || // String concatenation
+                                                    t.isIdentifier(node) || // Variable
+                                                    t.isCallExpression(node) || // Function call
+                                                    t.isMemberExpression(node); // Property access
+                                            };
+                                            // Helper to check if a node could evaluate to a number
+                                            const isNumberLike = (node) => {
+                                                return t.isNumericLiteral(node) ||
+                                                    t.isBinaryExpression(node) || // Math operations
+                                                    t.isUnaryExpression(node) || // Negative numbers, etc
+                                                    t.isConditionalExpression(node) || // Ternary
+                                                    t.isIdentifier(node) || // Variable
+                                                    t.isCallExpression(node) || // Function call
+                                                    t.isMemberExpression(node); // Property access
+                                            };
+                                            // Helper to check if a node is array-like
+                                            const isArrayLike = (node) => {
+                                                return t.isArrayExpression(node) ||
+                                                    t.isIdentifier(node) || // Variable
+                                                    t.isCallExpression(node) || // Function returning array
+                                                    t.isMemberExpression(node) || // Property access
+                                                    t.isConditionalExpression(node); // Ternary
+                                            };
+                                            // Helper to check if a node is object-like (but not array)
+                                            const isObjectLike = (node) => {
+                                                if (t.isArrayExpression(node))
+                                                    return false;
+                                                return t.isObjectExpression(node) ||
+                                                    t.isIdentifier(node) || // Variable
+                                                    t.isCallExpression(node) || // Function returning object
+                                                    t.isMemberExpression(node) || // Property access
+                                                    t.isConditionalExpression(node) || // Ternary
+                                                    t.isSpreadElement(node); // Spread syntax (though this is the problem case)
+                                            };
+                                            // Validate types based on property name
+                                            if (propName === 'ExtraFilter' || propName === 'OrderBy' || propName === 'EntityName') {
+                                                // These must be strings (ExtraFilter and OrderBy can also be null/undefined)
+                                                const allowNullUndefined = propName === 'ExtraFilter' || propName === 'OrderBy';
+                                                if (!isStringLike(value) && !(allowNullUndefined && isNullOrUndefined(value))) {
+                                                    let exampleValue = '';
+                                                    if (propName === 'ExtraFilter') {
+                                                        exampleValue = `"Status = 'Active' AND Type = 'Customer'"`;
+                                                    }
+                                                    else if (propName === 'OrderBy') {
+                                                        exampleValue = `"CreatedAt DESC"`;
+                                                    }
+                                                    else if (propName === 'EntityName') {
+                                                        exampleValue = `"Products"`;
+                                                    }
+                                                    violations.push({
+                                                        rule: 'runview-runquery-valid-properties',
+                                                        severity: 'critical',
+                                                        line: prop.loc?.start.line || 0,
+                                                        column: prop.loc?.start.column || 0,
+                                                        message: `${methodName} property '${propName}' must be a string, not ${t.isObjectExpression(value) ? 'an object' : t.isArrayExpression(value) ? 'an array' : 'a non-string value'}. Example: ${propName}: ${exampleValue}`,
+                                                        code: `${propName}: ${prop.value.type === 'ObjectExpression' ? '{...}' : prop.value.type === 'ArrayExpression' ? '[...]' : '...'}`
+                                                    });
+                                                }
+                                            }
+                                            else if (propName === 'Fields') {
+                                                // Fields must be an array of strings (or a string that we'll interpret as comma-separated)
+                                                if (!isArrayLike(value) && !isStringLike(value)) {
+                                                    violations.push({
+                                                        rule: 'runview-runquery-valid-properties',
+                                                        severity: 'critical',
+                                                        line: prop.loc?.start.line || 0,
+                                                        column: prop.loc?.start.column || 0,
+                                                        message: `${methodName} property 'Fields' must be an array of field names or a comma-separated string. Example: Fields: ['ID', 'Name', 'Status'] or Fields: 'ID, Name, Status'`,
+                                                        code: `Fields: ${prop.value.type === 'ObjectExpression' ? '{...}' : '...'}`
+                                                    });
+                                                }
+                                            }
+                                            else if (propName === 'MaxRows' || propName === 'StartRow') {
+                                                // These must be numbers
+                                                if (!isNumberLike(value)) {
+                                                    violations.push({
+                                                        rule: 'runview-runquery-valid-properties',
+                                                        severity: 'critical',
+                                                        line: prop.loc?.start.line || 0,
+                                                        column: prop.loc?.start.column || 0,
+                                                        message: `${methodName} property '${propName}' must be a number. Example: ${propName}: ${propName === 'MaxRows' ? '100' : '0'}`,
+                                                        code: `${propName}: ${prop.value.type === 'StringLiteral' ? '"..."' : prop.value.type === 'ObjectExpression' ? '{...}' : '...'}`
+                                                    });
+                                                }
+                                            }
+                                        }
                                     }
                                 }
                                 // Check that EntityName is present (required property)
@@ -3804,7 +4236,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 +4258,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)
                             });
                         }
@@ -3858,6 +4308,111 @@ ComponentLinter.universalComponentRules = [
                                             code: `${propName}: ...`
                                         });
                                     }
+                                    else {
+                                        // Property name is valid, now check its type
+                                        const value = prop.value;
+                                        // Helper to check if a node is null or undefined
+                                        const isNullOrUndefined = (node) => {
+                                            return t.isNullLiteral(node) ||
+                                                (t.isIdentifier(node) && node.name === 'undefined');
+                                        };
+                                        // Helper to check if a node could evaluate to a string
+                                        const isStringLike = (node, depth = 0) => {
+                                            // Prevent infinite recursion
+                                            if (depth > 3)
+                                                return false;
+                                            // Special handling for ternary operators - check both branches
+                                            if (t.isConditionalExpression(node)) {
+                                                const consequentOk = isStringLike(node.consequent, depth + 1) || isNullOrUndefined(node.consequent);
+                                                const alternateOk = isStringLike(node.alternate, depth + 1) || isNullOrUndefined(node.alternate);
+                                                return consequentOk && alternateOk;
+                                            }
+                                            // Explicitly reject object and array expressions
+                                            if (t.isObjectExpression(node) || t.isArrayExpression(node)) {
+                                                return false;
+                                            }
+                                            return t.isStringLiteral(node) ||
+                                                t.isTemplateLiteral(node) ||
+                                                t.isBinaryExpression(node) || // String concatenation
+                                                t.isIdentifier(node) || // Variable
+                                                t.isCallExpression(node) || // Function call
+                                                t.isMemberExpression(node); // Property access
+                                        };
+                                        // Helper to check if a node could evaluate to a number
+                                        const isNumberLike = (node) => {
+                                            return t.isNumericLiteral(node) ||
+                                                t.isBinaryExpression(node) || // Math operations
+                                                t.isUnaryExpression(node) || // Negative numbers, etc
+                                                t.isConditionalExpression(node) || // Ternary
+                                                t.isIdentifier(node) || // Variable
+                                                t.isCallExpression(node) || // Function call
+                                                t.isMemberExpression(node); // Property access
+                                        };
+                                        // Helper to check if a node is object-like (but not array)
+                                        const isObjectLike = (node) => {
+                                            if (t.isArrayExpression(node))
+                                                return false;
+                                            return t.isObjectExpression(node) ||
+                                                t.isIdentifier(node) || // Variable
+                                                t.isCallExpression(node) || // Function returning object
+                                                t.isMemberExpression(node) || // Property access
+                                                t.isConditionalExpression(node) || // Ternary
+                                                t.isSpreadElement(node); // Spread syntax
+                                        };
+                                        // Validate types based on property name
+                                        if (propName === 'QueryID' || propName === 'QueryName' || propName === 'CategoryID' || propName === 'CategoryPath') {
+                                            // These must be strings
+                                            if (!isStringLike(value)) {
+                                                let exampleValue = '';
+                                                if (propName === 'QueryID') {
+                                                    exampleValue = `"550e8400-e29b-41d4-a716-446655440000"`;
+                                                }
+                                                else if (propName === 'QueryName') {
+                                                    exampleValue = `"Sales by Region"`;
+                                                }
+                                                else if (propName === 'CategoryID') {
+                                                    exampleValue = `"123e4567-e89b-12d3-a456-426614174000"`;
+                                                }
+                                                else if (propName === 'CategoryPath') {
+                                                    exampleValue = `"/Reports/Sales/"`;
+                                                }
+                                                violations.push({
+                                                    rule: 'runview-runquery-valid-properties',
+                                                    severity: 'critical',
+                                                    line: prop.loc?.start.line || 0,
+                                                    column: prop.loc?.start.column || 0,
+                                                    message: `RunQuery property '${propName}' must be a string. Example: ${propName}: ${exampleValue}`,
+                                                    code: `${propName}: ${prop.value.type === 'ObjectExpression' ? '{...}' : prop.value.type === 'ArrayExpression' ? '[...]' : '...'}`
+                                                });
+                                            }
+                                        }
+                                        else if (propName === 'Parameters') {
+                                            // Parameters must be an object (Record<string, any>)
+                                            if (!isObjectLike(value)) {
+                                                violations.push({
+                                                    rule: 'runview-runquery-valid-properties',
+                                                    severity: 'critical',
+                                                    line: prop.loc?.start.line || 0,
+                                                    column: prop.loc?.start.column || 0,
+                                                    message: `RunQuery property 'Parameters' must be an object containing key-value pairs. Example: Parameters: { startDate: '2024-01-01', status: 'Active' }`,
+                                                    code: `Parameters: ${t.isArrayExpression(value) ? '[...]' : t.isStringLiteral(value) ? '"..."' : '...'}`
+                                                });
+                                            }
+                                        }
+                                        else if (propName === 'MaxRows' || propName === 'StartRow') {
+                                            // These must be numbers
+                                            if (!isNumberLike(value)) {
+                                                violations.push({
+                                                    rule: 'runview-runquery-valid-properties',
+                                                    severity: 'critical',
+                                                    line: prop.loc?.start.line || 0,
+                                                    column: prop.loc?.start.column || 0,
+                                                    message: `RunQuery property '${propName}' must be a number. Example: ${propName}: ${propName === 'MaxRows' ? '100' : '0'}`,
+                                                    code: `${propName}: ${prop.value.type === 'StringLiteral' ? '"..."' : prop.value.type === 'ObjectExpression' ? '{...}' : '...'}`
+                                                });
+                                            }
+                                        }
+                                    }
                                 }
                             }
                             // Check that at least one required property is present
@@ -4394,8 +4949,10 @@ ComponentLinter.universalComponentRules = [
         test: (ast, componentName, componentSpec) => {
             const violations = [];
             const standardProps = new Set(['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings']);
-            // Build set of allowed props: standard props + componentSpec properties
-            const allowedProps = new Set(standardProps);
+            // React special props that are automatically provided by React
+            const reactSpecialProps = new Set(['children']);
+            // Build set of allowed props: standard props + React special props + componentSpec properties
+            const allowedProps = new Set([...standardProps, ...reactSpecialProps]);
             // Add props from componentSpec.properties if they exist
             if (componentSpec?.properties) {
                 for (const prop of componentSpec.properties) {
@@ -4430,7 +4987,7 @@ ComponentLinter.universalComponentRules = [
                                     severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
-                                    message: `Component "${componentName}" accepts undeclared props: ${invalidProps.join(', ')}. Components can only accept standard props: ${Array.from(standardProps).join(', ')}${customPropsMessage}. All custom props must be defined in the component spec properties array.`
+                                    message: `Component "${componentName}" accepts undeclared props: ${invalidProps.join(', ')}. Components can only accept standard props: ${Array.from(standardProps).join(', ')}, React special props: ${Array.from(reactSpecialProps).join(', ')}${customPropsMessage}. All custom props must be defined in the component spec properties array.`
                                 });
                             }
                         }
@@ -4463,9 +5020,231 @@ ComponentLinter.universalComponentRules = [
                                         severity: 'critical',
                                         line: path.node.loc?.start.line || 0,
                                         column: path.node.loc?.start.column || 0,
-                                        message: `Component "${componentName}" accepts undeclared props: ${invalidProps.join(', ')}. Components can only accept standard props: ${Array.from(standardProps).join(', ')}${customPropsMessage}. All custom props must be defined in the component spec properties array.`
+                                        message: `Component "${componentName}" accepts undeclared props: ${invalidProps.join(', ')}. Components can only accept standard props: ${Array.from(standardProps).join(', ')}, React special props: ${Array.from(reactSpecialProps).join(', ')}${customPropsMessage}. All custom props must be defined in the component spec properties array.`
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'validate-dependency-props',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Build a map of dependency components to their specs
+            const dependencySpecs = new Map();
+            // Process embedded dependencies
+            if (componentSpec?.dependencies && Array.isArray(componentSpec.dependencies)) {
+                for (const dep of componentSpec.dependencies) {
+                    if (dep && dep.name) {
+                        if (dep.location === 'registry') {
+                            const match = core_entities_1.ComponentMetadataEngine.Instance.FindComponent(dep.name, dep.namespace, dep.registry);
+                            if (!match) {
+                                // the specified registry component was not found, we can't lint for it, but we should put a warning
+                                console.warn('Dependency component not found in registry', dep);
+                            }
+                            else {
+                                dependencySpecs.set(dep.name, match.spec);
+                            }
+                        }
+                        else {
+                            // Embedded dependencies have their spec inline
+                            dependencySpecs.set(dep.name, dep);
+                        }
+                    }
+                    else {
+                        // we have an invalid dep in the spec, not a fatal error but we should log this
+                        console.warn(`Invalid dependency in component spec`, dep);
+                    }
+                }
+            }
+            // For registry dependencies, we'd need ComponentMetadataEngine
+            // But since this is a static lint check, we'll focus on embedded deps
+            // Registry components would need async loading which doesn't fit the current sync pattern
+            // Now traverse JSX to find component usage
+            (0, traverse_1.default)(ast, {
+                JSXElement(path) {
+                    const openingElement = path.node.openingElement;
+                    // Check if this is one of our dependency components
+                    if (t.isJSXIdentifier(openingElement.name)) {
+                        const componentName = openingElement.name.name;
+                        const depSpec = dependencySpecs.get(componentName);
+                        if (depSpec) {
+                            // Collect props being passed
+                            const passedProps = new Set();
+                            const passedPropNodes = new Map();
+                            for (const attr of openingElement.attributes) {
+                                if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                                    const propName = attr.name.name;
+                                    passedProps.add(propName);
+                                    passedPropNodes.set(propName, attr);
+                                }
+                            }
+                            // Check required custom props
+                            if (depSpec.properties && Array.isArray(depSpec.properties)) {
+                                const requiredProps = [];
+                                const optionalProps = [];
+                                for (const prop of depSpec.properties) {
+                                    if (prop && prop.name && typeof prop.name === 'string') {
+                                        if (prop.required === true) {
+                                            requiredProps.push(prop.name);
+                                        }
+                                        else {
+                                            optionalProps.push(prop.name);
+                                        }
+                                    }
+                                }
+                                // Check for missing required props
+                                const missingRequired = requiredProps.filter(prop => {
+                                    // Special handling for 'children' prop
+                                    if (prop === 'children') {
+                                        // Check if JSX element has children nodes
+                                        const hasChildren = path.node.children && path.node.children.length > 0 &&
+                                            path.node.children.some(child => !t.isJSXText(child) || (t.isJSXText(child) && child.value.trim() !== ''));
+                                        return !passedProps.has(prop) && !hasChildren;
+                                    }
+                                    return !passedProps.has(prop);
+                                });
+                                // Separate children warnings from other critical props
+                                const missingChildren = missingRequired.filter(prop => prop === 'children');
+                                const missingOtherProps = missingRequired.filter(prop => prop !== 'children');
+                                // Critical violation for non-children required props
+                                if (missingOtherProps.length > 0) {
+                                    violations.push({
+                                        rule: 'validate-dependency-props',
+                                        severity: 'critical',
+                                        line: openingElement.loc?.start.line || 0,
+                                        column: openingElement.loc?.start.column || 0,
+                                        message: `Dependency component "${componentName}" is missing required props: ${missingOtherProps.join(', ')}. These props are marked as required in the component's specification.`,
+                                        code: `<${componentName} ... />`
+                                    });
+                                }
+                                // Medium severity warning for missing children when required
+                                if (missingChildren.length > 0) {
+                                    violations.push({
+                                        rule: 'validate-dependency-props',
+                                        severity: 'medium',
+                                        line: openingElement.loc?.start.line || 0,
+                                        column: openingElement.loc?.start.column || 0,
+                                        message: `Component "${componentName}" expects children but none were provided. The 'children' prop is marked as required in the component's specification.`,
+                                        code: `<${componentName} ... />`
                                     });
                                 }
+                                // Validate prop types for passed props
+                                for (const [propName, attrNode] of passedPropNodes) {
+                                    const propSpec = depSpec.properties.find(p => p.name === propName);
+                                    if (propSpec && propSpec.type) {
+                                        const value = attrNode.value;
+                                        // Type validation based on prop spec type
+                                        if (propSpec.type === 'string') {
+                                            // Check if value could be a string
+                                            if (value && t.isJSXExpressionContainer(value)) {
+                                                const expr = value.expression;
+                                                // Check for obvious non-string types
+                                                if (t.isNumericLiteral(expr) || t.isBooleanLiteral(expr) ||
+                                                    t.isArrayExpression(expr) || (t.isObjectExpression(expr) && !t.isTemplateLiteral(expr))) {
+                                                    violations.push({
+                                                        rule: 'validate-dependency-props',
+                                                        severity: 'high',
+                                                        line: attrNode.loc?.start.line || 0,
+                                                        column: attrNode.loc?.start.column || 0,
+                                                        message: `Prop "${propName}" on component "${componentName}" expects type "string" but received a different type.`,
+                                                        code: `${propName}={...}`
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        else if (propSpec.type === 'number') {
+                                            // Check if value could be a number
+                                            if (value && t.isJSXExpressionContainer(value)) {
+                                                const expr = value.expression;
+                                                if (t.isStringLiteral(expr) || t.isBooleanLiteral(expr) ||
+                                                    t.isArrayExpression(expr) || t.isObjectExpression(expr)) {
+                                                    violations.push({
+                                                        rule: 'validate-dependency-props',
+                                                        severity: 'high',
+                                                        line: attrNode.loc?.start.line || 0,
+                                                        column: attrNode.loc?.start.column || 0,
+                                                        message: `Prop "${propName}" on component "${componentName}" expects type "number" but received a different type.`,
+                                                        code: `${propName}={...}`
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        else if (propSpec.type === 'boolean') {
+                                            // Check if value could be a boolean
+                                            if (value && t.isJSXExpressionContainer(value)) {
+                                                const expr = value.expression;
+                                                if (t.isStringLiteral(expr) || t.isNumericLiteral(expr) ||
+                                                    t.isArrayExpression(expr) || t.isObjectExpression(expr)) {
+                                                    violations.push({
+                                                        rule: 'validate-dependency-props',
+                                                        severity: 'high',
+                                                        line: attrNode.loc?.start.line || 0,
+                                                        column: attrNode.loc?.start.column || 0,
+                                                        message: `Prop "${propName}" on component "${componentName}" expects type "boolean" but received a different type.`,
+                                                        code: `${propName}={...}`
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        else if (propSpec.type === 'array') {
+                                            // Check if value could be an array
+                                            if (value && t.isJSXExpressionContainer(value)) {
+                                                const expr = value.expression;
+                                                if (t.isStringLiteral(expr) || t.isNumericLiteral(expr) ||
+                                                    t.isBooleanLiteral(expr) || (t.isObjectExpression(expr) && !t.isArrayExpression(expr))) {
+                                                    violations.push({
+                                                        rule: 'validate-dependency-props',
+                                                        severity: 'high',
+                                                        line: attrNode.loc?.start.line || 0,
+                                                        column: attrNode.loc?.start.column || 0,
+                                                        message: `Prop "${propName}" on component "${componentName}" expects type "array" but received a different type.`,
+                                                        code: `${propName}={...}`
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        else if (propSpec.type === 'object') {
+                                            // Check if value could be an object
+                                            if (value && t.isJSXExpressionContainer(value)) {
+                                                const expr = value.expression;
+                                                if (t.isStringLiteral(expr) || t.isNumericLiteral(expr) ||
+                                                    t.isBooleanLiteral(expr) || t.isArrayExpression(expr)) {
+                                                    violations.push({
+                                                        rule: 'validate-dependency-props',
+                                                        severity: 'high',
+                                                        line: attrNode.loc?.start.line || 0,
+                                                        column: attrNode.loc?.start.column || 0,
+                                                        message: `Prop "${propName}" on component "${componentName}" expects type "object" but received a different type.`,
+                                                        code: `${propName}={...}`
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                // Check for unknown props (props not in the spec)
+                                const specPropNames = new Set(depSpec.properties.map(p => p.name).filter(Boolean));
+                                const standardProps = new Set(['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings']);
+                                const reactSpecialProps = new Set(['children']);
+                                for (const passedProp of passedProps) {
+                                    if (!specPropNames.has(passedProp) && !standardProps.has(passedProp) && !reactSpecialProps.has(passedProp)) {
+                                        violations.push({
+                                            rule: 'validate-dependency-props',
+                                            severity: 'medium',
+                                            line: passedPropNodes.get(passedProp)?.loc?.start.line || 0,
+                                            column: passedPropNodes.get(passedProp)?.loc?.start.column || 0,
+                                            message: `Prop "${passedProp}" is not defined in the specification for component "${componentName}". In addition to the standard MJ props, valid custom props: ${Array.from(specPropNames).join(', ') || 'none'}.`,
+                                            code: `${passedProp}={...}`
+                                        });
+                                    }
+                                }
                             }
                         }
                     }
@@ -4776,13 +5555,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 +5910,56 @@ ComponentLinter.universalComponentRules = [
         appliesTo: 'all',
         test: (ast, componentName, componentSpec) => {
             const violations = [];
-            // Track variables that hold RunView/RunQuery results
-            const resultVariables = new Map();
+            // 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, {
-                // 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
-            (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 +5968,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 +5989,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 +6043,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',
@@ -5493,6 +6251,197 @@ ComponentLinter.universalComponentRules = [
             return violations;
         }
     },
+    {
+        name: 'validate-runview-runquery-result-access',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // 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 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
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // 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',
@@ -6074,6 +7023,1044 @@ 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: 'low',
+                        line: 1,
+                        column: 0,
+                        message: `Component dependency "${depName}" is declared but never used. Consider removing it if not needed.`,
+                        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;
+        }
+    },
+    // New rules for catching RunQuery/RunView result access patterns
+    {
+        name: 'runquery-runview-ternary-array-check',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Track variables that hold RunView/RunQuery results
+            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 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
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Second pass: check for Array.isArray(result) ? result : [] pattern
+            (0, traverse_1.default)(ast, {
+                ConditionalExpression(path) {
+                    const test = path.node.test;
+                    const consequent = path.node.consequent;
+                    const alternate = path.node.alternate;
+                    // Check for Array.isArray(variable) pattern
+                    if (t.isCallExpression(test) &&
+                        t.isMemberExpression(test.callee) &&
+                        t.isIdentifier(test.callee.object) &&
+                        test.callee.object.name === 'Array' &&
+                        t.isIdentifier(test.callee.property) &&
+                        test.callee.property.name === 'isArray' &&
+                        test.arguments.length === 1 &&
+                        t.isIdentifier(test.arguments[0])) {
+                        const varName = test.arguments[0].name;
+                        // Check if this variable is a RunQuery/RunView result
+                        if (resultVariables.has(varName)) {
+                            const resultInfo = resultVariables.get(varName);
+                            // Check if the consequent is the same variable and alternate is []
+                            if (t.isIdentifier(consequent) &&
+                                consequent.name === varName &&
+                                t.isArrayExpression(alternate) &&
+                                alternate.elements.length === 0) {
+                                violations.push({
+                                    rule: 'runquery-runview-ternary-array-check',
+                                    severity: 'critical',
+                                    line: test.loc?.start.line || 0,
+                                    column: test.loc?.start.column || 0,
+                                    message: `${resultInfo.method} never returns an array directly. The pattern "Array.isArray(${varName}) ? ${varName} : []" will always evaluate to [] because ${varName} is an object with { Success, Results, ErrorMessage }.
+
+Correct patterns:
+  // Option 1: Simple with fallback
+  ${varName}.Results || []
+  
+  // Option 2: Check success first
+  if (${varName}.Success) {
+    setData(${varName}.Results || []);
+  } else {
+    console.error('Failed:', ${varName}.ErrorMessage);
+    setData([]);
+  }`,
+                                    code: `Array.isArray(${varName}) ? ${varName} : []`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'runquery-runview-direct-setstate',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Track variables that hold RunView/RunQuery results
+            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 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)) {
+                                    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)) {
+                                    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
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Second pass: check for passing result directly to setState functions
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check if this is a setState function call
+                    if (t.isIdentifier(callee)) {
+                        const funcName = callee.name;
+                        // Common setState patterns
+                        const setStatePatterns = [
+                            /^set[A-Z]/, // setData, setChartData, setItems, etc.
+                            /^update[A-Z]/, // updateData, updateItems, etc.
+                        ];
+                        const isSetStateFunction = setStatePatterns.some(pattern => pattern.test(funcName));
+                        if (isSetStateFunction && path.node.arguments.length > 0) {
+                            const firstArg = path.node.arguments[0];
+                            // Check if the argument is a ternary with Array.isArray check
+                            if (t.isConditionalExpression(firstArg)) {
+                                const test = firstArg.test;
+                                const consequent = firstArg.consequent;
+                                const alternate = firstArg.alternate;
+                                // Check for Array.isArray(variable) ? variable : []
+                                if (t.isCallExpression(test) &&
+                                    t.isMemberExpression(test.callee) &&
+                                    t.isIdentifier(test.callee.object) &&
+                                    test.callee.object.name === 'Array' &&
+                                    t.isIdentifier(test.callee.property) &&
+                                    test.callee.property.name === 'isArray' &&
+                                    test.arguments.length === 1 &&
+                                    t.isIdentifier(test.arguments[0])) {
+                                    const varName = test.arguments[0].name;
+                                    if (resultVariables.has(varName) &&
+                                        t.isIdentifier(consequent) &&
+                                        consequent.name === varName) {
+                                        const resultInfo = resultVariables.get(varName);
+                                        violations.push({
+                                            rule: 'runquery-runview-direct-setstate',
+                                            severity: 'critical',
+                                            line: firstArg.loc?.start.line || 0,
+                                            column: firstArg.loc?.start.column || 0,
+                                            message: `Passing ${resultInfo.method} result with incorrect Array.isArray check to ${funcName}. This will always pass an empty array because ${resultInfo.method} returns an object, not an array.
+
+Correct pattern:
+  if (${varName}.Success) {
+    ${funcName}(${varName}.Results || []);
+  } else {
+    console.error('Failed to load data:', ${varName}.ErrorMessage);
+    ${funcName}([]);
+  }
+  
+  // Or simpler:
+  ${funcName}(${varName}.Results || []);`,
+                                            code: `${funcName}(Array.isArray(${varName}) ? ${varName} : [])`
+                                        });
+                                    }
+                                }
+                            }
+                            // Check if passing result directly (not accessing .Results)
+                            if (t.isIdentifier(firstArg) && resultVariables.has(firstArg.name)) {
+                                const resultInfo = resultVariables.get(firstArg.name);
+                                violations.push({
+                                    rule: 'runquery-runview-direct-setstate',
+                                    severity: 'critical',
+                                    line: firstArg.loc?.start.line || 0,
+                                    column: firstArg.loc?.start.column || 0,
+                                    message: `Passing ${resultInfo.method} result object directly to ${funcName}. The result is an object { Success, Results, ErrorMessage }, not the data array.
+
+Correct pattern:
+  if (${firstArg.name}.Success) {
+    ${funcName}(${firstArg.name}.Results || []);
+  } else {
+    console.error('Failed to load data:', ${firstArg.name}.ErrorMessage);
+    ${funcName}([]);
+  }`,
+                                    code: `${funcName}(${firstArg.name})`
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'styles-invalid-path',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const analyzer = ComponentLinter.getStylesAnalyzer();
+            (0, traverse_1.default)(ast, {
+                MemberExpression(path) {
+                    // Build the complete property chain first
+                    let propertyChain = [];
+                    let current = path.node;
+                    // Walk up from the deepest member expression to build the full chain
+                    while (t.isMemberExpression(current)) {
+                        if (t.isIdentifier(current.property)) {
+                            propertyChain.unshift(current.property.name);
+                        }
+                        if (t.isIdentifier(current.object)) {
+                            propertyChain.unshift(current.object.name);
+                            break;
+                        }
+                        current = current.object;
+                    }
+                    // Only process if this is a styles access
+                    if (propertyChain[0] === 'styles') {
+                        // Validate the path
+                        if (!analyzer.isValidPath(propertyChain)) {
+                            const suggestions = analyzer.getSuggestionsForPath(propertyChain);
+                            const accessPath = propertyChain.join('.');
+                            let message = `Invalid styles property path: "${accessPath}"`;
+                            if (suggestions.didYouMean) {
+                                message += `\n\nDid you mean: ${suggestions.didYouMean}?`;
+                            }
+                            if (suggestions.correctPaths.length > 0) {
+                                message += `\n\nThe property "${propertyChain[propertyChain.length - 1]}" exists at:`;
+                                suggestions.correctPaths.forEach((p) => {
+                                    message += `\n  - ${p}`;
+                                });
+                            }
+                            if (suggestions.availableAtParent.length > 0) {
+                                const parentPath = propertyChain.slice(0, -1).join('.');
+                                message += `\n\nAvailable properties at ${parentPath}:`;
+                                message += `\n  ${suggestions.availableAtParent.slice(0, 5).join(', ')}`;
+                                if (suggestions.availableAtParent.length > 5) {
+                                    message += ` (and ${suggestions.availableAtParent.length - 5} more)`;
+                                }
+                            }
+                            // Get a contextual default value
+                            const defaultValue = analyzer.getDefaultValueForPath(propertyChain);
+                            message += `\n\nSuggested fix with safe access:\n  ${accessPath.replace(/\./g, '?.')} || ${defaultValue}`;
+                            violations.push({
+                                rule: 'styles-invalid-path',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: message,
+                                code: accessPath
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'styles-unsafe-access',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            const analyzer = ComponentLinter.getStylesAnalyzer();
+            (0, traverse_1.default)(ast, {
+                MemberExpression(path) {
+                    // Build the complete property chain first
+                    let propertyChain = [];
+                    let current = path.node;
+                    let hasOptionalChaining = path.node.optional || false;
+                    // Walk up from the deepest member expression to build the full chain
+                    while (t.isMemberExpression(current)) {
+                        if (current.optional) {
+                            hasOptionalChaining = true;
+                        }
+                        if (t.isIdentifier(current.property)) {
+                            propertyChain.unshift(current.property.name);
+                        }
+                        if (t.isIdentifier(current.object)) {
+                            propertyChain.unshift(current.object.name);
+                            break;
+                        }
+                        current = current.object;
+                    }
+                    // Only process if this is a styles access
+                    if (propertyChain[0] === 'styles') {
+                        // Only check valid paths for safe access
+                        if (analyzer.isValidPath(propertyChain)) {
+                            // Check if this is a nested access without optional chaining or fallback
+                            if (propertyChain.length > 2 && !hasOptionalChaining) {
+                                // Check if there's a fallback (|| operator)
+                                const parent = path.parent;
+                                const hasFallback = t.isLogicalExpression(parent) && parent.operator === '||';
+                                if (!hasFallback) {
+                                    const accessPath = propertyChain.join('.');
+                                    const defaultValue = analyzer.getDefaultValueForPath(propertyChain);
+                                    violations.push({
+                                        rule: 'styles-unsafe-access',
+                                        severity: 'high',
+                                        line: path.node.loc?.start.line || 0,
+                                        column: path.node.loc?.start.column || 0,
+                                        message: `Unsafe styles property access: "${accessPath}". While this path is valid, you should use optional chaining for safety.
+                      
+Example with optional chaining:
+  ${accessPath.replace(/\./g, '?.')} || ${defaultValue}
+  
+This prevents runtime errors if the styles object structure changes.`,
+                                        code: accessPath
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
+    {
+        name: 'runquery-runview-spread-operator',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Track variables that hold RunView/RunQuery results
+            const resultVariables = new Map();
+            // First pass: identify all RunView/RunQuery calls
+            (0, traverse_1.default)(ast, {
+                AwaitExpression(path) {
+                    const callExpr = path.node.argument;
+                    if (t.isCallExpression(callExpr) && t.isMemberExpression(callExpr.callee)) {
+                        const callee = callExpr.callee;
+                        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 if (subObject === 'rq' && method === 'RunQuery') {
+                                methodType = 'RunQuery';
+                            }
+                            if (methodType) {
+                                const parent = path.parent;
+                                if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+                                    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
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Second pass: check for spread operator usage
+            (0, traverse_1.default)(ast, {
+                SpreadElement(path) {
+                    if (t.isIdentifier(path.node.argument)) {
+                        const varName = path.node.argument.name;
+                        if (resultVariables.has(varName)) {
+                            const resultInfo = resultVariables.get(varName);
+                            violations.push({
+                                rule: 'runquery-runview-spread-operator',
+                                severity: 'critical',
+                                line: path.node.loc?.start.line || 0,
+                                column: path.node.loc?.start.column || 0,
+                                message: `Cannot use spread operator on ${resultInfo.method} result object. Use ...${varName}.Results to spread the data array.
+
+Correct pattern:
+  const allData = [...existingData, ...${varName}.Results];
+  
+  // Or with null safety:
+  const allData = [...existingData, ...(${varName}.Results || [])];`,
+                                code: `...${varName}`
+                            });
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
     }
 ];
 //# sourceMappingURL=component-linter.js.map