@empline/preflight 1.1.0

package/dist/checks/ui/z-index-check.js

@@ -0,0 +1,669 @@
+"use strict";
+/**
+ * Z-Index Consistency & Anti-Pattern Check
+ *
+ * BLOCKING checks:
+ * 1. isolation: isolate on sticky/fixed headers (traps dropdowns)
+ * 2. Hardcoded z-index values >= 100 without tokens
+ * 3. z-index without position (has no effect)
+ * 4. Stacking context creators (transform, opacity < 1, filter) on containers with z-indexed children
+ *
+ * ADVISORY checks:
+ * 5. Missing z-index on position: fixed/absolute elements
+ * 6. Potential z-index conflicts (same layer, same component)
+ *
+ * Usage:
+ *   pnpm preflight:z-index           # Run all checks
+ *   pnpm preflight:z-index --fix     # Auto-fix hardcoded values to tokens
+ *   pnpm preflight:z-index --verbose # Show all issues with context
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "ui/z-index-check";
+exports.name = "Z Index Check";
+exports.category = "ui";
+exports.blocking = true;
+exports.description = "Z-Index Consistency & Anti-Pattern Check";
+exports.tags = ["ui"];
+// Z-index token mapping for auto-fix
+const Z_INDEX_TOKEN_MAP = {
+    0: "var(--z-base)",
+    1: "var(--z-content-low)",
+    2: "var(--z-content-mid)",
+    10: "var(--z-content-overlay)",
+    20: "var(--z-content-controls)",
+    100: "var(--z-header)",
+    200: "var(--z-sidebar)",
+    300: "var(--z-navigation)",
+    1000: "var(--z-sticky)",
+    1010: "var(--z-fixed)",
+    1030: "var(--z-dropdown)",
+    1040: "var(--z-header-dropdown)",
+    1050: "var(--z-drawer)",
+    1060: "var(--z-backdrop)",
+    1070: "var(--z-modal)",
+    1080: "var(--z-popover)",
+    1090: "var(--z-tooltip)",
+    1100: "var(--z-toast)",
+    9999: "var(--z-toast)", // Common arbitrary value -> toast level
+};
+// Suggest closest token for arbitrary values
+function suggestToken(value) {
+    if (Z_INDEX_TOKEN_MAP[value])
+        return Z_INDEX_TOKEN_MAP[value];
+    // Find closest token
+    const tokens = Object.keys(Z_INDEX_TOKEN_MAP)
+        .map(Number)
+        .sort((a, b) => a - b);
+    for (let i = 0; i < tokens.length; i++) {
+        if (value <= tokens[i]) {
+            return Z_INDEX_TOKEN_MAP[tokens[i]];
+        }
+    }
+    return "var(--z-toast)"; // Highest level
+}
+// Valid token patterns
+const VALID_Z_INDEX_PATTERNS = [
+    /var\(--z-/,
+    /z-\[var\(--z-/,
+    /z-0|z-10|z-20|z-30|z-40|z-50|z-auto/,
+];
+function isValidZIndex(value) {
+    return VALID_Z_INDEX_PATTERNS.some((pattern) => pattern.test(value));
+}
+// CACHED FILE LISTS
+let _cachedFiles = null;
+async function getFiles() {
+    if (!_cachedFiles) {
+        _cachedFiles = await file_cache_1.fileCache.getAllTsTsxCss();
+    }
+    return _cachedFiles;
+}
+/**
+ * Check 1: isolation: isolate on sticky/fixed headers
+ * BLOCKING - Creates stacking context that traps dropdowns
+ */
+function checkIsolationOnStickyHeaders(content, file, lines) {
+    const issues = [];
+    // Only check header/nav components
+    if (!/(Header|Nav|AppBar)/i.test(file)) {
+        return issues;
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("preflight-ignore"))
+            continue;
+        if (/^\s*(\/\/|\/\*|\*)/.test(line))
+            continue;
+        if (/isolation:\s*["']?isolate["']?/.test(line)) {
+            const contextStart = Math.max(0, i - 20);
+            const contextEnd = Math.min(lines.length, i + 20);
+            const context = lines.slice(contextStart, contextEnd).join("\n");
+            if (/z-index.*sticky|zIndex.*sticky|position.*sticky|position.*fixed/i.test(context) ||
+                /--z-sticky|--z-fixed/.test(context)) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    message: `isolation: isolate on sticky/fixed header traps dropdowns. Remove to allow dropdowns to escape stacking context.`,
+                    snippet: line.trim(),
+                    severity: "error",
+                    category: "stacking-context",
+                });
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 2: Hardcoded z-index values without tokens
+ * BLOCKING for values >= 100
+ */
+function checkHardcodedZIndex(content, file, lines) {
+    const issues = [];
+    // Skip script files (they define the mappings) - normalize path separators
+    const normalizedPath = file.replace(/\\/g, "/");
+    if (normalizedPath.startsWith("scripts/") || normalizedPath.includes("/scripts/"))
+        return issues;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("preflight-ignore"))
+            continue;
+        if (/^\s*(\/\/|\/\*|\*)/.test(line))
+            continue;
+        // Check inline style: zIndex: 1000 or zIndex: "1000"
+        const styleMatch = line.match(/zIndex:\s*["']?(\d+)["']?/);
+        if (styleMatch) {
+            const value = parseInt(styleMatch[1], 10);
+            if (value >= 100 && !isValidZIndex(line)) {
+                const suggestedToken = suggestToken(value);
+                issues.push({
+                    file,
+                    line: i + 1,
+                    message: `Hardcoded zIndex: ${value}. Use token: ${suggestedToken}`,
+                    snippet: line.trim(),
+                    severity: "error",
+                    category: "hardcoded-zindex",
+                    fixable: true,
+                    fix: {
+                        oldText: styleMatch[0],
+                        newText: `zIndex: "${suggestedToken}"`,
+                    },
+                });
+            }
+        }
+        // Check Tailwind arbitrary: z-[1000]
+        const tailwindMatch = line.match(/z-\[(\d+)\]/g);
+        if (tailwindMatch) {
+            for (const match of tailwindMatch) {
+                const value = parseInt(match.match(/\d+/)[0], 10);
+                if (value >= 100) {
+                    const suggestedToken = suggestToken(value);
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        message: `Arbitrary z-index class ${match}. Use token: z-[${suggestedToken}]`,
+                        snippet: line.trim(),
+                        severity: "error",
+                        category: "hardcoded-zindex",
+                        fixable: true,
+                        fix: {
+                            oldText: match,
+                            newText: `z-[${suggestedToken}]`,
+                        },
+                    });
+                }
+            }
+        }
+        // Check CSS: z-index: 1000
+        if (file.endsWith(".css")) {
+            const cssMatch = line.match(/z-index:\s*(\d+)/);
+            if (cssMatch) {
+                const value = parseInt(cssMatch[1], 10);
+                if (value >= 100 && !line.includes("var(--z-")) {
+                    const suggestedToken = suggestToken(value);
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        message: `Hardcoded z-index: ${value}. Use token: ${suggestedToken}`,
+                        snippet: line.trim(),
+                        severity: "error",
+                        category: "hardcoded-zindex",
+                        fixable: true,
+                        fix: {
+                            oldText: cssMatch[0],
+                            newText: `z-index: ${suggestedToken}`,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 3: z-index without position (has no effect)
+ * BLOCKING - Common mistake
+ */
+function checkZIndexWithoutPosition(content, file, lines) {
+    const issues = [];
+    // Skip CSS files (different context rules)
+    if (file.endsWith(".css"))
+        return issues;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes("preflight-ignore"))
+            continue;
+        if (/^\s*(\/\/|\/\*|\*)/.test(line))
+            continue;
+        // Check for zIndex in style objects
+        if (/zIndex:\s*["']?(\d+|var\()/.test(line)) {
+            // Look in surrounding context for position
+            const contextStart = Math.max(0, i - 15);
+            const contextEnd = Math.min(lines.length, i + 15);
+            const context = lines.slice(contextStart, contextEnd).join("\n");
+            // Check if position is set in the same style block
+            const hasPosition = /position:\s*["']?(relative|absolute|fixed|sticky)["']?/.test(context) ||
+                /className.*(?:relative|absolute|fixed|sticky)/.test(context) ||
+                /\b(relative|absolute|fixed|sticky)\b/.test(context) ||
+                /getPositionStyles|positionStyles|\.\.\.position/.test(context); // Dynamic position
+            // Check if it's in a flex/grid context (z-index works without position)
+            const isFlexGridContext = /display:\s*["']?(flex|grid|inline-flex|inline-grid)["']?/.test(context) ||
+                /className.*(?:flex|grid|inline-flex|inline-grid)/.test(context) ||
+                /flexShrink|flexGrow|alignSelf|justifySelf|gridColumn|gridRow/.test(context);
+            if (!hasPosition && !isFlexGridContext) {
+                // Check if it's in a component that typically has position (modals, tooltips, etc.)
+                const isPositionedComponent = /(Modal|Tooltip|Popover|Dropdown|Menu|Dialog|Drawer|Overlay|Sidebar)/i.test(file) ||
+                    /(Modal|Tooltip|Popover|Dropdown|Menu|Dialog|Drawer|Overlay)/i.test(context);
+                if (!isPositionedComponent) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        message: `z-index without position has no effect. Add position: relative/absolute/fixed/sticky.`,
+                        snippet: line.trim(),
+                        severity: "error",
+                        category: "zindex-no-position",
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 4: Stacking context creators on containers
+ * BLOCKING - transform, opacity < 1, filter create stacking contexts
+ */
+function checkStackingContextCreators(content, file, lines) {
+    const issues = [];
+    // Only check layout/container components
+    if (!/(Layout|Container|Wrapper|Header|Nav|Section)/i.test(file)) {
+        return issues;
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const prevLine = i > 0 ? lines[i - 1] : "";
+        if (line.includes("preflight-ignore") || prevLine.includes("preflight-ignore"))
+            continue;
+        if (/^\s*(\/\/|\/\*|\*)/.test(line))
+            continue;
+        // Check for stacking context creators - be specific to avoid false positives
+        // Exclude transition-transform (doesn't create stacking context until animation)
+        // Exclude translate-y-full etc (conditional transforms)
+        const hasTransform = (/transform:\s*(?!none)/.test(line) && !/transition-transform/.test(line)) ||
+            (/\btransform\b/.test(line) && !/transition-transform|translate-/.test(line));
+        const hasOpacity = /opacity:\s*(?!1\b|"1")/.test(line) && !/transition.*opacity/.test(line);
+        const hasFilter = /(?<!backdrop-)filter:\s*(?!none)/.test(line);
+        // backdrop-filter is OK - it's commonly used for glass effects
+        const hasWillChange = /will-change:\s*(?!auto)/.test(line);
+        if (hasTransform || hasOpacity || hasFilter || hasWillChange) {
+            // Look for z-indexed children in surrounding context
+            const contextStart = Math.max(0, i - 30);
+            const contextEnd = Math.min(lines.length, i + 50);
+            const context = lines.slice(contextStart, contextEnd).join("\n");
+            // Check if this container has dropdown/menu children that render portals
+            // Skip if dropdowns use portals (they escape stacking context)
+            const hasDropdownChildren = /(Dropdown|Menu|Popover|UserMenu|MegaMenu)/i.test(context) &&
+                /z-index|zIndex|--z-dropdown|--z-header-dropdown/.test(context) &&
+                !/portal|Portal|createPortal/.test(context);
+            if (hasDropdownChildren) {
+                const creator = hasTransform
+                    ? "transform"
+                    : hasOpacity
+                        ? "opacity"
+                        : hasFilter
+                            ? "filter"
+                            : "will-change";
+                issues.push({
+                    file,
+                    line: i + 1,
+                    message: `${creator} creates stacking context that may trap dropdown children. Consider moving to a child element.`,
+                    snippet: line.trim(),
+                    severity: "error",
+                    category: "stacking-context",
+                });
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 5: Missing z-index on positioned elements
+ * BLOCKING - Prevents stacking issues
+ */
+function checkMissingZIndex(content, file, lines) {
+    const issues = [];
+    // Normalize path for consistent checks
+    const normalizedPath = file.replace(/\\/g, "/");
+    // Skip scripts and test files for this check
+    if (normalizedPath.startsWith("scripts/") || normalizedPath.includes("/scripts/"))
+        return issues;
+    if (normalizedPath.includes(".test.") || normalizedPath.includes(".spec."))
+        return issues;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const prevLine = i > 0 ? lines[i - 1] : "";
+        if (line.includes("preflight-ignore") || prevLine.includes("preflight-ignore"))
+            continue;
+        if (/^\s*(\/\/|\/\*|\*)/.test(line))
+            continue;
+        // Check for position: fixed/absolute without z-index
+        const positionMatch = line.match(/position:\s*["']?(fixed|absolute)["']?/);
+        if (positionMatch) {
+            const contextStart = Math.max(0, i - 10);
+            const contextEnd = Math.min(lines.length, i + 10);
+            const context = lines.slice(contextStart, contextEnd).join("\n");
+            const hasZIndex = /zIndex:|z-index:|z-\[|z-\d+/.test(context) || /--z-/.test(context);
+            if (!hasZIndex) {
+                // Skip common patterns that don't need explicit z-index
+                const isCommonPattern = /inset-0|top-0.*right-0.*bottom-0.*left-0/.test(context) || // Full overlay
+                    /sr-only|visually-hidden/.test(context) || // Screen reader only
+                    /::before|::after|:before|:after/.test(context) || // Pseudo elements in CSS
+                    /@keyframes/.test(context); // Animation keyframes
+                // Skip CVA (class-variance-authority) patterns - z-index is in the class string
+                // Look for cva() definition in the file and check if it has z-index
+                const isCvaPattern = /cva\s*\(/.test(content) && /z-\[var\(--z-/.test(content);
+                // Skip CSS utility class definitions (they're base classes, not actual usage)
+                // Match patterns like ".absolute { position: absolute; }" or ".fixed { position: fixed; }"
+                const isCssUtilityClass = file.endsWith(".css") &&
+                    /^\.(static|relative|absolute|fixed|sticky)\s*\{/.test(lines.slice(Math.max(0, i - 3), i + 1).join("\n"));
+                // Skip JS-generated styles (template literals with position)
+                const isJsGeneratedStyle = /style\.cssText\s*=\s*`/.test(context) || /createElement/.test(context);
+                if (!isCommonPattern && !isCvaPattern && !isCssUtilityClass && !isJsGeneratedStyle) {
+                    // Determine appropriate z-index based on context
+                    const suggestedToken = determineSuggestedZIndex(context, file);
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        message: `position: ${positionMatch[1]} without z-index. Add: zIndex: "${suggestedToken}"`,
+                        snippet: line.trim(),
+                        severity: "error",
+                        category: "missing-zindex",
+                        fixable: true,
+                        fix: {
+                            oldText: positionMatch[0],
+                            newText: `${positionMatch[0]},\n        zIndex: "${suggestedToken}"`,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Determine the appropriate z-index token based on context
+ */
+function determineSuggestedZIndex(context, file) {
+    // Modal/Dialog content
+    if (/modal|dialog/i.test(file) || /modal|dialog/i.test(context)) {
+        return "var(--z-modal)";
+    }
+    // Dropdown/Menu
+    if (/dropdown|menu|popover/i.test(file) || /dropdown|menu|popover/i.test(context)) {
+        return "var(--z-dropdown)";
+    }
+    // Tooltip
+    if (/tooltip/i.test(file) || /tooltip/i.test(context)) {
+        return "var(--z-tooltip)";
+    }
+    // Drawer/Sidebar
+    if (/drawer|sidebar/i.test(file) || /drawer|sidebar/i.test(context)) {
+        return "var(--z-drawer)";
+    }
+    // Header/Nav
+    if (/header|nav|appbar/i.test(file) || /header|nav/i.test(context)) {
+        return "var(--z-sticky)";
+    }
+    // Overlay/Backdrop
+    if (/overlay|backdrop/i.test(file) || /overlay|backdrop/i.test(context)) {
+        return "var(--z-backdrop)";
+    }
+    // Default to content overlay for most positioned elements
+    return "var(--z-content-overlay)";
+}
+/**
+ * Check 6: Potential z-index conflicts
+ * INFO - Same z-index values in related components
+ */
+function checkZIndexConflicts(allIssues) {
+    const conflicts = [];
+    const zIndexUsage = new Map();
+    // Collect all z-index usages
+    for (const [file, issues] of allIssues) {
+        // Re-scan for all z-index values
+        try {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line.includes("preflight-ignore"))
+                    continue;
+                // Extract z-index values
+                const matches = [
+                    ...line.matchAll(/zIndex:\s*["']?(\d+|var\([^)]+\))["']?/g),
+                    ...line.matchAll(/z-index:\s*(\d+|var\([^)]+\))/g),
+                    ...line.matchAll(/z-\[(\d+|var\([^)]+\))\]/g),
+                ];
+                for (const match of matches) {
+                    const value = match[1];
+                    if (!zIndexUsage.has(value)) {
+                        zIndexUsage.set(value, []);
+                    }
+                    zIndexUsage.get(value).push({ file, line: i + 1, snippet: line.trim() });
+                }
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    // Find conflicts (same value in different component types)
+    for (const [value, usages] of zIndexUsage) {
+        if (usages.length > 3) {
+            // Get unique component types
+            const componentTypes = new Set(usages.map((u) => {
+                const match = u.file.match(/([A-Z][a-z]+(?:Bar|Menu|Modal|Drawer|Header|Nav))/);
+                return match ? match[1] : path.basename(u.file);
+            }));
+            if (componentTypes.size > 2) {
+                conflicts.push({
+                    file: usages[0].file,
+                    line: usages[0].line,
+                    message: `z-index ${value} used in ${usages.length} places across ${componentTypes.size} component types. Consider using semantic tokens.`,
+                    snippet: `Used in: ${Array.from(componentTypes).slice(0, 3).join(", ")}...`,
+                    severity: "info",
+                    category: "zindex-conflict",
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+/**
+ * Auto-fix hardcoded z-index values
+ */
+async function autoFix(issues) {
+    let fixedCount = 0;
+    const fileChanges = new Map();
+    // Group fixable issues by file
+    const fixableByFile = new Map();
+    for (const issue of issues) {
+        if (issue.fixable && issue.fix) {
+            if (!fixableByFile.has(issue.file)) {
+                fixableByFile.set(issue.file, []);
+            }
+            fixableByFile.get(issue.file).push(issue);
+        }
+    }
+    // Apply fixes per file
+    for (const [file, fileIssues] of fixableByFile) {
+        try {
+            let content = fileChanges.get(file) || fs.readFileSync(file, "utf8");
+            for (const issue of fileIssues) {
+                if (issue.fix && content.includes(issue.fix.oldText)) {
+                    content = content.replace(issue.fix.oldText, issue.fix.newText);
+                    fixedCount++;
+                    console.log(`   ${console_chars_1.emoji.success} Fixed ${file}:${issue.line}`);
+                    console.log(`      ${issue.fix.oldText} → ${issue.fix.newText}`);
+                }
+            }
+            fileChanges.set(file, content);
+        }
+        catch (error) {
+            console.log(`   ${console_chars_1.emoji.error} Failed to fix ${file}: ${error}`);
+        }
+    }
+    // Write all changes
+    for (const [file, content] of fileChanges) {
+        fs.writeFileSync(file, content, "utf8");
+    }
+    return fixedCount;
+}
+/**
+ * Main check function
+ */
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    const isVerbose = process.argv.includes("--verbose");
+    const shouldFix = process.argv.includes("--fix");
+    console.log(`\n${console_chars_1.emoji.search} Z-Index Consistency Check\n`);
+    console.log("Checks:");
+    console.log("  1. isolation: isolate on sticky headers (BLOCKING)");
+    console.log("  2. Hardcoded z-index >= 100 without tokens (BLOCKING)");
+    console.log("  3. z-index without position (BLOCKING)");
+    console.log("  4. Stacking context creators on containers (BLOCKING)");
+    console.log("  5. Missing z-index on fixed/absolute (BLOCKING)");
+    console.log("  6. Z-index conflicts (INFO)\n");
+    const files = await getFiles();
+    const result = { blocking: [], advisory: [], info: [] };
+    const allFileIssues = new Map();
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Run all checks
+            const isolationIssues = checkIsolationOnStickyHeaders(content, file, lines);
+            const hardcodedIssues = checkHardcodedZIndex(content, file, lines);
+            const noPositionIssues = checkZIndexWithoutPosition(content, file, lines);
+            const stackingIssues = checkStackingContextCreators(content, file, lines);
+            const missingIssues = checkMissingZIndex(content, file, lines);
+            // Categorize - ALL are now blocking
+            result.blocking.push(...isolationIssues);
+            result.blocking.push(...hardcodedIssues);
+            result.blocking.push(...noPositionIssues);
+            result.blocking.push(...stackingIssues);
+            result.blocking.push(...missingIssues);
+            // Store for conflict check
+            allFileIssues.set(file, [
+                ...isolationIssues,
+                ...hardcodedIssues,
+                ...noPositionIssues,
+                ...stackingIssues,
+                ...missingIssues,
+            ]);
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    // Check for conflicts
+    const conflictIssues = checkZIndexConflicts(allFileIssues);
+    result.info.push(...conflictIssues);
+    // Report results
+    const totalBlocking = result.blocking.length;
+    const totalAdvisory = result.advisory.length;
+    const totalInfo = result.info.length;
+    const fixableCount = result.blocking.filter((i) => i.fixable).length;
+    if (totalBlocking > 0) {
+        console.log(`${console_chars_1.emoji.error} Found ${totalBlocking} BLOCKING issues:\n`);
+        // Group by category
+        const byCategory = new Map();
+        for (const issue of result.blocking) {
+            if (!byCategory.has(issue.category)) {
+                byCategory.set(issue.category, []);
+            }
+            byCategory.get(issue.category).push(issue);
+        }
+        for (const [category, issues] of byCategory) {
+            console.log(`  ${category} (${issues.length}):`);
+            const toShow = isVerbose ? issues : issues.slice(0, 3);
+            for (const issue of toShow) {
+                console.log(`    ${issue.file}:${issue.line}`);
+                console.log(`      ${issue.message}`);
+                if (isVerbose) {
+                    console.log(`      ${issue.snippet}`);
+                }
+            }
+            if (!isVerbose && issues.length > 3) {
+                console.log(`    ... and ${issues.length - 3} more`);
+            }
+            console.log();
+        }
+        if (fixableCount > 0) {
+            console.log(`${console_chars_1.emoji.hint} ${fixableCount} issues are auto-fixable.`);
+            if (shouldFix) {
+                console.log(`\n${console_chars_1.emoji.wrench} Running auto-fix...\n`);
+                const fixed = await autoFix(result.blocking);
+                console.log(`\n${console_chars_1.emoji.success} Fixed ${fixed} issues. Re-run to verify.`);
+                if (fixed === fixableCount) {
+                    process.exit(0); // All fixed, exit success
+                }
+            }
+            else {
+                console.log(`   Run with --fix to auto-fix.\n`);
+            }
+        }
+        process.exit(1);
+    }
+    if (totalAdvisory > 0) {
+        console.log(`${console_chars_1.emoji.warning} Found ${totalAdvisory} advisory issues:\n`);
+        const toShow = isVerbose ? result.advisory : result.advisory.slice(0, 5);
+        for (const issue of toShow) {
+            console.log(`  ${issue.file}:${issue.line}`);
+            console.log(`    ${issue.message}`);
+        }
+        if (!isVerbose && result.advisory.length > 5) {
+            console.log(`  ... and ${result.advisory.length - 5} more`);
+        }
+        console.log(`\n${console_chars_1.emoji.hint} Advisory issues don't block the build.\n`);
+    }
+    if (totalInfo > 0 && isVerbose) {
+        console.log(`${console_chars_1.emoji.info} Found ${totalInfo} informational notes:\n`);
+        for (const issue of result.info) {
+            console.log(`  ${issue.message}`);
+            console.log(`    ${issue.snippet}`);
+        }
+        console.log();
+    }
+    if (totalBlocking === 0) {
+        console.log(`${console_chars_1.emoji.success} Z-Index consistency check passed!`);
+        if (totalAdvisory > 0) {
+            console.log(`   (${totalAdvisory} advisory, ${totalInfo} info)`);
+        }
+    }
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch(console.error);
+}
+//# sourceMappingURL=z-index-check.js.map