@empline/preflight 1.0.20

package/dist/checks/quality/critical-type-imports.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env tsx
+/**
+ * Critical Type Imports Preflight (BLOCKING)
+ *
+ * Validates that Next.js files have required type imports that ESLint's
+ * unused-imports plugin incorrectly removes.
+ *
+ * Problem: ESLint's unused-imports plugin doesn't recognize type-only usage
+ * in function signatures like `(request: NextRequest)`, causing it to
+ * remove the import and break 273+ files.
+ *
+ * Usage:
+ *   pnpm preflight:critical-type-imports           # Check for missing imports
+ *   pnpm preflight:critical-type-imports --fix     # Auto-fix missing imports
+ *   pnpm preflight:critical-type-imports --dry-run # Preview fixes without applying
+ */
+export declare const id = "quality/critical-type-imports";
+export declare const name = "Critical Type Imports";
+export declare const category = "quality";
+export declare const blocking = true;
+export declare const description = "Critical Type Imports Preflight (BLOCKING)";
+export declare const tags: string[];
+//# sourceMappingURL=critical-type-imports.d.ts.map

package/dist/checks/quality/critical-type-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"critical-type-imports.d.ts","sourceRoot":"","sources":["../../../src/checks/quality/critical-type-imports.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;GAcG;AAUH,eAAO,MAAM,EAAE,kCAAkC,CAAC;AAClD,eAAO,MAAM,IAAI,0BAA0B,CAAC;AAC5C,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,OAAO,CAAC;AAC7B,eAAO,MAAM,WAAW,+CAA+C,CAAC;AACxE,eAAO,MAAM,IAAI,UAAc,CAAC"}

package/dist/checks/quality/critical-type-imports.js

