@empline/preflight 1.1.0

package/dist/checks/e2e/e2e-interaction-regression.js

@@ -0,0 +1,1042 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * E2E Interaction Regression Preflight
+ *
+ * Ensures that E2E tests actually verify interactive functionality works:
+ * - Buttons can be clicked and produce expected outcomes
+ * - Forms can be submitted and validation works
+ * - Navigation actions complete successfully
+ * - State changes are verified after interactions
+ *
+ * This catches the gap where tests "visit" pages but don't verify functionality.
+ */
+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-regression";
+exports.name = "E2e Interaction Regression";
+exports.category = "e2e";
+exports.blocking = false;
+exports.description = "E2E Interaction Regression Preflight";
+exports.tags = ["e2e", "testing"];
+// Critical user flows that MUST have interaction + outcome verification
+const CRITICAL_FLOWS = [
+    {
+        name: "Checkout Submit",
+        route: "/checkout",
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:submit|place.?order|pay|complete|continue|proceed)/i,
+            /\.fill\s*\([^)]*(?:shipping|address|card|zip|city|name|email)/i,
+        ],
+        outcomePatterns: [
+            /toHaveURL\s*\([^)]*(?:confirm|success|thank|payment)/i,
+            /getByText\s*\([^)]*(?:order|confirm|success|thank)/i,
+            /waitForResponse/i,
+            /expect\.poll/i,
+        ],
+        severity: "critical",
+    },
+    {
+        name: "Login Flow",
+        route: "/login",
+        interactionPatterns: [
+            /\.fill\s*\([^)]*(?:email|password)/i,
+            /\.click\s*\([^)]*(?:sign.?in|login|submit)/i,
+        ],
+        outcomePatterns: [
+            /toHaveURL\s*\(\s*(?!.*login)/i,
+            /getByText\s*\([^)]*(?:dashboard|welcome|account)/i,
+        ],
+        severity: "high",
+    },
+    {
+        name: "Registration Flow",
+        route: "/register",
+        interactionPatterns: [
+            /\.fill\s*\([^)]*(?:email|password|name)/i,
+            /\.click\s*\([^)]*(?:create|register|sign.?up|submit)/i,
+        ],
+        outcomePatterns: [
+            /toHaveURL\s*\(\s*(?!.*register)/i,
+            /getByText\s*\([^)]*(?:welcome|verify|success|check.?email)/i,
+        ],
+        severity: "high",
+    },
+    {
+        name: "Listing Creation",
+        route: "/store/listings",
+        interactionPatterns: [
+            /setInputFiles/i,
+            /\.click\s*\([^)]*(?:submit|approve|create|identify|upload)/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:success|submitted|created|approved)/i,
+            /toHaveURL\s*\([^)]*listing/i,
+        ],
+        severity: "high",
+    },
+    {
+        name: "Add to Cart",
+        route: "/product",
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:add.?to.?cart|buy|purchase|cart)/i,
+            /addToCartButton/i,
+            /data-testid.*add-to-cart/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:added|cart|item)/i,
+            /toHaveURL\s*\([^)]*cart/i,
+            /localStorage.*cart/i,
+            /cartBadge/i,
+            /cart-badge/i,
+            /not\.toHaveText.*0/i,
+        ],
+        severity: "high",
+    },
+    {
+        name: "Contact Form Submit",
+        route: "/contact",
+        interactionPatterns: [
+            /\.fill\s*\([^)]*(?:name|email|message|subject)/i,
+            /\.click\s*\([^)]*(?:send|submit)/i,
+            /getByLabel.*fill/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:sent|success|thank)/i,
+            /waitForRequest\s*\([^)]*contact/i,
+            /waitForResponse/i,
+            /contactRequests/i,
+            /expect\.poll/i,
+        ],
+        severity: "medium",
+    },
+    {
+        name: "Seller Dashboard Navigation",
+        route: "/store",
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:listing|order|setting|dashboard|nav)/i,
+            /listingsNav.*click/i,
+            /ordersNav.*click/i,
+            /settingsNav.*click/i,
+        ],
+        outcomePatterns: [
+            /toHaveURL\s*\([^)]*store/i,
+            /toContainText\s*\([^)]*(?:listing|order|setting)/i,
+            /getByRole.*heading/i,
+        ],
+        severity: "medium",
+    },
+    {
+        name: "Admin Approval Flow",
+        route: "/admin",
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:approve|reject|review)/i,
+            /approveButton.*click/i,
+            /rejectButton.*click/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:approved|rejected|success)/i,
+            /toHaveURL/i,
+            /approveRequestReceived|rejectRequestReceived/i,
+            /expect\.poll/i,
+        ],
+        severity: "high",
+    },
+];
+// REQUIRED critical actions - these MUST have test coverage or build fails
+const REQUIRED_CRITICAL_ACTIONS = [
+    // Ship actions (7x in /store/orders)
+    {
+        name: "Order Ship Action",
+        route: "/store/orders",
+        actionPatterns: [/handleShip|shipOrder|markShipped|markAsShipped|ship.*order/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:ship|mark.*shipped|fulfill)/i,
+            /shipButton/i,
+            /ship-button/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:shipped|fulfilled|tracking)/i,
+            /waitForResponse/i,
+            /toHaveText.*shipped/i,
+            /toBeVisible.*shipped/i,
+        ],
+        severity: "high",
+        count: 7,
+    },
+    // Approve actions (11x in /admin/listings, /store/listings/new)
+    {
+        name: "Listing Approve Action",
+        route: "/admin/listings",
+        actionPatterns: [/handleApprove|onApprove|approveItem|approveListing/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:approve|accept)/i,
+            /approveButton/i,
+            /approve-button/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:approved|success)/i,
+            /waitForResponse/i,
+            /toHaveText.*approved/i,
+            /toBeVisible.*approved/i,
+        ],
+        severity: "high",
+        count: 11,
+    },
+    // Delete actions (6x in /admin/listings, /admin/templates)
+    {
+        name: "Admin Delete Action",
+        route: "/admin",
+        actionPatterns: [/handleDelete|onDelete|deleteItem|deleteListing|deleteTemplate/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:delete|remove|trash)/i,
+            /deleteButton/i,
+            /delete-button/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:deleted|removed|success)/i,
+            /waitForResponse/i,
+            /not\.toBeVisible/i,
+            /toBeVisible.*deleted/i,
+        ],
+        severity: "high",
+        count: 6,
+    },
+    // Cancel actions (2x in /store/billing)
+    {
+        name: "Subscription Cancel Action",
+        route: "/store/billing",
+        actionPatterns: [/handleCancel|cancelSubscription|cancelPlan/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:cancel|unsubscribe)/i,
+            /cancelButton/i,
+            /cancel-subscription/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:cancelled|canceled|success)/i,
+            /waitForResponse/i,
+            /toBeVisible.*cancel/i,
+        ],
+        severity: "high",
+        count: 2,
+    },
+    // Reject actions (2x in /store/listings/new)
+    {
+        name: "Listing Reject Action",
+        route: "/store/listings",
+        actionPatterns: [/handleReject|onReject|rejectItem|rejectListing/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:reject|decline)/i,
+            /rejectButton/i,
+            /reject-button/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:rejected|declined)/i,
+            /waitForResponse/i,
+            /toBeVisible.*rejected/i,
+        ],
+        severity: "high",
+        count: 2,
+    },
+    // Publish actions (2x in /admin/listings)
+    {
+        name: "Listing Publish Action",
+        route: "/admin/listings",
+        actionPatterns: [/handlePublish|publishListing|publishItem/gi],
+        interactionPatterns: [
+            /\.click\s*\([^)]*(?:publish|go.*live)/i,
+            /publishButton/i,
+            /publish-button/i,
+        ],
+        outcomePatterns: [
+            /getByText\s*\([^)]*(?:published|live|active)/i,
+            /waitForResponse/i,
+            /toBeVisible.*publish/i,
+        ],
+        severity: "medium",
+        count: 2,
+    },
+    // Footer link navigation
+    {
+        name: "Footer Navigation Links",
+        route: "/",
+        actionPatterns: [/FooterLink|footer.*href|footer.*link/gi],
+        interactionPatterns: [/\.click\s*\([^)]*(?:footer|link)/i, /locator\s*\([^)]*footer/i],
+        outcomePatterns: [/toHaveURL/i, /toBeVisible/i],
+        severity: "low",
+        count: 1,
+    },
+];
+function getModeFromArgsOrEnv() {
+    const rawEnv = (process.env.PREFLIGHT_INTERACTION_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 === "warn" ? "warn" : "block";
+}
+function isVerbose() {
+    return process.argv.includes("--verbose");
+}
+// Patterns that indicate real user interactions
+const INTERACTION_PATTERNS = [
+    /\.click\s*\(/g,
+    /\.fill\s*\(/g,
+    /\.type\s*\(/g,
+    /\.press\s*\(/g,
+    /\.check\s*\(/g,
+    /\.uncheck\s*\(/g,
+    /\.selectOption\s*\(/g,
+    /\.setInputFiles\s*\(/g,
+    /\.dblclick\s*\(/g,
+    /\.hover\s*\(/g,
+    /smartClick\s*\(/g,
+    /smartFill\s*\(/g,
+];
+// Patterns that indicate outcome verification (not just visibility)
+const OUTCOME_ASSERTION_PATTERNS = [
+    /toHaveURL\s*\(/g, // Navigation completed
+    /toHaveTitle\s*\(/g, // Page changed
+    /toHaveValue\s*\(/g, // Input state changed
+    /toHaveText\s*\(/g, // Content changed
+    /toContainText\s*\(/g, // Content appeared
+    /getByText\s*\([^)]+\)\.toBeVisible/g, // Specific text appeared
+    /getByRole\s*\([^)]+\)\.toBeVisible/g, // Element appeared after action
+    /waitForResponse\s*\(/g, // API call completed
+    /waitForRequest\s*\(/g, // Request was made
+    /waitForURL\s*\(/g, // Navigation happened
+    /expect\.poll\s*\(/g, // State polling
+    /toHaveCount\s*\(/g, // List changed
+    /toBeEnabled\s*\(/g, // State changed
+    /toBeDisabled\s*\(/g, // State changed
+    /toBeChecked\s*\(/g, // Checkbox state
+    /localStorage|sessionStorage/g, // Storage verification
+    /not\.toBeVisible\s*\(/g, // Element disappeared
+    /toBeHidden\s*\(/g, // Element hidden
+    /toHaveAttribute\s*\(/g, // Attribute changed
+    /toHaveClass\s*\(/g, // Class changed
+    /toHaveCSS\s*\(/g, // Style changed
+];
+// Weak assertions that don't verify functionality
+const WEAK_ASSERTION_PATTERNS = [
+    /locator\s*\(\s*["']body["']\s*\).*toBeVisible/g,
+    /toBeVisible\s*\(\s*\)\s*;?\s*$/gm, // Just visibility, no context
+];
+// Critical action keywords that MUST have outcome verification
+const CRITICAL_ACTION_KEYWORDS = [
+    {
+        keyword: /delete|remove|trash/i,
+        requiredOutcome: /not\.toBeVisible|toBeHidden|toHaveCount\s*\(\s*0|removed|deleted/i,
+    },
+    {
+        keyword: /submit|save|confirm/i,
+        requiredOutcome: /waitForResponse|toHaveURL|success|saved|submitted/i,
+    },
+    { keyword: /approve|reject/i, requiredOutcome: /waitForResponse|approved|rejected|toHaveText/i },
+    { keyword: /add.*cart|buy|purchase/i, requiredOutcome: /cart|added|toHaveText|localStorage/i },
+    {
+        keyword: /checkout|place.*order|pay/i,
+        requiredOutcome: /toHaveURL|confirmation|success|thank/i,
+    },
+    { keyword: /ship|fulfill/i, requiredOutcome: /shipped|tracking|waitForResponse/i },
+    { keyword: /cancel/i, requiredOutcome: /cancelled|canceled|toHaveURL|closed/i },
+    { keyword: /refund/i, requiredOutcome: /refunded|waitForResponse|success/i },
+    {
+        keyword: /toggle|switch/i,
+        requiredOutcome: /toBeChecked|not\.toBeChecked|toHaveAttribute|aria-pressed/i,
+    },
+];
+/**
+ * Detailed per-click outcome analysis
+ * Ensures every click has a corresponding outcome verification
+ */
+function analyzeClickOutcomes(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const issues = [];
+    const relPath = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        // Find click actions
+        const clickMatch = line.match(/\.(click|check|uncheck|selectOption)\s*\(/);
+        if (!clickMatch)
+            continue;
+        // Get context around the click (what's being clicked)
+        const clickContext = line.trim();
+        // Look ahead for outcome verification (within 8 lines or until test block ends)
+        const lookAheadLines = lines.slice(i + 1, Math.min(i + 9, lines.length));
+        const lookAhead = lookAheadLines.join("\n");
+        // Check if test block ends before any assertion
+        const testEndIndex = lookAhead.search(/\}\s*\)\s*;|\}\s*\);/);
+        const contextToCheck = testEndIndex > 0 ? lookAhead.slice(0, testEndIndex) : lookAhead;
+        // Check for any outcome assertion (use fresh regex without global flag)
+        const outcomePatterns = [
+            /toHaveURL\s*\(/,
+            /toHaveTitle\s*\(/,
+            /toHaveValue\s*\(/,
+            /toHaveText\s*\(/,
+            /toContainText\s*\(/,
+            /getByText\s*\([^)]+\)\.toBeVisible/,
+            /getByRole\s*\([^)]+\)\.toBeVisible/,
+            /waitForResponse\s*\(/,
+            /waitForRequest\s*\(/,
+            /waitForURL\s*\(/,
+            /expect\.poll\s*\(/,
+            /toHaveCount\s*\(/,
+            /toBeEnabled\s*\(/,
+            /toBeDisabled\s*\(/,
+            /toBeChecked\s*\(/,
+            /localStorage|sessionStorage/,
+            /not\.toBeVisible\s*\(/,
+            /toBeHidden\s*\(/,
+            /toHaveAttribute\s*\(/,
+        ];
+        const hasOutcome = outcomePatterns.some((p) => p.test(contextToCheck));
+        // Check for weak-only assertions
+        const hasOnlyWeakAssertion = !hasOutcome && /toBeVisible\s*\(\s*\)/.test(contextToCheck);
+        if (!hasOutcome) {
+            // Determine severity based on what's being clicked
+            let severity = "medium";
+            let suggestedOutcome = "await expect(element).toBeVisible(); // Add specific outcome";
+            for (const { keyword, requiredOutcome } of CRITICAL_ACTION_KEYWORDS) {
+                if (keyword.test(clickContext)) {
+                    severity = /delete|checkout|pay|refund/i.test(clickContext) ? "critical" : "high";
+                    const outcomeExample = requiredOutcome.source.split("|")[0].replace(/\\/g, "");
+                    suggestedOutcome = `await expect(...).${outcomeExample}(...);`;
+                    break;
+                }
+            }
+            // Skip if it's just a navigation click followed by goto
+            if (/\.goto\s*\(/.test(contextToCheck))
+                continue;
+            // Skip hover actions (they often don't need outcome)
+            if (clickMatch[1] === "hover")
+                continue;
+            issues.push({
+                file: relPath,
+                line: lineNum,
+                clickText: clickContext.slice(0, 80),
+                issue: hasOnlyWeakAssertion
+                    ? "Click has only weak visibility assertion (no functional verification)"
+                    : "Click without outcome verification",
+                severity,
+                suggestedOutcome,
+            });
+        }
+    }
+    return issues;
+}
+function analyzeTestFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    let interactions = 0;
+    let outcomeAssertions = 0;
+    const issues = [];
+    // Count interactions
+    for (const pattern of INTERACTION_PATTERNS) {
+        const matches = content.match(pattern);
+        if (matches)
+            interactions += matches.length;
+    }
+    // Count outcome assertions
+    for (const pattern of OUTCOME_ASSERTION_PATTERNS) {
+        const matches = content.match(pattern);
+        if (matches)
+            outcomeAssertions += matches.length;
+    }
+    // Subtract weak assertions
+    for (const pattern of WEAK_ASSERTION_PATTERNS) {
+        const matches = content.match(pattern);
+        if (matches)
+            outcomeAssertions -= matches.length;
+    }
+    outcomeAssertions = Math.max(0, outcomeAssertions);
+    // Calculate score: interactions should have corresponding outcome checks
+    const ratio = interactions > 0 ? outcomeAssertions / interactions : 0;
+    const score = Math.min(100, Math.round(ratio * 100));
+    // Identify issues
+    if (interactions === 0) {
+        issues.push("No user interactions found (clicks, fills, etc.)");
+    }
+    if (interactions > 0 && outcomeAssertions === 0) {
+        issues.push("Has interactions but no outcome verification");
+    }
+    if (interactions > 5 && ratio < 0.3) {
+        issues.push(`Low outcome coverage: ${outcomeAssertions} outcomes for ${interactions} interactions`);
+    }
+    // Check for click-without-assertion pattern
+    const clickWithoutAssert = content.match(/\.click\s*\([^)]+\)\s*;\s*\n\s*\}\s*\)/g);
+    if (clickWithoutAssert && clickWithoutAssert.length > 0) {
+        issues.push("Click actions at end of test without outcome verification");
+    }
+    return {
+        file: filePath,
+        interactions,
+        outcomeAssertions,
+        score,
+        issues,
+        hasOutcomeVerification: outcomeAssertions > 0,
+    };
+}
+function checkCriticalFlowCoverage(testFiles) {
+    const results = [];
+    for (const flow of CRITICAL_FLOWS) {
+        const coverage = {
+            name: flow.name,
+            route: flow.route,
+            covered: false,
+            hasInteraction: false,
+            hasOutcome: false,
+            coveringTests: [],
+            severity: flow.severity,
+        };
+        for (const testFile of testFiles) {
+            const content = fs.readFileSync(testFile, "utf-8");
+            // Check if test covers this route
+            if (!content.includes(flow.route))
+                continue;
+            // Check for required interactions
+            const hasInteraction = flow.interactionPatterns.some((p) => p.test(content));
+            // Check for outcome verification
+            const hasOutcome = flow.outcomePatterns.some((p) => p.test(content));
+            if (hasInteraction || hasOutcome) {
+                coverage.coveringTests.push(path.relative(process.cwd(), testFile));
+            }
+            if (hasInteraction)
+                coverage.hasInteraction = true;
+            if (hasOutcome)
+                coverage.hasOutcome = true;
+        }
+        coverage.covered = coverage.hasInteraction && coverage.hasOutcome;
+        results.push(coverage);
+    }
+    return results;
+}
+function checkCriticalActionCoverage(testFiles) {
+    const results = [];
+    for (const action of REQUIRED_CRITICAL_ACTIONS) {
+        const coverage = {
+            name: action.name,
+            route: action.route,
+            covered: false,
+            hasInteraction: false,
+            hasOutcome: false,
+            coveringTests: [],
+            severity: action.severity,
+            expectedCount: action.count,
+        };
+        for (const testFile of testFiles) {
+            const content = fs.readFileSync(testFile, "utf-8");
+            // Check if test covers this route (or related routes)
+            const routeMatch = content.includes(action.route) ||
+                content.toLowerCase().includes(action.route.toLowerCase());
+            if (!routeMatch)
+                continue;
+            // Check for required interactions
+            const hasInteraction = action.interactionPatterns.some((p) => p.test(content));
+            // Check for outcome verification
+            const hasOutcome = action.outcomePatterns.some((p) => p.test(content));
+            if (hasInteraction || hasOutcome) {
+                coverage.coveringTests.push(path.relative(process.cwd(), testFile));
+            }
+            if (hasInteraction)
+                coverage.hasInteraction = true;
+            if (hasOutcome)
+                coverage.hasOutcome = true;
+        }
+        coverage.covered = coverage.hasInteraction && coverage.hasOutcome;
+        results.push(coverage);
+    }
+    return results;
+}
+// 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 run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    const mode = getModeFromArgsOrEnv();
+    const verbose = isVerbose();
+    const strictOutcomes = process.argv.includes("--strict-outcomes");
+    console.log(`\n${console_chars_1.emoji.target} E2E INTERACTION REGRESSION ANALYSIS`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`Mode: ${mode} | Verbose: ${verbose} | Strict Outcomes: ${strictOutcomes}`);
+    console.log("Checking that tests verify functionality actually works...\n");
+    // Find all E2E test files
+    const testFiles = await getE2ESpecFiles();
+    // Exclude utility files
+    const specFiles = testFiles.filter((f) => !f.includes("/utils/") && !f.includes("setup") && !f.includes("fixture"));
+    console.log(`📂 Analyzing ${specFiles.length} test files...\n`);
+    // Analyze each test file
+    const analyses = [];
+    for (const file of specFiles) {
+        const analysis = analyzeTestFile(file);
+        analyses.push(analysis);
+    }
+    // NEW: Per-click outcome analysis
+    const allClickIssues = [];
+    if (strictOutcomes || verbose) {
+        for (const file of specFiles) {
+            const clickIssues = analyzeClickOutcomes(file);
+            allClickIssues.push(...clickIssues);
+        }
+    }
+    // Categorize results
+    const noInteractions = analyses.filter((a) => a.interactions === 0);
+    const noOutcomes = analyses.filter((a) => a.interactions > 0 && a.outcomeAssertions === 0);
+    const lowCoverage = analyses.filter((a) => a.score > 0 && a.score < 30 && a.interactions > 3);
+    const goodCoverage = analyses.filter((a) => a.score >= 50);
+    // Report: Tests with no interactions (just page visits)
+    if (noInteractions.length > 0) {
+        console.log(`${console_chars_1.emoji.warning}  TESTS WITH NO USER INTERACTIONS`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log("These tests only visit pages without clicking/filling anything:\n");
+        for (const a of noInteractions.slice(0, 10)) {
+            const relPath = path.relative(process.cwd(), a.file).replace(/\\/g, "/");
+            console.log(`   ${console_chars_1.emoji.file} ${relPath}`);
+        }
+        if (noInteractions.length > 10) {
+            console.log(`   ... and ${noInteractions.length - 10} more`);
+        }
+        console.log();
+    }
+    // Report: Tests with interactions but no outcome verification
+    if (noOutcomes.length > 0) {
+        console.log(`${console_chars_1.emoji.bell} TESTS WITH INTERACTIONS BUT NO OUTCOME VERIFICATION`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log("These tests click/fill but don't verify the action worked:\n");
+        for (const a of noOutcomes.slice(0, 15)) {
+            const relPath = path.relative(process.cwd(), a.file).replace(/\\/g, "/");
+            console.log(`   ${console_chars_1.emoji.error} ${relPath}`);
+            console.log(`      ${a.interactions} interactions, 0 outcome assertions`);
+            if (verbose && a.issues.length > 0) {
+                a.issues.forEach((i) => console.log(`      ${console_chars_1.chars.arrow} ${i}`));
+            }
+        }
+        if (noOutcomes.length > 15) {
+            console.log(`   ... and ${noOutcomes.length - 15} more`);
+        }
+        console.log();
+    }
+    // Report: Low coverage tests
+    if (lowCoverage.length > 0 && verbose) {
+        console.log(`${console_chars_1.emoji.lightning} TESTS WITH LOW OUTCOME COVERAGE`);
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        for (const a of lowCoverage.slice(0, 10)) {
+            const relPath = path.relative(process.cwd(), a.file).replace(/\\/g, "/");
+            console.log(`   ${console_chars_1.emoji.lightning} ${relPath} (score: ${a.score}%)`);
+            console.log(`      ${a.interactions} interactions, ${a.outcomeAssertions} outcomes`);
+        }
+        console.log();
+    }
+    // Critical Flow Coverage
+    console.log(`${console_chars_1.emoji.target} CRITICAL FLOW COVERAGE`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    const flowCoverage = checkCriticalFlowCoverage(specFiles);
+    const uncoveredFlows = flowCoverage.filter((f) => !f.covered);
+    const partialFlows = flowCoverage.filter((f) => !f.covered && (f.hasInteraction || f.hasOutcome));
+    const coveredFlows = flowCoverage.filter((f) => f.covered);
+    console.log(`\n${console_chars_1.emoji.success} Fully Covered: ${coveredFlows.length}/${flowCoverage.length}`);
+    for (const f of coveredFlows) {
+        console.log(`   ${console_chars_1.emoji.success} ${f.name} (${f.route})`);
+        if (verbose && f.coveringTests.length > 0) {
+            console.log(`      Tests: ${f.coveringTests.slice(0, 2).join(", ")}`);
+        }
+    }
+    if (partialFlows.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning}  Partial Coverage: ${partialFlows.length}`);
+        for (const f of partialFlows) {
+            const missing = [];
+            if (!f.hasInteraction)
+                missing.push("interactions");
+            if (!f.hasOutcome)
+                missing.push("outcome verification");
+            console.log(`   ${console_chars_1.emoji.warning}  ${f.name} (${f.route}) - missing: ${missing.join(", ")}`);
+            if (f.coveringTests.length > 0) {
+                console.log(`      Tests: ${f.coveringTests.slice(0, 2).join(", ")}`);
+            }
+        }
+    }
+    const missingFlows = flowCoverage.filter((f) => !f.hasInteraction && !f.hasOutcome);
+    if (missingFlows.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} No Coverage: ${missingFlows.length}`);
+        for (const f of missingFlows) {
+            console.log(`   ${console_chars_1.emoji.error} ${f.name} (${f.route})`);
+        }
+    }
+    // REQUIRED Critical Action Coverage
+    console.log(`\n\n${console_chars_1.emoji.bell} REQUIRED CRITICAL ACTION COVERAGE`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log("These actions MUST have test coverage or build will fail:\n");
+    const actionCoverage = checkCriticalActionCoverage(specFiles);
+    const coveredActions = actionCoverage.filter((a) => a.covered);
+    const uncoveredActions = actionCoverage.filter((a) => !a.covered);
+    const highSeverityUncovered = uncoveredActions.filter((a) => a.severity === "critical" || a.severity === "high");
+    // Group by severity
+    const bySeverity = {
+        critical: actionCoverage.filter((a) => a.severity === "critical"),
+        high: actionCoverage.filter((a) => a.severity === "high"),
+        medium: actionCoverage.filter((a) => a.severity === "medium"),
+        low: actionCoverage.filter((a) => a.severity === "low"),
+    };
+    for (const [severity, actions] of Object.entries(bySeverity)) {
+        if (actions.length === 0)
+            continue;
+        const icon = severity === "critical"
+            ? "${emoji.stop}"
+            : severity === "high"
+                ? "${emoji.warning}"
+                : severity === "medium"
+                    ? "${emoji.warning}"
+                    : "${emoji.info}";
+        const covered = actions.filter((a) => a.covered).length;
+        console.log(`${icon} ${severity.toUpperCase()} (${covered}/${actions.length} covered):`);
+        for (const action of actions) {
+            const status = action.covered ? `${console_chars_1.emoji.success}` : `${console_chars_1.emoji.error}`;
+            const details = [];
+            if (!action.hasInteraction)
+                details.push("no interaction");
+            if (!action.hasOutcome)
+                details.push("no outcome check");
+            console.log(`   ${status} ${action.name} (${action.route}) [${action.expectedCount}x]`);
+            if (!action.covered && details.length > 0) {
+                console.log(`      Missing: ${details.join(", ")}`);
+            }
+            if (verbose && action.coveringTests.length > 0) {
+                console.log(`      Tests: ${action.coveringTests.slice(0, 2).join(", ")}`);
+            }
+        }
+        console.log();
+    }
+    // Generate actionable fix suggestions
+    console.log(`\n${console_chars_1.emoji.wrench} SUGGESTED FIXES`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    for (const flow of partialFlows) {
+        console.log(`\n${console_chars_1.emoji.memo} ${flow.name} (${flow.route}):`);
+        if (!flow.hasInteraction) {
+            console.log(`   Add interactions like:`);
+            const suggestions = getInteractionSuggestions(flow.name);
+            suggestions.forEach((s) => console.log(`     - ${s}`));
+        }
+        if (!flow.hasOutcome) {
+            console.log(`   Add outcome verification like:`);
+            const suggestions = getOutcomeSuggestions(flow.name);
+            suggestions.forEach((s) => console.log(`     - ${s}`));
+        }
+    }
+    // Suggestions for uncovered critical actions
+    for (const action of uncoveredActions) {
+        console.log(`\n${console_chars_1.emoji.memo} ${action.name} (${action.route}):`);
+        const suggestions = getCriticalActionSuggestions(action.name);
+        suggestions.forEach((s) => console.log(`   - ${s}`));
+    }
+    // Summary
+    console.log("\n" + (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 test files: ${specFiles.length}`);
+    console.log(`Tests with good coverage (≥50%): ${goodCoverage.length}`);
+    console.log(`Tests with no interactions: ${noInteractions.length}`);
+    console.log(`Tests with no outcome verification: ${noOutcomes.length}`);
+    console.log(`Critical flows covered: ${coveredFlows.length}/${flowCoverage.length}`);
+    console.log(`Required actions covered: ${coveredActions.length}/${actionCoverage.length}`);
+    console.log(`High severity uncovered: ${highSeverityUncovered.length}`);
+    // NEW: Click outcome analysis results
+    if (allClickIssues.length > 0) {
+        const criticalClicks = allClickIssues.filter((i) => i.severity === "critical");
+        const highClicks = allClickIssues.filter((i) => i.severity === "high");
+        console.log(`\n${console_chars_1.emoji.bell} PER-CLICK OUTCOME ANALYSIS`);
+        console.log((0, console_chars_1.createDivider)(60, "light"));
+        console.log(`Clicks without outcome verification: ${allClickIssues.length}`);
+        console.log(`  ${console_chars_1.emoji.stop} Critical: ${criticalClicks.length}`);
+        console.log(`  ${console_chars_1.emoji.warning} High: ${highClicks.length}`);
+        if (verbose || strictOutcomes) {
+            if (criticalClicks.length > 0) {
+                console.log(`\n${console_chars_1.emoji.stop} CRITICAL CLICKS WITHOUT OUTCOMES:`);
+                criticalClicks.slice(0, 15).forEach((i) => {
+                    console.log(`   ${i.file}:${i.line}`);
+                    console.log(`      ${i.clickText}`);
+                    console.log(`      Fix: ${i.suggestedOutcome}`);
+                });
+                if (criticalClicks.length > 15) {
+                    console.log(`   ... and ${criticalClicks.length - 15} more`);
+                }
+            }
+            if (highClicks.length > 0 && verbose) {
+                console.log(`\n${console_chars_1.emoji.warning} HIGH PRIORITY CLICKS WITHOUT OUTCOMES:`);
+                highClicks.slice(0, 10).forEach((i) => {
+                    console.log(`   ${i.file}:${i.line}`);
+                    console.log(`      ${i.clickText}`);
+                });
+                if (highClicks.length > 10) {
+                    console.log(`   ... and ${highClicks.length - 10} more`);
+                }
+            }
+        }
+    }
+    // Determine exit status
+    const errors = [];
+    const warnings = [];
+    // Critical: flows without any coverage
+    if (missingFlows.length > 0) {
+        errors.push(`${missingFlows.length} critical flow(s) have no interaction regression tests`);
+    }
+    // Critical: high severity actions without coverage (BLOCKS BUILD)
+    if (highSeverityUncovered.length > 0) {
+        errors.push(`${highSeverityUncovered.length} HIGH/CRITICAL severity action(s) have no test coverage`);
+        for (const action of highSeverityUncovered) {
+            errors.push(`  ${console_chars_1.chars.arrow} ${action.name} (${action.route})`);
+        }
+    }
+    // NEW: Critical clicks without outcomes (in strict mode)
+    if (strictOutcomes && allClickIssues.length > 0) {
+        const criticalClicks = allClickIssues.filter((i) => i.severity === "critical");
+        if (criticalClicks.length > 0) {
+            errors.push(`${criticalClicks.length} CRITICAL click(s) have no outcome verification`);
+            criticalClicks.slice(0, 5).forEach((i) => {
+                errors.push(`  ${console_chars_1.chars.arrow} ${i.file}:${i.line} - ${i.clickText.slice(0, 50)}`);
+            });
+        }
+    }
+    // Warning: tests that click but don't verify
+    if (noOutcomes.length > 5) {
+        warnings.push(`${noOutcomes.length} tests have interactions without outcome verification`);
+    }
+    // Warning: partial flow coverage
+    if (partialFlows.length > 0) {
+        warnings.push(`${partialFlows.length} critical flow(s) have partial coverage`);
+    }
+    // Warning: medium/low severity actions without coverage
+    const mediumLowUncovered = uncoveredActions.filter((a) => a.severity === "medium" || a.severity === "low");
+    if (mediumLowUncovered.length > 0) {
+        warnings.push(`${mediumLowUncovered.length} medium/low severity action(s) lack test coverage`);
+    }
+    // Warning: high-severity clicks without outcomes (non-strict mode)
+    if (!strictOutcomes && allClickIssues.length > 0) {
+        const highClicks = allClickIssues.filter((i) => i.severity === "high" || i.severity === "critical");
+        if (highClicks.length > 10) {
+            warnings.push(`${highClicks.length} high-severity clicks lack outcome verification (use --strict-outcomes to block)`);
+        }
+    }
+    if (warnings.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning}  WARNINGS:`);
+        warnings.forEach((w) => console.log(`   - ${w}`));
+    }
+    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 regression check FAILED`);
+            writeReport(specFiles.length, goodCoverage.length, noInteractions.length, noOutcomes.length, flowCoverage, actionCoverage);
+            process.exit(1);
+        }
+        console.log("\nMode=warn: not blocking build.");
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.success} Interaction regression check PASSED`);
+    }
+    writeReport(specFiles.length, goodCoverage.length, noInteractions.length, noOutcomes.length, flowCoverage, actionCoverage);
+    process.exit(0);
+}
+function writeReport(totalTests, goodCoverage, noInteractions, noOutcomes, flowCoverage, actionCoverage) {
+    const reportDir = path.join(process.cwd(), "test-results");
+    if (!fs.existsSync(reportDir)) {
+        fs.mkdirSync(reportDir, { recursive: true });
+    }
+    const report = {
+        timestamp: new Date().toISOString(),
+        summary: {
+            totalTests,
+            testsWithGoodCoverage: goodCoverage,
+            testsWithNoInteractions: noInteractions,
+            testsWithNoOutcomeVerification: noOutcomes,
+            criticalFlowsCovered: flowCoverage.filter((f) => f.covered).length,
+            criticalFlowsTotal: flowCoverage.length,
+            requiredActionsCovered: actionCoverage.filter((a) => a.covered).length,
+            requiredActionsTotal: actionCoverage.length,
+            highSeverityUncovered: actionCoverage.filter((a) => !a.covered && (a.severity === "critical" || a.severity === "high")).length,
+        },
+        criticalFlows: flowCoverage.map((f) => ({
+            name: f.name,
+            route: f.route,
+            covered: f.covered,
+            hasInteraction: f.hasInteraction,
+            hasOutcome: f.hasOutcome,
+            severity: f.severity,
+            coveringTests: f.coveringTests,
+        })),
+        requiredActions: actionCoverage.map((a) => ({
+            name: a.name,
+            route: a.route,
+            covered: a.covered,
+            hasInteraction: a.hasInteraction,
+            hasOutcome: a.hasOutcome,
+            severity: a.severity,
+            expectedCount: a.expectedCount,
+            coveringTests: a.coveringTests,
+        })),
+    };
+    fs.writeFileSync(path.join(reportDir, "e2e-interaction-report.json"), JSON.stringify(report, null, 2));
+}
+run().catch((err) => {
+    console.error(`${console_chars_1.emoji.error} Preflight failed:`, err);
+    process.exit(1);
+});
+// Helper functions for actionable suggestions
+function getInteractionSuggestions(flowName) {
+    const suggestions = {
+        "Checkout Submit": [
+            'await page.fill(\'[data-testid="shipping-name"]\', "Test User");',
+            "await page.click('[data-testid=\"place-order-button\"]');",
+        ],
+        "Add to Cart": [
+            "await page.click('[data-testid=\"add-to-cart\"]');",
+            "await page.click('.product-card');",
+        ],
+        "Contact Form Submit": [
+            'await page.fill(\'input[name="email"]\', "test@example.com");',
+            "await page.click('button[type=\"submit\"]');",
+        ],
+        "Seller Dashboard Navigation": [
+            "await page.click('[data-testid=\"nav-listings\"]');",
+            "await page.click('a[href*=\"/store/orders\"]');",
+        ],
+        "Admin Approval Flow": [
+            "await page.click('button:has-text(\"Approve\")');",
+            "await page.click('button:has-text(\"Reject\")');",
+        ],
+    };
+    return suggestions[flowName] || ["await page.click('button[type=\"submit\"]');"];
+}
+function getOutcomeSuggestions(flowName) {
+    const suggestions = {
+        "Checkout Submit": [
+            "await expect(page).toHaveURL(/\\/confirmation|\\/success/);",
+            "await expect(page.getByText(/order.*confirmed|thank you/i)).toBeVisible();",
+        ],
+        "Add to Cart": [
+            "await expect(page.getByText(/added to cart/i)).toBeVisible();",
+            'await expect(page.locator(\'[data-testid="cart-badge"]\').not.toHaveText("0");',
+        ],
+        "Contact Form Submit": [
+            "await expect(page.getByText(/message sent|thank you/i)).toBeVisible();",
+            'await page.waitForResponse(resp => resp.url().includes("/api/contact"));',
+        ],
+        "Seller Dashboard Navigation": [
+            "await expect(page).toHaveURL(/\\/store\\/listings/);",
+            'await expect(page.getByRole("heading")).toContainText(/listings/i);',
+        ],
+        "Admin Approval Flow": [
+            "await expect(page.getByText(/approved|success/i)).toBeVisible();",
+            'await page.waitForResponse(resp => resp.url().includes("/api/admin"));',
+        ],
+    };
+    return suggestions[flowName] || ["await expect(page).toHaveURL(/success/);"];
+}
+function getCriticalActionSuggestions(actionName) {
+    const suggestions = {
+        "Order Ship Action": [
+            'test("should mark order as shipped", async ({ page }) => {',
+            '  await page.goto("/store/orders");',
+            "  await page.click('button:has-text(\"Ship\")');",
+            "  await expect(page.getByText(/shipped|tracking/i)).toBeVisible();",
+            "});",
+        ],
+        "Listing Approve Action": [
+            'test("should approve listing", async ({ page }) => {',
+            '  await page.goto("/admin/listings");',
+            "  await page.click('button:has-text(\"Approve\")');",
+            '  await page.waitForResponse(r => r.url().includes("/api/admin"));',
+            "  await expect(page.getByText(/approved/i)).toBeVisible();",
+            "});",
+        ],
+        "Admin Delete Action": [
+            'test("should delete item", async ({ page }) => {',
+            '  await page.goto("/admin/listings");',
+            "  await page.click('button:has-text(\"Delete\")');",
+            "  await page.click('button:has-text(\"Confirm\")');",
+            "  await expect(page.getByText(/deleted/i)).toBeVisible();",
+            "});",
+        ],
+        "Subscription Cancel Action": [
+            'test("should cancel subscription", async ({ page }) => {',
+            '  await page.goto("/store/billing");',
+            "  await page.click('button:has-text(\"Cancel\")');",
+            "  await expect(page.getByText(/cancelled/i)).toBeVisible();",
+            "});",
+        ],
+        "Listing Reject Action": [
+            'test("should reject listing", async ({ page }) => {',
+            '  await page.goto("/store/listings/new");',
+            "  await page.click('button:has-text(\"Reject\")');",
+            "  await expect(page.getByText(/rejected/i)).toBeVisible();",
+            "});",
+        ],
+        "Listing Publish Action": [
+            'test("should publish listing", async ({ page }) => {',
+            '  await page.goto("/admin/listings");',
+            "  await page.click('button:has-text(\"Publish\")');",
+            "  await expect(page.getByText(/published|live/i)).toBeVisible();",
+            "});",
+        ],
+        "Footer Navigation Links": [
+            'test("should navigate via footer links", async ({ page }) => {',
+            '  await page.goto("/");',
+            "  await page.click('footer a:has-text(\"About\")');",
+            "  await expect(page).toHaveURL(/about/);",
+            "});",
+        ],
+    };
+    return (suggestions[actionName] || [
+        'test("should perform action", async ({ page }) => {',
+        "  await page.click('button');",
+        "  await expect(page.getByText(/success/i)).toBeVisible();",
+        "});",
+    ]);
+}
+//# sourceMappingURL=e2e-interaction-regression.js.map