qa360 2.2.20 → 2.3.1

package/{cli/dist → dist}/core/crawler/selector-generator.js

@@ -2,9 +2,25 @@
  * QA360 Selector Generator
  *
  * Generates stable, resilient CSS selectors for web elements
+ *
+ * NOW WITH INTELLIGENT PROFILE-AWARE GENERATION!
+ * The selector generation adapts to the detected site profile:
+ * - PROFIL_MODERN: data-testid first (React apps, SaaS)
+ * - PROFIL_ACCESSIBLE: ARIA role first (banks, government)
+ * - PROFIL_LEGACY: Semantic ID first (ASP.NET, PHP legacy)
+ * - PROFIL_MINIMAL: Text content first (landing pages)
  */
+import { isGeneratedId as checkGeneratedId, isUtilityClass as checkUtilityClass } from './intelligent-selector-generator.js';
+// ═══════════════════════════════════════════════════════════════════════════════
+// RE-EXPORT INTELLIGENT SELECTOR GENERATOR
+// ═══════════════════════════════════════════════════════════════════════════════
+export { SiteProfiler, analyzeSite, determineSiteProfile, } from './site-profiler.js';
+export { IntelligentSelectorGenerator, generateSelector as generateIntelligentSelector, generateSelectorWithMetadata, initializeSelectorGenerator, getSiteProfile, getSelectorStrategy, SELECTOR_STRATEGIES, isGeneratedId, isSemanticId, isUtilityClass, } from './intelligent-selector-generator.js';
+// ═══════════════════════════════════════════════════════════════════════════════
+// LEGACY API (for backward compatibility)
+// ═══════════════════════════════════════════════════════════════════════════════
 /**
- * Selector priority (most stable first)
+ * Selector priority (most stable first) - LEGACY
  */
 const SELECTOR_PRIORITY = [
     'data-testid', // Best: explicit test attribute
@@ -50,9 +66,12 @@ export function generateSelector(element) {
     if (className && !isGenericClass(className)) {
         const classes = className.split(' ').filter(c => !isGenericClass(c));
         if (classes.length > 0) {
-            const classSelector = classes.map(c => `.${escapeCss(c)}`).join('');
-            // Qualify with tag if available
-            return tagName ? `${tagName}${classSelector}` : classSelector;
+            // Smart class selection: prioritize meaningful classes
+            const meaningfulClasses = selectMeaningfulClasses(classes);
+            const classSelector = meaningfulClasses.map(c => `.${escapeCss(c)}`).join('');
+            // Limit total selector length
+            const qualifiedSelector = tagName ? `${tagName}${classSelector}` : classSelector;
+            return truncateSelector(qualifiedSelector, 200);
         }
     }
     // 7. Tag + text content (for buttons, links)
@@ -116,32 +135,23 @@ export async function generateSelectorFromElement(element, page) {
 }
 /**
  * Check if ID is auto-generated (not stable)
+ * Uses enhanced patterns from intelligent-selector-generator
  */
 function isGeneratedId(id) {
-    // Patterns indicating auto-generated IDs
-    const generatedPatterns = [
-        /^\w+_\d+$/, // react_123, vue_456
-        /^(ember|ember)\d+$/, // ember1234
-        /^yui_[^_]+_\d+$/, // yui_gen_123
-        /^\w+-\w+-\w+$/, // random-hash patterns
-        /^[a-f0-9]{8,}$/, // hex hashes
-    ];
-    return generatedPatterns.some(pattern => pattern.test(id));
+    return checkGeneratedId(id);
 }
 /**
- * Check if class is too generic
+ * Check if class is too generic or utility class
+ * Uses enhanced patterns from intelligent-selector-generator
  */
 function isGenericClass(className) {
-    const genericClasses = [
-        'active', 'inactive', 'selected', 'disabled', 'enabled',
-        'hidden', 'visible', 'show', 'hide', 'open', 'closed',
-        'first', 'last', 'odd', 'even',
-        'container', 'wrapper', 'content', 'section',
-        'btn', 'button', 'input', 'form', 'field',
-        'row', 'col', 'column', 'grid',
-    ];
+    // For single class check
     const classes = className.split(' ');
-    return classes.every(c => genericClasses.includes(c));
+    if (classes.length === 1) {
+        return checkUtilityClass(className);
+    }
+    // For multiple classes, check if ALL are utility
+    return classes.every(c => checkUtilityClass(c));
 }
 /**
  * Check if selector is considered stable
@@ -169,6 +179,72 @@ function isSelectorStable(selector) {
 function escapeCss(str) {
     return str.replace(/(["\\])/g, '\\$1').replace(/"/g, '\\"');
 }
+/**
+ * Select the most meaningful classes from a class list
+ * Prioritizes: unique identifiers, component names, action-oriented classes
+ * Deprioritizes: utility classes (spacing, colors, sizing)
+ */
+function selectMeaningfulClasses(classes) {
+    // Tailwind and other utility class patterns to deprioritize
+    const utilityPatterns = [
+        /^(p|m|px|py|pt|pb|pl|pr)-/, // spacing
+        /^(mt|mb|ml|mr)-/, // margin spacing
+        /^(text|bg|border)-/, // colors
+        /^(w|h)-/, // sizing
+        /^(flex|grid|block|inline)/, // display
+        /^(justify|items|self)/, // flexbox/grid
+        /^(rounded|shadow|opacity)/, // styling
+        /^gap-/, // flex gap
+        /^(line-)?height-/, // height
+        /^(font|weight|size)/, // typography
+    ];
+    // Score each class by "meaningfulness"
+    const scored = classes.map(cls => {
+        let score = 50; // base score
+        // Bonus: component-like names (contain meaningful words)
+        if (/[A-Z][a-z]+/.test(cls))
+            score += 30; // CamelCase components
+        if (/button|btn|input|form|card|modal|nav|header|footer|sidebar|menu|dropdown/i.test(cls))
+            score += 25;
+        // Bonus: contains numbers (likely unique)
+        if (/\d+/.test(cls))
+            score += 15;
+        // Penalty: utility classes
+        for (const pattern of utilityPatterns) {
+            if (pattern.test(cls)) {
+                score -= 40;
+                break;
+            }
+        }
+        return { class: cls, score };
+    });
+    // Sort by score (descending) and take top 5
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, 5).map(s => s.class);
+}
+/**
+ * Truncate selector to max length while keeping it valid
+ * Preserves the most specific parts
+ */
+function truncateSelector(selector, maxLength) {
+    if (selector.length <= maxLength)
+        return selector;
+    // For class-based selectors, remove classes from the middle
+    const classMatch = selector.match(/^(\w+)((\.[\w-]+)+)$/);
+    if (classMatch) {
+        const tag = classMatch[1];
+        const classes = classMatch[2].split('.').filter(c => c); // Remove empty strings
+        // Keep first 2 and last 2 classes (most specific)
+        if (classes.length > 4) {
+            const kept = [...classes.slice(0, 2), ...classes.slice(-2)];
+            const truncated = `${tag}.${kept.join('.')}`;
+            if (truncated.length <= maxLength)
+                return truncated;
+        }
+    }
+    // Final fallback: just truncate (may not be valid CSS but prevents overflow)
+    return selector.substring(0, maxLength - 3) + '...';
+}
 /**
  * Optimize selector for resiliency
  */

package/dist/core/crawler/site-profiler.d.ts

@@ -0,0 +1,89 @@
+/**
+ * QA360 Site Profiler
+ *
+ * Analyzes a website to detect its characteristics and determine
+ * the optimal selector strategy. This enables adaptive testing
+ * based on the site's framework, accessibility, and testing maturity.
+ *
+ * Philosophy: "Know the site to test it better"
+ */
+import type { Page } from '@playwright/test';
+/**
+ * Site analysis results
+ */
+export interface SiteAnalysis {
+    hasTestIds: number;
+    hasAriaLabels: number;
+    hasRoles: number;
+    hasSemanticIds: number;
+    hasLabels: number;
+    hasPlaceholders: number;
+    hasAltTexts: number;
+    totalElements: number;
+    framework: Framework | null;
+    cssFramework: CssFramework | null;
+    testabilityScore: number;
+    accessibilityScore: number;
+    patterns: {
+        hasReact: boolean;
+        hasVue: boolean;
+        hasAngular: boolean;
+        hasSvelte: boolean;
+        hasNext: boolean;
+        hasNuxt: boolean;
+        hasRemix: boolean;
+        hasAstro: boolean;
+        hasTailwind: boolean;
+        hasBootstrap: boolean;
+        hasMUI: boolean;
+        hasChakra: boolean;
+        hasAntDesign: boolean;
+        hasBulma: boolean;
+    };
+}
+/**
+ * Detected JavaScript frameworks
+ */
+export type Framework = 'react' | 'vue' | 'angular' | 'svelte' | 'next' | 'nuxt' | 'remix' | 'astro' | 'solid' | 'preact' | 'lit' | 'stencil' | null;
+/**
+ * Detected CSS frameworks
+ */
+export type CssFramework = 'tailwind' | 'bootstrap' | 'mui' | 'chakra' | 'ant' | 'bulma' | 'foundation' | 'spectacle' | 'tachyons' | null;
+/**
+ * Site profile type
+ */
+export type SiteProfile = 'PROFIL_MODERN' | 'PROFIL_ACCESSIBLE' | 'PROFIL_LEGACY' | 'PROFIL_MINIMAL';
+/**
+ * Site Profiler - Analyzes websites for adaptive testing
+ */
+export declare class SiteProfiler {
+    /**
+     * Analyze the current page to determine site characteristics
+     * Called ONCE at the beginning of the crawl
+     */
+    analyzeSite(page: Page): Promise<SiteAnalysis>;
+    /**
+     * Determine the site profile based on analysis
+     */
+    determineProfile(analysis: SiteAnalysis): SiteProfile;
+    /**
+     * Get a human-readable description of the profile
+     */
+    getProfileDescription(profile: SiteProfile): string;
+    /**
+     * Get the recommended strategy for the profile
+     */
+    getRecommendedStrategy(profile: SiteProfile): string;
+}
+/**
+ * Default profiler instance
+ */
+export declare const defaultProfiler: SiteProfiler;
+/**
+ * Quick analyze function (convenience wrapper)
+ */
+export declare function analyzeSite(page: Page): Promise<SiteAnalysis>;
+/**
+ * Quick profile determination (convenience wrapper)
+ */
+export declare function determineSiteProfile(analysis: SiteAnalysis): SiteProfile;

package/dist/core/crawler/site-profiler.js

@@ -0,0 +1,290 @@
+/**
+ * QA360 Site Profiler
+ *
+ * Analyzes a website to detect its characteristics and determine
+ * the optimal selector strategy. This enables adaptive testing
+ * based on the site's framework, accessibility, and testing maturity.
+ *
+ * Philosophy: "Know the site to test it better"
+ */
+/**
+ * Site Profiler - Analyzes websites for adaptive testing
+ */
+export class SiteProfiler {
+    /**
+     * Analyze the current page to determine site characteristics
+     * Called ONCE at the beginning of the crawl
+     */
+    async analyzeSite(page) {
+        const analysis = await page.evaluate(() => {
+            // Count test ID attributes
+            const testIds = document.querySelectorAll('[data-testid], [data-cy], [data-test], [data-test-id], [data-qa], [data-automation], [data-e2e], [data-selenium]').length;
+            // Count ARIA attributes
+            const ariaLabels = document.querySelectorAll('[aria-label]').length;
+            const ariaLabelledby = document.querySelectorAll('[aria-labelledby]').length;
+            const ariaDescriptions = document.querySelectorAll('[aria-describedby]').length;
+            const roles = document.querySelectorAll('[role]').length;
+            // Count form accessibility
+            const labels = document.querySelectorAll('label[for]').length;
+            const placeholders = document.querySelectorAll('[placeholder]').length;
+            // Count images with alt text
+            const altTexts = document.querySelectorAll('img[alt]:not([alt=""])').length;
+            // Count semantic HTML
+            const semanticTags = document.querySelectorAll('main, nav, header, footer, article, section, aside, dialog, modal').length;
+            // Count interactive elements
+            const buttons = document.querySelectorAll('button, [role="button"]').length;
+            const inputs = document.querySelectorAll('input, select, textarea').length;
+            const links = document.querySelectorAll('a[href]').length;
+            const totalInteractive = buttons + inputs + links;
+            // === FRAMEWORK DETECTION ===
+            // React
+            const hasReact = !!(document.querySelector('[data-reactroot], [data-reactid]') ||
+                window.__REACT_DEVTOOLS_GLOBAL_HOOK__ ||
+                window.React ||
+                document.querySelector('[data-react-checksum]'));
+            // Next.js
+            const hasNext = !!(document.querySelector('[data-next-page]') ||
+                document.querySelector('style[id^="__jsx-"]') ||
+                document.querySelector('script[id^="__NEXT_DATA__"]'));
+            // Vue
+            const hasVue = !!(document.querySelector('[data-v-]') ||
+                window.__VUE__ ||
+                window.Vue);
+            // Nuxt
+            const hasNuxt = !!(document.querySelector('[data-n-]') ||
+                document.querySelector('[data-nuxt-]') ||
+                window.__NUXT__);
+            // Angular
+            const hasAngular = !!(document.querySelector('[ng-version], [_nghost-], [_ngcontent-]') ||
+                window.ng ||
+                window.getAllAngularRootElements);
+            // Svelte
+            const hasSvelte = !!(document.querySelector('[class*="svelte-"]') ||
+                window.__SVELTE__);
+            // Remix
+            const hasRemix = !!(document.querySelector('script[remix]') ||
+                document.querySelector('[data-remix-]') ||
+                document.querySelector('link[href*="remix"]'));
+            // Astro
+            const hasAstro = !!(document.querySelector('[data-astro-]') ||
+                document.querySelector('astro-island, astro-fragment'));
+            // Stencil
+            const hasStencil = !!(document.querySelector('[class*="hydrated"]') ||
+                window.stencil);
+            // SolidJS
+            const hasSolid = !!window.SolidJS;
+            // Preact
+            const hasPreact = !!window.preact;
+            // Lit
+            const hasLit = !!document.querySelector('shadow-root') || !!window.LitElement;
+            // === CSS FRAMEWORK DETECTION ===
+            // Tailwind CSS
+            const hasTailwind = !!(document.querySelector('[class*="flex"][class*="items-"]') ||
+                document.querySelector('[class*="bg-"][class*="-500"]') ||
+                document.querySelector('[class*="hover:"][class*="bg-"]') ||
+                document.querySelector('script[src*="tailwind"]'));
+            // Bootstrap
+            const hasBootstrap = !!(document.querySelector('[class*="col-"][class*="row"]') ||
+                document.querySelector('[class*="btn-"][class*="primary"]') ||
+                document.querySelector('[class*="navbar"]') ||
+                document.querySelector('link[href*="bootstrap"]'));
+            // Material UI
+            const hasMUI = !!(document.querySelector('[class*="Mui"]') ||
+                document.querySelector('[class^="css-"][class*="-"]') ||
+                document.querySelector('svg[class*="MuiSvg"]'));
+            // Chakra UI
+            const hasChakra = !!(document.querySelector('[class*="chakra-"]') ||
+                document.querySelector('[data-chakra]'));
+            // Ant Design
+            const hasAnt = !!(document.querySelector('[class*="ant-"]') ||
+                document.querySelector('[class^="ant-"]'));
+            // Bulma
+            const hasBulma = !!(document.querySelector('[class*="is-"][class*="primary"]') ||
+                document.querySelector('[class*="navbar"]') ||
+                document.querySelector('link[href*="bulma"]'));
+            // Foundation
+            const hasFoundation = !!(document.querySelector('[class*="grid-"]') ||
+                document.querySelector('link[href*="foundation"]'));
+            // Tachyons
+            const hasTachyons = !!(document.querySelector('[class*="flex"][class*="items-center"]') ||
+                document.querySelector('link[href*="tachyons"]'));
+            return {
+                testIds,
+                ariaLabels,
+                ariaLabelledby,
+                ariaDescriptions,
+                roles,
+                labels,
+                placeholders,
+                altTexts,
+                semanticTags,
+                buttons,
+                inputs,
+                links,
+                totalInteractive,
+                hasReact,
+                hasNext,
+                hasVue,
+                hasNuxt,
+                hasAngular,
+                hasSvelte,
+                hasRemix,
+                hasAstro,
+                hasStencil,
+                hasSolid,
+                hasPreact,
+                hasLit,
+                hasTailwind,
+                hasBootstrap,
+                hasMUI,
+                hasChakra,
+                hasAnt,
+                hasBulma,
+                hasFoundation,
+                hasTachyons,
+            };
+        });
+        // Calculate totals
+        const totalElements = analysis.totalInteractive || 1;
+        const totalAria = analysis.ariaLabels + analysis.ariaLabelledby + analysis.ariaDescriptions;
+        // Determine framework
+        let framework = null;
+        if (analysis.hasNext)
+            framework = 'next';
+        else if (analysis.hasReact)
+            framework = 'react';
+        else if (analysis.hasNuxt)
+            framework = 'nuxt';
+        else if (analysis.hasVue)
+            framework = 'vue';
+        else if (analysis.hasRemix)
+            framework = 'remix';
+        else if (analysis.hasAngular)
+            framework = 'angular';
+        else if (analysis.hasAstro)
+            framework = 'astro';
+        else if (analysis.hasSvelte)
+            framework = 'svelte';
+        else if (analysis.hasSolid)
+            framework = 'solid';
+        else if (analysis.hasPreact)
+            framework = 'preact';
+        else if (analysis.hasLit)
+            framework = 'lit';
+        else if (analysis.hasStencil)
+            framework = 'stencil';
+        // Determine CSS framework
+        let cssFramework = null;
+        if (analysis.hasTailwind)
+            cssFramework = 'tailwind';
+        else if (analysis.hasMUI)
+            cssFramework = 'mui';
+        else if (analysis.hasChakra)
+            cssFramework = 'chakra';
+        else if (analysis.hasAnt)
+            cssFramework = 'ant';
+        else if (analysis.hasBootstrap)
+            cssFramework = 'bootstrap';
+        else if (analysis.hasBulma)
+            cssFramework = 'bulma';
+        else if (analysis.hasFoundation)
+            cssFramework = 'foundation';
+        else if (analysis.hasTachyons)
+            cssFramework = 'tachyons';
+        // Calculate scores
+        const testabilityScore = Math.round((analysis.testIds / totalElements) * 100);
+        const accessibilityScore = Math.round(((totalAria + analysis.roles + analysis.labels + analysis.altTexts) / (totalElements * 2)) * 100);
+        return {
+            hasTestIds: analysis.testIds,
+            hasAriaLabels: totalAria,
+            hasRoles: analysis.roles,
+            hasSemanticIds: analysis.semanticTags,
+            hasLabels: analysis.labels,
+            hasPlaceholders: analysis.placeholders,
+            hasAltTexts: analysis.altTexts,
+            totalElements,
+            framework,
+            cssFramework,
+            testabilityScore,
+            accessibilityScore,
+            patterns: {
+                hasReact: analysis.hasReact,
+                hasVue: analysis.hasVue,
+                hasAngular: analysis.hasAngular,
+                hasSvelte: analysis.hasSvelte,
+                hasNext: analysis.hasNext,
+                hasNuxt: analysis.hasNuxt,
+                hasRemix: analysis.hasRemix,
+                hasAstro: analysis.hasAstro,
+                hasTailwind: analysis.hasTailwind,
+                hasBootstrap: analysis.hasBootstrap,
+                hasMUI: analysis.hasMUI,
+                hasChakra: analysis.hasChakra,
+                hasAntDesign: analysis.hasAnt,
+                hasBulma: analysis.hasBulma,
+            },
+        };
+    }
+    /**
+     * Determine the site profile based on analysis
+     */
+    determineProfile(analysis) {
+        const { hasTestIds, hasAriaLabels, totalElements } = analysis;
+        const testIdRatio = totalElements > 0 ? hasTestIds / totalElements : 0;
+        const a11yRatio = totalElements > 0 ? hasAriaLabels / totalElements : 0;
+        // PROFIL_MODERN: Site moderne avec data-testid (>30% des éléments)
+        if (testIdRatio > 0.3) {
+            return 'PROFIL_MODERN';
+        }
+        // PROFIL_ACCESSIBLE: Bonne accessibilité mais peu de testids
+        if (a11yRatio > 0.6 && testIdRatio < 0.1) {
+            return 'PROFIL_ACCESSIBLE';
+        }
+        // PROFIL_LEGACY: Site legacy avec peu d'attributs
+        if (analysis.accessibilityScore < 30 && testIdRatio < 0.05) {
+            return 'PROFIL_LEGACY';
+        }
+        // PROFIL_MINIMAL: Site minimaliste
+        return 'PROFIL_MINIMAL';
+    }
+    /**
+     * Get a human-readable description of the profile
+     */
+    getProfileDescription(profile) {
+        const descriptions = {
+            PROFIL_MODERN: 'Site moderne avec data-testid (React Testing Library, Cypress)',
+            PROFIL_ACCESSIBLE: 'Site accessible (ARIA, labels) mais sans testids',
+            PROFIL_LEGACY: 'Site legacy (ASP.NET, PHP ancien, WordPress)',
+            PROFIL_MINIMAL: 'Site minimaliste (landing pages, blogs)',
+        };
+        return descriptions[profile];
+    }
+    /**
+     * Get the recommended strategy for the profile
+     */
+    getRecommendedStrategy(profile) {
+        const strategies = {
+            PROFIL_MODERN: 'TIER 1 = data-testid (contrat explicite dev/QA)',
+            PROFIL_ACCESSIBLE: 'TIER 1 = role + aria-label (Testing Library)',
+            PROFIL_LEGACY: 'TIER 1 = ID sémantique, TIER 2 = name',
+            PROFIL_MINIMAL: 'TIER 1 = texte visible, TIER 2 = role',
+        };
+        return strategies[profile];
+    }
+}
+/**
+ * Default profiler instance
+ */
+export const defaultProfiler = new SiteProfiler();
+/**
+ * Quick analyze function (convenience wrapper)
+ */
+export async function analyzeSite(page) {
+    return defaultProfiler.analyzeSite(page);
+}
+/**
+ * Quick profile determination (convenience wrapper)
+ */
+export function determineSiteProfile(analysis) {
+    return defaultProfiler.determineProfile(analysis);
+}

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

@@ -0,0 +1,144 @@
+/**
+ * Source Maps Handler
+ *
+ * P1 - Source map parsing and error mapping
+ *
+ * Supports:
+ * - Source map detection
+ * - Source map parsing
+ * - Error stack trace mapping
+ * - Original source location resolution
+ * - Source content retrieval
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Use_a_source_map
+ */
+export interface SourceMapLocation {
+    /** Generated file line number (1-based) */
+    generatedLine: number;
+    /** Generated file column number (1-based) */
+    generatedColumn: number;
+    /** Original source file */
+    originalSource: string | null;
+    /** Original file line number */
+    originalLine: number | null;
+    /** Original file column number */
+    originalColumn: number | null;
+    /** Function name */
+    name: string | null;
+}
+export interface SourceMapInfo {
+    /** Source map URL */
+    url: string;
+    /** Source map content (base64 or external) */
+    content: string | null;
+    /** Number of sources in the map */
+    sourceCount: number;
+    /** Source file names */
+    sources: string[];
+    /** Source root */
+    sourceRoot: string;
+    /** Has mappings */
+    hasMappings: boolean;
+    /** Source map format version */
+    version: number;
+    /** Whether source map is valid */
+    valid: boolean;
+}
+export interface MappedError {
+    /** Original error */
+    original: Error;
+    /** Mapped stack trace */
+    mappedStack: Array<{
+        filename: string;
+        line: number;
+        column: number;
+        function: string | null;
+        originalFilename: string | null;
+        originalLine: number | null;
+        originalColumn: number | null;
+    }>;
+    /** Source map was used */
+    sourceMapUsed: boolean;
+}
+export interface SourceMapResult {
+    /** Source maps found */
+    sourceMaps: Map<string, SourceMapInfo>;
+    /** Files with source maps */
+    filesWithSourceMaps: string[];
+    /** Files without source maps */
+    filesWithoutSourceMaps: string[];
+    /** Coverage percentage */
+    sourceMapCoverage: number;
+}
+/**
+ * Source Maps Handler class
+ */
+export declare class SourceMapsHandler {
+    private page;
+    private sourceMapsCache;
+    constructor(page: any);
+    /**
+     * Get all source map URLs from the page
+     */
+    getSourceMapURLs(): Promise<Map<string, string>>;
+    /**
+     * Fetch and parse a source map
+     */
+    fetchSourceMap(sourceMapUrl: string): Promise<SourceMapInfo>;
+    /**
+     * Get all source maps from the page
+     */
+    getAllSourceMaps(): Promise<SourceMapResult>;
+    /**
+     * Map an error stack trace using source maps
+     */
+    mapError(error: Error): Promise<MappedError>;
+    /**
+     * Map a generated location to original location
+     */
+    mapLocation(filename: string, line: number, column: number): Promise<SourceMapLocation>;
+    /**
+     * Get original source content from source map
+     */
+    getOriginalSource(sourceMapUrl: string, sourceIndex: number): Promise<string | null>;
+    /**
+     * Check if source maps are enabled for a file
+     */
+    hasSourceMap(filename: string): Promise<boolean>;
+    /**
+     * Inject source map helper into the page
+     */
+    injectSourceMapHelper(): Promise<void>;
+    /**
+     * Validate source map quality
+     */
+    validateSourceMaps(): Promise<{
+        total: number;
+        valid: number;
+        invalid: number;
+        missing: number;
+        hasNames: number;
+        hasSourceContent: number;
+        avgSourceCount: number;
+    }>;
+    /**
+     * Get source map statistics
+     */
+    getStatistics(): Promise<{
+        sourceMapCoverage: number;
+        totalFiles: number;
+        filesWithSourceMaps: number;
+        avgMappingsPerFile: number;
+        avgSourcesPerFile: number;
+        recommendation: string;
+    }>;
+    /**
+     * Clear source map cache
+     */
+    clearCache(): void;
+}
+/**
+ * Factory function to create Source Maps Handler
+ */
+export declare function createSourceMapsHandler(page: any): SourceMapsHandler;
+export default SourceMapsHandler;