@@ -0,0 +1,632 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Critical Type Imports Preflight (BLOCKING)
+ *
+ * Validates that Next.js files have required type imports that ESLint's
+ * unused-imports plugin incorrectly removes.
+ *
+ * Problem: ESLint's unused-imports plugin doesn't recognize type-only usage
+ * in function signatures like `(request: NextRequest)`, causing it to
+ * remove the import and break 273+ files.
+ *
+ * Usage:
+ *   pnpm preflight:critical-type-imports           # Check for missing imports
+ *   pnpm preflight:critical-type-imports --fix     # Auto-fix missing imports
+ *   pnpm preflight:critical-type-imports --dry-run # Preview fixes without applying
+ */
+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;
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+const console_chars_1 = require("../../utils/console-chars");
+// Check metadata
+exports.id = "quality/critical-type-imports";
+exports.name = "Critical Type Imports";
+exports.category = "quality";
+exports.blocking = true;
+exports.description = "Critical Type Imports Preflight (BLOCKING)";
+exports.tags = ["quality"];
+// Critical type imports that ESLint incorrectly removes
+// These are used in type annotations but not recognized as "used"
+//
+// IMPORTANT: This list was expanded after a major incident where lint --fix
+// removed 600+ type imports across 220 files, breaking the build.
+// The unused-imports plugin doesn't understand TypeScript type-only usage.
+const CRITICAL_TYPE_IMPORTS = [
+    // CLASS-VARIANCE-AUTHORITY (CVA) - Used in UI component type definitions
+    // Pattern: interface Props extends VariantProps<typeof variants> { }
+    {
+        type: "VariantProps",
+        module: "class-variance-authority",
+        pattern: /VariantProps<typeof\s+\w+>/,
+        fileTypes: ["component", "ui"],
+    },
+    // NEXT.JS - App Router types
+    {
+        type: "NextRequest",
+        module: "next/server",
+        pattern: /:\s*NextRequest\b/,
+        fileTypes: ["route"],
+    },
+    {
+        type: "NextResponse",
+        module: "next/server",
+        pattern: /:\s*NextResponse\b|NextResponse\./,
+        fileTypes: ["route"],
+    },
+    {
+        type: "Metadata",
+        module: "next",
+        pattern: /:\s*Metadata\b|export\s+const\s+metadata\s*:\s*Metadata/,
+        fileTypes: ["page", "layout"],
+    },
+    {
+        type: "ResolvingMetadata",
+        module: "next",
+        pattern: /:\s*ResolvingMetadata\b/,
+        fileTypes: ["page", "layout"],
+    },
+    // Next.js Pages Router (if used)
+    { type: "NextApiRequest", module: "next", pattern: /:\s*NextApiRequest\b/, fileTypes: ["api"] },
+    { type: "NextApiResponse", module: "next", pattern: /:\s*NextApiResponse\b/, fileTypes: ["api"] },
+    {
+        type: "GetServerSidePropsContext",
+        module: "next",
+        pattern: /:\s*GetServerSidePropsContext\b/,
+        fileTypes: ["page"],
+    },
+    {
+        type: "GetStaticPropsContext",
+        module: "next",
+        pattern: /:\s*GetStaticPropsContext\b/,
+        fileTypes: ["page"],
+    },
+    // REACT - Core types used in type annotations
+    {
+        type: "ReactNode",
+        module: "react",
+        pattern: /:\s*ReactNode\b|<ReactNode>/,
+        fileTypes: ["component", "ui", "layout", "page", "lib", "hook"],
+    },
+    {
+        type: "ReactElement",
+        module: "react",
+        pattern: /:\s*ReactElement\b|<ReactElement>/,
+        fileTypes: ["component", "ui", "lib", "hook"],
+    },
+    {
+        type: "RefObject",
+        module: "react",
+        pattern: /:\s*\bRefObject<|\bRefObject</,
+        fileTypes: ["component", "ui", "hook"],
+    },
+    {
+        type: "MutableRefObject",
+        module: "react",
+        pattern: /:\s*MutableRefObject<|MutableRefObject</,
+        fileTypes: ["component", "ui", "hook"],
+    },
+    {
+        type: "CSSProperties",
+        module: "react",
+        pattern: /:\s*CSSProperties\b/,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "ChangeEvent",
+        module: "react",
+        pattern: /:\s*ChangeEvent<|ChangeEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "KeyboardEvent",
+        module: "react",
+        pattern: /:\s*KeyboardEvent<|KeyboardEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "MouseEvent",
+        module: "react",
+        pattern: /:\s*MouseEvent<|MouseEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "FocusEvent",
+        module: "react",
+        pattern: /:\s*FocusEvent<|FocusEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "FormEvent",
+        module: "react",
+        pattern: /:\s*FormEvent<|FormEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "DragEvent",
+        module: "react",
+        pattern: /:\s*DragEvent<|DragEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "SyntheticEvent",
+        module: "react",
+        pattern: /:\s*SyntheticEvent<|SyntheticEvent</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "Dispatch",
+        module: "react",
+        pattern: /:\s*Dispatch<|Dispatch</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    {
+        type: "SetStateAction",
+        module: "react",
+        pattern: /SetStateAction</,
+        fileTypes: ["component", "ui", "hook", "lib"],
+    },
+    { type: "FC", module: "react", pattern: /:\s*FC<|FC</, fileTypes: ["component", "ui"] },
+    {
+        type: "PropsWithChildren",
+        module: "react",
+        pattern: /PropsWithChildren</,
+        fileTypes: ["component", "ui"],
+    },
+    // React HTML attribute types (used in component prop interfaces)
+    {
+        type: "LabelHTMLAttributes",
+        module: "react",
+        pattern: /LabelHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "ButtonHTMLAttributes",
+        module: "react",
+        pattern: /ButtonHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "InputHTMLAttributes",
+        module: "react",
+        pattern: /InputHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "TextareaHTMLAttributes",
+        module: "react",
+        pattern: /TextareaHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "SelectHTMLAttributes",
+        module: "react",
+        pattern: /SelectHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "ImgHTMLAttributes",
+        module: "react",
+        pattern: /ImgHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "AnchorHTMLAttributes",
+        module: "react",
+        pattern: /AnchorHTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "HTMLAttributes",
+        module: "react",
+        pattern: /[^A-Za-z]HTMLAttributes</,
+        fileTypes: ["component", "ui"],
+    },
+    {
+        type: "ComponentProps",
+        module: "react",
+        pattern: /ComponentProps</,
+        fileTypes: ["component", "ui"],
+    },
+    // PRISMA - Namespace types
+    // ESLint's unused-imports doesn't recognize namespace usage like `Prisma.JsonValue`
+    // Uses custom check function to exclude comments and string literals
+    {
+        type: "Prisma",
+        module: "@prisma/client",
+        pattern: /\bPrisma\./,
+        fileTypes: ["route", "page", "layout", "api", "lib", "script"],
+        excludeComments: true,
+    },
+];
+async function findMissingImports() {
+    const missing = [];
+    const stats = {
+        routeFiles: 0,
+        pageFiles: 0,
+        layoutFiles: 0,
+        libFiles: 0,
+        scriptFiles: 0,
+        totalScanned: 0,
+        missingCount: 0,
+        filesAffected: 0,
+    };
+    // Scan API routes
+    const routeFiles = await (0, glob_1.glob)("app/**/route.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    stats.routeFiles = routeFiles.length;
+    for (const file of routeFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["route"], missing);
+    }
+    // Scan page files
+    const pageFiles = await (0, glob_1.glob)("app/**/page.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    stats.pageFiles = pageFiles.length;
+    for (const file of pageFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["page"], missing);
+    }
+    // Scan layout files
+    const layoutFiles = await (0, glob_1.glob)("app/**/layout.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    stats.layoutFiles = layoutFiles.length;
+    for (const file of layoutFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["layout"], missing);
+    }
+    // Scan pages router API routes (if they exist)
+    const pagesApiFiles = await (0, glob_1.glob)("pages/api/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    for (const file of pagesApiFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["api"], missing);
+    }
+    // Scan lib files for Prisma namespace usage and React types
+    const libFiles = await (0, glob_1.glob)("lib/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**", "**/__mocks__/**"],
+    });
+    stats.libFiles = libFiles.length;
+    for (const file of libFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["lib"], missing);
+    }
+    // Scan scripts for Prisma namespace usage (seeds, migrations, utilities)
+    const scriptFiles = await (0, glob_1.glob)("scripts/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**", "**/__mocks__/**"],
+    });
+    stats.scriptFiles = scriptFiles.length;
+    for (const file of scriptFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["script"], missing);
+    }
+    // CRITICAL: Scan components for VariantProps and React types
+    // This was added after lint --fix removed 600+ type imports
+    // Scan UI components (highest priority - VariantProps lives here)
+    const uiFiles = await (0, glob_1.glob)("components/ui/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    for (const file of uiFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["ui", "component"], missing);
+    }
+    // Scan shared components
+    const sharedComponentFiles = await (0, glob_1.glob)("components/shared/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    for (const file of sharedComponentFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["component"], missing);
+    }
+    // Scan all other components
+    const otherComponentFiles = await (0, glob_1.glob)("components/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**", "components/ui/**", "components/shared/**"],
+    });
+    for (const file of otherComponentFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["component"], missing);
+    }
+    // Scan hooks
+    const hookFiles = await (0, glob_1.glob)("hooks/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    for (const file of hookFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["hook"], missing);
+    }
+    // Scan contexts
+    const contextFiles = await (0, glob_1.glob)("contexts/**/*.{ts,tsx}", {
+        ignore: ["**/node_modules/**", "**/.next/**"],
+    });
+    for (const file of contextFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        checkFileForMissingImports(file, content, ["component", "hook"], missing);
+    }
+    const componentCount = uiFiles.length + sharedComponentFiles.length + otherComponentFiles.length;
+    const hookCount = hookFiles.length;
+    const contextCount = contextFiles.length;
+    stats.totalScanned =
+        stats.routeFiles +
+            stats.pageFiles +
+            stats.layoutFiles +
+            pagesApiFiles.length +
+            stats.libFiles +
+            stats.scriptFiles +
+            componentCount +
+            hookCount +
+            contextCount;
+    stats.missingCount = missing.length;
+    stats.filesAffected = new Set(missing.map((m) => m.file)).size;
+    return { missing, stats };
+}
+function checkFileForMissingImports(file, content, fileTypes, missing) {
+    for (const { type, module, pattern, fileTypes: allowedTypes, excludeComments, } of CRITICAL_TYPE_IMPORTS) {
+        // Skip if this type isn't relevant for this file type
+        if (!allowedTypes.some((t) => fileTypes.includes(t)))
+            continue;
+        // Check if type is used in the file
+        let isUsed = false;
+        let usageLine = 1;
+        const lines = content.split("\n");
+        if (excludeComments) {
+            // For patterns that need comment exclusion, check line by line
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+                // Skip comment lines
+                if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*"))
+                    continue;
+                // Skip lines where the match is inside a string literal
+                if (pattern.test(line)) {
+                    // Simple heuristic: if Prisma. appears before any quote on the line, it's likely code
+                    const prismaIndex = line.indexOf("Prisma.");
+                    const firstQuote = Math.min(line.indexOf('"') === -1 ? Infinity : line.indexOf('"'), line.indexOf("'") === -1 ? Infinity : line.indexOf("'"), line.indexOf("`") === -1 ? Infinity : line.indexOf("`"));
+                    if (prismaIndex < firstQuote) {
+                        isUsed = true;
+                        usageLine = i + 1;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            // Standard pattern check
+            if (pattern.test(content)) {
+                isUsed = true;
+                for (let i = 0; i < lines.length; i++) {
+                    if (pattern.test(lines[i])) {
+                        usageLine = i + 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (isUsed) {
+            // Check if it's imported - handles multiple patterns:
+            // 1. `import type { X } from "module"`
+            // 2. `import { type X } from "module"`
+            // 3. `import React, { type X } from "module"` (default + named)
+            // 4. `import { X, type Y } from "module"` (mixed)
+            const escapedModule = module.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const importPatterns = [
+                // Pattern 1: import type { X } from "module"
+                new RegExp(`import\\s+type\\s+\\{[^}]*\\b${type}\\b[^}]*\\}\\s+from\\s+['"]${escapedModule}['"]`),
+                // Pattern 2: import { type X } from "module" (inline type)
+                new RegExp(`import\\s+\\{[^}]*\\btype\\s+${type}\\b[^}]*\\}\\s+from\\s+['"]${escapedModule}['"]`),
+                // Pattern 3: import Default, { type X } from "module"
+                new RegExp(`import\\s+\\w+\\s*,\\s*\\{[^}]*\\btype\\s+${type}\\b[^}]*\\}\\s+from\\s+['"]${escapedModule}['"]`),
+                // Pattern 4: import { X } from "module" (non-type import, still valid)
+                new RegExp(`import\\s+\\{[^}]*\\b${type}\\b[^}]*\\}\\s+from\\s+['"]${escapedModule}['"]`),
+                // Pattern 5: import Default, { X } from "module" (default + named, non-type)
+                new RegExp(`import\\s+\\w+\\s*,\\s*\\{[^}]*\\b${type}\\b[^}]*\\}\\s+from\\s+['"]${escapedModule}['"]`),
+            ];
+            const isImported = importPatterns.some((regex) => regex.test(content));
+            // For React types, also check if accessed via React namespace (React.X)
+            // This is valid when React is imported as a default import
+            let isAccessedViaNamespace = false;
+            if (module === "react" && !isImported) {
+                // Check if the type is used with React. prefix (e.g., React.HTMLAttributes)
+                const namespacePattern = new RegExp(`React\\.${type}[<\\b]`);
+                if (namespacePattern.test(content)) {
+                    // Verify React is imported as default
+                    const reactDefaultImport = /import\s+React[\s,]/.test(content);
+                    if (reactDefaultImport) {
+                        isAccessedViaNamespace = true;
+                    }
+                }
+            }
+            if (!isImported && !isAccessedViaNamespace) {
+                missing.push({
+                    file,
+                    usedType: type,
+                    line: usageLine,
+                });
+            }
+        }
+    }
+}
+async function fixMissingImports(missing, dryRun) {
+    // Group by file and module for efficient processing
+    const byFileAndModule = new Map();
+    for (const m of missing) {
+        const config = CRITICAL_TYPE_IMPORTS.find((c) => c.type === m.usedType);
+        if (!config)
+            continue;
+        if (!byFileAndModule.has(m.file)) {
+            byFileAndModule.set(m.file, new Map());
+        }
+        const moduleMap = byFileAndModule.get(m.file);
+        if (!moduleMap.has(config.module)) {
+            moduleMap.set(config.module, []);
+        }
+        const types = moduleMap.get(config.module);
+        if (!types.includes(m.usedType)) {
+            types.push(m.usedType);
+        }
+    }
+    let fixed = 0;
+    for (const [filePath, moduleMap] of byFileAndModule) {
+        const content = fs.readFileSync(filePath, "utf8");
+        let newContent = content;
+        for (const [moduleName, types] of moduleMap) {
+            // Check what types are already imported from this module
+            // Match both `import type { X }` and `import { type X }` patterns
+            const importRegex = new RegExp(`import\\s+(?:type\\s+)?\\{([^}]*)\\}\\s+from\\s+['"]${moduleName.replace("/", "\\/")}['"]`, "g");
+            const match = importRegex.exec(newContent);
+            if (match) {
+                // There's an existing import from this module
+                const existingImports = match[1];
+                const typesToAdd = [];
+                for (const typeName of types) {
+                    // Check if type is already imported (with or without `type` keyword)
+                    const typeAlreadyImported = new RegExp(`\\b(?:type\\s+)?${typeName}\\b`).test(existingImports);
+                    if (!typeAlreadyImported) {
+                        typesToAdd.push(typeName);
+                    }
+                }
+                if (typesToAdd.length > 0) {
+                    if (dryRun) {
+                        console.log(`   ${console_chars_1.emoji.hint} Would add 'type ${typesToAdd.join(", type ")}' to existing import in ${filePath}`);
+                    }
+                    else {
+                        // Add the types to the existing import with inline `type` keyword
+                        const newImports = typesToAdd.map((t) => `type ${t}`).join(", ");
+                        const updatedImportContent = existingImports.trim()
+                            ? `${existingImports.trimEnd()}, ${newImports}`
+                            : newImports;
+                        newContent = newContent.replace(match[0], match[0].replace(existingImports, updatedImportContent));
+                    }
+                    fixed += typesToAdd.length;
+                }
+            }
+            else {
+                // No existing import from this module - create a new type import
+                const typesToAdd = types.filter((t) => {
+                    // Double-check it's not imported elsewhere with a different pattern
+                    const altPattern = new RegExp(`import\\s+.*\\b${t}\\b.*from\\s+['"]${moduleName.replace("/", "\\/")}['"]`);
+                    return !altPattern.test(newContent);
+                });
+                if (typesToAdd.length > 0) {
+                    if (dryRun) {
+                        console.log(`   ${console_chars_1.emoji.hint} Would add \`import type { ${typesToAdd.join(", ")} } from "${moduleName}"\` to ${filePath}`);
+                    }
+                    else {
+                        // Find the right place to insert (after "use client" directive if present)
+                        const useClientMatch = newContent.match(/^["']use client["'];?\s*\n/);
+                        const insertPos = useClientMatch ? useClientMatch[0].length : 0;
+                        const newImport = `import type { ${typesToAdd.join(", ")} } from "${moduleName}";\n`;
+                        newContent = newContent.slice(0, insertPos) + newImport + newContent.slice(insertPos);
+                    }
+                    fixed += typesToAdd.length;
+                }
+            }
+        }
+        if (!dryRun && newContent !== content) {
+            fs.writeFileSync(filePath, newContent, "utf8");
+        }
+    }
+    return fixed;
+}
+async function main() {
+    const startTime = Date.now();
+    const args = process.argv.slice(2);
+    const shouldFix = args.includes("--fix");
+    const dryRun = args.includes("--dry-run");
+    console.log(`\n${console_chars_1.emoji.search} CRITICAL TYPE IMPORTS PREFLIGHT`);
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    console.log("Checking for missing type imports that ESLint incorrectly removes...\n");
+    const { missing, stats } = await findMissingImports();
+    const elapsed = Date.now() - startTime;
+    // Show scan stats
+    console.log(`${console_chars_1.emoji.chart} Scanned ${stats.totalScanned} files in ${elapsed}ms`);
+    console.log(`   ${console_chars_1.chars.bullet} Route files: ${stats.routeFiles}`);
+    console.log(`   ${console_chars_1.chars.bullet} Page files: ${stats.pageFiles}`);
+    console.log(`   ${console_chars_1.chars.bullet} Layout files: ${stats.layoutFiles}`);
+    console.log(`   ${console_chars_1.chars.bullet} Lib files: ${stats.libFiles}`);
+    console.log(`   ${console_chars_1.chars.bullet} Script files: ${stats.scriptFiles}\n`);
+    if (missing.length === 0) {
+        console.log(`${console_chars_1.emoji.success} All critical type imports are present`);
+        console.log((0, console_chars_1.createDivider)(70, "heavy"));
+        console.log(`\n${console_chars_1.emoji.success} CRITICAL TYPE IMPORTS PREFLIGHT PASSED\n`);
+        process.exit(0);
+    }
+    console.log(`${console_chars_1.emoji.error} Found ${stats.missingCount} missing imports in ${stats.filesAffected} files:\n`);
+    // Group by file for display
+    const byFile = new Map();
+    for (const m of missing) {
+        const list = byFile.get(m.file) || [];
+        list.push(m);
+        byFile.set(m.file, list);
+    }
+    for (const [file, imports] of byFile) {
+        console.log(`   ${console_chars_1.emoji.file} ${file}`);
+        for (const imp of imports) {
+            console.log(`      ${console_chars_1.chars.bullet} Missing: ${imp.usedType} (used at line ${imp.line})`);
+        }
+    }
+    if (shouldFix || dryRun) {
+        console.log(`\n${dryRun ? console_chars_1.emoji.search : console_chars_1.emoji.wrench} ${dryRun ? "Dry run - previewing fixes..." : "Fixing missing imports..."}`);
+        const fixedCount = await fixMissingImports(missing, dryRun);
+        if (dryRun) {
+            console.log(`\n${console_chars_1.emoji.hint} Would fix ${fixedCount} missing imports`);
+            console.log(`${console_chars_1.emoji.hint} Run with --fix to apply changes`);
+            console.log((0, console_chars_1.createDivider)(70, "heavy"));
+            console.log(`\n${console_chars_1.emoji.error} CRITICAL TYPE IMPORTS PREFLIGHT FAILED (dry run)\n`);
+            process.exit(1);
+        }
+        else {
+            console.log(`${console_chars_1.emoji.success} Fixed ${fixedCount} missing imports`);
+            console.log((0, console_chars_1.createDivider)(70, "heavy"));
+            console.log(`\n${console_chars_1.emoji.success} CRITICAL TYPE IMPORTS PREFLIGHT PASSED (after fix)\n`);
+            process.exit(0);
+        }
+    }
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    console.log(`\n${console_chars_1.emoji.hint} To preview fixes: pnpm preflight:critical-type-imports --dry-run`);
+    console.log(`${console_chars_1.emoji.hint} To auto-fix: pnpm preflight:critical-type-imports --fix`);
+    console.log(`\n${console_chars_1.emoji.error} CRITICAL TYPE IMPORTS PREFLIGHT FAILED (BLOCKING)\n`);
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error(`${console_chars_1.emoji.error} Preflight failed:`, err);
+    process.exit(1);
+});
+//# sourceMappingURL=critical-type-imports.js.map