@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-interactive-states.js

@@ -0,0 +1,2474 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * UI Interactive States Preflight (BLOCKING)
+ *
+ * Google/Meta/X-level interactive state consistency.
+ * Ensures hover, active, focus, and disabled states are consistent across all components.
+ *
+ * Checks:
+ * 1. Hover state consistency - Same hover tokens across similar components
+ * 2. Active/pressed state coverage - All buttons have active states
+ * 3. Focus ring consistency - Same focus style across components
+ * 4. Disabled state styling - Consistent disabled appearance
+ * 5. Cursor consistency - Correct cursor for each state
+ *
+ * Usage:
+ *   pnpm preflight:ui-interactive-states              # All checks
+ *   pnpm preflight:ui-interactive-states hover        # Hover states only
+ *   pnpm preflight:ui-interactive-states active       # Active states only
+ *   pnpm preflight:ui-interactive-states focus        # Focus states only
+ *   pnpm preflight:ui-interactive-states disabled     # Disabled states only
+ *   pnpm preflight:ui-interactive-states cursor       # Cursor consistency only
+ */
+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.UIInteractiveStatesModule = exports.STANDARD_HOVER_TOKENS = exports.STANDARD_FOCUS_STYLES = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+const EXCLUDED = [...glob_patterns_1.STANDARD_EXCLUDES, "**/*.test.tsx", "**/*.spec.tsx", "**/*.stories.tsx"];
+// INTERACTIVE STATE STANDARDS
+/**
+ * Standard hover tokens - should be consistent across components
+ */
+const STANDARD_HOVER_TOKENS = {
+    // Background hovers
+    "bg-tertiary": "var(--bg-tertiary)",
+    "overlay-light": "var(--overlay-light)",
+    "overlay-medium": "var(--overlay-medium)",
+    "primary-hover": "var(--primary-hover)",
+    // Tailwind equivalents
+    "bg-tertiary-tw": "hover:bg-[var(--bg-tertiary)]",
+    "overlay-light-tw": "hover:bg-[var(--overlay-light)]",
+};
+exports.STANDARD_HOVER_TOKENS = STANDARD_HOVER_TOKENS;
+/**
+ * Standard focus ring styles
+ */
+const STANDARD_FOCUS_STYLES = {
+    ring: "focus-visible:ring-2",
+    ringColor: "focus-visible:ring-primary",
+    outline: "focus-visible:outline-none",
+};
+exports.STANDARD_FOCUS_STYLES = STANDARD_FOCUS_STYLES;
+/**
+ * Interactive elements that should have hover states
+ */
+const INTERACTIVE_ELEMENTS = [
+    "Button",
+    "IconButton",
+    "Link",
+    "a",
+    "MenuItem",
+    "ListItemButton",
+    "Tab",
+    "Chip",
+    "Card", // When clickable
+];
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class UIInteractiveStatesModule {
+    verbose;
+    parallel = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    async getTsxFiles() {
+        return file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    /**
+     * 1. Hover State Consistency
+     * Ensure consistent hover background tokens
+     */
+    async checkHoverStateConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        // Track hover patterns used across codebase
+        const hoverPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Skip lines with preflight-ignore comment (current line or up to 5 lines before)
+                const contextLines = lines.slice(Math.max(0, i - 5), i + 1).join("\n");
+                if (contextLines.includes("preflight-ignore")) {
+                    continue;
+                }
+                // Track hover:bg-* patterns
+                const hoverBgMatch = line.match(/hover:bg-\[([^\]]+)\]/);
+                if (hoverBgMatch) {
+                    const pattern = hoverBgMatch[1];
+                    const existing = hoverPatterns.get(pattern) || { count: 0, files: [] };
+                    existing.count++;
+                    if (!existing.files.includes(file))
+                        existing.files.push(file);
+                    hoverPatterns.set(pattern, existing);
+                }
+                // Check for hardcoded hover colors (not using tokens)
+                if (/hover:bg-(?:gray|slate|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d{2,3}/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "hardcoded-hover-color",
+                        severity: "warning",
+                        message: "Hardcoded Tailwind color for hover state",
+                        suggestion: "Use hover:bg-[var(--bg-tertiary)] or hover:bg-[var(--overlay-light)]",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for inline hover styles (should use Tailwind)
+                if (/:hover/.test(line) && /style=/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "inline-hover-style",
+                        severity: "warning",
+                        message: "Inline CSS hover style (prefer Tailwind)",
+                        suggestion: "Use Tailwind hover: classes instead of inline :hover styles",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        // Report inconsistent hover patterns
+        if (hoverPatterns.size > 3) {
+            const sorted = [...hoverPatterns.entries()].sort((a, b) => b[1].count - a[1].count);
+            const summary = sorted
+                .slice(0, 5)
+                .map(([p, d]) => `${p} (${d.count}x)`)
+                .join(", ");
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "hover-pattern-inconsistency",
+                severity: "info",
+                message: `${hoverPatterns.size} different hover background patterns detected`,
+                suggestion: `Standardize on 2-3 hover tokens. Top patterns: ${summary}`,
+            });
+        }
+        return {
+            name: "Hover State Consistency",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. Active/Pressed State Coverage
+     * Ensure interactive elements have active states
+     */
+    async checkActiveStateCoverage() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                // Check buttons with hover but no active state
+                if (/<Button/.test(line) || /className=["'][^"']*hover:/.test(line)) {
+                    const hasHover = /hover:/.test(contextBlock);
+                    const hasActive = /active:|:active/.test(contextBlock);
+                    // Only flag if it has custom hover but no active
+                    if (hasHover && !hasActive && /className=/.test(line)) {
+                        const hasBuiltInButton = /<Button|<IconButton|<LoadingButton|<AnimatedButton/.test(line);
+                        if (!hasBuiltInButton) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "hover-no-active",
+                                severity: "info",
+                                message: "Interactive element has hover state but no active state",
+                                suggestion: "Add active:scale-[0.98] or active:bg-[var(--overlay-medium)] for feedback",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check custom clickable elements
+                if (/<div[^>]*onClick|<Box[^>]*onClick/.test(line)) {
+                    const hasActive = /active:|:active/.test(contextBlock);
+                    const hasCursor = /cursor-pointer/.test(contextBlock);
+                    if (hasCursor && !hasActive) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "clickable-no-active",
+                            severity: "info",
+                            message: "Clickable element without active/pressed state",
+                            suggestion: "Add active:scale-[0.98] or active:opacity-90 for tactile feedback",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Active State Coverage",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. Focus Ring Consistency
+     * Ensure focus states use consistent styling
+     */
+    async checkFocusRingConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        // Track focus ring patterns
+        const focusPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track focus ring color patterns
+                const focusRingMatch = line.match(/focus(?:-visible)?:ring-(\w+)/);
+                if (focusRingMatch) {
+                    const color = focusRingMatch[1];
+                    focusPatterns.set(color, (focusPatterns.get(color) || 0) + 1);
+                }
+                // Check for focus:outline-none without ring
+                if (/focus:outline-none/.test(line) && !/focus(?:-visible)?:ring/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasOtherFocusIndicator = /focus:border|focus:shadow|focus:bg/.test(contextBlock);
+                    if (!hasOtherFocusIndicator) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "outline-none-no-alternative",
+                            severity: "warning",
+                            message: "focus:outline-none without alternative focus indicator",
+                            suggestion: "Add focus-visible:ring-2 focus-visible:ring-primary",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for focus: instead of focus-visible: (accessibility issue)
+                if (/\bfocus:(?!visible)/.test(line) && /ring|outline|border|shadow/.test(line)) {
+                    // Skip if focus-visible is also present
+                    if (!/focus-visible:/.test(line)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "focus-instead-of-focus-visible",
+                            severity: "info",
+                            message: "Using focus: instead of focus-visible: for visual indicators",
+                            suggestion: "Use focus-visible: to only show focus ring for keyboard navigation",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Report focus ring color inconsistencies
+        if (focusPatterns.size > 2) {
+            const sorted = [...focusPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "focus-ring-color-inconsistency",
+                severity: "info",
+                message: `${focusPatterns.size} different focus ring colors detected`,
+                suggestion: `Standardize on primary ring color. Usage: ${sorted.map(([c, n]) => `${c}(${n})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Focus Ring Consistency",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. Disabled State Styling
+     * Ensure disabled states are consistent
+     */
+    async checkDisabledStateStyling() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                // Check for disabled prop without cursor-not-allowed
+                if (/disabled[=:]/.test(line)) {
+                    const hasNotAllowed = /cursor-not-allowed|pointer-events-none/.test(contextBlock);
+                    const hasDisabledStyles = /disabled:/.test(contextBlock);
+                    const isBuiltInComponent = /<Button|<IconButton|<TextField|<Select|<Checkbox|<Radio/.test(line);
+                    if (!isBuiltInComponent && !hasNotAllowed && !hasDisabledStyles) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "disabled-no-cursor",
+                            severity: "info",
+                            message: "Disabled element without cursor-not-allowed",
+                            suggestion: "Add disabled:cursor-not-allowed disabled:opacity-50",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for hardcoded disabled opacity
+                if (/disabled.*opacity-(?!50)(\d+)/.test(line)) {
+                    const opacityMatch = line.match(/opacity-(\d+)/);
+                    if (opacityMatch && !["50", "60"].includes(opacityMatch[1])) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "inconsistent-disabled-opacity",
+                            severity: "info",
+                            message: `Disabled opacity-${opacityMatch[1]} (standard is opacity-50)`,
+                            suggestion: "Use disabled:opacity-50 for consistency",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Disabled State Styling",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Cursor Consistency
+     * Ensure correct cursor for each element type
+     */
+    async checkCursorConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                // Check for onClick without cursor-pointer
+                if (/onClick=/.test(line)) {
+                    const isInteractiveElement = /<(Button|IconButton|a|Link|MenuItem|Tab|Chip)/.test(line);
+                    const hasCursor = /cursor-/.test(contextBlock);
+                    const isDisabled = /disabled/.test(contextBlock);
+                    if (!isInteractiveElement && !hasCursor && !isDisabled) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "onclick-no-cursor",
+                            severity: "info",
+                            message: "Clickable element without cursor-pointer",
+                            suggestion: "Add cursor-pointer to indicate clickability",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for cursor-pointer on non-interactive elements
+                if (/cursor-pointer/.test(line) &&
+                    !/(onClick|href|to=|role=["']button)/.test(contextBlock)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "cursor-pointer-not-interactive",
+                        severity: "info",
+                        message: "cursor-pointer on non-interactive element",
+                        suggestion: "Only use cursor-pointer on actually clickable elements",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for loading states without cursor-wait
+                if (/(isLoading|loading|isPending)\s*&&/.test(line)) {
+                    const hasCursorWait = /cursor-wait/.test(contextBlock);
+                    // This is optional, so just info
+                }
+            }
+        }
+        return {
+            name: "Cursor Consistency",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Scale Feedback Consistency
+     * Ensure active:scale values are consistent across components
+     */
+    async checkScaleFeedbackConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        // Track scale values used
+        const scaleValues = new Map();
+        const STANDARD_SCALES = ["scale-95", "scale-[0.98]", "scale-[0.97]", "scale-100"];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track active:scale-* patterns
+                const scaleMatch = line.match(/active:scale-\[?([^\s\]"']+)\]?/);
+                if (scaleMatch) {
+                    const value = scaleMatch[1];
+                    const existing = scaleValues.get(value) || { count: 0, files: [] };
+                    existing.count++;
+                    if (!existing.files.includes(file))
+                        existing.files.push(file);
+                    scaleValues.set(value, existing);
+                }
+                // Check for non-standard scale values
+                const nonStandardScale = line.match(/active:scale-\[([0-9.]+)\]/);
+                if (nonStandardScale) {
+                    const value = parseFloat(nonStandardScale[1]);
+                    if (value < 0.95 || value > 0.99) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "unusual-scale-value",
+                            severity: "info",
+                            message: `Unusual scale value: ${value} (standard is 0.97-0.98)`,
+                            suggestion: "Use active:scale-[0.98] or active:scale-95 for consistency",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Report scale inconsistencies
+        if (scaleValues.size > 2) {
+            const sorted = [...scaleValues.entries()].sort((a, b) => b[1].count - a[1].count);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "scale-inconsistency",
+                severity: "info",
+                message: `${scaleValues.size} different active:scale values detected`,
+                suggestion: `Standardize on 1-2 scale values. Usage: ${sorted.map(([v, d]) => `${v}(${d.count})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Scale Feedback Consistency",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 7. Loading Spinner Consistency
+     * Ensure loading spinners use consistent sizing and patterns
+     */
+    async checkLoadingSpinnerConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        // Track spinner sizes
+        const spinnerSizes = new Map();
+        const STANDARD_SIZES = [16, 20, 24, 32, 40];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check CircularProgress/Spinner size
+                const sizeMatch = line.match(/<(?:CircularProgress|Spinner)[^>]*size[=:][\s{]*(\d+)/);
+                if (sizeMatch) {
+                    const size = parseInt(sizeMatch[1]);
+                    spinnerSizes.set(String(size), (spinnerSizes.get(String(size)) || 0) + 1);
+                    if (!STANDARD_SIZES.includes(size)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "non-standard-spinner-size",
+                            severity: "info",
+                            message: `Non-standard spinner size: ${size}px`,
+                            suggestion: `Use standard sizes: ${STANDARD_SIZES.join(", ")}px`,
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for loading without visual indicator
+                if (/isLoading\s*\?\s*[^:]*:[^<]*<Button/.test(line) || /loading\s*\?\s*[^:]*:[^<]*<Button/.test(line)) {
+                    const hasSpinner = /CircularProgress|Spinner|animate-spin/.test(content.substring(Math.max(0, content.indexOf(line) - 200), content.indexOf(line) + 200));
+                    if (!hasSpinner) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "loading-no-spinner",
+                            severity: "info",
+                            message: "Loading state without visual spinner indicator",
+                            suggestion: "Add CircularProgress or Spinner component during loading",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Loading Spinner Consistency",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 8. Reduced Motion Support (Accessibility)
+     * Check for prefers-reduced-motion support in animations
+     */
+    async checkReducedMotionSupport() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        let hasReducedMotionSupport = false;
+        let animationCount = 0;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Check for reduced motion support
+            if (/prefers-reduced-motion|motion-reduce|motion-safe/.test(content)) {
+                hasReducedMotionSupport = true;
+            }
+            // Count animation usage
+            const animations = (content.match(/animate-|transition-|@keyframes/g) || []).length;
+            animationCount += animations;
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for complex animations without reduced motion alternative
+                if (/animate-(?:bounce|pulse|ping|spin)/.test(line)) {
+                    const contextBlock = content.substring(Math.max(0, content.indexOf(line) - 100), content.indexOf(line) + line.length + 100);
+                    if (!/motion-reduce|prefers-reduced-motion/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "animation-no-reduced-motion",
+                            severity: "info",
+                            message: "Animation without reduced-motion alternative",
+                            suggestion: "Add motion-reduce:animate-none for accessibility",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Global check: if we have many animations but no reduced motion support
+        if (animationCount > 20 && !hasReducedMotionSupport) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "no-reduced-motion-global",
+                severity: "warning",
+                message: `${animationCount} animations found but no prefers-reduced-motion support detected`,
+                suggestion: "Add global CSS: @media (prefers-reduced-motion: reduce) { *, *::before, *::after { animation-duration: 0.01ms !important; } }",
+            });
+        }
+        return {
+            name: "Reduced Motion Support",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 9. Async Operation Feedback
+     * Check that async operations provide success/error feedback
+     */
+    async checkAsyncOperationFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for fetch/mutation without success feedback
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Look for async handlers that might need feedback
+                if (/async.*=>\s*\{/.test(line) && /fetch\(|\.mutate|\.mutateAsync/.test(content)) {
+                    const fnBlock = content.substring(content.indexOf(line), Math.min(content.indexOf(line) + 500, content.length));
+                    // Check if there's success feedback
+                    const hasSuccessFeedback = /success\(|toast\.|showToast|setSuccess|onSuccess/.test(fnBlock);
+                    const hasErrorFeedback = /catch|\.catch|error\(|showError|onError/.test(fnBlock);
+                    // Only flag if it has error handling but no success feedback (intentional pattern check)
+                    if (hasErrorFeedback && !hasSuccessFeedback && /response\.ok|\.then/.test(fnBlock)) {
+                        // Skip if it's clearly a background operation
+                        if (!/sync|refresh|poll|interval/i.test(fnBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "async-no-success-feedback",
+                                severity: "info",
+                                message: "Async operation has error handling but no visible success feedback",
+                                suggestion: "Add success toast/notification after successful operations",
+                                snippet: line.trim().substring(0, 60),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            name: "Async Operation Feedback",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 10. Transition Property Consistency
+     * Ensure transition properties are consistent (all vs specific)
+     */
+    async checkTransitionConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const transitionTypes = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track transition-all vs specific transitions
+                if (/transition-all/.test(line)) {
+                    transitionTypes.set("all", (transitionTypes.get("all") || 0) + 1);
+                }
+                if (/transition-(?:colors|opacity|shadow|transform)/.test(line)) {
+                    const match = line.match(/transition-(colors|opacity|shadow|transform)/);
+                    if (match) {
+                        transitionTypes.set(match[1], (transitionTypes.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for transition-all on performance-critical elements
+                if (/transition-all/.test(line) && /<(?:img|Image|video|canvas)/i.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "transition-all-media",
+                        severity: "warning",
+                        message: "transition-all on media element may cause performance issues",
+                        suggestion: "Use specific transitions: transition-opacity or transition-transform",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        // Report if mixed patterns
+        if (transitionTypes.size > 3) {
+            const sorted = [...transitionTypes.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "transition-inconsistency",
+                severity: "info",
+                message: `Multiple transition patterns detected`,
+                suggestion: `Consider standardizing. Usage: ${sorted.map(([t, c]) => `${t}(${c})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Transition Consistency",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 11. Touch/Gesture Feedback
+     * Check for mobile touch states and gesture feedback
+     */
+    async checkTouchGestureFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for touch-action usage consistency
+                if (/touch-action/.test(line)) {
+                    const touchActionMatch = line.match(/touch-action[:\s]+["']?(\w+)/);
+                    if (touchActionMatch) {
+                        // touch-action: none can cause accessibility issues
+                        if (touchActionMatch[1] === "none") {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "touch-action-none",
+                                severity: "warning",
+                                message: "touch-action: none disables all touch gestures",
+                                suggestion: "Use touch-action: pan-x, pan-y, or manipulation instead for better UX",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check for tap-highlight removal without alternative
+                if (/-webkit-tap-highlight-color:\s*transparent/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasActiveFeedback = /active:|:active/.test(contextBlock);
+                    if (!hasActiveFeedback) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "tap-highlight-no-alternative",
+                            severity: "info",
+                            message: "Tap highlight removed without alternative touch feedback",
+                            suggestion: "Add active:bg-* or active:scale-* for touch feedback",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for swipeable elements without visual affordance
+                if (/onTouchStart|onSwipe|swipeable|Swipeable/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 10, lines.length)).join("\n");
+                    const hasSwipeIndicator = /swipe|drag|arrow|chevron|indicator/i.test(contextBlock);
+                    if (!hasSwipeIndicator) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "swipe-no-affordance",
+                            severity: "info",
+                            message: "Swipeable element may lack visual affordance",
+                            suggestion: "Add visual indicators (arrows, dots) to show swipe capability",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Touch/Gesture Feedback",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 12. Scroll Snap Consistency
+     * Check for consistent scroll-snap patterns
+     */
+    async checkScrollSnapConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const scrollSnapTypes = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track scroll-snap-type patterns
+                const snapTypeMatch = line.match(/scroll-snap-type[:\s]+["']?([^;"'\s}]+)/);
+                if (snapTypeMatch) {
+                    const type = snapTypeMatch[1];
+                    scrollSnapTypes.set(type, (scrollSnapTypes.get(type) || 0) + 1);
+                }
+                // Check for snap container without snap children
+                if (/snap-(?:x|y|both|mandatory|proximity)/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasSnapChildren = /snap-(?:start|center|end|align)/.test(contextBlock);
+                    if (!hasSnapChildren) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "snap-container-no-children",
+                            severity: "info",
+                            message: "Scroll snap container may lack snap-aligned children",
+                            suggestion: "Add snap-start, snap-center, or snap-end to child elements",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for scroll-behavior: smooth
+                if (/scroll-behavior:\s*smooth|scroll-smooth/.test(line)) {
+                    const contextBlock = content.substring(Math.max(0, content.indexOf(line) - 200), content.indexOf(line) + 200);
+                    // Should respect reduced motion
+                    if (!/motion-reduce|prefers-reduced-motion/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "smooth-scroll-no-motion-check",
+                            severity: "info",
+                            message: "Smooth scroll without reduced-motion consideration",
+                            suggestion: "Add motion-reduce:scroll-auto for accessibility",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Report inconsistent snap types
+        if (scrollSnapTypes.size > 2) {
+            const sorted = [...scrollSnapTypes.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "scroll-snap-inconsistency",
+                severity: "info",
+                message: `${scrollSnapTypes.size} different scroll-snap-type values detected`,
+                suggestion: `Standardize snap behavior. Usage: ${sorted.map(([t, c]) => `${t}(${c})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Scroll Snap Consistency",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 13. Drag and Drop Feedback
+     * Check for DnD visual indicators and feedback
+     */
+    async checkDragDropFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for draggable without visual feedback
+                if (/draggable[=:]|onDragStart|useDrag|Draggable/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    // Check for drag cursor
+                    const hasDragCursor = /cursor-(?:grab|move|grabbing)/.test(contextBlock);
+                    if (!hasDragCursor) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "draggable-no-cursor",
+                            severity: "info",
+                            message: "Draggable element without grab cursor",
+                            suggestion: "Add cursor-grab and active:cursor-grabbing for drag feedback",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for drag visual feedback (opacity, scale, shadow)
+                    const hasDragVisual = /dragging|isDragging|opacity|shadow|scale/.test(contextBlock);
+                    if (!hasDragVisual) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "draggable-no-visual",
+                            severity: "info",
+                            message: "Draggable element may lack visual drag state",
+                            suggestion: "Add opacity-50 or shadow-lg during drag for visual feedback",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for drop zone visual feedback
+                if (/onDrop|onDragOver|onDragEnter|useDrop|Droppable/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasDropVisual = /isOver|isDragOver|dragOver|drop.*highlight|border.*dashed/.test(contextBlock);
+                    if (!hasDropVisual) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "dropzone-no-visual",
+                            severity: "info",
+                            message: "Drop zone may lack visual feedback on drag over",
+                            suggestion: "Add border highlight or background change when dragging over",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Drag and Drop Feedback",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 14. Input Validation Feedback
+     * Check for real-time validation visual feedback
+     */
+    async checkInputValidationFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for form validation without visual feedback
+                if (/(?:errors|error)\[["']?\w+["']?\]|formState\.errors|fieldState\.error/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    // Check for error visual styling
+                    const hasErrorStyling = /error|destructive|red|border-.*error|text-.*error|ring-.*error/.test(contextBlock);
+                    if (!hasErrorStyling) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "validation-no-visual",
+                            severity: "info",
+                            message: "Form validation error without visual feedback",
+                            suggestion: "Add red border or text color for validation errors",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for error shake animation
+                    const hasShakeAnimation = /shake|animate-shake|wiggle/.test(contextBlock);
+                    // This is optional but nice to have - not flagging as issue
+                }
+                // Check for success validation feedback (e.g., checkmark)
+                if (/isValid|isValidating|validation.*success/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const hasSuccessIndicator = /check|success|green|valid.*icon/.test(contextBlock);
+                    // Optional - good to have but not required
+                }
+                // Check for TextField/Input with error prop
+                if (/<(?:TextField|Input)[^>]*error[=:]/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasHelperText = /helperText|FormHelperText|error.*message/.test(contextBlock);
+                    if (!hasHelperText) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "input-error-no-message",
+                            severity: "info",
+                            message: "Input with error state but no helper text",
+                            suggestion: "Add helperText to explain the validation error",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Input Validation Feedback",
+            passed: true, // Info only
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 15. Toast/Notification Timing
+     * Check for consistent notification durations
+     */
+    async checkToastNotificationTiming() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        // Standard durations (in ms)
+        const STANDARD_DURATIONS = [3000, 5000, 7000, 10000];
+        const toastDurations = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for toast/notification duration
+                const durationMatch = line.match(/(?:duration|autoHideDuration|timeout)[=:]\s*\{?\s*(\d+)/);
+                if (durationMatch && /toast|notification|snackbar|alert/i.test(content.substring(Math.max(0, content.indexOf(line) - 100), content.indexOf(line) + 100))) {
+                    const duration = parseInt(durationMatch[1]);
+                    toastDurations.set(duration, (toastDurations.get(duration) || 0) + 1);
+                    // Check for very short durations (< 2s)
+                    if (duration < 2000) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "toast-too-short",
+                            severity: "warning",
+                            message: `Toast duration ${duration}ms is too short to read`,
+                            suggestion: "Use at least 3000ms (3s) for readable notifications",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for very long durations (> 15s) without dismiss
+                    if (duration > 15000) {
+                        const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                        const hasDismiss = /dismiss|close|onClose/.test(contextBlock);
+                        if (!hasDismiss) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "toast-too-long-no-dismiss",
+                                severity: "info",
+                                message: `Toast duration ${duration}ms is long - ensure user can dismiss`,
+                                suggestion: "Add dismiss button for long-duration notifications",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                    // Check for non-standard durations
+                    if (!STANDARD_DURATIONS.includes(duration) && duration >= 2000 && duration <= 15000) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "toast-non-standard-duration",
+                            severity: "info",
+                            message: `Non-standard toast duration: ${duration}ms`,
+                            suggestion: `Use standard durations: ${STANDARD_DURATIONS.join(", ")}ms`,
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for success toast after action
+                if (/success\(|showSuccess|toast\.success/.test(line)) {
+                    // Good - has success feedback
+                }
+                // Check for error toast persistence
+                if (/error\(|showError|toast\.error/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasLongerDuration = /duration.*[5-9]\d{3}|duration.*1\d{4}|persistent|autoHide.*false/.test(contextBlock);
+                    if (!hasLongerDuration) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "error-toast-short",
+                            severity: "info",
+                            message: "Error notification may auto-dismiss too quickly",
+                            suggestion: "Error toasts should stay longer (5-7s) or be manually dismissable",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Report inconsistent durations
+        if (toastDurations.size > 3) {
+            const sorted = [...toastDurations.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "toast-duration-inconsistency",
+                severity: "info",
+                message: `${toastDurations.size} different toast durations detected`,
+                suggestion: `Standardize on 2-3 durations. Usage: ${sorted.map(([d, c]) => `${d}ms(${c})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Toast/Notification Timing",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 16. Skeleton-to-Content Match
+     * Check that skeleton sizes match actual loaded content
+     */
+    async checkSkeletonContentMatch() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const skeletonDimensions = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/<Skeleton\b/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const widthMatch = contextBlock.match(/(?:width|w)=["'{]\s*(\d+|[\w-]+)/);
+                    const heightMatch = contextBlock.match(/(?:height|h)=["'{]\s*(\d+|[\w-]+)/);
+                    if (widthMatch || heightMatch) {
+                        const dim = `${widthMatch?.[1] || "auto"}x${heightMatch?.[1] || "auto"}`;
+                        const existing = skeletonDimensions.get(dim) || [];
+                        existing.push({ file, line: i + 1 });
+                        skeletonDimensions.set(dim, existing);
+                    }
+                    if (!widthMatch && !heightMatch && !/className=["'][^"']*(?:w-|h-)/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "skeleton-no-dimensions",
+                            severity: "info",
+                            message: "Skeleton without explicit dimensions may cause layout shift",
+                            suggestion: "Add width/height props or Tailwind w-/h- classes matching content size",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        if (skeletonDimensions.size > 10) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "many-skeleton-dimensions",
+                severity: "info",
+                message: `${skeletonDimensions.size} different skeleton dimension combinations detected`,
+                suggestion: "Consider standardizing skeleton sizes for consistency",
+            });
+        }
+        return {
+            name: "Skeleton-to-Content Match",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 17. Empty State Patterns
+     * Check for consistent empty state component usage
+     */
+    async checkEmptyStatePatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const emptyStatePatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/(?:data|items|results|list)(?:\?)?\.length\s*===?\s*0|isEmpty|noData|noResults/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const usesEmptyStateComponent = /<EmptyState|<NoData|<NoResults|<Empty\b/i.test(contextBlock);
+                    const hasInlineEmpty = /No\s+\w+\s+(?:found|available|yet)|Nothing\s+to\s+show|Empty/i.test(contextBlock);
+                    const hasIcon = /<(?:Icon|SvgIcon|\w+Icon)|📭|🔍|📋/.test(contextBlock);
+                    const hasAction = /<Button|onClick|href=/.test(contextBlock);
+                    if (!usesEmptyStateComponent && hasInlineEmpty) {
+                        emptyStatePatterns.set("inline-text", (emptyStatePatterns.get("inline-text") || 0) + 1);
+                        if (!hasIcon) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "empty-state-no-icon",
+                                severity: "info",
+                                message: "Empty state without visual icon",
+                                suggestion: "Add an icon to make empty states more visually distinct",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                        if (!hasAction) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "empty-state-no-action",
+                                severity: "info",
+                                message: "Empty state without call-to-action",
+                                suggestion: "Consider adding a button or link to help users take action",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                    else if (usesEmptyStateComponent) {
+                        emptyStatePatterns.set("component", (emptyStatePatterns.get("component") || 0) + 1);
+                    }
+                }
+            }
+        }
+        if (emptyStatePatterns.get("inline-text") && emptyStatePatterns.get("component")) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "mixed-empty-state-patterns",
+                severity: "info",
+                message: `Mixed empty state patterns: ${emptyStatePatterns.get("component")} components, ${emptyStatePatterns.get("inline-text")} inline`,
+                suggestion: "Standardize on EmptyState component for consistency",
+            });
+        }
+        return {
+            name: "Empty State Patterns",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 18. Selection Feedback
+     * Check for multi-select and checkbox visual states
+     */
+    async checkSelectionFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/selectedItems|selectedRows|selection|isSelected|onSelect/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasSelectedStyle = /selected.*bg-|bg-.*selected|ring.*selected|border.*selected|data-\[selected\]/i.test(contextBlock);
+                    const hasCheckbox = /<Checkbox|<input.*type=["']checkbox/.test(contextBlock);
+                    if (!hasSelectedStyle && !hasCheckbox) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "selection-no-visual",
+                            severity: "info",
+                            message: "Selection logic without clear visual feedback",
+                            suggestion: "Add background color or border change for selected items",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    const hasMultiSelect = /selectedItems|selectedRows|Set<|new Set/.test(contextBlock);
+                    const hasSelectAll = /selectAll|toggleAll|Select All/i.test(content);
+                    if (hasMultiSelect && !hasSelectAll) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "multi-select-no-select-all",
+                            severity: "info",
+                            message: "Multi-select without Select All option",
+                            suggestion: "Add Select All checkbox for bulk operations",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                if (/<(?:tr|TableRow)[^>]*onClick/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    if (!/hover:|cursor-pointer/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "clickable-row-no-hover",
+                            severity: "info",
+                            message: "Clickable table row without hover feedback",
+                            suggestion: "Add hover:bg-* and cursor-pointer for clickable rows",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Selection Feedback",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 19. Accordion Animation
+     * Check for consistent expand/collapse animations
+     */
+    async checkAccordionAnimation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const animationPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/<(?:Accordion|Collapsible|Disclosure|Expandable)\b/i.test(line) ||
+                    /isOpen|isExpanded|expanded|collapsed/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasTransition = /transition-|animate-/.test(contextBlock);
+                    const hasMaxHeight = /max-h-|maxHeight/.test(contextBlock);
+                    const hasFramerMotion = /motion\.|AnimatePresence|variants/.test(contextBlock);
+                    const hasRadixAnimation = /data-\[state=/.test(contextBlock);
+                    if (hasTransition)
+                        animationPatterns.set("tailwind-transition", (animationPatterns.get("tailwind-transition") || 0) + 1);
+                    if (hasFramerMotion)
+                        animationPatterns.set("framer-motion", (animationPatterns.get("framer-motion") || 0) + 1);
+                    if (hasRadixAnimation)
+                        animationPatterns.set("radix-data-state", (animationPatterns.get("radix-data-state") || 0) + 1);
+                    if (/height.*transition|transition.*height/.test(contextBlock) && !hasMaxHeight) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "height-animation-no-max",
+                            severity: "info",
+                            message: "Height animation may need max-height for smooth transitions",
+                            suggestion: "Use max-h-0/max-h-[value] with overflow-hidden for smooth accordion",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    const hasConditionalRender = /\{.*&&|isOpen\s*\?|\{.*\?.*:/.test(contextBlock);
+                    if (hasConditionalRender && !hasTransition && !hasFramerMotion && !hasRadixAnimation) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "accordion-no-animation",
+                            severity: "info",
+                            message: "Collapsible content without animation",
+                            suggestion: "Add transition animation for smoother UX",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        if (animationPatterns.size > 1) {
+            const sorted = [...animationPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "mixed-accordion-animations",
+                severity: "info",
+                message: `Multiple accordion animation patterns detected`,
+                suggestion: `Consider standardizing. Usage: ${sorted.map(([p, c]) => `${p}(${c})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Accordion Animation",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 20. Modal Entry/Exit Animation
+     * Check for consistent modal animation patterns
+     */
+    async checkModalAnimation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const modalAnimations = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/<(?:Dialog|Modal|Sheet|Drawer|AlertDialog)\b/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 30, lines.length)).join("\n");
+                    const hasTransition = /transition-|animate-/.test(contextBlock);
+                    const hasFramerMotion = /motion\.|AnimatePresence/.test(contextBlock);
+                    const hasRadixAnimation = /data-\[state=/.test(contextBlock);
+                    if (hasFramerMotion)
+                        modalAnimations.set("framer-motion", (modalAnimations.get("framer-motion") || 0) + 1);
+                    if (hasRadixAnimation)
+                        modalAnimations.set("radix", (modalAnimations.get("radix") || 0) + 1);
+                    if (hasTransition && !hasFramerMotion && !hasRadixAnimation) {
+                        modalAnimations.set("tailwind", (modalAnimations.get("tailwind") || 0) + 1);
+                    }
+                    const hasBackdrop = /backdrop|overlay|scrim/i.test(contextBlock);
+                    const hasBackdropAnimation = /backdrop.*(?:opacity|fade|transition)|(?:opacity|fade|transition).*backdrop/i.test(contextBlock);
+                    if (hasBackdrop && !hasBackdropAnimation && !hasRadixAnimation) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "modal-backdrop-no-animation",
+                            severity: "info",
+                            message: "Modal backdrop without fade animation",
+                            suggestion: "Add opacity transition to backdrop for polished feel",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    if (!hasRadixAnimation && !hasFramerMotion) {
+                        const hasExitAnimation = /exit|leave|closing|animate-out/i.test(contextBlock);
+                        if (hasTransition && !hasExitAnimation) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "modal-no-exit-animation",
+                                severity: "info",
+                                message: "Modal may lack exit animation",
+                                suggestion: "Add exit animation for smooth close transition",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (modalAnimations.size > 1) {
+            const sorted = [...modalAnimations.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "mixed-modal-animations",
+                severity: "info",
+                message: `Multiple modal animation patterns detected`,
+                suggestion: `Consider standardizing. Usage: ${sorted.map(([p, c]) => `${p}(${c})`).join(", ")}`,
+            });
+        }
+        return {
+            name: "Modal Entry/Exit Animation",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 21. Copy-to-Clipboard Feedback
+     * Check for success indication after clipboard operations
+     */
+    async checkCopyFeedback() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/navigator\.clipboard|writeText|copyToClipboard|useCopy|copy\(/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasToast = /toast|notification|snackbar/i.test(contextBlock);
+                    const hasIconChange = /copied|check|success|CheckIcon|ClipboardCheck/i.test(contextBlock);
+                    const hasTooltip = /tooltip|Tooltip|title=["']Copied/i.test(contextBlock);
+                    const hasStateChange = /setCopied|isCopied|copied.*true/.test(contextBlock);
+                    if (!hasToast && !hasIconChange && !hasTooltip && !hasStateChange) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "copy-no-feedback",
+                            severity: "warning",
+                            message: "Clipboard copy without visual feedback",
+                            suggestion: "Add toast, icon change, or tooltip to confirm copy action",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    if (hasStateChange) {
+                        const hasTimeout = /setTimeout|useTimeout|delay/.test(contextBlock);
+                        if (!hasTimeout) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "copy-state-no-reset",
+                                severity: "info",
+                                message: "Copy state may not reset after showing 'Copied'",
+                                suggestion: "Reset copied state after 2-3 seconds with setTimeout",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            name: "Copy-to-Clipboard Feedback",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 22. Infinite Scroll Loading
+     * Check for loading indicators at scroll boundaries
+     */
+    async checkInfiniteScrollLoading() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/useInfiniteQuery|InfiniteScroll|useInfiniteScroll|fetchNextPage|hasNextPage/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 30, lines.length)).join("\n");
+                    const hasLoadingIndicator = /isFetchingNextPage|loadingMore|isLoadingMore|loading.*spinner|CircularProgress|Spinner/i.test(contextBlock);
+                    const hasLoadMoreButton = /Load\s*More|Show\s*More|loadMore/i.test(contextBlock);
+                    if (!hasLoadingIndicator && !hasLoadMoreButton) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "infinite-scroll-no-loading",
+                            severity: "warning",
+                            message: "Infinite scroll without visible loading indicator",
+                            suggestion: "Show spinner or skeleton when fetching next page",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    const hasEndIndicator = /hasNextPage.*false|no.*more|end.*of.*list|reached.*end/i.test(contextBlock);
+                    if (!hasEndIndicator) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "infinite-scroll-no-end",
+                            severity: "info",
+                            message: "Infinite scroll may not indicate when all items are loaded",
+                            suggestion: "Show 'No more items' message when hasNextPage is false",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Infinite Scroll Loading",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 23. Filter Active State
+     * Check for visual feedback when filters are applied
+     */
+    async checkFilterActiveState() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/filters?State|activeFilters?|appliedFilters?|filterValues?/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 30, lines.length)).join("\n");
+                    const hasFilterCount = /filterCount|activeCount|badge|\.length|\.size/i.test(contextBlock);
+                    const hasBadgeComponent = /<Badge|<Chip|<Tag|count=/i.test(contextBlock);
+                    if (hasFilterCount && !hasBadgeComponent) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "filter-count-no-badge",
+                            severity: "info",
+                            message: "Filter count tracked but may not be visually displayed",
+                            suggestion: "Show badge with active filter count on filter button",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    const hasClearAll = /clearAll|resetFilters?|clearFilters?|remove.*all/i.test(contextBlock);
+                    if (!hasClearAll) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "no-clear-all-filters",
+                            severity: "info",
+                            message: "Filter management without Clear All option",
+                            suggestion: "Add 'Clear All' button when filters are active",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                if (/<(?:Filter|FilterMenu|FilterPopover|FilterDropdown)\b/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasActiveStyle = /active|selected|bg-primary|variant=["']default/.test(contextBlock);
+                    if (!hasActiveStyle) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "filter-trigger-no-active-state",
+                            severity: "info",
+                            message: "Filter trigger may not show when filters are active",
+                            suggestion: "Change button style or add badge when filters are applied",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                if (/FilterChip|FilterTag|activeFilter/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const hasRemove = /onRemove|onDelete|onClear|×|✕|close|CloseIcon/i.test(contextBlock);
+                    if (!hasRemove) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "filter-chip-no-remove",
+                            severity: "info",
+                            message: "Filter chip without remove/clear button",
+                            suggestion: "Add X button to allow removing individual filters",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Filter Active State",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 24. Optimistic Updates
+     * Check for optimistic UI patterns in mutations
+     */
+    async checkOptimisticUpdates() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for mutations that could benefit from optimistic updates
+                if (/useMutation|mutateAsync|\.mutate\(/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 20, lines.length)).join("\n");
+                    const hasOptimistic = /optimistic|onMutate.*return|previousData|rollback/i.test(contextBlock);
+                    const isLikeOrToggle = /like|favorite|bookmark|toggle|follow|vote/i.test(contextBlock);
+                    // Toggle-type actions should use optimistic updates
+                    if (isLikeOrToggle && !hasOptimistic) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "toggle-no-optimistic",
+                            severity: "info",
+                            message: "Toggle action without optimistic update",
+                            suggestion: "Add optimistic update for instant feedback on like/toggle actions",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for error rollback
+                    if (hasOptimistic && !/onError.*previous|rollback|setQueryData/i.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "optimistic-no-rollback",
+                            severity: "warning",
+                            message: "Optimistic update may lack error rollback",
+                            suggestion: "Add onError handler to rollback optimistic changes on failure",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for direct state updates that should wait for server
+                if (/setItems|setData|setState/.test(line) && /delete|remove/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const hasAwait = /await|\.then|onSuccess/.test(contextBlock);
+                    if (!hasAwait) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "delete-before-confirm",
+                            severity: "info",
+                            message: "State update before server confirmation",
+                            suggestion: "Consider waiting for server response or implementing optimistic update pattern",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Optimistic Updates",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 25. Undo/Redo Patterns
+     * Check for undo functionality on destructive actions
+     */
+    async checkUndoRedoPatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        let hasUndoSystem = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for undo system presence
+            if (/useUndo|undo.*redo|history.*stack|command.*pattern/i.test(content)) {
+                hasUndoSystem = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for delete actions without undo
+                if (/onDelete|handleDelete|deleteItem|removeItem/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasUndo = /undo|Undo|restore|Restore|unarchive/i.test(contextBlock);
+                    const hasSoftDelete = /soft.*delete|archive|trash|isDeleted/i.test(contextBlock);
+                    const hasConfirmation = /confirm|Confirm|Dialog|Modal/i.test(contextBlock);
+                    if (!hasUndo && !hasSoftDelete && !hasConfirmation) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "delete-no-undo",
+                            severity: "info",
+                            message: "Delete action without undo option",
+                            suggestion: "Add undo toast, soft delete, or confirmation dialog for destructive actions",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for bulk actions without undo
+                if (/bulkDelete|deleteSelected|removeAll|deleteMany/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasUndo = /undo|restore/i.test(contextBlock);
+                    if (!hasUndo) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "bulk-delete-no-undo",
+                            severity: "warning",
+                            message: "Bulk delete without undo option",
+                            suggestion: "Bulk deletes should have undo capability or require extra confirmation",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for toast with undo action
+                if (/toast\(|showToast|notification\(/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    const isDeletion = /delete|remove|archive/i.test(contextBlock);
+                    const hasUndoAction = /action.*undo|undo.*action|Undo/i.test(contextBlock);
+                    if (isDeletion && !hasUndoAction) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "delete-toast-no-undo",
+                            severity: "info",
+                            message: "Deletion toast without undo action",
+                            suggestion: "Add 'Undo' action button to deletion confirmation toast",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Undo/Redo Patterns",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 26. Keyboard Shortcuts
+     * Check for keyboard navigation and shortcut support
+     */
+    async checkKeyboardShortcuts() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        let hasKeyboardShortcuts = false;
+        let hasShortcutHelp = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for keyboard shortcut system
+            if (/useHotkeys|useKeyboard|onKeyDown|KeyboardEvent|Mousetrap|hotkeys-js/i.test(content)) {
+                hasKeyboardShortcuts = true;
+            }
+            if (/shortcut.*help|keyboard.*shortcuts|hotkeys.*modal|shortcut.*dialog|\?.*shortcuts/i.test(content)) {
+                hasShortcutHelp = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for actions that commonly need shortcuts
+                if (/<(?:SearchInput|SearchField|Search)\b/i.test(line)) {
+                    const contextBlock = content;
+                    const hasSearchShortcut = /(?:cmd|ctrl|meta)\+k|\/.*search|focus.*search/i.test(contextBlock);
+                    if (!hasSearchShortcut) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "search-no-shortcut",
+                            severity: "info",
+                            message: "Search input without keyboard shortcut",
+                            suggestion: "Add Cmd/Ctrl+K shortcut to focus search (standard pattern)",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for keyboard event handlers
+                if (/onKeyDown|onKeyUp|onKeyPress/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    // Check for Escape key handling in modals/popups
+                    if (/<(?:Dialog|Modal|Popover|Menu)\b/i.test(content.substring(Math.max(0, content.indexOf(line) - 200), content.indexOf(line) + 200))) {
+                        const hasEscape = /Escape|key.*27|e\.key\s*===?\s*["']Escape/i.test(contextBlock);
+                        if (!hasEscape) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "modal-no-escape",
+                                severity: "info",
+                                message: "Keyboard handler may not handle Escape key",
+                                suggestion: "Add Escape key to close modals/popups",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                    // Check for arrow key navigation in lists
+                    if (/list|menu|dropdown|options/i.test(content.substring(Math.max(0, content.indexOf(line) - 100), content.indexOf(line) + 100))) {
+                        const hasArrows = /ArrowUp|ArrowDown|Arrow(?:Left|Right)|key.*(?:38|40)/i.test(contextBlock);
+                        if (!hasArrows) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "list-no-arrow-nav",
+                                severity: "info",
+                                message: "List keyboard handler without arrow navigation",
+                                suggestion: "Add ArrowUp/ArrowDown for keyboard navigation",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check for Enter key on clickable elements
+                if (/<div[^>]*onClick|role=["']button/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasKeyboard = /onKeyDown|onKeyPress|onKeyUp/.test(contextBlock);
+                    const hasTabIndex = /tabIndex/.test(contextBlock);
+                    if (!hasKeyboard && hasTabIndex) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "clickable-no-enter",
+                            severity: "info",
+                            message: "Focusable clickable element without keyboard handler",
+                            suggestion: "Add onKeyDown to handle Enter/Space for keyboard activation",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Global check for shortcut documentation
+        if (hasKeyboardShortcuts && !hasShortcutHelp) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "shortcuts-no-help",
+                severity: "info",
+                message: "Keyboard shortcuts exist but no help/documentation found",
+                suggestion: "Add keyboard shortcut help modal (often triggered by '?')",
+            });
+        }
+        return {
+            name: "Keyboard Shortcuts",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 27. Search Debounce
+     * Check for debouncing on search/filter inputs
+     */
+    async checkSearchDebounce() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for search inputs without debounce
+                if (/search|filter|query/i.test(line) && /onChange|onInput/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 10), Math.min(i + 10, lines.length)).join("\n");
+                    const hasDebounce = /debounce|useDebounce|useDeferredValue|setTimeout|lodash.*debounce/i.test(contextBlock);
+                    const hasThrottle = /throttle|useThrottle/i.test(contextBlock);
+                    if (!hasDebounce && !hasThrottle) {
+                        // Check if it triggers an API call
+                        const triggersApi = /fetch|api|query|refetch|search.*\(/i.test(contextBlock);
+                        if (triggersApi) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "search-no-debounce",
+                                severity: "warning",
+                                message: "Search input triggers API without debouncing",
+                                suggestion: "Add debounce (300-500ms) to prevent excessive API calls",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check for useEffect with search dependency
+                if (/useEffect/.test(line)) {
+                    const effectBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasSearchDep = /\[.*(?:search|query|filter).*\]/i.test(effectBlock);
+                    const hasApi = /fetch|api|\.get|\.post/i.test(effectBlock);
+                    if (hasSearchDep && hasApi) {
+                        const hasDebounce = /debounce|setTimeout|useDeferredValue/i.test(effectBlock);
+                        if (!hasDebounce) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "effect-search-no-debounce",
+                                severity: "warning",
+                                message: "useEffect with search dependency may fire too frequently",
+                                suggestion: "Debounce the search value or use useDeferredValue",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check debounce timing
+                const debounceMatch = line.match(/debounce[^,]*,\s*(\d+)/i);
+                if (debounceMatch) {
+                    const delay = parseInt(debounceMatch[1]);
+                    if (delay < 150) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "debounce-too-short",
+                            severity: "info",
+                            message: `Debounce delay ${delay}ms may be too short`,
+                            suggestion: "Use 300-500ms for search debouncing",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    if (delay > 1000) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "debounce-too-long",
+                            severity: "info",
+                            message: `Debounce delay ${delay}ms may feel sluggish`,
+                            suggestion: "300-500ms is usually optimal for search",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Search Debounce",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 28. Confirmation Dialogs
+     * Check for confirmation on destructive actions
+     */
+    async checkConfirmationDialogs() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for destructive actions without confirmation
+                if (/handleDelete|onDelete|deleteItem|removeItem|handleRemove/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasConfirm = /confirm|Confirm|Dialog|Modal|AlertDialog|window\.confirm/i.test(contextBlock);
+                    const hasUndo = /undo|restore/i.test(contextBlock);
+                    if (!hasConfirm && !hasUndo) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "delete-no-confirmation",
+                            severity: "warning",
+                            message: "Delete action without confirmation dialog",
+                            suggestion: "Add confirmation dialog for destructive actions",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for dangerous operations
+                if (/reset.*data|clear.*all|wipe|purge|truncate/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasDoubleConfirm = /type.*confirm|enter.*name|type.*DELETE/i.test(contextBlock);
+                    if (!hasDoubleConfirm) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "dangerous-no-double-confirm",
+                            severity: "info",
+                            message: "High-risk operation without extra confirmation",
+                            suggestion: "Require typing 'DELETE' or item name for dangerous operations",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check confirmation dialog patterns
+                if (/<(?:AlertDialog|ConfirmDialog|ConfirmationModal)\b/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    // Check for clear destructive action button
+                    const hasDestructiveButton = /variant=["']destructive|color=["']error|danger|red/i.test(contextBlock);
+                    if (!hasDestructiveButton) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "confirm-no-destructive-style",
+                            severity: "info",
+                            message: "Confirmation dialog without destructive button styling",
+                            suggestion: "Use red/destructive variant for delete confirmation button",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for clear cancel option
+                    const hasCancelButton = /cancel|Cancel|onCancel|close|Close|dismiss/i.test(contextBlock);
+                    if (!hasCancelButton) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "confirm-no-cancel",
+                            severity: "warning",
+                            message: "Confirmation dialog may lack clear cancel option",
+                            suggestion: "Always provide obvious cancel/close option",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Confirmation Dialogs",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 29. Progress Indicators
+     * Check for progress tracking on multi-step operations
+     */
+    async checkProgressIndicators() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const progressPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for multi-step processes
+                if (/step|Step|currentStep|activeStep/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasStepper = /<Stepper|<Steps|<ProgressSteps|StepIndicator/i.test(contextBlock);
+                    const hasProgress = /progress|Progress|step.*of.*total/i.test(contextBlock);
+                    if (!hasStepper && !hasProgress) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "steps-no-indicator",
+                            severity: "info",
+                            message: "Multi-step process without progress indicator",
+                            suggestion: "Add Stepper component to show progress through steps",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Track stepper pattern
+                    if (hasStepper) {
+                        progressPatterns.set("stepper", (progressPatterns.get("stepper") || 0) + 1);
+                    }
+                }
+                // Check for file uploads
+                if (/upload|Upload|handleUpload|onUpload/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 25, lines.length)).join("\n");
+                    const hasProgress = /progress|Progress|percent|loaded.*total/i.test(contextBlock);
+                    const hasProgressBar = /<Progress|<LinearProgress|ProgressBar/i.test(contextBlock);
+                    if (!hasProgress && !hasProgressBar) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "upload-no-progress",
+                            severity: "warning",
+                            message: "File upload without progress indicator",
+                            suggestion: "Show upload progress bar with percentage",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for bulk operations
+                if (/bulk|batch|process.*items|import.*data/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasProgress = /progress|processed|current.*total|\d+.*of.*\d+/i.test(contextBlock);
+                    if (!hasProgress) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "bulk-no-progress",
+                            severity: "info",
+                            message: "Bulk operation without progress tracking",
+                            suggestion: "Show 'X of Y processed' indicator for bulk operations",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check progress bar accessibility
+                if (/<Progress|<LinearProgress|<CircularProgress/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasAriaLabel = /aria-label|aria-valuetext|aria-valuenow/i.test(contextBlock);
+                    if (!hasAriaLabel) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "progress-no-aria",
+                            severity: "info",
+                            message: "Progress indicator may lack screen reader support",
+                            suggestion: "Add aria-label or aria-valuetext for accessibility",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Progress Indicators",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 30. Error Recovery
+     * Check for retry mechanisms and error recovery UI
+     */
+    async checkErrorRecovery() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for error states without retry
+                if (/isError|error\s*&&|\.error\s*\?|hasError/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasRetry = /retry|Retry|refetch|try.*again|reload/i.test(contextBlock);
+                    const hasErrorMessage = /error.*message|message.*error|Error:|display.*error/i.test(contextBlock);
+                    if (!hasRetry) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "error-no-retry",
+                            severity: "info",
+                            message: "Error state without retry option",
+                            suggestion: "Add 'Try Again' or 'Retry' button for recoverable errors",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    if (!hasErrorMessage) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "error-no-message",
+                            severity: "warning",
+                            message: "Error state without clear error message",
+                            suggestion: "Display user-friendly error message explaining what went wrong",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for network error handling
+                if (/catch|\.catch|onError/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasOfflineCheck = /offline|navigator\.onLine|network.*error/i.test(contextBlock);
+                    const hasTimeoutCheck = /timeout|TIMEOUT|timed.*out/i.test(contextBlock);
+                    // Check if it distinguishes network errors
+                    if (/fetch|api|axios/i.test(contextBlock) && !hasOfflineCheck) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "no-offline-handling",
+                            severity: "info",
+                            message: "API error handling may not detect offline state",
+                            suggestion: "Check navigator.onLine and show appropriate offline message",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for ErrorBoundary usage
+                if (/<ErrorBoundary/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasFallback = /fallback|Fallback|renderError|FallbackComponent/i.test(contextBlock);
+                    const hasRetry = /retry|reset|recover/i.test(contextBlock);
+                    if (!hasFallback) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "boundary-no-fallback",
+                            severity: "warning",
+                            message: "ErrorBoundary without fallback UI",
+                            suggestion: "Add fallback prop with user-friendly error UI",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    if (!hasRetry) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "boundary-no-retry",
+                            severity: "info",
+                            message: "ErrorBoundary without retry mechanism",
+                            suggestion: "Add reset/retry functionality to recover from errors",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Error Recovery",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 31. Success Celebrations
+     * Check for micro-animations and feedback on successful actions
+     */
+    async checkSuccessCelebrations() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        let hasConfetti = false;
+        let hasSuccessAnimation = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for celebration libraries
+            if (/confetti|canvas-confetti|lottie|celebrate/i.test(content)) {
+                hasConfetti = true;
+            }
+            if (/success.*animate|animate.*success|pulse|bounce.*success/i.test(content)) {
+                hasSuccessAnimation = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for significant success events
+                if (/onSuccess|success\(|showSuccess|isSuccess/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    // Check for completion/milestone events
+                    const isMilestone = /complete|finish|checkout|payment|submit.*order|upgrade/i.test(contextBlock);
+                    const hasSpecialFeedback = /confetti|celebrate|animation|animate|party|🎉|✨/i.test(contextBlock);
+                    if (isMilestone && !hasSpecialFeedback) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "milestone-no-celebration",
+                            severity: "info",
+                            message: "Milestone event without celebratory feedback",
+                            suggestion: "Consider adding confetti or special animation for completed purchases/signups",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for checkmark animations
+                if (/<Check|<SuccessIcon|CheckCircle|CheckIcon/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasAnimation = /animate|motion|transition/i.test(contextBlock);
+                    // This is nice-to-have, just track
+                }
+                // Check for form submission success
+                if (/onSubmit.*success|handleSubmit.*success|form.*success/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasSuccessFeedback = /toast|notification|success.*message|✓|check/i.test(contextBlock);
+                    const hasRedirect = /navigate|redirect|router\.push|window\.location/i.test(contextBlock);
+                    if (!hasSuccessFeedback && !hasRedirect) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "form-success-no-feedback",
+                            severity: "info",
+                            message: "Form submission success without clear feedback",
+                            suggestion: "Show success toast or checkmark animation after submission",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for save operations
+                if (/save|Save|handleSave|onSave/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const hasSuccessFeedback = /success|saved|toast|notification|check/i.test(contextBlock);
+                    const hasAutoSave = /auto.*save|autosave|debounce.*save/i.test(contextBlock);
+                    if (!hasSuccessFeedback && !hasAutoSave) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "save-no-feedback",
+                            severity: "info",
+                            message: "Save action without success confirmation",
+                            suggestion: "Show 'Saved!' indicator or checkmark briefly after save",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Success Celebrations",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run all checks
+     */
+    async runAll(filter) {
+        const startTime = Date.now();
+        const checks = [];
+        const checkMap = {
+            hover: () => this.checkHoverStateConsistency(),
+            active: () => this.checkActiveStateCoverage(),
+            focus: () => this.checkFocusRingConsistency(),
+            disabled: () => this.checkDisabledStateStyling(),
+            cursor: () => this.checkCursorConsistency(),
+            scale: () => this.checkScaleFeedbackConsistency(),
+            spinner: () => this.checkLoadingSpinnerConsistency(),
+            motion: () => this.checkReducedMotionSupport(),
+            feedback: () => this.checkAsyncOperationFeedback(),
+            transition: () => this.checkTransitionConsistency(),
+            touch: () => this.checkTouchGestureFeedback(),
+            scroll: () => this.checkScrollSnapConsistency(),
+            dnd: () => this.checkDragDropFeedback(),
+            validation: () => this.checkInputValidationFeedback(),
+            toast: () => this.checkToastNotificationTiming(),
+            skeleton: () => this.checkSkeletonContentMatch(),
+            empty: () => this.checkEmptyStatePatterns(),
+            selection: () => this.checkSelectionFeedback(),
+            accordion: () => this.checkAccordionAnimation(),
+            modal: () => this.checkModalAnimation(),
+            copy: () => this.checkCopyFeedback(),
+            infinite: () => this.checkInfiniteScrollLoading(),
+            filter: () => this.checkFilterActiveState(),
+            optimistic: () => this.checkOptimisticUpdates(),
+            undo: () => this.checkUndoRedoPatterns(),
+            keyboard: () => this.checkKeyboardShortcuts(),
+            debounce: () => this.checkSearchDebounce(),
+            confirm: () => this.checkConfirmationDialogs(),
+            progress: () => this.checkProgressIndicators(),
+            recovery: () => this.checkErrorRecovery(),
+            celebrate: () => this.checkSuccessCelebrations(),
+        };
+        if (filter && checkMap[filter]) {
+            checks.push(await checkMap[filter]());
+        }
+        else {
+            for (const check of Object.values(checkMap)) {
+                checks.push(await check());
+            }
+        }
+        const errors = checks.reduce((sum, c) => sum + c.issues.filter((i) => i.severity === "error").length, 0);
+        const warnings = checks.reduce((sum, c) => sum + c.issues.filter((i) => i.severity === "warning").length, 0);
+        return {
+            module: "UI Interactive States",
+            passed: errors === 0,
+            totalDuration: Date.now() - startTime,
+            checks,
+            summary: {
+                total: checks.length,
+                passed: checks.filter((c) => c.passed).length,
+                failed: checks.filter((c) => !c.passed).length,
+                errors,
+                warnings,
+            },
+        };
+    }
+}
+exports.UIInteractiveStatesModule = UIInteractiveStatesModule;
+// CLI ENTRY POINT
+async function main() {
+    const args = process.argv.slice(2);
+    const filter = args.find((a) => !a.startsWith("-"));
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const parallel = args.includes("--parallel") || args.includes("-p");
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const module = new UIInteractiveStatesModule({ verbose, parallel });
+    const result = await module.runAll(filter);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log(`${console_chars_1.emoji.target} UI INTERACTIVE STATES CHECK`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log();
+    for (const check of result.checks) {
+        const icon = check.passed
+            ? console_chars_1.emoji.success
+            : check.issues.some((i) => i.severity === "error")
+                ? console_chars_1.emoji.error
+                : console_chars_1.emoji.warning;
+        console.log(`${icon} ${check.name} (${check.duration}ms)`);
+        if (check.issues.length > 0 && (verbose || check.issues.some((i) => i.severity !== "info"))) {
+            for (const issue of check.issues.slice(0, verbose ? 100 : 5)) {
+                const sevIcon = issue.severity === "error"
+                    ? console_chars_1.emoji.error
+                    : issue.severity === "warning"
+                        ? console_chars_1.emoji.warning
+                        : console_chars_1.emoji.info;
+                const relPath = path.relative(process.cwd(), issue.file).replace(/\\/g, "/");
+                console.log(`  ${sevIcon} ${relPath}:${issue.line}`);
+                console.log(`     ${issue.message}`);
+                console.log(`     ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+            }
+            if (!verbose && check.issues.length > 5) {
+                console.log(`  ... and ${check.issues.length - 5} more issues`);
+            }
+        }
+        console.log();
+    }
+    console.log((0, console_chars_1.createDivider)(80, "light"));
+    console.log(`Total: ${result.summary.total} checks | ${console_chars_1.emoji.error} ${result.summary.errors} errors | ${console_chars_1.emoji.warning} ${result.summary.warnings} warnings`);
+    console.log(`Duration: ${(result.totalDuration / 1000).toFixed(2)}s`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    if (result.summary.errors > 0) {
+        console.log(`\n${console_chars_1.emoji.error} INTERACTIVE STATES CHECK FAILED\n`);
+        process.exit(1);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.success} INTERACTIVE STATES CHECK PASSED\n`);
+        process.exit(0);
+    }
+}
+if (require.main === module)
+    main();
+//# sourceMappingURL=ui-interactive-states.js.map