@empline/preflight 1.1.0

package/dist/checks/e2e/e2e-interaction-coverage-scan.js

@@ -0,0 +1,1665 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * E2E Interaction Coverage Scanner
+ *
+ * Automatically discovers interactive elements in the app and verifies
+ * they have corresponding E2E test coverage with outcome verification.
+ *
+ * This goes beyond the basic critical flow check to find ALL:
+ * - Form submissions
+ * - Button clicks with side effects
+ * - Modal/dialog interactions
+ * - CRUD operations
+ * - State-changing actions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.run = run;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "e2e/e2e-interaction-coverage-scan";
+exports.name = "E2e Interaction Coverage Scan";
+exports.category = "e2e";
+exports.blocking = false;
+exports.description = "E2E Interaction Coverage Scanner";
+exports.tags = ["e2e", "testing"];
+function formatInteractionForReport(i) {
+    const selector = i.selectorType && i.selectorValue
+        ? `${i.selectorType}:${i.selectorValue}`
+        : "(no-stable-selector)";
+    const file = i.file.replace(process.cwd() + path.sep, "");
+    const severityIcon = i.severity === "critical"
+        ? "${emoji.stop}"
+        : i.severity === "high"
+            ? "${emoji.warning}"
+            : i.severity === "medium"
+                ? "${emoji.warning}"
+                : "${emoji.info}";
+    const sharedTag = i.isSharedComponent ? " [shared]" : "";
+    return `${severityIcon} ${i.type} ${selector}${sharedTag} @ ${file}:${i.line}`;
+}
+function getTopUncoveredInteractions(route, max) {
+    const uncovered = route.interactions.filter((i) => !i.hasTestCoverage);
+    // Enhancement #4: Sort by severity first, then by selector availability
+    const severityOrder = {
+        critical: 0,
+        high: 1,
+        medium: 2,
+        low: 3,
+    };
+    uncovered.sort((a, b) => {
+        // First by severity
+        const aSeverity = severityOrder[a.severity || "low"];
+        const bSeverity = severityOrder[b.severity || "low"];
+        if (aSeverity !== bSeverity)
+            return aSeverity - bSeverity;
+        // Then prefer selector-based actionable controls
+        const aHasSelector = Boolean(a.selectorType && a.selectorValue);
+        const bHasSelector = Boolean(b.selectorType && b.selectorValue);
+        if (aHasSelector !== bHasSelector)
+            return aHasSelector ? -1 : 1;
+        // Then by line number
+        return a.line - b.line;
+    });
+    return uncovered.slice(0, max);
+}
+function getModeFromArgsOrEnv() {
+    const rawEnv = (process.env.PREFLIGHT_INTERACTION_SCAN_MODE || "").toLowerCase();
+    const argv = process.argv.slice(2);
+    const modeArg = argv.find((a) => a.startsWith("--mode="));
+    const rawArg = modeArg ? modeArg.split("=")[1] : "";
+    const raw = (rawArg || rawEnv || "block").toLowerCase();
+    return raw === "block" ? "block" : "warn";
+}
+function isVerbose() {
+    return process.argv.includes("--verbose");
+}
+function isActionsMode() {
+    return (process.argv.includes("--actions") ||
+        /^(1|true)$/i.test(process.env.PREFLIGHT_INTERACTION_SCAN_ACTIONS ?? ""));
+}
+function isJsonOutput() {
+    return process.argv.includes("--json");
+}
+function isQuietMode() {
+    return process.argv.includes("--quiet") || process.argv.includes("-q");
+}
+function showHelp() {
+    console.log(`
+E2E Interaction Coverage Scanner
+
+Usage: npx tsx e2e-interaction-coverage-scan.ts [options]
+
+Options:
+  --mode=warn|block    Set mode (default: block)
+                       - warn: Report issues but don't fail
+                       - block: Fail if coverage thresholds not met
+  
+  --actions            Enable actions mode (stricter selector-based checks)
+                       Requires specific click/check/fill patterns for actionable controls
+                       
+                       Actions mode enhancements:
+                       - Detects buttons, toggles, selects, menus, tabs, dialogs
+                       - Tracks form input .fill() coverage
+                       - Assigns severity levels (critical/high/medium/low)
+                       - Cross-references shared component library
+                       - Generates suggested test code snippets
+  
+  --verbose            Show detailed output including:
+                       - Partial coverage routes
+                       - Suggested test code for uncovered elements
+                       - Shared component indicators
+  
+  --json               Output results in JSON format (for CI integration)
+  
+  --quiet, -q          Minimal output (only errors and final result)
+  
+  --help, -h           Show this help message
+
+Environment Variables:
+  PREFLIGHT_INTERACTION_SCAN_MODE              Set mode (warn|block)
+  PREFLIGHT_INTERACTION_SCAN_ACTIONS           Enable actions mode (1|true)
+  PREFLIGHT_INTERACTION_SCAN_MIN_ROUTE_COVERAGE    Minimum route coverage % (default: 80 in actions mode)
+  PREFLIGHT_INTERACTION_SCAN_MIN_OVERALL_COVERAGE  Minimum overall coverage % (default: 90 in actions mode)
+
+Severity Levels (in actions mode):
+  ${console_chars_1.emoji.stop} CRITICAL - Payment, checkout, refund, delete actions
+  ${console_chars_1.emoji.warning} HIGH     - Save, submit, approve, reject, form inputs
+  ${console_chars_1.emoji.warning} MEDIUM   - Toggles, selects, menus
+  ${console_chars_1.emoji.info} LOW      - Tabs, accordions, navigation
+
+Examples:
+  npx tsx e2e-interaction-coverage-scan.ts --mode=warn --verbose
+  npx tsx e2e-interaction-coverage-scan.ts --actions --json
+  PREFLIGHT_INTERACTION_SCAN_ACTIONS=1 npx tsx e2e-interaction-coverage-scan.ts
+`);
+}
+function shouldShowHelp() {
+    return process.argv.includes("--help") || process.argv.includes("-h");
+}
+function getMinRouteCoverage(actionsMode) {
+    const raw = process.env.PREFLIGHT_INTERACTION_SCAN_MIN_ROUTE_COVERAGE;
+    if (raw) {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    // Threshold for per-route coverage
+    // Set to 0 to only warn about low coverage routes without blocking
+    // The overall coverage threshold is the primary gate
+    return actionsMode ? 0 : 0;
+}
+function getMinOverallCoverage(actionsMode) {
+    const raw = process.env.PREFLIGHT_INTERACTION_SCAN_MIN_OVERALL_COVERAGE;
+    if (raw) {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    // Overall coverage threshold - 80% is reasonable with enhanced detection
+    // This accounts for form inputs, selects, and other new element types
+    return actionsMode ? 80 : 0;
+}
+function extractImportSpecifiers(content) {
+    const specifiers = [];
+    const importFrom = /from\s+["']([^"']+)["']/g;
+    let match;
+    while ((match = importFrom.exec(content)) !== null) {
+        specifiers.push(match[1]);
+    }
+    const dynamicImport = /import\(\s*["']([^"']+)["']\s*\)/g;
+    while ((match = dynamicImport.exec(content)) !== null) {
+        specifiers.push(match[1]);
+    }
+    return specifiers;
+}
+function resolveAppImport(fromFile, specifier) {
+    const fromDir = path.dirname(fromFile);
+    const candidates = [];
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        const base = path.resolve(fromDir, specifier);
+        candidates.push(base);
+    }
+    else if (specifier.startsWith("@/app/")) {
+        const rel = specifier.replace(/^@\//, "");
+        candidates.push(path.resolve(process.cwd(), rel));
+    }
+    else {
+        return null;
+    }
+    const resolvedCandidates = [];
+    for (const base of candidates) {
+        if (base.endsWith(".ts") || base.endsWith(".tsx")) {
+            resolvedCandidates.push(base);
+            continue;
+        }
+        resolvedCandidates.push(`${base}.tsx`, `${base}.ts`, path.join(base, "index.tsx"), path.join(base, "index.ts"));
+    }
+    for (const filePath of resolvedCandidates) {
+        if (fs.existsSync(filePath) && filePath.replace(/\\/g, "/").includes("/app/")) {
+            return filePath;
+        }
+    }
+    return null;
+}
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedE2ESpecFiles = null;
+async function getE2ESpecFiles() {
+    if (!_cachedE2ESpecFiles) {
+        _cachedE2ESpecFiles = await file_cache_1.fileCache.getE2ESpecFiles();
+    }
+    return _cachedE2ESpecFiles;
+}
+async function computeReachableAppFiles(pageFiles) {
+    const reachable = new Set();
+    const queue = [];
+    for (const entry of pageFiles) {
+        reachable.add(entry);
+        queue.push(entry);
+    }
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (!current)
+            continue;
+        const content = fs.readFileSync(current, "utf-8");
+        const imports = extractImportSpecifiers(content);
+        for (const spec of imports) {
+            const resolved = resolveAppImport(current, spec);
+            if (!resolved)
+                continue;
+            if (reachable.has(resolved))
+                continue;
+            reachable.add(resolved);
+            queue.push(resolved);
+        }
+    }
+    return reachable;
+}
+// Routes that MUST have interaction test coverage
+const REQUIRED_ROUTES = [
+    // Critical revenue paths
+    {
+        route: "/checkout",
+        reason: "Payment processing - Critical revenue path",
+        severity: "critical",
+    },
+    {
+        route: "/cart",
+        reason: "Cart management - Add, Remove, Update actions",
+        severity: "high",
+    },
+    {
+        route: "/product/",
+        reason: "Product page - Add to cart, Sell one like this, Seller links",
+        severity: "high",
+    },
+    // Account settings - User preferences (NEW)
+    {
+        route: "/account/notifications",
+        reason: "Notification preferences - Email/SMS/Push toggles, Save preferences",
+        severity: "high",
+    },
+    {
+        route: "/account/profile",
+        reason: "Profile management - Update name, email, phone, visibility toggle, permalink",
+        severity: "high",
+    },
+    {
+        route: "/account/settings",
+        reason: "Account settings - Profile updates, password change",
+        severity: "medium",
+    },
+    // Store/Seller management
+    {
+        route: "/store/orders",
+        reason: "Order management - Ship, Cancel, Refund actions",
+        severity: "high",
+    },
+    {
+        route: "/store/billing",
+        reason: "Subscription management - Cancel actions",
+        severity: "high",
+    },
+    {
+        route: "/store/listings/new",
+        reason: "Listing creation - Form submission, image upload",
+        severity: "high",
+    },
+    {
+        route: "/store/notifications",
+        reason: "Store notification preferences - Email/SMS/Push toggles",
+        severity: "medium",
+    },
+    {
+        route: "/store/profile",
+        reason: "Store profile - Update store info, logo upload",
+        severity: "medium",
+    },
+    // Admin management
+    {
+        route: "/admin/listings",
+        reason: "Listing approval - Approve, Reject, Delete, Publish actions",
+        severity: "high",
+    },
+    {
+        route: "/admin/templates",
+        reason: "Template management - Delete actions",
+        severity: "medium",
+    },
+    {
+        route: "/admin/users",
+        reason: "User management - Suspend, Verify, Block actions",
+        severity: "high",
+    },
+    {
+        route: "/admin/stores",
+        reason: "Store management - Verify, Suspend actions",
+        severity: "high",
+    },
+];
+// Patterns to detect interactive elements
+const INTERACTION_PATTERNS = {
+    form: [/onSubmit\s*=\s*\{/g, /handleSubmit/g, /type\s*=\s*["']submit["']/g, /<form\s/gi],
+    button: [
+        /onClick\s*=\s*\{[^}]*(?:delete|remove|cancel|approve|reject|save|update|create|add|submit|confirm)/gi,
+        /handleDelete/g,
+        /handleRemove/g,
+        /handleApprove/g,
+        /handleReject/g,
+        /handleSave/g,
+        /handleCreate/g,
+        /handleUpdate/g,
+        /handleCancel/g,
+    ],
+    modal: [/Dialog|Modal/g, /setOpen\s*\(/g, /setIsOpen\s*\(/g, /onClose\s*=\s*\{/g],
+    crud: [
+        /prisma\.\w+\.create/g,
+        /prisma\.\w+\.update/g,
+        /prisma\.\w+\.delete/g,
+        /\.mutate\s*\(/g,
+        /useMutation/g,
+    ],
+    navigation: [/router\.push\s*\(/g, /router\.replace\s*\(/g, /redirect\s*\(/g],
+    toggle: [/onChange\s*=\s*\{[^}]*toggle/gi, /setEnabled/g, /setActive/g, /handleToggle/g],
+    link: [
+        /href\s*=\s*["']\/[^"']+["']/g, // Internal links
+        /<Link\s+[^>]*href/g,
+        /FooterLink\s+href/g,
+    ],
+};
+// Enhancement #1: Extended actionable component types
+const ACTION_TAGS = [
+    // Buttons - high priority
+    { tag: "Button", type: "button", requires: ["onClick", "typeSubmit"], severity: "high" },
+    { tag: "IconButton", type: "button", requires: ["onClick"], severity: "medium" },
+    { tag: "LoadingButton", type: "button", requires: ["onClick", "typeSubmit"], severity: "high" },
+    { tag: "AnimatedButton", type: "button", requires: ["onClick"], severity: "medium" },
+    // Toggles
+    { tag: "Switch", type: "toggle", requires: ["onChange"], severity: "high" },
+    { tag: "Checkbox", type: "toggle", requires: ["onChange"], severity: "medium" },
+    { tag: "Radio", type: "toggle", requires: ["onChange"], severity: "medium" },
+    // Forms
+    { tag: "form", type: "form", requires: ["onSubmit"], severity: "critical" },
+    // Enhancement #1: New component types
+    // Selects and Dropdowns
+    { tag: "Select", type: "select", requires: ["onChange", "onSelect"], severity: "high" },
+    { tag: "SmartDropdown", type: "select", requires: ["onChange", "onSelect"], severity: "medium" },
+    { tag: "CategorySelector", type: "select", requires: ["onChange"], severity: "medium" },
+    { tag: "ConditionSelector", type: "select", requires: ["onChange"], severity: "medium" },
+    { tag: "GradingSelector", type: "select", requires: ["onChange"], severity: "medium" },
+    { tag: "LeagueSelector", type: "select", requires: ["onChange"], severity: "medium" },
+    { tag: "OptionCardSelector", type: "select", requires: ["onChange"], severity: "medium" },
+    // Menus
+    { tag: "Menu", type: "menu", requires: ["onClick"], severity: "medium" },
+    { tag: "DropdownMenu", type: "menu", requires: ["onClick"], severity: "medium" },
+    { tag: "ActionCenter", type: "menu", requires: ["onClick"], severity: "medium" },
+    { tag: "QuickActions", type: "menu", requires: ["onClick"], severity: "medium" },
+    // Tabs
+    { tag: "Tabs", type: "tab", requires: ["onChange", "onSelect"], severity: "medium" },
+    { tag: "Tab", type: "tab", requires: ["onClick"], severity: "low" },
+    // Accordions
+    { tag: "Accordion", type: "accordion", requires: ["onChange"], severity: "low" },
+    { tag: "AccordionItem", type: "accordion", requires: ["onClick"], severity: "low" },
+    // Dialogs and Modals
+    { tag: "Dialog", type: "dialog", requires: ["onOpenChange"], severity: "high" },
+    { tag: "Modal", type: "dialog", requires: ["onOpenChange"], severity: "high" },
+    { tag: "UnifiedDialog", type: "dialog", requires: ["onOpenChange"], severity: "high" },
+    { tag: "ConfirmDialog", type: "dialog", requires: ["onOpenChange"], severity: "critical" },
+    { tag: "CompSearchDialog", type: "dialog", requires: ["onOpenChange"], severity: "medium" },
+];
+// Enhancement #2: Form input tags that need .fill() coverage
+const INPUT_TAGS = [
+    { tag: "Input", type: "input", severity: "high" },
+    { tag: "TextField", type: "input", severity: "high" },
+    { tag: "TextArea", type: "input", severity: "medium" },
+    { tag: "Textarea", type: "input", severity: "medium" },
+    { tag: "NumericInput", type: "input", severity: "high" },
+    { tag: "PriceInput", type: "input", severity: "critical" },
+    { tag: "QuantityInput", type: "input", severity: "high" },
+    { tag: "WeightInput", type: "input", severity: "medium" },
+    { tag: "SearchInput", type: "input", severity: "medium" },
+    { tag: "UnifiedSearch", type: "input", severity: "medium" },
+    { tag: "DatePicker", type: "input", severity: "medium" },
+    { tag: "DateRangePicker", type: "input", severity: "medium" },
+];
+// Enhancement #5: Shared component patterns to cross-reference
+const SHARED_COMPONENT_PATTERNS = [
+    "UnifiedProductCard",
+    "UnifiedDialog",
+    "UnifiedEmptyState",
+    "UnifiedPagination",
+    "UnifiedSearch",
+    "ConfirmDialog",
+    "EnhancedDataTable",
+    "BulkActionToolbar",
+    "ActionButtonGroup",
+    "ActionCard",
+    "ActionRow",
+    "QuickActions",
+    "FilterSystem",
+    "FormBuilder",
+    "ImageUploadZone",
+    "FileUpload",
+    "CardUploadWizard",
+];
+// Critical action patterns that MUST have test coverage
+const CRITICAL_ACTION_PATTERNS = [
+    {
+        pattern: /handleDelete|onDelete|deleteItem|removeItem/gi,
+        name: "Delete action",
+        severity: "high",
+    },
+    {
+        pattern: /handleApprove|onApprove|approveItem|handleApproval/gi,
+        name: "Approve action",
+        severity: "high",
+    },
+    {
+        pattern: /handleReject|onReject|rejectItem|handleRejection/gi,
+        name: "Reject action",
+        severity: "high",
+    },
+    {
+        pattern: /handlePayment|processPayment|submitPayment/gi,
+        name: "Payment action",
+        severity: "critical",
+    },
+    {
+        pattern: /handleCheckout|submitOrder|placeOrder/gi,
+        name: "Checkout action",
+        severity: "critical",
+    },
+    { pattern: /handleRefund|processRefund/gi, name: "Refund action", severity: "critical" },
+    {
+        pattern: /handleCancel|cancelOrder|cancelSubscription/gi,
+        name: "Cancel action",
+        severity: "high",
+    },
+    {
+        pattern: /handleShip|shipOrder|markShipped|markAsShipped/gi,
+        name: "Ship action",
+        severity: "high",
+    },
+    {
+        pattern: /handlePublish|publishListing|publishItem/gi,
+        name: "Publish action",
+        severity: "medium",
+    },
+    { pattern: /handleSuspend|suspendUser|suspendStore/gi, name: "Suspend action", severity: "high" },
+    { pattern: /handleVerify|verifyUser|verifyStore/gi, name: "Verify action", severity: "medium" },
+    {
+        pattern: /handleBulk|bulkAction|bulkDelete|bulkApprove/gi,
+        name: "Bulk action",
+        severity: "high",
+    },
+    { pattern: /handleExport|exportData|downloadCsv/gi, name: "Export action", severity: "medium" },
+    { pattern: /handleImport|importData|uploadCsv/gi, name: "Import action", severity: "medium" },
+    // Additional critical patterns
+    {
+        pattern: /handleArchive|archiveItem|archiveListing/gi,
+        name: "Archive action",
+        severity: "medium",
+    },
+    {
+        pattern: /handleRestore|restoreItem|restoreListing/gi,
+        name: "Restore action",
+        severity: "medium",
+    },
+    {
+        pattern: /handleDuplicate|duplicateItem|cloneListing/gi,
+        name: "Duplicate action",
+        severity: "low",
+    },
+    { pattern: /handleTransfer|transferOwnership/gi, name: "Transfer action", severity: "high" },
+    { pattern: /handleBlock|blockUser|banUser/gi, name: "Block/Ban action", severity: "high" },
+    { pattern: /handleUnblock|unblockUser|unbanUser/gi, name: "Unblock action", severity: "medium" },
+    // Account/Profile settings patterns
+    {
+        pattern: /handleSave|handleSaveSlug|handleSaveProfileDetails/gi,
+        name: "Save settings action",
+        severity: "high",
+    },
+    {
+        pattern: /handleToggleVisibility|toggleNotification|toggleAllForChannel/gi,
+        name: "Toggle preference action",
+        severity: "high",
+    },
+    {
+        pattern: /updateProfileVisibility|updateProfileSlug|updateProfileDetails/gi,
+        name: "Profile update action",
+        severity: "high",
+    },
+];
+function extractRouteFromFile(filePath) {
+    // Convert file path to route
+    // app/store/orders/page.tsx -> /store/orders
+    // app/(marketing)/about/page.tsx -> /about
+    // app/account/notifications/AccountNotificationsClient.tsx -> /account/notifications
+    const normalized = filePath.replace(/\\/g, "/");
+    let route = normalized
+        .replace(/^app/, "")
+        .replace(/\/page\.tsx$/, "")
+        .replace(/\/[A-Z][a-zA-Z]*Client\.tsx$/, "") // Remove client component files like AccountNotificationsClient.tsx
+        .replace(/\/[A-Z][a-zA-Z0-9_]*\.tsx$/, "") // Remove other component files like Step4ProductSelection.tsx
+        .replace(/\/\([^)]+\)/g, "") // Remove route groups
+        .replace(/\/_components.*$/, "") // Remove component folders
+        .replace(/\/components.*$/, "");
+    if (!route || route === "")
+        route = "/";
+    if (!route.startsWith("/"))
+        route = "/" + route;
+    return route;
+}
+function getLineNumberAtIndex(content, index) {
+    return content.substring(0, index).split("\n").length;
+}
+function extractJsxTag(content, startIndex) {
+    // Extract a JSX/HTML tag starting at '<' until the matching '>'
+    // while respecting string quotes and JSX expression braces.
+    if (content[startIndex] !== "<")
+        return null;
+    let i = startIndex;
+    let inSingle = false;
+    let inDouble = false;
+    let braceDepth = 0;
+    while (i < content.length) {
+        const ch = content[i];
+        const prev = i > startIndex ? content[i - 1] : "";
+        if (!inDouble && ch === "'" && prev !== "\\") {
+            inSingle = !inSingle;
+        }
+        else if (!inSingle && ch === '"' && prev !== "\\") {
+            inDouble = !inDouble;
+        }
+        else if (!inSingle && !inDouble) {
+            if (ch === "{")
+                braceDepth++;
+            if (ch === "}" && braceDepth > 0)
+                braceDepth--;
+            if (ch === ">" && braceDepth === 0) {
+                const tagText = content.slice(startIndex, i + 1);
+                return { tagText, endIndex: i + 1 };
+            }
+        }
+        i++;
+    }
+    return null;
+}
+function extractFirstLiteralChildText(content, tagEndIndex, tagName) {
+    // Attempts to extract simple literal text like: <Button>Save</Button>
+    // Only handles immediate string content (no JSX expressions).
+    const after = content.slice(tagEndIndex);
+    const closeIdx = after.indexOf(`</${tagName}>`);
+    if (closeIdx === -1)
+        return null;
+    const between = after.slice(0, closeIdx);
+    const trimmed = between.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{") || trimmed.includes("<"))
+        return null;
+    return trimmed;
+}
+function parseSelectorFromTag(tagText) {
+    const testId = tagText.match(/data-testid\s*=\s*["']([^"']+)["']/i)?.[1];
+    if (testId)
+        return { selectorType: "testid", selectorValue: testId };
+    const aria = tagText.match(/aria-label\s*=\s*["']([^"']+)["']/i)?.[1];
+    if (aria)
+        return { selectorType: "aria-label", selectorValue: aria };
+    const label = tagText.match(/\blabel\s*=\s*["']([^"']+)["']/i)?.[1];
+    if (label)
+        return { selectorType: "label", selectorValue: label };
+    const title = tagText.match(/\btitle\s*=\s*["']([^"']+)["']/i)?.[1];
+    if (title)
+        return { selectorType: "label", selectorValue: title };
+    return null;
+}
+function hasRequiredHandler(tagText, requires) {
+    const hasOnClick = /\bonClick\s*=\s*\{/i.test(tagText);
+    const hasOnChange = /\bonChange\s*=\s*\{/i.test(tagText);
+    const hasOnSubmit = /\bonSubmit\s*=\s*\{/i.test(tagText);
+    const hasTypeSubmit = /\btype\s*=\s*["']submit["']/i.test(tagText);
+    const hasOnSelect = /\bonSelect\s*=\s*\{/i.test(tagText);
+    const hasOnOpenChange = /\bonOpenChange\s*=\s*\{/i.test(tagText);
+    // For Button, treat submit buttons as actionable even without explicit onClick.
+    return requires.some((r) => {
+        if (r === "onClick")
+            return hasOnClick;
+        if (r === "onChange")
+            return hasOnChange;
+        if (r === "onSubmit")
+            return hasOnSubmit;
+        if (r === "onSelect")
+            return hasOnSelect;
+        if (r === "onOpenChange")
+            return hasOnOpenChange;
+        return hasTypeSubmit;
+    });
+}
+function findActionableControlsInFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const route = extractRouteFromFile(filePath);
+    const interactions = [];
+    // Enhancement #1: Process ACTION_TAGS (buttons, toggles, selects, menus, tabs, dialogs)
+    for (const { tag, type, requires, severity } of ACTION_TAGS) {
+        const tagRegex = new RegExp(`<${tag}\\b`, "g");
+        let match;
+        while ((match = tagRegex.exec(content)) !== null) {
+            const startIndex = match.index;
+            const tagExtract = extractJsxTag(content, startIndex);
+            if (!tagExtract)
+                continue;
+            const tagText = tagExtract.tagText;
+            if (!hasRequiredHandler(tagText, requires))
+                continue;
+            const selector = parseSelectorFromTag(tagText);
+            const line = getLineNumberAtIndex(content, startIndex);
+            let name = `${tag}:${type}`;
+            let selectorType;
+            let selectorValue;
+            if (selector) {
+                selectorType = selector.selectorType;
+                selectorValue = selector.selectorValue;
+                name = selector.selectorValue;
+            }
+            else if (tag === "Button" ||
+                tag === "IconButton" ||
+                tag === "LoadingButton" ||
+                tag === "AnimatedButton") {
+                const childText = extractFirstLiteralChildText(content, tagExtract.endIndex, tag);
+                if (childText) {
+                    selectorType = "text";
+                    selectorValue = childText;
+                    name = childText;
+                }
+                else {
+                    // No stable selector; skip in actions mode to avoid noise.
+                    continue;
+                }
+            }
+            else {
+                // For toggles/forms without selector, skip in actions mode to avoid noise.
+                continue;
+            }
+            // Enhancement #5: Check if this is a shared component
+            const isSharedComponent = SHARED_COMPONENT_PATTERNS.some((pattern) => tag === pattern || tagText.includes(pattern));
+            // Enhancement #4: Determine severity based on context
+            let effectiveSeverity = severity;
+            if (selectorValue) {
+                const lowerValue = selectorValue.toLowerCase();
+                if (/delete|remove|cancel|refund/.test(lowerValue)) {
+                    effectiveSeverity = "critical";
+                }
+                else if (/save|submit|confirm|approve|reject/.test(lowerValue)) {
+                    effectiveSeverity = "high";
+                }
+            }
+            // Enhancement #6: Generate suggested test code
+            const suggestedTest = generateSuggestedTest(route, type, selectorType, selectorValue, name);
+            interactions.push({
+                file: filePath,
+                route,
+                type,
+                name,
+                line,
+                hasTestCoverage: false,
+                coveringTests: [],
+                selectorType,
+                selectorValue,
+                severity: effectiveSeverity,
+                isSharedComponent,
+                suggestedTest,
+            });
+        }
+    }
+    // Enhancement #2: Process INPUT_TAGS (form inputs that need .fill() coverage)
+    for (const { tag, type, severity } of INPUT_TAGS) {
+        const tagRegex = new RegExp(`<${tag}\\b`, "g");
+        let match;
+        while ((match = tagRegex.exec(content)) !== null) {
+            const startIndex = match.index;
+            const tagExtract = extractJsxTag(content, startIndex);
+            if (!tagExtract)
+                continue;
+            const tagText = tagExtract.tagText;
+            const selector = parseSelectorFromTag(tagText);
+            const line = getLineNumberAtIndex(content, startIndex);
+            // Also check for placeholder as selector
+            const placeholder = tagText.match(/placeholder\s*=\s*["']([^"']+)["']/i)?.[1];
+            let name = `${tag}:${type}`;
+            let selectorType;
+            let selectorValue;
+            if (selector) {
+                selectorType = selector.selectorType;
+                selectorValue = selector.selectorValue;
+                name = selector.selectorValue;
+            }
+            else if (placeholder) {
+                selectorType = "placeholder";
+                selectorValue = placeholder;
+                name = placeholder;
+            }
+            else {
+                // No stable selector; skip
+                continue;
+            }
+            // Skip toggle/visibility buttons that are incorrectly detected as inputs
+            // These are typically IconButtons inside Input endAdornment
+            if (selectorValue && /toggle|visibility/i.test(selectorValue)) {
+                continue;
+            }
+            // Enhancement #4: Determine severity based on field type
+            let effectiveSeverity = severity;
+            if (selectorValue) {
+                const lowerValue = selectorValue.toLowerCase();
+                if (/email|password|card|cvv|ssn|phone/.test(lowerValue)) {
+                    effectiveSeverity = "critical";
+                }
+                else if (/name|address|price|amount|quantity/.test(lowerValue)) {
+                    effectiveSeverity = "high";
+                }
+            }
+            // Enhancement #6: Generate suggested test code
+            const suggestedTest = generateSuggestedTestForInput(route, selectorType, selectorValue, name);
+            interactions.push({
+                file: filePath,
+                route,
+                type,
+                name,
+                line,
+                hasTestCoverage: false,
+                coveringTests: [],
+                selectorType,
+                selectorValue,
+                severity: effectiveSeverity,
+                suggestedTest,
+            });
+        }
+    }
+    return interactions;
+}
+// Enhancement #6: Generate suggested test code for buttons/actions
+function generateSuggestedTest(route, type, selectorType, selectorValue, name) {
+    if (!selectorType || !selectorValue)
+        return "";
+    const routeForTest = route === "/" ? "/" : route;
+    let selector = "";
+    let action = ".click()";
+    switch (selectorType) {
+        case "testid":
+            selector = `page.getByTestId("${selectorValue}")`;
+            break;
+        case "aria-label":
+        case "label":
+            if (type === "button") {
+                selector = `page.getByRole("button", { name: "${selectorValue}" })`;
+            }
+            else if (type === "toggle") {
+                selector = `page.getByLabel("${selectorValue}")`;
+                action = ".check()";
+            }
+            else {
+                selector = `page.getByLabel("${selectorValue}")`;
+            }
+            break;
+        case "text":
+            selector = `page.getByRole("button", { name: "${selectorValue}" })`;
+            break;
+        default:
+            return "";
+    }
+    return `test("should ${type === "toggle" ? "toggle" : "click"} ${name}", async ({ page }) => {
+  await page.goto("${routeForTest}");
+  await ${selector}${action};
+  await expect(page.locator("main")).toBeVisible(); // Add specific outcome
+});`;
+}
+// Enhancement #6: Generate suggested test code for form inputs
+function generateSuggestedTestForInput(route, selectorType, selectorValue, name) {
+    if (!selectorType || !selectorValue)
+        return "";
+    const routeForTest = route === "/" ? "/" : route;
+    let selector = "";
+    switch (selectorType) {
+        case "testid":
+            selector = `page.getByTestId("${selectorValue}")`;
+            break;
+        case "aria-label":
+        case "label":
+            selector = `page.getByLabel("${selectorValue}")`;
+            break;
+        case "placeholder":
+            selector = `page.getByPlaceholder("${selectorValue}")`;
+            break;
+        default:
+            return "";
+    }
+    return `test("should fill ${name} field", async ({ page }) => {
+  await page.goto("${routeForTest}");
+  await ${selector}.fill("test value");
+  await expect(${selector}).toHaveValue("test value");
+});`;
+}
+function findInteractionsInFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const route = extractRouteFromFile(filePath);
+    const interactions = [];
+    for (const [type, patterns] of Object.entries(INTERACTION_PATTERNS)) {
+        for (const pattern of patterns) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const lineNumber = content.substring(0, match.index).split("\n").length;
+                const lineContent = lines[lineNumber - 1] || "";
+                // Extract a meaningful name from context
+                let name = match[0].replace(/[=\s{(]/g, "").substring(0, 30);
+                // Try to get better context from surrounding lines
+                const contextStart = Math.max(0, lineNumber - 3);
+                const contextEnd = Math.min(lines.length, lineNumber + 2);
+                const context = lines.slice(contextStart, contextEnd).join(" ");
+                // Look for button/form labels
+                const labelMatch = context.match(/(?:label|name|title|aria-label)\s*[=:]\s*["']([^"']+)["']/i);
+                if (labelMatch) {
+                    name = labelMatch[1];
+                }
+                interactions.push({
+                    file: filePath,
+                    route,
+                    type: type,
+                    name,
+                    line: lineNumber,
+                    hasTestCoverage: false,
+                    coveringTests: [],
+                });
+            }
+        }
+    }
+    return interactions;
+}
+function findCriticalActionsInFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const actions = [];
+    for (const { pattern, name, severity } of CRITICAL_ACTION_PATTERNS) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const lineNumber = content.substring(0, match.index).split("\n").length;
+            actions.push({ name, severity, line: lineNumber });
+        }
+    }
+    return actions;
+}
+function getRouteMatchCandidates(route) {
+    // For dynamic routes, tests typically hit example URLs rather than the literal
+    // pattern string (e.g. "/product/[slug]" vs "/product/e2e-baseball-card-1").
+    // Treat the static prefix as a valid coverage signal.
+    const candidates = new Set();
+    candidates.add(route);
+    if (route.includes("[")) {
+        // Replace dynamic segments with empty string.
+        const prefix = route.replace(/\[[^\]]+\]/g, "").replace(/\/\/+/g, "/");
+        if (prefix && prefix !== "/") {
+            candidates.add(prefix);
+            // Also add a no-trailing-slash variant to catch tests using "/product".
+            if (prefix.endsWith("/")) {
+                candidates.add(prefix.slice(0, -1));
+            }
+            else {
+                candidates.add(prefix + "/");
+            }
+        }
+    }
+    return Array.from(candidates);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function testHasOutcome(content) {
+    return /toHaveURL|toHaveText|toContainText|toBeVisible|waitForResponse|expect\.poll|toHaveValue|toBeEnabled|toBeDisabled|toBeChecked/i.test(content);
+}
+function testCoversInteractionBySelector(content, interaction) {
+    if (!interaction.selectorType || !interaction.selectorValue)
+        return false;
+    const value = interaction.selectorValue;
+    // Outcome is required for all actionable selector-based checks.
+    if (!testHasOutcome(content))
+        return false;
+    // Enhancement #2: For input types, check for .fill() coverage
+    if (interaction.type === "input") {
+        return testCoversInputBySelector(content, interaction);
+    }
+    // Enhancement #1: For select types, check for .selectOption() or .click()
+    if (interaction.type === "select") {
+        return testCoversSelectBySelector(content, interaction);
+    }
+    if (interaction.selectorType === "testid") {
+        const v = escapeRegExp(value);
+        // Direct chained pattern
+        const testIdClick = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.click\\s*\\(`, "i");
+        const locatorClick = new RegExp(`locator\\(\\s*['\"][^'\"]*data-testid[^'\"]*${v}[^'\"]*['\"]\\s*\\)[\\s\\S]{0,120}\\.click\\s*\\(`, "i");
+        const locatorDataTestIdClick = new RegExp(`locator\\(\\s*['\"]\\[data-testid=['\"]${v}['\"]\\]\\s*['\"]\\s*\\)[\\s\\S]{0,120}\\.click\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByTestId("..."); ... x.click(
+        const testIdVarClick = new RegExp(`=\\s*(?:page\\.)?getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        const testIdCheck = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.(check|uncheck)\\s*\\(`, "i");
+        if (interaction.type === "toggle") {
+            return (testIdCheck.test(content) ||
+                testIdClick.test(content) ||
+                locatorClick.test(content) ||
+                locatorDataTestIdClick.test(content) ||
+                testIdVarClick.test(content));
+        }
+        return (testIdClick.test(content) ||
+            locatorClick.test(content) ||
+            locatorDataTestIdClick.test(content) ||
+            testIdVarClick.test(content));
+    }
+    if (interaction.selectorType === "aria-label" || interaction.selectorType === "label") {
+        const v = escapeRegExp(value);
+        // Direct chained pattern
+        const roleClick = new RegExp(`getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,200}name:\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.click\\s*\\(`, "i");
+        const labelClick = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.click\\s*\\(`, "i");
+        const labelCheck = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.(check|uncheck)\\s*\\(`, "i");
+        const ariaLocatorClick = new RegExp(`locator\\(\\s*['\"][^'\"]*aria-label[^'\"]*${v}[^'\"]*['\"]\\s*\\)[\\s\\S]{0,120}\\.click\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByLabel("..."); ... x.click(
+        const labelVarClick = new RegExp(`=\\s*(?:page\\.)?getByLabel\\(\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        // Variable-based pattern for getByRole: const x = page.getByRole("button", { name: "..." }); ... x.click(
+        const roleVarClick = new RegExp(`=\\s*(?:page\\.)?getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,200}name:\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        if (interaction.type === "toggle") {
+            return (labelCheck.test(content) ||
+                roleClick.test(content) ||
+                labelClick.test(content) ||
+                ariaLocatorClick.test(content) ||
+                labelVarClick.test(content) ||
+                roleVarClick.test(content));
+        }
+        return (roleClick.test(content) ||
+            labelClick.test(content) ||
+            ariaLocatorClick.test(content) ||
+            labelVarClick.test(content) ||
+            roleVarClick.test(content));
+    }
+    if (interaction.selectorType === "text") {
+        const v = escapeRegExp(value);
+        // Direct chained pattern
+        const roleClick = new RegExp(`getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,200}name:\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.click\\s*\\(`, "i");
+        const textClick = new RegExp(`getByText\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.click\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByRole("button", { name: "..." }); ... x.click(
+        const roleVarClick = new RegExp(`=\\s*(?:page\\.)?getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,200}name:\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByText("..."); ... x.click(
+        const textVarClick = new RegExp(`=\\s*(?:page\\.)?getByText\\(\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        if (roleClick.test(content) ||
+            textClick.test(content) ||
+            roleVarClick.test(content) ||
+            textVarClick.test(content))
+            return true;
+        // Allow partial regex matches for dynamic text labels like
+        // "Mark All Read ({unreadCount})" where tests should sensibly use
+        // name: /Mark All Read/i.
+        const prefix = value.split(/[({]/)[0]?.trim();
+        if (prefix && prefix.length >= 4) {
+            const p = escapeRegExp(prefix);
+            const roleClickPrefix = new RegExp(`getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,220}name:\\s*\\/[^\\/]*${p}[^\\/]*\\/[igmsuy]*[\\s\\S]{0,140}\\)\\.click\\s*\\(`, "i");
+            const textClickPrefix = new RegExp(`getByText\\(\\s*\\/[^\\/]*${p}[^\\/]*\\/[igmsuy]*[\\s\\S]{0,140}\\)\\.click\\s*\\(`, "i");
+            // Variable-based pattern with prefix
+            const roleVarClickPrefix = new RegExp(`=\\s*(?:page\\.)?getByRole\\(\\s*['\"]button['\"][\\s\\S]{0,220}name:\\s*\\/[^\\/]*${p}[^\\/]*\\/[igmsuy]*[\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+            return (roleClickPrefix.test(content) ||
+                textClickPrefix.test(content) ||
+                roleVarClickPrefix.test(content));
+        }
+        return false;
+    }
+    return false;
+}
+// Enhancement #2: Check if test covers input with .fill()
+// Supports both direct chained patterns and variable-based patterns
+function testCoversInputBySelector(content, interaction) {
+    if (!interaction.selectorType || !interaction.selectorValue)
+        return false;
+    const value = interaction.selectorValue;
+    const v = escapeRegExp(value);
+    if (interaction.selectorType === "testid") {
+        // Direct chained pattern
+        const testIdFill = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.fill\\s*\\(`, "i");
+        const testIdType = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.type\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByTestId("..."); ... x.fill(
+        const testIdVarFill = new RegExp(`=\\s*(?:page\\.)?getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,500}\\.fill\\s*\\(`, "i");
+        return testIdFill.test(content) || testIdType.test(content) || testIdVarFill.test(content);
+    }
+    if (interaction.selectorType === "label" || interaction.selectorType === "aria-label") {
+        // Direct chained pattern
+        const labelFill = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.fill\\s*\\(`, "i");
+        const labelType = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.type\\s*\\(`, "i");
+        const roleTextbox = new RegExp(`getByRole\\(\\s*['\"]textbox['\"][\\s\\S]{0,200}name:\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.fill\\s*\\(`, "i");
+        // Variable-based pattern: const x = page.getByLabel("..."); ... x.fill(
+        const labelVarFill = new RegExp(`=\\s*(?:page\\.)?getByLabel\\(\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.fill\\s*\\(`, "i");
+        return (labelFill.test(content) ||
+            labelType.test(content) ||
+            roleTextbox.test(content) ||
+            labelVarFill.test(content));
+    }
+    if (interaction.selectorType === "placeholder") {
+        // Direct chained pattern
+        const placeholderFill = new RegExp(`getByPlaceholder\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.fill\\s*\\(`, "i");
+        const placeholderType = new RegExp(`getByPlaceholder\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.type\\s*\\(`, "i");
+        // Variable-based pattern
+        const placeholderVarFill = new RegExp(`=\\s*(?:page\\.)?getByPlaceholder\\(\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.fill\\s*\\(`, "i");
+        return (placeholderFill.test(content) ||
+            placeholderType.test(content) ||
+            placeholderVarFill.test(content));
+    }
+    return false;
+}
+// Enhancement #1: Check if test covers select with .selectOption() or .click()
+// Supports both direct chained patterns and variable-based patterns
+function testCoversSelectBySelector(content, interaction) {
+    if (!interaction.selectorType || !interaction.selectorValue)
+        return false;
+    const value = interaction.selectorValue;
+    const v = escapeRegExp(value);
+    if (interaction.selectorType === "testid") {
+        // Direct chained pattern
+        const testIdSelect = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.selectOption\\s*\\(`, "i");
+        const testIdClick = new RegExp(`getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,120}\\.click\\s*\\(`, "i");
+        // Variable-based pattern
+        const testIdVarClick = new RegExp(`=\\s*(?:page\\.)?getByTestId\\(\\s*['\"]${v}['\"]\\s*\\)[\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        return testIdSelect.test(content) || testIdClick.test(content) || testIdVarClick.test(content);
+    }
+    if (interaction.selectorType === "label" || interaction.selectorType === "aria-label") {
+        // Direct chained pattern
+        const labelSelect = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.selectOption\\s*\\(`, "i");
+        const labelClick = new RegExp(`getByLabel\\(\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.click\\s*\\(`, "i");
+        const roleCombobox = new RegExp(`getByRole\\(\\s*['\"]combobox['\"][\\s\\S]{0,200}name:\\s*(?:['\"]${v}['\"]|\\/${v}\\/[igmsuy]*)[\\s\\S]{0,120}\\)\\.(?:selectOption|click)\\s*\\(`, "i");
+        // Variable-based pattern
+        const labelVarClick = new RegExp(`=\\s*(?:page\\.)?getByLabel\\(\\s*['\"]${v}['\"][\\s\\S]{0,500}\\.click\\s*\\(`, "i");
+        return (labelSelect.test(content) ||
+            labelClick.test(content) ||
+            roleCombobox.test(content) ||
+            labelVarClick.test(content));
+    }
+    return false;
+}
+function checkTestCoverage(interactions, testFiles) {
+    // Build index of test content
+    const testContentIndex = new Map();
+    for (const testFile of testFiles) {
+        if (fs.existsSync(testFile)) {
+            testContentIndex.set(testFile, fs.readFileSync(testFile, "utf-8"));
+        }
+    }
+    for (const interaction of interactions) {
+        const route = interaction.route;
+        const routeCandidates = getRouteMatchCandidates(route);
+        const coveringTests = [];
+        for (const [testFile, content] of testContentIndex) {
+            // Check if test covers this route
+            const coversRoute = routeCandidates.some((candidate) => content.includes(candidate) || content.includes(candidate.replace(/\//g, "\\/")));
+            if (!coversRoute)
+                continue;
+            // If the interaction has a stable selector (actions mode), require the test
+            // to actually click/check that selector (not just any click on the route).
+            if (interaction.selectorType && interaction.selectorValue) {
+                if (testCoversInteractionBySelector(content, interaction)) {
+                    coveringTests.push(testFile);
+                }
+                continue;
+            }
+            // Check if test has relevant interactions
+            let hasRelevantInteraction = false;
+            switch (interaction.type) {
+                case "form":
+                    hasRelevantInteraction = /\.fill\s*\(|\.type\s*\(|submit/i.test(content);
+                    break;
+                case "button":
+                    hasRelevantInteraction = /\.click\s*\(/i.test(content);
+                    break;
+                case "modal":
+                    hasRelevantInteraction = /dialog|modal|\.click\s*\(/i.test(content);
+                    break;
+                case "crud":
+                    hasRelevantInteraction = /waitForResponse|waitForRequest|\.click\s*\(/i.test(content);
+                    break;
+                case "navigation":
+                    hasRelevantInteraction = /toHaveURL|\.click\s*\(|\.goto\s*\(/i.test(content);
+                    break;
+                case "toggle":
+                    hasRelevantInteraction = /\.click\s*\(|\.check\s*\(/i.test(content);
+                    break;
+                case "link":
+                    // Links are covered if test navigates to the page and verifies content
+                    hasRelevantInteraction = /\.goto\s*\(|\.locator\s*\(|getByText|getByRole/i.test(content);
+                    break;
+            }
+            // Check for outcome verification
+            const hasOutcome = testHasOutcome(content);
+            if (hasRelevantInteraction && hasOutcome) {
+                coveringTests.push(testFile);
+            }
+        }
+        interaction.hasTestCoverage = coveringTests.length > 0;
+        interaction.coveringTests = coveringTests;
+    }
+    return interactions;
+}
+function groupByRoute(interactions) {
+    const routeMap = new Map();
+    for (const interaction of interactions) {
+        if (!routeMap.has(interaction.route)) {
+            routeMap.set(interaction.route, {
+                route: interaction.route,
+                file: interaction.file,
+                interactions: [],
+                testCoverage: 0,
+            });
+        }
+        routeMap.get(interaction.route).interactions.push(interaction);
+    }
+    // Calculate coverage percentage
+    for (const routeData of routeMap.values()) {
+        const covered = routeData.interactions.filter((i) => i.hasTestCoverage).length;
+        routeData.testCoverage =
+            routeData.interactions.length > 0
+                ? Math.round((covered / routeData.interactions.length) * 100)
+                : 100;
+    }
+    return Array.from(routeMap.values()).sort((a, b) => a.testCoverage - b.testCoverage);
+}
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    // Check for help flag first
+    if (shouldShowHelp()) {
+        showHelp();
+        process.exit(0);
+    }
+    const mode = getModeFromArgsOrEnv();
+    const verbose = isVerbose();
+    const jsonOutput = isJsonOutput();
+    const quiet = isQuietMode();
+    const actionsMode = isActionsMode();
+    const minRouteCoverage = getMinRouteCoverage(actionsMode);
+    const minOverallCoverage = getMinOverallCoverage(actionsMode);
+    console.log(`\n${console_chars_1.emoji.search} E2E INTERACTION COVERAGE SCANNER`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`Mode: ${mode} | Verbose: ${verbose}`);
+    if (actionsMode) {
+        console.log(`${console_chars_1.emoji.info} Actions mode enabled: requiring selector-specific clicks/checks for actionable controls (set PREFLIGHT_INTERACTION_SCAN_ACTIONS=0 to disable).`);
+    }
+    console.log("Scanning app for interactive elements...\n");
+    // Find all app files
+    let appFiles = await file_cache_1.fileCache.getAppAllTSX();
+    // In actions mode, only scan files reachable from pages to avoid false
+    // positives from orphan components.
+    if (actionsMode) {
+        const pageFiles = await file_cache_1.fileCache.getPageFiles();
+        const reachable = await computeReachableAppFiles(pageFiles);
+        appFiles = appFiles.filter((f) => reachable.has(f));
+    }
+    // Find all test files
+    const testFiles = await getE2ESpecFiles();
+    console.log(`📂 Scanning ${appFiles.length} app files...`);
+    console.log(`📂 Found ${testFiles.length} E2E test files...\n`);
+    // Find all interactions
+    let allInteractions = [];
+    const criticalActions = [];
+    for (const file of appFiles) {
+        const interactions = findInteractionsInFile(file);
+        allInteractions.push(...interactions);
+        if (actionsMode) {
+            allInteractions.push(...findActionableControlsInFile(file));
+        }
+        // Find critical actions
+        const route = extractRouteFromFile(file);
+        const actions = findCriticalActionsInFile(file);
+        for (const action of actions) {
+            criticalActions.push({
+                file,
+                route,
+                ...action,
+                hasCoverage: false,
+            });
+        }
+    }
+    // Deduplicate interactions (same type on same line)
+    const seen = new Set();
+    allInteractions = allInteractions.filter((i) => {
+        const key = `${i.file}:${i.line}:${i.type}:${i.selectorType ?? ""}:${i.selectorValue ?? ""}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    console.log(`${console_chars_1.emoji.target} Found ${allInteractions.length} interactive elements`);
+    console.log(`${console_chars_1.emoji.warning}  Found ${criticalActions.length} critical actions\n`);
+    // Check test coverage
+    allInteractions = checkTestCoverage(allInteractions, testFiles);
+    // Check critical action coverage
+    for (const action of criticalActions) {
+        const routeCandidates = getRouteMatchCandidates(action.route);
+        const hasTest = testFiles.some((testFile) => {
+            if (!fs.existsSync(testFile))
+                return false;
+            const content = fs.readFileSync(testFile, "utf-8");
+            const coversRoute = routeCandidates.some((candidate) => content.includes(candidate) || content.includes(candidate.replace(/\//g, "\\/")));
+            return (coversRoute &&
+                /\.click\s*\(/.test(content) &&
+                /toHaveURL|toHaveText|toBeVisible|waitForResponse/.test(content));
+        });
+        action.hasCoverage = hasTest;
+    }
+    // Group by route
+    const routeData = groupByRoute(allInteractions);
+    // Report: Routes with no coverage
+    const noCoverage = routeData.filter((r) => r.testCoverage === 0 && r.interactions.length > 0);
+    const lowCoverage = routeData.filter((r) => r.testCoverage > 0 && r.testCoverage < 50);
+    const goodCoverage = routeData.filter((r) => r.testCoverage >= 50);
+    if (noCoverage.length > 0) {
+        console.log(`${console_chars_1.emoji.error} ROUTES WITH NO INTERACTION TEST COVERAGE`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        for (const route of noCoverage.slice(0, 20)) {
+            console.log(`\n   📍 ${route.route} (${route.interactions.length} interactions)`);
+            if (verbose) {
+                const types = new Map();
+                for (const i of route.interactions) {
+                    types.set(i.type, (types.get(i.type) || 0) + 1);
+                }
+                console.log(`      Types: ${Array.from(types.entries())
+                    .map(([t, c]) => `${t}(${c})`)
+                    .join(", ")}`);
+                const top = getTopUncoveredInteractions(route, 8);
+                if (top.length > 0) {
+                    console.log("      Missing interactions (sample):");
+                    top.forEach((i) => console.log(`        - ${formatInteractionForReport(i)}`));
+                }
+            }
+        }
+        if (noCoverage.length > 20) {
+            console.log(`\n   ... and ${noCoverage.length - 20} more routes`);
+        }
+        console.log();
+    }
+    if (lowCoverage.length > 0 && verbose) {
+        console.log(`${console_chars_1.emoji.warning}  ROUTES WITH LOW COVERAGE (<50%)`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        for (const route of lowCoverage.slice(0, 10)) {
+            console.log(`   ${console_chars_1.emoji.lightning} ${route.route} (${route.testCoverage}% coverage)`);
+            const top = getTopUncoveredInteractions(route, 6);
+            if (top.length > 0) {
+                console.log("      Missing interactions (sample):");
+                top.forEach((i) => console.log(`        - ${formatInteractionForReport(i)}`));
+            }
+        }
+        console.log();
+    }
+    if (verbose) {
+        const partial = routeData
+            .filter((r) => r.interactions.length > 0 && r.testCoverage < 100)
+            .sort((a, b) => a.testCoverage - b.testCoverage);
+        if (partial.length > 0) {
+            console.log(`${console_chars_1.emoji.info}  ROUTES WITH PARTIAL COVERAGE (<100%)`);
+            console.log((0, console_chars_1.createDivider)(60, "heavy"));
+            for (const route of partial.slice(0, 12)) {
+                console.log(`   ${console_chars_1.emoji.lightning} ${route.route} (${route.testCoverage}% coverage)`);
+                const top = getTopUncoveredInteractions(route, 6);
+                if (top.length > 0) {
+                    console.log("      Missing interactions (sample):");
+                    top.forEach((i) => console.log(`        - ${formatInteractionForReport(i)}`));
+                }
+            }
+            if (partial.length > 12) {
+                console.log(`   ${console_chars_1.chars.ellipsis} and ${partial.length - 12} more`);
+            }
+            console.log();
+        }
+    }
+    // Report: Critical actions without coverage
+    const uncoveredCritical = criticalActions.filter((a) => !a.hasCoverage);
+    const criticalBySeverity = {
+        critical: uncoveredCritical.filter((a) => a.severity === "critical"),
+        high: uncoveredCritical.filter((a) => a.severity === "high"),
+        medium: uncoveredCritical.filter((a) => a.severity === "medium"),
+    };
+    if (uncoveredCritical.length > 0) {
+        console.log(`${console_chars_1.emoji.bell} CRITICAL ACTIONS WITHOUT TEST COVERAGE`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        if (criticalBySeverity.critical.length > 0) {
+            console.log(`\n   ${console_chars_1.emoji.stop} CRITICAL (payment, checkout, refund):`);
+            for (const action of criticalBySeverity.critical.slice(0, 10)) {
+                console.log(`      - ${action.name} at ${action.route}`);
+            }
+        }
+        if (criticalBySeverity.high.length > 0) {
+            console.log(`\n   ${console_chars_1.emoji.warning} HIGH (delete, approve, reject, cancel, ship):`);
+            for (const action of criticalBySeverity.high.slice(0, 15)) {
+                console.log(`      - ${action.name} at ${action.route}`);
+            }
+            if (criticalBySeverity.high.length > 15) {
+                console.log(`      ... and ${criticalBySeverity.high.length - 15} more`);
+            }
+        }
+        if (criticalBySeverity.medium.length > 0 && verbose) {
+            console.log(`\n   ${console_chars_1.emoji.warning} MEDIUM (publish, verify):`);
+            for (const action of criticalBySeverity.medium.slice(0, 10)) {
+                console.log(`      - ${action.name} at ${action.route}`);
+            }
+        }
+        console.log();
+    }
+    // Check required routes coverage
+    console.log(`${console_chars_1.emoji.clipboard} REQUIRED ROUTES COVERAGE`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    const requiredRouteCoverage = [];
+    // Build test content index for required routes check
+    const testContents = [];
+    for (const testFile of testFiles) {
+        if (fs.existsSync(testFile)) {
+            testContents.push(fs.readFileSync(testFile, "utf-8"));
+        }
+    }
+    for (const req of REQUIRED_ROUTES) {
+        const matchingRoute = routeData.find((r) => r.route.includes(req.route) || req.route.includes(r.route));
+        // Check if any test file references this route AND has interactions + outcomes
+        const hasDirectTestCoverage = testContents.some((content) => {
+            const hasRoute = content.includes(req.route) ||
+                content.includes(`"${req.route}"`) ||
+                content.includes(`'${req.route}'`);
+            const hasInteraction = /\.click\s*\(|\.fill\s*\(/i.test(content);
+            const hasOutcome = /toHaveURL|toBeVisible|waitForResponse|getByText/i.test(content);
+            return hasRoute && hasInteraction && hasOutcome;
+        });
+        const covered = hasDirectTestCoverage || (matchingRoute ? matchingRoute.testCoverage > 0 : false);
+        const interactionCount = matchingRoute ? matchingRoute.interactions.length : 0;
+        requiredRouteCoverage.push({
+            route: req.route,
+            reason: req.reason,
+            severity: req.severity,
+            covered,
+            interactionCount,
+        });
+    }
+    const coveredRequired = requiredRouteCoverage.filter((r) => r.covered);
+    const uncoveredRequired = requiredRouteCoverage.filter((r) => !r.covered);
+    console.log(`\n${console_chars_1.emoji.success} Covered: ${coveredRequired.length}/${requiredRouteCoverage.length}`);
+    for (const r of coveredRequired) {
+        console.log(`   ${console_chars_1.emoji.success} ${r.route}`);
+    }
+    if (uncoveredRequired.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} Uncovered: ${uncoveredRequired.length}`);
+        for (const r of uncoveredRequired) {
+            const icon = r.severity === "critical"
+                ? "${emoji.stop}"
+                : r.severity === "high"
+                    ? "${emoji.warning}"
+                    : "${emoji.warning}";
+            console.log(`   ${icon} ${r.route} (${r.severity})`);
+            console.log(`      Reason: ${r.reason}`);
+        }
+    }
+    console.log();
+    // Enhancement #7: Detect and report static/orphan routes
+    const allPageRoutes = await findAllPageRoutes();
+    const routesWithInteractions = new Set(routeData.map((r) => r.route));
+    const staticRoutes = allPageRoutes.filter((r) => !routesWithInteractions.has(r));
+    const uncoveredStaticRoutes = [];
+    if (staticRoutes.length > 0) {
+        for (const route of staticRoutes) {
+            if (!checkStaticRouteCoverage(route, testFiles)) {
+                uncoveredStaticRoutes.push(route);
+            }
+        }
+        if (uncoveredStaticRoutes.length > 0) {
+            console.log(`${console_chars_1.emoji.error} STATIC/ORPHAN ROUTES WITHOUT TEST COVERAGE`);
+            console.log((0, console_chars_1.createDivider)(60, "heavy"));
+            console.log(`${console_chars_1.emoji.info} These routes have no detectable interactions but must still be visited by E2E tests.`);
+            for (const route of uncoveredStaticRoutes.slice(0, 20)) {
+                console.log(`   📍 ${route} (0 interactions)`);
+            }
+            if (uncoveredStaticRoutes.length > 20) {
+                console.log(`\n   ... and ${uncoveredStaticRoutes.length - 20} more routes`);
+            }
+            console.log();
+        }
+    }
+    // Summary
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`${console_chars_1.emoji.chart} SUMMARY`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`Total interactive elements: ${allInteractions.length}`);
+    console.log(`Routes with interactions: ${routeData.length}`);
+    console.log(`Routes with no coverage: ${noCoverage.length}`);
+    console.log(`Routes with low coverage: ${lowCoverage.length}`);
+    console.log(`Routes with good coverage: ${goodCoverage.length}`);
+    console.log(`Critical actions uncovered: ${uncoveredCritical.length} (${criticalBySeverity.critical.length} critical, ${criticalBySeverity.high.length} high)`);
+    console.log(`Required routes covered: ${coveredRequired.length}/${requiredRouteCoverage.length}`);
+    // Calculate overall score
+    const coveredInteractions = allInteractions.filter((i) => i.hasTestCoverage).length;
+    const overallCoverage = allInteractions.length > 0
+        ? Math.round((coveredInteractions / allInteractions.length) * 100)
+        : 100;
+    console.log(`\n${console_chars_1.emoji.graph} Overall interaction coverage: ${overallCoverage}%`);
+    // Write report
+    writeReport(routeData, criticalActions, overallCoverage, requiredRouteCoverage);
+    // Determine exit status
+    const errors = [];
+    const warnings = [];
+    if (criticalBySeverity.critical.length > 0) {
+        errors.push(`${criticalBySeverity.critical.length} CRITICAL actions (payment/checkout/refund) have no test coverage`);
+    }
+    // Check for uncovered required routes with high/critical severity
+    const uncoveredHighRequired = uncoveredRequired.filter((r) => r.severity === "critical" || r.severity === "high");
+    if (uncoveredHighRequired.length > 0) {
+        errors.push(`${uncoveredHighRequired.length} required HIGH/CRITICAL routes have no test coverage`);
+        for (const r of uncoveredHighRequired) {
+            errors.push(`  ${console_chars_1.chars.arrow} ${r.route}: ${r.reason}`);
+        }
+    }
+    if (criticalBySeverity.high.length > 5) {
+        warnings.push(`${criticalBySeverity.high.length} HIGH severity actions lack test coverage`);
+    }
+    if (noCoverage.length > 10) {
+        warnings.push(`${noCoverage.length} routes have zero interaction test coverage`);
+    }
+    if (overallCoverage < 30) {
+        warnings.push(`Overall interaction coverage is only ${overallCoverage}%`);
+    }
+    // Medium severity required routes
+    const uncoveredMediumRequired = uncoveredRequired.filter((r) => r.severity === "medium");
+    if (uncoveredMediumRequired.length > 0) {
+        warnings.push(`${uncoveredMediumRequired.length} required MEDIUM routes lack test coverage`);
+    }
+    if (warnings.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning}  WARNINGS:`);
+        warnings.forEach((w) => console.log(`   - ${w}`));
+    }
+    if (actionsMode && minRouteCoverage > 0) {
+        const belowMin = routeData.filter((r) => r.interactions.length > 0 && r.testCoverage < minRouteCoverage);
+        if (belowMin.length > 0) {
+            errors.push(`${belowMin.length} routes are below minimum interaction coverage of ${minRouteCoverage}% (actions mode)`);
+            for (const r of belowMin.slice(0, 10)) {
+                errors.push(`  ${console_chars_1.chars.arrow} ${r.route}: ${r.testCoverage}% (${r.interactions.length} interactions)`);
+            }
+            if (belowMin.length > 10) {
+                errors.push(`  ${console_chars_1.chars.ellipsis} and ${belowMin.length - 10} more`);
+            }
+        }
+    }
+    if (actionsMode && minOverallCoverage > 0 && overallCoverage < minOverallCoverage) {
+        errors.push(`Overall interaction coverage is ${overallCoverage}%, below minimum ${minOverallCoverage}% (actions mode)`);
+    }
+    if (errors.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} ERRORS:`);
+        errors.forEach((e) => console.log(`   - ${e}`));
+        if (mode === "block") {
+            console.log(`\n${console_chars_1.emoji.error} Interaction coverage scan FAILED`);
+            process.exit(1);
+        }
+        console.log("\nMode=warn: not blocking build.");
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.success} Interaction coverage scan PASSED`);
+    }
+    process.exit(0);
+}
+function writeReport(routeData, criticalActions, overallCoverage, requiredRouteCoverage) {
+    const reportDir = path.join(process.cwd(), "test-results");
+    if (!fs.existsSync(reportDir)) {
+        fs.mkdirSync(reportDir, { recursive: true });
+    }
+    // Enhancement #4 & #6: Include severity breakdown and suggested tests
+    const allInteractions = routeData.flatMap((r) => r.interactions);
+    const uncoveredBySeverity = {
+        critical: allInteractions.filter((i) => !i.hasTestCoverage && i.severity === "critical"),
+        high: allInteractions.filter((i) => !i.hasTestCoverage && i.severity === "high"),
+        medium: allInteractions.filter((i) => !i.hasTestCoverage && i.severity === "medium"),
+        low: allInteractions.filter((i) => !i.hasTestCoverage && i.severity === "low"),
+    };
+    // Enhancement #5: Count shared component usage
+    const sharedComponentCount = allInteractions.filter((i) => i.isSharedComponent).length;
+    const uncoveredSharedComponents = allInteractions.filter((i) => !i.hasTestCoverage && i.isSharedComponent);
+    const report = {
+        timestamp: new Date().toISOString(),
+        overallCoverage,
+        summary: {
+            totalRoutes: routeData.length,
+            routesWithNoCoverage: routeData.filter((r) => r.testCoverage === 0).length,
+            routesWithLowCoverage: routeData.filter((r) => r.testCoverage > 0 && r.testCoverage < 50)
+                .length,
+            routesWithGoodCoverage: routeData.filter((r) => r.testCoverage >= 50).length,
+            criticalActionsUncovered: criticalActions.filter((a) => !a.hasCoverage).length,
+            requiredRoutesCovered: requiredRouteCoverage.filter((r) => r.covered).length,
+            requiredRoutesTotal: requiredRouteCoverage.length,
+            // Enhancement #4: Severity breakdown
+            uncoveredBySeverity: {
+                critical: uncoveredBySeverity.critical.length,
+                high: uncoveredBySeverity.high.length,
+                medium: uncoveredBySeverity.medium.length,
+                low: uncoveredBySeverity.low.length,
+            },
+            // Enhancement #5: Shared component stats
+            sharedComponentsTotal: sharedComponentCount,
+            sharedComponentsUncovered: uncoveredSharedComponents.length,
+        },
+        requiredRoutes: requiredRouteCoverage,
+        // Enhancement #4: Critical uncovered interactions with suggested tests
+        criticalUncovered: uncoveredBySeverity.critical.slice(0, 20).map((i) => ({
+            route: i.route,
+            type: i.type,
+            name: i.name,
+            selectorType: i.selectorType ?? null,
+            selectorValue: i.selectorValue ?? null,
+            file: i.file.replace(process.cwd() + path.sep, ""),
+            line: i.line,
+            suggestedTest: i.suggestedTest ?? null,
+        })),
+        highUncovered: uncoveredBySeverity.high.slice(0, 30).map((i) => ({
+            route: i.route,
+            type: i.type,
+            name: i.name,
+            selectorType: i.selectorType ?? null,
+            selectorValue: i.selectorValue ?? null,
+            file: i.file.replace(process.cwd() + path.sep, ""),
+            line: i.line,
+            suggestedTest: i.suggestedTest ?? null,
+        })),
+        lowCoverageRoutes: routeData
+            .filter((r) => r.testCoverage > 0 && r.testCoverage < 50)
+            .slice(0, 25)
+            .map((r) => ({
+            route: r.route,
+            testCoverage: r.testCoverage,
+            interactionCount: r.interactions.length,
+            missingSample: getTopUncoveredInteractions(r, 12).map((i) => ({
+                type: i.type,
+                name: i.name,
+                severity: i.severity ?? null,
+                selectorType: i.selectorType ?? null,
+                selectorValue: i.selectorValue ?? null,
+                file: i.file,
+                line: i.line,
+                suggestedTest: i.suggestedTest ?? null,
+            })),
+        })),
+        uncoveredRoutes: routeData
+            .filter((r) => r.testCoverage === 0)
+            .map((r) => ({
+            route: r.route,
+            interactionCount: r.interactions.length,
+            types: [...new Set(r.interactions.map((i) => i.type))],
+            missingSample: getTopUncoveredInteractions(r, 12).map((i) => ({
+                type: i.type,
+                name: i.name,
+                severity: i.severity ?? null,
+                selectorType: i.selectorType ?? null,
+                selectorValue: i.selectorValue ?? null,
+                file: i.file,
+                line: i.line,
+                suggestedTest: i.suggestedTest ?? null,
+            })),
+        })),
+        uncoveredCriticalActions: criticalActions
+            .filter((a) => !a.hasCoverage)
+            .map((a) => ({
+            route: a.route,
+            action: a.name,
+            severity: a.severity,
+        })),
+        // Enhancement #5: Uncovered shared components
+        uncoveredSharedComponents: uncoveredSharedComponents.slice(0, 20).map((i) => ({
+            route: i.route,
+            type: i.type,
+            name: i.name,
+            file: i.file.replace(process.cwd() + path.sep, ""),
+            line: i.line,
+            suggestedTest: i.suggestedTest ?? null,
+        })),
+    };
+    fs.writeFileSync(path.join(reportDir, "e2e-interaction-scan-report.json"), JSON.stringify(report, null, 2));
+}
+// Enhancement #7: Find all page routes to detect static pages with no interactions
+async function findAllPageRoutes() {
+    const pageFiles = await file_cache_1.fileCache.getPageFiles();
+    return pageFiles.map((file) => extractRouteFromFile(file)).sort();
+}
+/**
+ * Enhancement #7: Check coverage for static routes
+ * A static route is covered if a test navigates to it or checks its URL.
+ */
+function checkStaticRouteCoverage(route, testFiles) {
+    // Build test content index (lazy loaded ideally, but for now we read all)
+    const routeCandidates = getRouteMatchCandidates(route);
+    for (const testFile of testFiles) {
+        if (!fs.existsSync(testFile))
+            continue;
+        const content = fs.readFileSync(testFile, "utf-8");
+        // Check if test interacts with this route
+        const hasRoute = routeCandidates.some((candidate) => content.includes(candidate) || content.includes(candidate.replace(/\//g, "\\/")));
+        if (hasRoute) {
+            // For static pages, essentially just visiting or asserting URL is enough
+            return /\.goto\s*\(/.test(content) || /toHaveURL/.test(content);
+        }
+    }
+    return false;
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch(console.error);
+}
+//# sourceMappingURL=e2e-interaction-coverage-scan.js.map