@memberjunction/react-test-harness 2.96.0 → 2.98.0

package/dist/lib/component-runner.js

@@ -45,7 +45,6 @@ class ComponentRunner {
         const hasErrors = lintResult.violations.some(v => v.severity === 'critical' || v.severity === 'high');
         return {
             violations: lintResult.violations,
-            suggestions: lintResult.suggestions,
             hasErrors
         };
     }
@@ -53,7 +52,6 @@ class ComponentRunner {
         const startTime = Date.now();
         const errors = [];
         const warnings = [];
-        const criticalWarnings = [];
         const consoleLogs = [];
         const dataErrors = []; // Track data access errors from RunView/RunQuery
         let renderCount = 0;
@@ -121,9 +119,9 @@ class ComponentRunner {
                 throw new Error('Failed to inject MJReactRuntime into page context');
             }
             // Set up error tracking
-            await this.setupErrorTracking(page);
+            await this.setupErrorTracking(page, options.componentSpec, allLibraries);
             // Set up console logging
-            this.setupConsoleLogging(page, consoleLogs, warnings, criticalWarnings);
+            this.setupConsoleLogging(page, consoleLogs, warnings);
             // Expose MJ utilities to the page
             await this.exposeMJUtilities(page, options, dataErrors, debug);
             if (debug) {
@@ -131,22 +129,25 @@ class ComponentRunner {
                 console.log('  - spec.name:', options.componentSpec.name);
                 console.log('  - spec.code length:', options.componentSpec.code?.length || 0);
                 console.log('  - props:', JSON.stringify(options.props || {}, null, 2));
-                console.log('  - componentLibraries count:', allLibraries?.length || 0);
-                if (allLibraries && allLibraries.length > 0) {
-                    console.log('  - First few libraries:', allLibraries.slice(0, 3).map(lib => ({
-                        Name: lib.Name,
-                        GlobalVariable: lib.GlobalVariable
+                // Show spec-specific libraries, not all available libraries
+                if (options.componentSpec.libraries && options.componentSpec.libraries.length > 0) {
+                    console.log('  - spec requires libraries:', options.componentSpec.libraries.map(lib => ({
+                        name: lib.name,
+                        globalVariable: lib.globalVariable,
+                        version: lib.version
                     })));
                 }
+                else {
+                    console.log('  - spec requires libraries: none');
+                }
+                // Total available libraries in metadata (for context only)
+                console.log('  - total available libraries in metadata:', allLibraries?.length || 0);
             }
             // Execute the component using the real React runtime with timeout (Recommendation #1)
             const executionPromise = page.evaluate(async ({ spec, props, debug, componentLibraries }) => {
                 if (debug) {
                     console.log('🎯 Starting component execution');
-                    console.log('📚 BROWSER: Received componentLibraries:', componentLibraries?.length || 0);
-                    if (componentLibraries?.length > 0) {
-                        console.log('  First library:', componentLibraries[0]);
-                    }
+                    console.log('📚 BROWSER: Component libraries available for loading:', componentLibraries?.length || 0);
                 }
                 // Declare renderCheckInterval at the top scope for cleanup
                 let renderCheckInterval;
@@ -215,8 +216,15 @@ class ComponentRunner {
                     // The spec might not have globalVariable, but we need it for the runtime to work
                     if (spec.libraries && componentLibraries) {
                         for (const specLib of spec.libraries) {
+                            // Skip if library entry is invalid
+                            if (!specLib || !specLib.name) {
+                                if (debug) {
+                                    console.warn('  ⚠️ Skipping invalid library entry (missing name):', specLib);
+                                }
+                                continue;
+                            }
                             if (!specLib.globalVariable) {
-                                const libDef = componentLibraries.find(l => l.Name.toLowerCase() === specLib.name.toLowerCase());
+                                const libDef = componentLibraries.find(l => l && l.Name && l.Name.toLowerCase() === specLib.name.toLowerCase());
                                 if (libDef && libDef.GlobalVariable) {
                                     specLib.globalVariable = libDef.GlobalVariable;
                                     if (debug) {
@@ -257,10 +265,17 @@ class ComponentRunner {
                             message: `Component registration failed: ${registrationError.message || registrationError}`,
                             stack: registrationError.stack,
                             type: 'registration-error',
-                            phase: 'component-compilation'
+                            phase: 'component-compilation',
+                            source: 'runtime-wrapper'
                         });
                         window.__testHarnessTestFailed = true;
-                        throw registrationError; // Re-throw for outer handler
+                        // Don't re-throw - let execution continue to collect this error properly
+                        // Return a failure result so the Promise resolves properly
+                        return {
+                            success: false,
+                            error: `Component registration failed: ${registrationError.message || registrationError}`,
+                            componentCount: 0
+                        };
                     }
                     if (debug && !registrationResult.success) {
                         console.log('❌ Registration failed:', registrationResult.errors);
@@ -319,7 +334,8 @@ class ComponentRunner {
                                 window.__testHarnessRuntimeErrors = window.__testHarnessRuntimeErrors || [];
                                 window.__testHarnessRuntimeErrors.push({
                                     message: `Likely infinite render loop: ${currentRenderCount} createElement calls (max: ${MAX_RENDERS_ALLOWED})`,
-                                    type: 'render-loop'
+                                    type: 'render-loop',
+                                    source: 'test-harness'
                                 });
                                 // Try to unmount to stop the madness
                                 try {
@@ -369,7 +385,8 @@ class ComponentRunner {
                                 message: enhancedMessage,
                                 stack: error.stack,
                                 type: 'react-render-error',
-                                phase: 'component-render'
+                                phase: 'component-render',
+                                source: 'user-component' // This is the actual error from user's component
                             });
                             window.__testHarnessTestFailed = true;
                             return { hasError: true, error };
@@ -421,7 +438,8 @@ class ComponentRunner {
                     window.__testHarnessRuntimeErrors.push({
                         message: error.message || String(error),
                         stack: error.stack,
-                        type: 'execution-error'
+                        type: 'execution-error',
+                        source: 'runtime-wrapper'
                     });
                     window.__testHarnessTestFailed = true;
                     return {
@@ -439,17 +457,34 @@ class ComponentRunner {
             const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Component execution timeout after ${globalTimeout}ms`)), globalTimeout));
             // Race between execution and timeout
             let executionResult;
+            let hasTimeout = false;
             try {
                 executionResult = await Promise.race([executionPromise, timeoutPromise]);
             }
             catch (timeoutError) {
                 // Handle timeout gracefully
+                hasTimeout = true;
                 errors.push(`Component execution timed out after ${globalTimeout}ms`);
                 executionResult = {
                     success: false,
                     error: timeoutError instanceof Error ? timeoutError.message : 'Execution timeout'
                 };
             }
+            // Ensure executionResult has proper shape
+            if (!executionResult) {
+                executionResult = {
+                    success: false,
+                    error: 'Component execution returned no result'
+                };
+                errors.push('Component execution failed to return a result');
+            }
+            else if (!executionResult.success && executionResult.error) {
+                // Add the execution error if it hasn't been captured elsewhere
+                const errorMsg = `Component execution failed: ${executionResult.error}`;
+                if (!errors.some(e => e.includes(executionResult.error))) {
+                    errors.push(errorMsg);
+                }
+            }
             if (debug) {
                 console.log('Execution result:', executionResult);
             }
@@ -458,9 +493,9 @@ class ComponentRunner {
             await page.waitForTimeout(renderWaitTime);
             // Get render count
             renderCount = await page.evaluate(() => window.__testHarnessRenderCount || 0);
-            // Collect all errors
-            const runtimeErrors = await this.collectRuntimeErrors(page);
-            errors.push(...runtimeErrors);
+            // Collect all errors with source information
+            const runtimeErrorsWithSource = await this.collectRuntimeErrors(page);
+            errors.push(...runtimeErrorsWithSource.map(e => e.message)); // Extract messages for backward compat
             // Collect warnings (separate from errors)
             const collectedWarnings = await this.collectWarnings(page);
             warnings.push(...collectedWarnings);
@@ -470,8 +505,9 @@ class ComponentRunner {
             const asyncErrors = await this.collectRuntimeErrors(page);
             // Only add new errors
             asyncErrors.forEach(err => {
-                if (!errors.includes(err)) {
-                    errors.push(err);
+                if (!errors.includes(err.message)) {
+                    errors.push(err.message);
+                    runtimeErrorsWithSource.push(err); // Keep the structured version too
                 }
             });
             // Also check for new warnings
@@ -485,34 +521,93 @@ class ComponentRunner {
             const html = await page.content();
             // Take screenshot
             const screenshot = await page.screenshot();
+            // Check for excessive render count first
+            const hasRenderLoop = renderCount > ComponentRunner.MAX_RENDER_COUNT;
+            if (hasRenderLoop) {
+                errors.push(`Possible render loop: ${renderCount} createElement calls detected (likely infinite loop)`);
+            }
             // Determine success
             const success = errors.length === 0 &&
-                criticalWarnings.length === 0 &&
-                renderCount <= ComponentRunner.MAX_RENDER_COUNT &&
+                !hasRenderLoop &&
+                !hasTimeout &&
                 executionResult.success;
-            if (renderCount > ComponentRunner.MAX_RENDER_COUNT) {
-                errors.push(`Possible render loop: ${renderCount} createElement calls detected (likely infinite loop)`);
-            }
             // Combine runtime errors with data errors
             const allErrors = [...errors, ...dataErrors];
-            const result = {
-                success: success && dataErrors.length === 0, // Fail if we have data errors
-                html,
-                errors: allErrors.map(e => ({
+            // Map runtime errors with source info and specific rules
+            const errorViolations = runtimeErrorsWithSource.map(e => ({
+                message: e.message,
+                severity: 'critical',
+                rule: e.rule || 'runtime-error', // Use specific rule from collectRuntimeErrors
+                line: 0,
+                column: 0,
+                source: e.source
+            }));
+            // Add timeout error if detected
+            if (hasTimeout) {
+                errorViolations.push({
+                    message: `Component execution timed out after ${globalTimeout}ms`,
+                    severity: 'critical',
+                    rule: 'timeout',
+                    line: 0,
+                    column: 0,
+                    source: 'test-harness' // This is a test harness timeout
+                });
+            }
+            // Add render loop error if detected
+            if (hasRenderLoop) {
+                errorViolations.push({
+                    message: `Possible render loop: ${renderCount} createElement calls detected (likely infinite loop)`,
+                    severity: 'critical',
+                    rule: 'render-loop',
+                    line: 0,
+                    column: 0,
+                    source: 'test-harness' // This is a test harness detection
+                });
+            }
+            // Add data errors without source
+            dataErrors.forEach(e => {
+                errorViolations.push({
                     message: e,
                     severity: 'critical',
                     rule: 'runtime-error',
                     line: 0,
-                    column: 0
-                })),
-                warnings: warnings.map(w => ({
+                    column: 0,
+                    source: 'user-component' // Data errors are from user's data access code
+                });
+            });
+            // Check warnings for critical patterns and move them to errors
+            const criticalWarningViolations = [];
+            const regularWarnings = [];
+            warnings.forEach(w => {
+                if (ComponentRunner.CRITICAL_WARNING_PATTERNS.some(pattern => pattern.test(w))) {
+                    // This is a critical warning - add to errors
+                    criticalWarningViolations.push({
+                        message: w,
+                        severity: 'critical',
+                        rule: 'critical-react-warning',
+                        line: 0,
+                        column: 0,
+                        source: 'react-framework'
+                    });
+                }
+                else {
+                    // Regular warning
+                    regularWarnings.push(w);
+                }
+            });
+            // Combine all error violations
+            const allErrorViolations = [...errorViolations, ...criticalWarningViolations];
+            const result = {
+                success: success && dataErrors.length === 0 && criticalWarningViolations.length === 0, // Fail on critical warnings too
+                html,
+                errors: allErrorViolations,
+                warnings: regularWarnings.map(w => ({
                     message: w,
                     severity: 'low',
                     rule: 'warning',
                     line: 0,
                     column: 0
                 })),
-                criticalWarnings,
                 console: consoleLogs,
                 screenshot,
                 executionTime: Date.now() - startTime,
@@ -524,19 +619,35 @@ class ComponentRunner {
             return result;
         }
         catch (error) {
-            errors.push(error instanceof Error ? error.message : String(error));
-            // Combine runtime errors with data errors
-            const allErrors = [...errors, ...dataErrors];
-            const result = {
-                success: false,
-                html: '',
-                errors: allErrors.map(e => ({
+            // For catch block errors, we need to handle them specially
+            const catchError = {
+                message: error instanceof Error ? error.message : String(error),
+                source: 'test-harness' // Errors caught here are usually test harness issues
+            };
+            // Create error violations including the catch error
+            const errorViolations = [{
+                    message: catchError.message,
+                    severity: 'critical',
+                    rule: 'runtime-error',
+                    line: 0,
+                    column: 0,
+                    source: catchError.source
+                }];
+            // Add any data errors
+            dataErrors.forEach(e => {
+                errorViolations.push({
                     message: e,
                     severity: 'critical',
                     rule: 'runtime-error',
                     line: 0,
-                    column: 0
-                })),
+                    column: 0,
+                    source: 'user-component'
+                });
+            });
+            const result = {
+                success: false,
+                html: '',
+                errors: errorViolations,
                 warnings: warnings.map(w => ({
                     message: w,
                     severity: 'low',
@@ -544,7 +655,6 @@ class ComponentRunner {
                     line: 0,
                     column: 0
                 })),
-                criticalWarnings,
                 console: consoleLogs,
                 executionTime: Date.now() - startTime,
                 renderCount
@@ -743,20 +853,91 @@ class ComponentRunner {
     /**
      * Set up error tracking in the page
      */
-    async setupErrorTracking(page) {
-        await page.evaluate(() => {
+    async setupErrorTracking(page, componentSpec, allLibraries) {
+        await page.evaluate(({ spec, availableLibraries }) => {
             // Initialize error tracking
             window.__testHarnessRuntimeErrors = [];
             window.__testHarnessConsoleErrors = [];
             window.__testHarnessConsoleWarnings = [];
             window.__testHarnessTestFailed = false;
             window.__testHarnessRenderCount = 0;
-            // Track renders
+            // Track renders and detect invalid element types
             const originalCreateElement = window.React?.createElement;
             if (originalCreateElement) {
-                window.React.createElement = function (...args) {
+                window.React.createElement = function (type, props, ...children) {
                     window.__testHarnessRenderCount++;
-                    return originalCreateElement.apply(this, args);
+                    // Enhanced error detection for invalid element types
+                    if (type !== null && type !== undefined) {
+                        const typeOf = typeof type;
+                        // Check for the common "object instead of component" error
+                        if (typeOf === 'object' && !window.React.isValidElement(type)) {
+                            // Try to get a meaningful name for the object
+                            let objectInfo = 'unknown object';
+                            try {
+                                if (type.constructor && type.constructor.name) {
+                                    objectInfo = type.constructor.name;
+                                }
+                                else if (type.name) {
+                                    objectInfo = type.name;
+                                }
+                                else {
+                                    // Try to show what properties it has
+                                    const keys = Object.keys(type).slice(0, 5);
+                                    if (keys.length > 0) {
+                                        objectInfo = `object with properties: ${keys.join(', ')}`;
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                // Ignore errors in trying to get object info
+                            }
+                            // Generate helpful error message
+                            const errorMsg = [
+                                `Invalid JSX element type: React received an object (${objectInfo}) instead of a React component function.`,
+                                '',
+                                'This often occurs when JSX elements or React.createElement receive an object instead of a valid component function.',
+                                '',
+                                'Inspect all instances where you are using JSX elements that come from libraries or components to ensure they are properly referenced.',
+                                '',
+                                'The exact fix depends on the specific library or component structure.'
+                            ].join('\\n');
+                            // Log to both console and error tracking
+                            console.error('🔴 Invalid JSX Element Type Detected:', errorMsg);
+                            // Store the error for later collection
+                            window.__testHarnessRuntimeErrors = window.__testHarnessRuntimeErrors || [];
+                            window.__testHarnessRuntimeErrors.push({
+                                message: errorMsg,
+                                type: 'invalid-element-type',
+                                phase: 'createElement',
+                                source: 'enhanced-detection',
+                                elementInfo: objectInfo
+                            });
+                            // Still try to call the original to get React's error too
+                            // This will provide the component stack trace
+                        }
+                    }
+                    else if (type === undefined) {
+                        // Undefined component - likely a failed destructure or missing import
+                        const errorMsg = [
+                            'Invalid JSX element type: component is undefined.',
+                            '',
+                            'This occurs when a JSX element references a component that is undefined at runtime.',
+                            '',
+                            'Inspect how this component is being accessed - it may not exist in the expected location or may have a different name.',
+                            '',
+                            'Check that the component exists in your dependencies or libraries and is properly referenced.'
+                        ].join('\\n');
+                        console.error('🔴 Undefined JSX Component:', errorMsg);
+                        window.__testHarnessRuntimeErrors = window.__testHarnessRuntimeErrors || [];
+                        window.__testHarnessRuntimeErrors.push({
+                            message: errorMsg,
+                            type: 'undefined-component',
+                            phase: 'createElement',
+                            source: 'enhanced-detection'
+                        });
+                    }
+                    // Call original createElement
+                    return originalCreateElement.call(this, type, props, ...children);
                 };
             }
             // Override console.error
@@ -785,12 +966,91 @@ class ComponentRunner {
                 }
                 originalConsoleError.apply(console, args);
             };
+            // Helper function to analyze undefined identifiers
+            const analyzeUndefinedIdentifier = (identifier, spec, availableLibraries) => {
+                const result = {
+                    isInSpecLibraries: false,
+                    isInSpecDependencies: false,
+                    isAvailableLibrary: false,
+                    matchedLibrary: null,
+                    specLibraries: spec?.libraries || [],
+                    specDependencies: spec?.dependencies || []
+                };
+                // Check if it's in spec libraries
+                result.isInSpecLibraries = result.specLibraries.some((lib) => lib.globalVariable === identifier);
+                // Check if it's in spec dependencies  
+                result.isInSpecDependencies = result.specDependencies.some((dep) => dep.name === identifier);
+                // Check against ALL available libraries (case-insensitive)
+                if (availableLibraries) {
+                    const availableLib = availableLibraries.find((lib) => lib.GlobalVariable &&
+                        lib.GlobalVariable.toLowerCase() === identifier.toLowerCase());
+                    if (availableLib) {
+                        result.isAvailableLibrary = true;
+                        result.matchedLibrary = availableLib;
+                    }
+                }
+                return result;
+            };
+            // Helper function to generate guidance message
+            const generateGuidance = (identifier, analysis) => {
+                // Case 1: Trying to use a library not in their spec
+                if (analysis.isAvailableLibrary && !analysis.isInSpecLibraries) {
+                    const libList = analysis.specLibraries.length > 0
+                        ? analysis.specLibraries.map((l) => l.globalVariable || l.name).filter(Boolean).join(', ')
+                        : 'no third-party libraries';
+                    return `${identifier} is not defined. It appears you're trying to use the ${analysis.matchedLibrary.Name} library. ` +
+                        `You do NOT have access to this library. ` +
+                        `Your architect gave you access to: ${libList}. ` +
+                        `You must work within these constraints and cannot load additional libraries.`;
+                }
+                // Case 2: Should be a component but not properly accessed
+                if (analysis.isInSpecDependencies) {
+                    return `${identifier} is not defined. This component exists in your dependencies. ` +
+                        `Ensure you've destructured it: const { ${identifier} } = components; ` +
+                        `or accessed it as: components.${identifier}`;
+                }
+                // Case 3: Not a valid library or component
+                const libList = analysis.specLibraries.length > 0
+                    ? `Available libraries: ${analysis.specLibraries.map((l) => l.globalVariable || l.name).filter(Boolean).join(', ')}`
+                    : 'No third-party libraries are available';
+                const depList = analysis.specDependencies.length > 0
+                    ? `Available components: ${analysis.specDependencies.map((d) => d.name).join(', ')}`
+                    : 'No component dependencies are available';
+                return `${identifier} is not defined. This is not a valid library or component in your specification. ` +
+                    `${libList}. ${depList}. ` +
+                    `You must only use the libraries and components specified in your component specification.`;
+            };
             // Global error handler
             window.addEventListener('error', (event) => {
+                // Check for "X is not defined" errors
+                const notDefinedMatch = event.message?.match(/^(\w+) is not defined$/);
+                if (notDefinedMatch) {
+                    const identifier = notDefinedMatch[1];
+                    // Analyze what this identifier might be
+                    const analysis = analyzeUndefinedIdentifier(identifier, spec, availableLibraries);
+                    // Generate specific guidance
+                    const guidance = generateGuidance(identifier, analysis);
+                    // Store enhanced error with specific guidance
+                    window.__testHarnessRuntimeErrors.push({
+                        message: guidance,
+                        stack: event.error?.stack,
+                        type: 'undefined-identifier',
+                        source: 'user-component',
+                        identifier: identifier
+                    });
+                    window.__testHarnessTestFailed = true;
+                    return;
+                }
+                // Handle other errors as before
+                let source = 'user-component'; // Default to user component
+                if (event.message && event.message.includes('Script error')) {
+                    source = 'runtime-wrapper';
+                }
                 window.__testHarnessRuntimeErrors.push({
                     message: event.error?.message || event.message,
                     stack: event.error?.stack,
-                    type: 'runtime'
+                    type: 'runtime',
+                    source: source
                 });
                 window.__testHarnessTestFailed = true;
             });
@@ -799,12 +1059,13 @@ class ComponentRunner {
                 window.__testHarnessRuntimeErrors.push({
                     message: 'Unhandled Promise Rejection: ' + (event.reason?.message || event.reason),
                     stack: event.reason?.stack,
-                    type: 'promise-rejection'
+                    type: 'promise-rejection',
+                    source: 'user-component' // Async errors are likely from user code
                 });
                 window.__testHarnessTestFailed = true;
                 event.preventDefault();
             });
-        });
+        }, { spec: componentSpec, availableLibraries: allLibraries || [] });
     }
     /**
      * Collect runtime errors from the page
@@ -817,25 +1078,99 @@ class ComponentRunner {
                 testFailed: window.__testHarnessTestFailed || false
             };
         });
-        const errors = [];
-        // Only add "test failed" message if there are actual errors
-        if (errorData.testFailed && (errorData.runtimeErrors.length > 0 || errorData.consoleErrors.length > 0)) {
-            errors.push('Test marked as failed by error handlers');
-        }
+        // Track unique errors and their counts
+        const errorMap = new Map();
+        // Check if we have any specific React render errors
+        const hasSpecificReactError = errorData.runtimeErrors.some((error) => error.type === 'react-render-error' &&
+            !error.message.includes('Script error'));
+        // Process runtime errors with their source information
         errorData.runtimeErrors.forEach((error) => {
-            // Include phase information if available to help identify where the error occurred
-            const phase = error.phase ? ` (during ${error.phase})` : '';
-            const errorMsg = `${error.type} error: ${error.message}${phase}`;
-            if (!errors.includes(errorMsg)) {
-                errors.push(errorMsg);
+            // Skip generic "Script error" messages if we have more specific React errors
+            if (hasSpecificReactError &&
+                error.type === 'runtime' &&
+                error.message === 'Script error.') {
+                return; // Skip this generic error
+            }
+            // Map error types to specific rule names
+            let rule = 'runtime-error';
+            switch (error.type) {
+                case 'invalid-element-type':
+                    rule = 'invalid-jsx-element';
+                    break;
+                case 'undefined-component':
+                    rule = 'undefined-jsx-component';
+                    break;
+                case 'undefined-identifier':
+                    rule = 'undefined-identifier';
+                    break;
+                case 'react-render-error':
+                    rule = 'react-render-error';
+                    break;
+                case 'render-loop':
+                    rule = 'infinite-render-loop';
+                    break;
+                case 'registration-error':
+                    rule = 'component-registration-error';
+                    break;
+                case 'execution-error':
+                    rule = 'execution-error';
+                    break;
+                case 'runtime':
+                    rule = 'runtime-error';
+                    break;
+                case 'promise-rejection':
+                    rule = 'unhandled-promise-rejection';
+                    break;
+            }
+            // Create a key for deduplication based on message and type
+            const key = `${error.type}:${error.message}`;
+            if (errorMap.has(key)) {
+                // Increment count for duplicate
+                errorMap.get(key).count++;
+            }
+            else {
+                // Add new error
+                errorMap.set(key, {
+                    error: {
+                        message: error.message,
+                        source: error.source,
+                        type: error.type,
+                        rule: rule
+                    },
+                    count: 1
+                });
             }
         });
+        // Process console errors
         errorData.consoleErrors.forEach((error) => {
-            const errorMsg = `Console error: ${error}`;
-            if (!errors.includes(errorMsg)) {
-                errors.push(errorMsg);
+            const key = `console-error:${error}`;
+            if (errorMap.has(key)) {
+                errorMap.get(key).count++;
+            }
+            else {
+                errorMap.set(key, {
+                    error: {
+                        message: error,
+                        source: 'react-framework',
+                        type: 'console-error',
+                        rule: 'console-error'
+                    },
+                    count: 1
+                });
             }
         });
+        // Convert map to array with occurrence counts
+        const errors = [];
+        errorMap.forEach(({ error, count }) => {
+            // Append count if > 1
+            const message = count > 1
+                ? `${error.message} (occurred ${count} times)`
+                : error.message;
+            errors.push({
+                ...error,
+                message
+            });
+        });
         return errors;
     }
     /**
@@ -858,7 +1193,7 @@ class ComponentRunner {
     /**
      * Set up console logging
      */
-    setupConsoleLogging(page, consoleLogs, warnings, criticalWarnings) {
+    setupConsoleLogging(page, consoleLogs, warnings) {
         page.on('console', (msg) => {
             const type = msg.type();
             const text = msg.text();
@@ -869,10 +1204,6 @@ class ComponentRunner {
                 if (!warnings.includes(text)) {
                     warnings.push(text);
                 }
-                // Check if it's a critical warning that should fail the test
-                if (ComponentRunner.CRITICAL_WARNING_PATTERNS.some(pattern => pattern.test(text))) {
-                    criticalWarnings.push(text);
-                }
             }
         });
         page.on('pageerror', (error) => {
@@ -1333,12 +1664,6 @@ class ComponentRunner {
                 console.log(`  ${i + 1}. ${warn.message}`);
             });
         }
-        if (result.criticalWarnings && result.criticalWarnings.length > 0) {
-            console.log('\n🔴 Critical Warnings:', result.criticalWarnings.length);
-            result.criticalWarnings.forEach((warn, i) => {
-                console.log(`  ${i + 1}. ${warn}`);
-            });
-        }
         console.log('\n========================================\n');
     }
 }