qa360 2.3.2 → 2.3.3

package/dist/core/adapters/playwright-ui.d.ts

@@ -159,6 +159,12 @@ export declare class PlaywrightUiAdapter {
      * Test page with actions (for user journeys)
      */
     private testPageWithActions;
+    /**
+     * Smart click with automatic hover/scroll fallback for invisible elements
+     * Handles dropdown menus that require hover to reveal clickable items
+     */
+    private smartClick;
+    private sleep;
     /**
      * Execute a single page action
      */

package/dist/core/adapters/playwright-ui.js

@@ -1474,6 +1474,70 @@ export class PlaywrightUiAdapter {
             };
         }
     }
+    /**
+     * Smart click with automatic hover/scroll fallback for invisible elements
+     * Handles dropdown menus that require hover to reveal clickable items
+     */
+    async smartClick(selector, timeout) {
+        const page = this.page;
+        const maxRetries = 3;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // First, try a direct click
+                await page.click(selector, { timeout: timeout / maxRetries, force: false });
+                return;
+            }
+            catch (error) {
+                // If direct click failed, try fallback strategies
+                const isVisible = await page.isVisible(selector).catch(() => false);
+                const isAttached = await page.locator(selector).count().then(c => c > 0).catch(() => false);
+                if (!isAttached) {
+                    throw error; // Element doesn't exist, no point retrying
+                }
+                if (!isVisible) {
+                    // Strategy 1: Scroll into view
+                    try {
+                        await page.locator(selector).first().scrollIntoViewIfNeeded({ timeout: 1000 });
+                        await this.sleep(200); // Wait for scroll to complete
+                    }
+                    catch { /* Ignore scroll errors */ }
+                    // Strategy 2: Try to hover on parent to reveal dropdown
+                    try {
+                        // Extract parent selector (remove last pseudo-class or attribute)
+                        const parentSelectors = [
+                            selector.replace(/::.+$/, ''), // Remove pseudo-class
+                            selector.replace(/\[\w+=.+\]$/, ''), // Remove attribute
+                        ];
+                        for (const parent of parentSelectors) {
+                            if (parent !== selector) {
+                                const isParentVisible = await page.isVisible(parent).catch(() => false);
+                                if (isParentVisible) {
+                                    await page.locator(parent).first().hover({ timeout: 1000 });
+                                    await this.sleep(300); // Wait for dropdown animation
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    catch { /* Ignore hover errors */ }
+                    // Strategy 3: Force click after revealing
+                    try {
+                        await page.click(selector, { timeout: 2000, force: true });
+                        return;
+                    }
+                    catch { /* Continue to next attempt */ }
+                }
+                // Last attempt: force click
+                if (attempt === maxRetries - 1) {
+                    await page.click(selector, { timeout, force: true });
+                    return;
+                }
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
     /**
      * Execute a single page action
      */
@@ -1488,7 +1552,7 @@ export class PlaywrightUiAdapter {
                 if (!action.selector) {
                     throw new Error('Click action requires a selector');
                 }
-                await this.page.click(action.selector, { timeout });
+                await this.smartClick(action.selector, timeout);
                 break;
             case 'fill':
                 if (!action.selector) {
@@ -1536,6 +1600,26 @@ export class PlaywrightUiAdapter {
                     }
                 }
                 break;
+            case 'press':
+                if (action.value) {
+                    if (action.selector) {
+                        await this.page.locator(action.selector).press(action.value, { timeout });
+                    }
+                    else {
+                        await this.page.keyboard.press(action.value);
+                    }
+                }
+                break;
+            case 'waitForSelector':
+                if (action.selector) {
+                    await this.page.waitForSelector(action.selector, { timeout });
+                }
+                break;
+            case 'hover':
+                if (action.selector) {
+                    await this.page.hover(action.selector, { timeout });
+                }
+                break;
             default:
                 console.warn(`Unknown action type: ${action.type}`);
         }

package/dist/core/crawler/consent-handler.d.ts

@@ -5,6 +5,8 @@
  * Supports all major Consent Management Platforms (CMPs).
  *
  * Philosophy: "80% of EU sites block interaction with consent banners"
+ *
+ * NEW: Continuous monitoring mode for async-loaded banners
  */
 import type { Page } from '@playwright/test';
 /**
@@ -17,6 +19,8 @@ export interface ConsentOptions {
     timeout?: number;
     /** Custom selector override */
     customSelector?: string;
+    /** Enable continuous monitoring (watches for banners appearing during session) */
+    continuous?: boolean;
 }
 /**
  * Consent Handler - Auto-detects and handles GDPR/CCPA banners
@@ -30,6 +34,19 @@ export declare class ConsentHandler {
      * @returns true if a banner was found and handled, false otherwise
      */
     static handleConsent(page: Page, options?: ConsentOptions): Promise<boolean>;
+    /**
+     * Start continuous monitoring for consent banners
+     * Uses MutationObserver to detect banners that appear after page load
+     */
+    private static startContinuousMonitoring;
+    /**
+     * Stop continuous monitoring for a page
+     */
+    static stopContinuousMonitoring(page: Page): void;
+    /**
+     * Stop all continuous monitoring
+     */
+    static stopAllMonitoring(): void;
     /**
      * Try a specific CMP
      */

package/dist/core/crawler/consent-handler.js

@@ -5,7 +5,13 @@
  * Supports all major Consent Management Platforms (CMPs).
  *
  * Philosophy: "80% of EU sites block interaction with consent banners"
+ *
+ * NEW: Continuous monitoring mode for async-loaded banners
+ */
+/**
+ * Active monitoring sessions (used to stop continuous monitoring)
  */
+const activeMonitors = new Map();
 /**
  * CMP (Consent Management Platform) Selectors
  */
@@ -82,51 +88,121 @@ const CONSENT_SELECTORS = {
     // === GENERIC PATTERNS (fallback for unknown CMPs) ===
     generic: {
         accept: [
+            // Attribute-based patterns
             '[id*="cookie"][id*="accept"]',
             '[id*="cookie"][id*="agree"]',
+            '[id*="cookie"][id*="allow"]',
             '[class*="cookie"][class*="accept"]',
             '[class*="cookie"][class*="agree"]',
+            '[class*="cookie"][class*="allow"]',
+            '[data-cookie*="accept"]',
+            '[data-cookie*="agree"]',
             '[id*="consent"][id*="accept"]',
             '[class*="consent"][class*="accept"]',
+            // Text-based patterns (English)
             'button:has-text("Accept")',
             'button:has-text("Accept All")',
-            'button:has-text("Accepter")',
-            'button:has-text("Tout accepter")',
-            "button:has-text(\"J'accepte\")",
+            'button:has-text("Accept Cookies")',
             'button:has-text("I agree")',
+            'button:has-text("I accept")',
+            'button:has-text("Agree")',
             'button:has-text("OK")',
             'button:has-text("Got it")',
+            // Text-based patterns (French)
+            'button:has-text("Accepter")',
+            'button:has-text("Tout accepter")',
+            "button:has-text(\"J'accepte\")",
             'button:has-text("Accepter les cookies")',
+            'button:has-text("Tout accepter")',
+            // Text-based patterns (German)
+            'button:has-text("Akzeptieren")',
+            'button:has-text("Alle akzeptieren")',
+            'button:has-text("Zustimmen")',
+            'button:has-text("OK")',
+            // Text-based patterns (Spanish)
+            'button:has-text("Aceptar")',
+            'button:has-text("Aceptar todo")',
+            'button:has-text("Aceptar cookies")',
+            // Common button classes
+            '.btn-accept',
+            '.btn-agree',
+            '.btn-allow',
+            '.accept-btn',
+            '.agree-btn',
+            '#btn-accept',
+            '#btn-agree',
+            // Data attributes
+            '[data-action="accept"]',
+            '[data-action="agree"]',
+            '[data-consent="accept"]',
+            '[data-cy="cookie-accept"]',
         ],
         reject: [
             '[id*="cookie"][id*="reject"]',
             '[id*="cookie"][id*="decline"]',
             '[id*="cookie"][id*="refuse"]',
+            '[id*="cookie"][id*="deny"]',
             '[class*="cookie"][class*="reject"]',
+            '[class*="cookie"][class*="decline"]',
+            '[class*="cookie"][class*="refuse"]',
             'button:has-text("Reject")',
+            'button:has-text("Reject All")',
             'button:has-text("Refuser")',
-            'button:has-text("Decline")',
             'button:has-text("Tout refuser")',
+            'button:has-text("Decline")',
+            'button:has-text("Decline All")',
+            'button:has-text("Refuser tout")',
+            '.btn-reject',
+            '.btn-decline',
+            '#btn-reject',
         ],
         banner: [
+            // ID-based patterns
             '[id*="cookie-banner"]',
             '[id*="cookie-consent"]',
             '[id*="cookie-notice"]',
-            '[id*="gdpr"]',
+            '[id*="gdpr-banner"]',
+            '[id*="gdpr-consent"]',
             '[id*="consent-banner"]',
             '[id*="consent-notice"]',
+            '[id*="privacy-banner"]',
+            '[id*="privacy-notice"]',
+            // Class-based patterns
             '[class*="cookie-banner"]',
             '[class*="cookie-consent"]',
+            '[class*="cookie-notice"]',
+            '[class*="cookie-popup"]',
             '[class*="gdpr-banner"]',
+            '[class*="gdpr-consent"]',
             '[class*="consent-banner"]',
+            '[class*="consent-popup"]',
+            '[class*="privacy-banner"]',
+            // ARIA-based patterns
             '[aria-label*="cookie"]',
             '[aria-label*="consent"]',
+            '[aria-label*="gdpr"]',
+            '[aria-describedby*="cookie"]',
             '[role="dialog"][id*="cookie"]',
+            '[role="dialog"][id*="consent"]',
+            '[role="alertdialog"][id*="cookie"]',
+            // Common banner IDs/classes
             '.cookie-banner',
             '.cookie-consent',
+            '.cookie-notice',
             '.gdpr-banner',
+            '.consent-banner',
+            '.consent-popup',
             '#cookie-banner',
             '#cookie-consent',
+            '#gdpr-banner',
+            '#consent-banner',
+            // Data attributes
+            '[data-cookie-banner]',
+            '[data-consent-banner]',
+            '[data-gdpr-banner]',
+            // Fixed position elements (common for banners)
+            '[style*="position: fixed"][class*="cookie"]',
+            '[style*="position:fixed"][class*="cookie"]',
         ],
         name: 'Generic',
     },
@@ -143,7 +219,7 @@ export class ConsentHandler {
      * @returns true if a banner was found and handled, false otherwise
      */
     static async handleConsent(page, options = {}) {
-        const { action = 'accept', timeout = 3000, customSelector } = options;
+        const { action = 'accept', timeout = 15000, customSelector, continuous = false } = options;
         if (action === 'ignore') {
             return false;
         }
@@ -152,11 +228,13 @@ export class ConsentHandler {
             return await this.handleCustom(page, customSelector, timeout);
         }
         // Try each known CMP
+        let handled = false;
         for (const [cmpName, selectors] of Object.entries(CONSENT_SELECTORS)) {
             try {
-                const handled = await this.tryCMP(page, cmpName, selectors, action, timeout);
-                if (handled) {
-                    return true;
+                const result = await this.tryCMP(page, cmpName, selectors, action, timeout);
+                if (result) {
+                    handled = true;
+                    break; // Found and handled, no need to try other CMPs
                 }
             }
             catch {
@@ -164,7 +242,95 @@ export class ConsentHandler {
                 continue;
             }
         }
-        return false; // No consent banner found
+        // Start continuous monitoring if requested
+        if (continuous) {
+            this.startContinuousMonitoring(page, action);
+        }
+        return handled;
+    }
+    /**
+     * Start continuous monitoring for consent banners
+     * Uses MutationObserver to detect banners that appear after page load
+     */
+    static startContinuousMonitoring(page, action) {
+        // Stop existing monitor for this page if any
+        if (activeMonitors.has(page)) {
+            return; // Already monitoring
+        }
+        let attempts = 0;
+        const maxAttempts = 30; // Check for up to 30 seconds (30 * 1000ms)
+        const checkInterval = setInterval(async () => {
+            attempts++;
+            try {
+                // Quick check if any consent banner is present
+                const hasBanner = await page.evaluate(() => {
+                    const selectors = [
+                        // OneTrust
+                        '#onetrust-banner-sdk, #onetrust-consent-sdk',
+                        // Cookiebot
+                        '#CybotCookiebotDialog, .CookieDialog',
+                        // Generic patterns
+                        '[id*="cookie-banner"], [id*="cookie-consent"], [id*="gdpr"]',
+                        '[class*="cookie-banner"], [class*="cookie-consent"], [class*="gdpr-banner"]',
+                        '[aria-label*="cookie"], [aria-label*="consent"]',
+                        '#cookie-banner, #cookie-consent, .cookie-banner, .cookie-consent',
+                    ];
+                    for (const sel of selectors) {
+                        const el = document.querySelector(sel);
+                        if (el) {
+                            const rect = el.getBoundingClientRect();
+                            // Check if visible (has dimensions and not hidden)
+                            if (rect.width > 0 && rect.height > 0) {
+                                const style = window.getComputedStyle(el);
+                                if (style.display !== 'none' && style.visibility !== 'hidden') {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    return false;
+                });
+                if (hasBanner) {
+                    console.log('  🍪 Consent banner detected (continuous monitoring)');
+                    // Try to handle it
+                    const handled = await this.handleConsent(page, { action, timeout: 5000 });
+                    if (handled) {
+                        console.log('  ✅ Consent banner handled (continuous monitoring)');
+                    }
+                }
+            }
+            catch {
+                // Page might be closed, ignore
+            }
+            // Stop after max attempts
+            if (attempts >= maxAttempts) {
+                clearInterval(checkInterval);
+                activeMonitors.delete(page);
+            }
+        }, 1000); // Check every second
+        // Store cleanup function
+        activeMonitors.set(page, () => {
+            clearInterval(checkInterval);
+        });
+    }
+    /**
+     * Stop continuous monitoring for a page
+     */
+    static stopContinuousMonitoring(page) {
+        const cleanup = activeMonitors.get(page);
+        if (cleanup) {
+            cleanup();
+            activeMonitors.delete(page);
+        }
+    }
+    /**
+     * Stop all continuous monitoring
+     */
+    static stopAllMonitoring() {
+        for (const cleanup of activeMonitors.values()) {
+            cleanup();
+        }
+        activeMonitors.clear();
     }
     /**
      * Try a specific CMP

package/dist/core/crawler/intelligent-selector-generator.js

@@ -119,7 +119,9 @@ const GENERATED_ID_PATTERNS = [
     // === NEW - Generic ===
     /^[a-f0-9]{8}-[a-f0-9]{4}-/, // UUID prefix
     /^\w+-[a-f0-9]{6,}$/, // name-hash
-    /^_?[a-zA-Z]+_[a-z0-9]{5,}$/, // CSS Modules
+    /^_?[a-zA-Z]+_[a-z0-9]{5,}$/, // CSS Modules (basic)
+    /^[\w-]+-module__[\w]+--[\w-]+$/, // CSS Modules (GitHub-style: Component-module__element--hash)
+    /^[\w]+__[\w]+--[\w-]+$/, // CSS Modules BEM with hash: Block__Element--modifier-hash
     /^[a-f0-9]{32}$/, // MD5 hash
     /^[a-f0-9]{40}$/, // SHA1 hash
 ];

package/dist/core/crawler/journey-generator.js

@@ -248,6 +248,9 @@ export class JourneyGenerator {
                 });
                 // Fill form fields
                 for (const field of form.fields) {
+                    // Skip radio/checkbox here - they're handled separately below
+                    if (field.inputType === 'radio' || field.inputType === 'checkbox')
+                        continue;
                     if (!field.required && Math.random() > 0.5)
                         continue;
                     const step = {
@@ -256,7 +259,7 @@ export class JourneyGenerator {
                         action: field.inputType === 'select-one' ? 'select' : 'fill',
                         selector: field.selector,
                     };
-                    // Set appropriate test value
+                    // Set appropriate test value based on input type
                     if (field.inputType === 'email') {
                         step.value = 'test@example.com';
                     }
@@ -269,17 +272,66 @@ export class JourneyGenerator {
                         const num = typeof min === 'number' ? min + 1 : 1;
                         step.value = String(typeof max === 'number' ? Math.min(num, max - 1) : num);
                     }
+                    else if (field.inputType === 'time') {
+                        step.value = '13:30'; // Valid time format
+                    }
+                    else if (field.inputType === 'date') {
+                        step.value = '2024-01-15'; // Valid date format
+                    }
+                    else if (field.inputType === 'datetime-local') {
+                        step.value = '2024-01-15T13:30'; // Valid datetime format
+                    }
+                    else if (field.inputType === 'url') {
+                        step.value = 'https://example.com';
+                    }
+                    else if (field.inputType === 'color') {
+                        step.value = '#ff0000';
+                    }
+                    else if (field.inputType === 'range') {
+                        const min = field.validation?.min || 0;
+                        const max = field.validation?.max || 100;
+                        step.value = String((Number(min) + Number(max)) / 2);
+                    }
                     else if (field.inputType === 'select-one' && field.options && field.options.length > 0) {
                         step.value = field.options[0];
                     }
-                    else if (field.inputType === 'checkbox') {
-                        step.action = 'check';
-                    }
                     else {
                         step.value = 'Test value';
                     }
                     steps.push(step);
                 }
+                // Handle radio buttons (select one option per radio group)
+                const radioGroups = new Map();
+                for (const field of form.fields) {
+                    if (field.inputType === 'radio' && field.name) {
+                        if (!radioGroups.has(field.name)) {
+                            radioGroups.set(field.name, []);
+                        }
+                        radioGroups.get(field.name).push(field);
+                    }
+                }
+                for (const [groupName, radios] of radioGroups) {
+                    // Select the first radio option
+                    if (radios.length > 0) {
+                        steps.push({
+                            order: steps.length + 1,
+                            description: `Select ${groupName} option`,
+                            action: 'check',
+                            selector: radios[0].selector,
+                        });
+                    }
+                }
+                // Handle checkboxes (check all required ones)
+                for (const field of form.fields) {
+                    if (field.inputType === 'checkbox' && field.required) {
+                        steps.push({
+                            order: steps.length + 1,
+                            description: `Check ${field.name || 'checkbox'}`,
+                            action: 'check',
+                            selector: field.selector,
+                        });
+                    }
+                }
                 // Submit form
                 if (form.submitButton) {
                     // Wait for submit button

package/dist/core/crawler/page-analyzer.d.ts

@@ -89,9 +89,15 @@ export declare class PageAnalyzer {
      */
     private analyzeNavigation;
     /**
-     * Run accessibility scan using axe-core
+     * Run accessibility scan using axe-core with native ARIA fallback
+     * When CSP blocks external scripts, falls back to native ARIA inspection
      */
     private runAccessibilityScan;
+    /**
+     * Native ARIA accessibility scan (fallback when axe-core is blocked)
+     * Uses browser's built-in ARIA inspection capabilities
+     */
+    private runNativeAriaScan;
     /**
      * Detect page type
      */

package/dist/core/crawler/page-analyzer.js

@@ -10,7 +10,7 @@
  */
 import { chromium } from '@playwright/test';
 import { generateSelectorFromElement, SiteProfiler, initializeSelectorGenerator, } from './selector-generator.js';
-import { handleConsent } from './consent-handler.js';
+import { handleConsent, ConsentHandler } from './consent-handler.js';
 /**
  * Page Analyzer class
  */
@@ -491,8 +491,13 @@ export class PageAnalyzer {
             // PART 4: HANDLE GDPR/COOKIE CONSENT BANNERS
             // ═══════════════════════════════════════════════════════════════════════════════
             const consentAction = this.options.consentAction || 'accept';
-            const consentTimeout = this.options.consentTimeout || 3000;
-            await handleConsent(this.page, { action: consentAction, timeout: consentTimeout });
+            const consentTimeout = this.options.consentTimeout || 15000;
+            const continuousConsent = this.options.continuousConsent !== false; // true by default
+            await handleConsent(this.page, {
+                action: consentAction,
+                timeout: consentTimeout,
+                continuous: continuousConsent,
+            });
             // ═══════════════════════════════════════════════════════════════════════════════
             // INTELLIGENT SITE PROFILING (First page only)
             // ═══════════════════════════════════════════════════════════════════════════════
@@ -1045,7 +1050,8 @@ export class PageAnalyzer {
         return navigation;
     }
     /**
-     * Run accessibility scan using axe-core
+     * Run accessibility scan using axe-core with native ARIA fallback
+     * When CSP blocks external scripts, falls back to native ARIA inspection
      */
     async runAccessibilityScan() {
         try {
@@ -1095,6 +1101,119 @@ export class PageAnalyzer {
                 incomplete: axeResults.incomplete?.length || 0,
             };
         }
+        catch (error) {
+            // CSP fallback: Native ARIA inspection when axe-core is blocked
+            console.log('    ⚠️  axe-core blocked by CSP, using native ARIA inspection');
+            return await this.runNativeAriaScan();
+        }
+    }
+    /**
+     * Native ARIA accessibility scan (fallback when axe-core is blocked)
+     * Uses browser's built-in ARIA inspection capabilities
+     */
+    async runNativeAriaScan() {
+        try {
+            const results = await this.page.evaluate(() => {
+                const violations = [];
+                // Check 1: Images without alt text
+                const imagesWithoutAlt = document.querySelectorAll('img:not([alt])');
+                if (imagesWithoutAlt.length > 0) {
+                    violations.push({
+                        id: 'image-alt',
+                        impact: 'serious',
+                        description: 'Images must have alternate text',
+                        nodes: Array.from(imagesWithoutAlt).slice(0, 10).map(img => ({
+                            target: [img.tagName + (img.id ? `#${img.id}` : '')],
+                        })),
+                    });
+                }
+                // Check 2: Links without accessible name
+                const linksWithoutText = Array.from(document.querySelectorAll('a')).filter(a => !a.textContent?.trim() && !a.getAttribute('aria-label') && !a.getAttribute('aria-labelledby'));
+                if (linksWithoutText.length > 0) {
+                    violations.push({
+                        id: 'link-name',
+                        impact: 'serious',
+                        description: 'Links must have discernible text',
+                        nodes: linksWithoutText.slice(0, 10).map(a => ({
+                            target: [`a${a.id ? `#${a.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 3: Form fields without labels
+                const inputsWithoutLabels = Array.from(document.querySelectorAll('input, select, textarea')).filter(el => {
+                    if (el.type === 'hidden')
+                        return false;
+                    const id = el.id;
+                    const hasLabel = document.querySelector(`label[for="${id}"]`);
+                    const hasAriaLabel = el.getAttribute('aria-label') || el.getAttribute('aria-labelledby');
+                    const hasParentLabel = el.closest('label');
+                    return !hasLabel && !hasAriaLabel && !hasParentLabel;
+                });
+                if (inputsWithoutLabels.length > 0) {
+                    violations.push({
+                        id: 'label',
+                        impact: 'serious',
+                        description: 'Form fields must have labels',
+                        nodes: inputsWithoutLabels.slice(0, 10).map(el => ({
+                            target: [`${el.tagName}${el.id ? `#${el.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 4: Buttons without accessible name
+                const buttonsWithoutText = Array.from(document.querySelectorAll('button')).filter(btn => !btn.textContent?.trim() && !btn.getAttribute('aria-label') && !btn.getAttribute('aria-labelledby'));
+                if (buttonsWithoutText.length > 0) {
+                    violations.push({
+                        id: 'button-name',
+                        impact: 'serious',
+                        description: 'Buttons must have discernible text',
+                        nodes: buttonsWithoutText.slice(0, 10).map(btn => ({
+                            target: [`button${btn.id ? `#${btn.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 5: Empty headings
+                const emptyHeadings = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6')).filter(h => !h.textContent?.trim());
+                if (emptyHeadings.length > 0) {
+                    violations.push({
+                        id: 'empty-heading',
+                        impact: 'moderate',
+                        description: 'Headings must not be empty',
+                        nodes: emptyHeadings.slice(0, 10).map(h => ({
+                            target: [`${h.tagName}${h.id ? `#${h.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Count positive checks (passes)
+                const allImages = document.querySelectorAll('img').length;
+                const allLinks = document.querySelectorAll('a').length;
+                const allButtons = document.querySelectorAll('button').length;
+                const allInputs = document.querySelectorAll('input:not([type="hidden"]), select, textarea').length;
+                const allHeadings = document.querySelectorAll('h1, h2, h3, h4, h5, h6').length;
+                const passes = (allImages - imagesWithoutAlt.length) +
+                    (allLinks - linksWithoutText.length) +
+                    (allButtons - buttonsWithoutText.length) +
+                    (allInputs - inputsWithoutLabels.length) +
+                    (allHeadings - emptyHeadings.length);
+                return { violations, passes };
+            });
+            // Calculate score from native scan results
+            const criticalCount = results.violations.filter((v) => v.impact === 'critical').length;
+            const seriousCount = results.violations.filter((v) => v.impact === 'serious').length;
+            const moderateCount = results.violations.filter((v) => v.impact === 'moderate').length;
+            const score = Math.max(0, 100 - (criticalCount * 25 + seriousCount * 10 + moderateCount * 5));
+            return {
+                score: Math.round(score),
+                violations: results.violations.map((v) => ({
+                    id: v.id,
+                    impact: v.impact || 'moderate',
+                    description: v.description,
+                    nodes: v.nodes?.length || 0,
+                    selectors: (v.nodes || []).slice(0, 5).map((n) => n.target?.[0] || '').filter(Boolean),
+                })),
+                passes: results.passes || 0,
+                incomplete: 0,
+            };
+        }
         catch {
             return undefined;
         }
@@ -1147,6 +1266,10 @@ export class PageAnalyzer {
      */
     async cleanup() {
         try {
+            // Stop continuous consent monitoring
+            if (this.page) {
+                ConsentHandler.stopContinuousMonitoring(this.page);
+            }
             if (this.page)
                 await this.page.close();
             if (this.context)

package/dist/core/generation/crawler-pack-generator.js

@@ -88,7 +88,21 @@ function generatePackFromCrawlResult(crawlResult, options) {
         // Only include HTML pages (filter out CSS, JS, images, etc.)
         return !/\.(css|js|json|xml|pdf|zip|jpg|jpeg|png|gif|svg|ico|woff|woff2|ttf|eot)$/i.test(url);
     });
-    const pages = htmlPages.map(p => `${baseUrl}${p.path.startsWith('/') ? '' : '/'}${p.path}`);
+    // Build pages array - use full URL if available, otherwise construct from baseUrl + path
+    const pages = htmlPages.map(p => {
+        // If page has a full URL, use it directly
+        if (p.url && p.url.startsWith('http')) {
+            return p.url;
+        }
+        // Otherwise, construct from baseUrl (being careful not to duplicate paths)
+        const pagePath = p.path;
+        // If baseUrl already ends with the page path, just use baseUrl
+        if (baseUrl.endsWith(pagePath) || pagePath === '/' || pagePath === '') {
+            return baseUrl;
+        }
+        // Otherwise append the path
+        return `${baseUrl}${pagePath.startsWith('/') ? '' : '/'}${pagePath}`;
+    });
     // Generate YAML (v2 format)
     let yaml = `# QA360 Pack v2 - Generated by crawler
 # Source: ${options.baseUrl}
@@ -136,39 +150,43 @@ ${pages.map(p => `        - "${p}"`).join('\n')}
             const gateName = journey.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
             // Build page objects with actions from journey steps
             const pageMap = new Map();
+            let currentUrl = journey.entryPoint;
+            // Initialize with entry point
+            const absoluteEntryPoint = currentUrl.startsWith('http') ? currentUrl : `${baseUrl}${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`;
+            pageMap.set(absoluteEntryPoint, { url: absoluteEntryPoint, actions: [] });
             for (const step of journey.steps) {
                 const stepTyped = step;
-                const url = stepTyped.expected?.url || stepTyped.url;
-                if (url && url !== 'undefined') {
-                    // Convert relative URLs to absolute
-                    const absoluteUrl = url.startsWith('http') ? url : `${baseUrl}${url.startsWith('/') ? '' : '/'}${url}`;
-                    if (!pageMap.has(absoluteUrl)) {
-                        pageMap.set(absoluteUrl, { url: absoluteUrl, actions: [] });
+                const actionType = stepTyped.action || 'navigate';
+                // For navigate actions, update current URL from step.value
+                if (actionType === 'navigate') {
+                    const navigateUrl = stepTyped.value || stepTyped.expected?.url || stepTyped.url;
+                    if (navigateUrl && navigateUrl !== 'undefined') {
+                        currentUrl = navigateUrl.startsWith('http') ? navigateUrl : `${baseUrl}${navigateUrl.startsWith('/') ? '' : '/'}${navigateUrl}`;
+                        if (!pageMap.has(currentUrl)) {
+                            pageMap.set(currentUrl, { url: currentUrl, actions: [] });
+                        }
                     }
-                    // Add action to the page
-                    const page = pageMap.get(absoluteUrl);
-                    const actionType = stepTyped.action || 'navigate';
+                }
+                // Add action to the current page
+                if (pageMap.has(currentUrl)) {
+                    const page = pageMap.get(currentUrl);
                     // Map journey actions to page actions
                     const pageAction = { type: actionType };
                     if (stepTyped.selector) {
                         pageAction.selector = stepTyped.selector;
                     }
-                    if (stepTyped.value) {
+                    if (stepTyped.value && actionType !== 'navigate') {
                         pageAction.value = stepTyped.value;
                     }
                     if (stepTyped.wait) {
                         pageAction.options = { timeout: stepTyped.wait };
                     }
-                    // Add action if it's meaningful (skip simple navigation)
-                    if (actionType !== 'navigate' || stepTyped.selector || stepTyped.value) {
+                    // Add action if it's meaningful (skip empty navigate)
+                    if (actionType !== 'navigate' || stepTyped.selector) {
                         page.actions.push(pageAction);
                     }
                 }
             }
-            // If no pages found, use entry point
-            if (pageMap.size === 0) {
-                pageMap.set(journey.entryPoint, { url: journey.entryPoint, actions: [] });
-            }
             const pages = Array.from(pageMap.values());
             // Generate YAML for pages with actions
             if (pages.every((p) => p.actions.length === 0)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",