@empline/preflight 1.0.20

package/dist/checks/nextjs/nextjs16-compatibility.js

@@ -0,0 +1,1208 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Next.js 16+ Compatibility Preflight (BLOCKING)
+ *
+ * Ensures codebase is ready for Next.js 16 and future versions.
+ * Detects deprecated patterns and enforces new APIs.
+ *
+ * Key Next.js 16 Changes:
+ * 1. Turbopack is default (no --turbopack flag needed)
+ * 2. Async Request APIs are REQUIRED (no sync fallback)
+ * 3. middleware.ts renamed to proxy.ts (edge runtime deprecated)
+ * 4. React 19.2 with React Compiler support
+ * 5. cacheLife/cacheTag stable (no unstable_ prefix)
+ * 6. PPR via cacheComponents (not experimental_ppr)
+ * 7. next/legacy/image deprecated
+ * 8. images.domains deprecated (use remotePatterns)
+ * 9. Parallel routes require default.js
+ * 10. ESLint flat config default
+ * 11. SSR/Client boundary validation (Turbopack module instantiation)
+ * 12. Date.now()/new Date() in Client Components require Suspense boundary
+ * 13. generateStaticParams must be async
+ * 14. next/router removed (use next/navigation)
+ * 15. next/font optimization changes
+ * 16. instrumentation.ts for monitoring setup
+ *
+ * Usage:
+ *   pnpm preflight:nextjs16           # All checks
+ *   pnpm preflight:nextjs16:verbose   # Detailed output
+ *   pnpm preflight:nextjs16:warn      # Warning mode (non-blocking)
+ *   pnpm preflight:nextjs16:json      # JSON output for CI
+ *   pnpm preflight:nextjs16:fix       # Auto-fix simple issues
+ */
+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 crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+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");
+// Check metadata
+exports.id = "nextjs/nextjs16-compatibility";
+exports.name = "Nextjs16 Compatibility";
+exports.category = "nextjs";
+exports.blocking = true;
+exports.description = "Next.js 16+ Compatibility Preflight (BLOCKING)";
+exports.tags = ["nextjs"];
+// Cache file for incremental scanning
+const CACHE_FILE = ".next/preflight-nextjs16-cache.json";
+const EXCLUDED = (0, glob_patterns_1.extendExcludes)(glob_patterns_1.STANDARD_EXCLUDES_WITH_TESTS, [
+    "**/test-results/**",
+    "**/scripts/active/preflights/**",
+]);
+// CHECK 1: Async Request APIs (cookies, headers, params, searchParams)
+function checkAsyncRequestAPIs(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check app directory files for params/searchParams
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const isAppDir = normalizedPath.includes("/app/");
+    // Patterns for synchronous access that should be async
+    const syncPatterns = [
+        // Direct destructuring without await
+        { pattern: /const\s*\{\s*(cookies|headers)\s*\}\s*=\s*(?!await)/, api: "cookies/headers" },
+        // Synchronous cookies() call
+        { pattern: /(?<!await\s+)cookies\(\)\.get\(/, api: "cookies" },
+        { pattern: /(?<!await\s+)cookies\(\)\.set\(/, api: "cookies" },
+        { pattern: /(?<!await\s+)cookies\(\)\.delete\(/, api: "cookies" },
+        // Synchronous headers() call
+        { pattern: /(?<!await\s+)headers\(\)\.get\(/, api: "headers" },
+    ];
+    // Only check params/searchParams in app directory page/layout files
+    if (isAppDir && normalizedPath.match(/\/(page|layout)\.(ts|tsx|js|jsx)$/)) {
+        // params without Promise type in function signature (not type definitions)
+        syncPatterns.push({
+            pattern: /(?:async\s+)?function\s+\w+\s*\(\s*\{\s*params\s*\}\s*:\s*\{\s*params:\s*\{/,
+            api: "params",
+        }, {
+            pattern: /(?:async\s+)?function\s+\w+\s*\(\s*\{\s*searchParams\s*\}\s*:\s*\{\s*searchParams:\s*\{/,
+            api: "searchParams",
+        });
+    }
+    lines.forEach((line, idx) => {
+        for (const { pattern, api } of syncPatterns) {
+            if (pattern.test(line)) {
+                // Skip if it's a type definition or interface
+                if (line.includes("interface") || line.includes("type ") || line.includes("Promise<")) {
+                    continue;
+                }
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "sync-request-api",
+                    severity: "error",
+                    message: `Synchronous ${api} access is removed in Next.js 16`,
+                    suggestion: `Use async/await: const ${api} = await ${api}()`,
+                    snippet: line.trim(),
+                });
+            }
+        }
+    });
+    return issues;
+}
+// CHECK 2: Deprecated unstable_ prefixes
+function checkUnstablePrefixes(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    const deprecatedPrefixes = [
+        // unstable_cache still works in Next.js 16, just deprecated - mark as info
+        // Migration to "use cache" directive requires experimental dynamicIO flag
+        {
+            pattern: /unstable_cache/,
+            replacement: '"use cache" directive (requires dynamicIO)',
+            api: "unstable_cache",
+            severity: "info",
+        },
+        {
+            pattern: /unstable_noStore/,
+            replacement: "noStore",
+            api: "unstable_noStore",
+            severity: "warning",
+        },
+        {
+            pattern: /unstable_cacheLife/,
+            replacement: "cacheLife",
+            api: "unstable_cacheLife",
+            severity: "warning",
+        },
+        {
+            pattern: /unstable_cacheTag/,
+            replacement: "cacheTag",
+            api: "unstable_cacheTag",
+            severity: "warning",
+        },
+        {
+            pattern: /experimental_ppr/,
+            replacement: "cacheComponents",
+            api: "experimental_ppr",
+            severity: "warning",
+        },
+    ];
+    lines.forEach((line, idx) => {
+        for (const { pattern, replacement, api, severity } of deprecatedPrefixes) {
+            if (pattern.test(line)) {
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "deprecated-unstable-prefix",
+                    severity,
+                    message: `${api} is deprecated in Next.js 16`,
+                    suggestion: `Use ${replacement} instead`,
+                    snippet: line.trim(),
+                });
+            }
+        }
+    });
+    return issues;
+}
+// CHECK 3: Legacy Image Component
+function checkLegacyImage(filePath, content) {
+    const issues = [];
+    // Skip preflight files (they contain the pattern in check logic)
+    if (filePath.includes("preflights"))
+        return issues;
+    const lines = content.split("\n");
+    lines.forEach((line, idx) => {
+        if (line.includes("next/legacy/image") || line.includes("from 'next/legacy/image'")) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "legacy-image",
+                severity: "error",
+                message: "next/legacy/image is deprecated in Next.js 16",
+                suggestion: "Migrate to next/image with updated props",
+                snippet: line.trim(),
+            });
+        }
+    });
+    return issues;
+}
+// CHECK 4: useFormState (deprecated, use useActionState)
+function checkUseFormState(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    lines.forEach((line, idx) => {
+        if (line.includes("useFormState") && !line.includes("useActionState")) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "deprecated-useFormState",
+                severity: "warning",
+                message: "useFormState is deprecated in React 19",
+                suggestion: "Use useActionState instead (includes pending state)",
+                snippet: line.trim(),
+            });
+        }
+    });
+    return issues;
+}
+// CHECK 5: Middleware to Proxy migration
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedAllCodeFiles = null;
+async function getAllCodeFiles() {
+    if (!_cachedAllCodeFiles) {
+        _cachedAllCodeFiles = await file_cache_1.fileCache.getAllCodeFiles();
+    }
+    return _cachedAllCodeFiles;
+}
+async function checkMiddlewareFile() {
+    const issues = [];
+    // Check if middleware.ts exists (should be renamed to proxy.ts in Next.js 16)
+    const middlewarePaths = [
+        "middleware.ts",
+        "middleware.js",
+        "src/middleware.ts",
+        "src/middleware.js",
+    ];
+    for (const middlewarePath of middlewarePaths) {
+        if (fs.existsSync(middlewarePath)) {
+            const content = fs.readFileSync(middlewarePath, "utf-8");
+            // Check if using edge runtime (deprecated in proxy)
+            if (content.includes("runtime = 'edge'") || content.includes('runtime: "edge"')) {
+                issues.push({
+                    file: middlewarePath,
+                    line: 1,
+                    type: "middleware-edge-runtime",
+                    severity: "info",
+                    message: "Edge runtime in middleware is deprecated in Next.js 16",
+                    suggestion: "Rename to proxy.ts and use nodejs runtime, or keep middleware.ts for edge",
+                });
+            }
+            // Check for deprecated export name
+            if (content.includes("export function middleware") ||
+                content.includes("export const middleware")) {
+                issues.push({
+                    file: middlewarePath,
+                    line: 1,
+                    type: "middleware-export-name",
+                    severity: "info",
+                    message: "Consider renaming middleware to proxy for Next.js 16",
+                    suggestion: "Rename file to proxy.ts and export function proxy()",
+                });
+            }
+        }
+    }
+    return issues;
+}
+// CHECK 5b: generateStaticParams must be async
+function checkGenerateStaticParams(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check page files in app directory
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (!normalizedPath.includes("/app/") || !normalizedPath.match(/\/page\.(ts|tsx|js|jsx)$/)) {
+        return issues;
+    }
+    lines.forEach((line, idx) => {
+        // Check for non-async generateStaticParams
+        if (/export\s+function\s+generateStaticParams\s*\(/.test(line) &&
+            !/export\s+async\s+function\s+generateStaticParams/.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "sync-generateStaticParams",
+                severity: "error",
+                message: "generateStaticParams must be async in Next.js 16",
+                suggestion: "Change to: export async function generateStaticParams()",
+                snippet: line.trim(),
+                fixable: true,
+                fixType: "rename-api",
+            });
+        }
+        // Also check const arrow function syntax
+        if (/export\s+const\s+generateStaticParams\s*=\s*\(/.test(line) &&
+            !/export\s+const\s+generateStaticParams\s*=\s*async/.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "sync-generateStaticParams",
+                severity: "error",
+                message: "generateStaticParams must be async in Next.js 16",
+                suggestion: "Change to: export const generateStaticParams = async () =>",
+                snippet: line.trim(),
+                fixable: true,
+                fixType: "rename-api",
+            });
+        }
+    });
+    return issues;
+}
+// CHECK 5c: next/router is removed (use next/navigation)
+function checkNextRouter(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check app directory files
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (!normalizedPath.includes("/app/") && !normalizedPath.includes("/components/")) {
+        return issues;
+    }
+    lines.forEach((line, idx) => {
+        // Check for next/router imports
+        if (/from\s+['"]next\/router['"]/.test(line) ||
+            /require\s*\(\s*['"]next\/router['"]\s*\)/.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "deprecated-next-router",
+                severity: "error",
+                message: "next/router is removed in App Router - use next/navigation",
+                suggestion: "Replace with: import { useRouter, usePathname, useSearchParams } from 'next/navigation'",
+                snippet: line.trim(),
+                fixable: true,
+                fixType: "replace-import",
+            });
+        }
+        // Check for useRouter from next/router specifically
+        if (/useRouter\s*\(\s*\)/.test(line) && content.includes("from 'next/router'")) {
+            // Additional check - router.query is not available in next/navigation
+            if (content.includes("router.query") || content.includes(".query")) {
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "router-query-deprecated",
+                    severity: "error",
+                    message: "router.query is not available in next/navigation",
+                    suggestion: "Use useSearchParams() or useParams() instead",
+                    snippet: line.trim(),
+                });
+            }
+        }
+    });
+    return issues;
+}
+// CHECK 5d: next/font changes
+function checkNextFont(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    lines.forEach((line, idx) => {
+        // Check for deprecated font loading patterns
+        if (/from\s+['"]@next\/font\//.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "deprecated-next-font-import",
+                severity: "warning",
+                message: "@next/font is deprecated - use next/font",
+                suggestion: "Replace @next/font/google with next/font/google",
+                snippet: line.trim(),
+                fixable: true,
+                fixType: "replace-import",
+            });
+        }
+        // Check for font display swap (now default, explicit setting may conflict)
+        // Skip comments
+        const trimmedLine = line.trim();
+        if (!trimmedLine.startsWith("//") &&
+            /display:\s*['"]swap['"]/.test(line) &&
+            content.includes("next/font")) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "font-display-default",
+                severity: "info",
+                message: "display: 'swap' is now the default in Next.js 16",
+                suggestion: 'You can remove explicit display: "swap" as it\'s the default',
+                snippet: line.trim(),
+            });
+        }
+    });
+    return issues;
+}
+// CHECK 5e: Pages Router APIs in App Directory
+function checkPagesRouterAPIs(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check app directory files
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (!normalizedPath.includes("/app/")) {
+        return issues;
+    }
+    const pagesRouterAPIs = [
+        { pattern: /export\s+(async\s+)?function\s+getServerSideProps/, api: "getServerSideProps" },
+        { pattern: /export\s+(async\s+)?function\s+getStaticProps/, api: "getStaticProps" },
+        { pattern: /export\s+(async\s+)?function\s+getInitialProps/, api: "getInitialProps" },
+        { pattern: /export\s+const\s+getServerSideProps/, api: "getServerSideProps" },
+        { pattern: /export\s+const\s+getStaticProps/, api: "getStaticProps" },
+    ];
+    lines.forEach((line, idx) => {
+        for (const { pattern, api } of pagesRouterAPIs) {
+            if (pattern.test(line)) {
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "pages-router-api-in-app",
+                    severity: "error",
+                    message: `${api} is a Pages Router API - not supported in App Router`,
+                    suggestion: "Use Server Components with async/await, or generateStaticParams for static generation",
+                    snippet: line.trim(),
+                });
+            }
+        }
+    });
+    return issues;
+}
+// CHECK 5f: instrumentation.ts location
+async function checkInstrumentationFile() {
+    const issues = [];
+    // Check for instrumentation file in wrong locations
+    const wrongLocations = [
+        "src/instrumentation.ts",
+        "src/instrumentation.js",
+        "app/instrumentation.ts",
+        "app/instrumentation.js",
+    ];
+    const correctLocations = ["instrumentation.ts", "instrumentation.js"];
+    const hasCorrectLocation = correctLocations.some((f) => fs.existsSync(f));
+    for (const wrongPath of wrongLocations) {
+        if (fs.existsSync(wrongPath)) {
+            issues.push({
+                file: wrongPath,
+                line: 1,
+                type: "instrumentation-wrong-location",
+                severity: "warning",
+                message: "instrumentation.ts should be in project root in Next.js 16",
+                suggestion: "Move to project root: instrumentation.ts",
+            });
+        }
+    }
+    // Info if no instrumentation file exists (optional feature)
+    if (!hasCorrectLocation && wrongLocations.every((f) => !fs.existsSync(f))) {
+        // This is optional, don't report
+    }
+    return issues;
+}
+// CHECK 5g: Metadata file conventions
+async function checkMetadataFiles() {
+    const issues = [];
+    // Find opengraph and twitter image files with old naming
+    const oldPatterns = await (0, glob_1.glob)("app/**/og.{png,jpg,jpeg,gif}", { ignore: EXCLUDED });
+    const oldTwitterPatterns = await (0, glob_1.glob)("app/**/twitter.{png,jpg,jpeg,gif}", { ignore: EXCLUDED });
+    for (const file of oldPatterns) {
+        issues.push({
+            file,
+            line: 1,
+            type: "deprecated-og-image-name",
+            severity: "info",
+            message: "og.png naming convention - consider using opengraph-image.png",
+            suggestion: "Rename to opengraph-image.png for Next.js 16 convention",
+        });
+    }
+    for (const file of oldTwitterPatterns) {
+        issues.push({
+            file,
+            line: 1,
+            type: "deprecated-twitter-image-name",
+            severity: "info",
+            message: "twitter.png naming convention - consider using twitter-image.png",
+            suggestion: "Rename to twitter-image.png for Next.js 16 convention",
+        });
+    }
+    return issues;
+}
+// CHECK 6: Parallel Routes default.js requirement
+async function checkParallelRoutes() {
+    const issues = [];
+    // Find all parallel route slots (directories starting with @)
+    const parallelRoutes = await (0, glob_1.glob)("app/**/@*/", { ignore: EXCLUDED });
+    for (const routeDir of parallelRoutes) {
+        const defaultFile = ["default.tsx", "default.ts", "default.js", "default.jsx"]
+            .map((f) => path.join(routeDir, f))
+            .find((f) => fs.existsSync(f));
+        if (!defaultFile) {
+            issues.push({
+                file: routeDir,
+                line: 1,
+                type: "missing-parallel-route-default",
+                severity: "error",
+                message: "Parallel route slot missing default.js file",
+                suggestion: "Create default.tsx that returns null or calls notFound()",
+            });
+        }
+    }
+    return issues;
+}
+// CHECK 7: Config deprecations
+function checkNextConfig() {
+    const issues = [];
+    const configPaths = ["next.config.js", "next.config.mjs", "next.config.ts"];
+    for (const configPath of configPaths) {
+        if (!fs.existsSync(configPath))
+            continue;
+        const content = fs.readFileSync(configPath, "utf-8");
+        const lines = content.split("\n");
+        lines.forEach((line, idx) => {
+            // Check for deprecated images.domains
+            if (line.includes("domains:") && !line.includes("remotePatterns")) {
+                issues.push({
+                    file: configPath,
+                    line: idx + 1,
+                    type: "deprecated-images-domains",
+                    severity: "warning",
+                    message: "images.domains is deprecated in Next.js 16",
+                    suggestion: "Use images.remotePatterns instead for better security",
+                    snippet: line.trim(),
+                });
+            }
+            // Check for experimental.turbopack (now top-level)
+            if (line.includes("experimental") && line.includes("turbopack")) {
+                issues.push({
+                    file: configPath,
+                    line: idx + 1,
+                    type: "experimental-turbopack",
+                    severity: "info",
+                    message: "experimental.turbopack is now a top-level config",
+                    suggestion: "Move turbopack config to top level: turbopack: { ... }",
+                    snippet: line.trim(),
+                });
+            }
+            // Check for skipMiddlewareUrlNormalize (renamed)
+            if (line.includes("skipMiddlewareUrlNormalize")) {
+                issues.push({
+                    file: configPath,
+                    line: idx + 1,
+                    type: "renamed-config-option",
+                    severity: "warning",
+                    message: "skipMiddlewareUrlNormalize renamed to skipProxyUrlNormalize",
+                    suggestion: "Rename to skipProxyUrlNormalize",
+                    snippet: line.trim(),
+                });
+            }
+            // Check for serverRuntimeConfig/publicRuntimeConfig (removed)
+            if (line.includes("serverRuntimeConfig") || line.includes("publicRuntimeConfig")) {
+                issues.push({
+                    file: configPath,
+                    line: idx + 1,
+                    type: "removed-runtime-config",
+                    severity: "error",
+                    message: "serverRuntimeConfig and publicRuntimeConfig are removed in Next.js 16",
+                    suggestion: "Use environment variables instead (NEXT_PUBLIC_ for client)",
+                    snippet: line.trim(),
+                });
+            }
+        });
+    }
+    return issues;
+}
+// CHECK 8: SSR/Client Component Boundary Validation (Turbopack)
+function checkSSRClientBoundary(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Skip test files, scripts, and pure utility files
+    if (filePath.includes(".test.") ||
+        filePath.includes(".spec.") ||
+        filePath.includes("scripts/") ||
+        filePath.includes("__mocks__/") ||
+        filePath.includes("prisma/")) {
+        return issues;
+    }
+    const hasUseClient = content.includes('"use client"') || content.includes("'use client'");
+    // Client-only APIs that require "use client" directive
+    const clientOnlyPatterns = [
+        { pattern: /\buseEffect\s*\(/, api: "useEffect", type: "hook" },
+        { pattern: /\buseState\s*[<(]/, api: "useState", type: "hook" },
+        { pattern: /\buseRef\s*[<(]/, api: "useRef", type: "hook" },
+        { pattern: /\buseCallback\s*[<(]/, api: "useCallback", type: "hook" },
+        { pattern: /\buseMemo\s*[<(]/, api: "useMemo", type: "hook" },
+        { pattern: /\buseContext\s*\(/, api: "useContext", type: "hook" },
+        { pattern: /\buseReducer\s*[<(]/, api: "useReducer", type: "hook" },
+        { pattern: /\buseLayoutEffect\s*\(/, api: "useLayoutEffect", type: "hook" },
+        { pattern: /\bdocument\.(?!cookie)/, api: "document", type: "browser-api" },
+        { pattern: /\bwindow\.(?!location\.origin)/, api: "window", type: "browser-api" },
+        { pattern: /\blocalStorage\./, api: "localStorage", type: "browser-api" },
+        { pattern: /\bsessionStorage\./, api: "sessionStorage", type: "browser-api" },
+    ];
+    // Check if file uses client-only APIs without "use client"
+    if (!hasUseClient) {
+        const detectedAPIs = [];
+        lines.forEach((line, idx) => {
+            // Skip imports, comments, and type definitions
+            const trimmed = line.trim();
+            if (trimmed.startsWith("import ") ||
+                trimmed.startsWith("//") ||
+                trimmed.startsWith("*") ||
+                trimmed.startsWith("/*") ||
+                trimmed.startsWith("type ") ||
+                trimmed.startsWith("interface ") ||
+                trimmed.includes("typeof ")) {
+                return;
+            }
+            for (const { pattern, api, type } of clientOnlyPatterns) {
+                if (pattern.test(line)) {
+                    detectedAPIs.push({ api, line: idx + 1, type });
+                }
+            }
+        });
+        // Only report if we found React hooks or browser APIs
+        const criticalAPIs = detectedAPIs.filter((a) => a.type === "hook" || a.type === "browser-api");
+        if (criticalAPIs.length > 0) {
+            const firstAPI = criticalAPIs[0];
+            const allAPIs = [...new Set(criticalAPIs.map((a) => a.api))].join(", ");
+            // Determine if this is a hooks file or component file
+            const isHooksFile = filePath.includes("/hooks/") ||
+                filePath.includes("\\hooks\\") ||
+                filePath.match(/use[A-Z].*\.(ts|tsx)$/);
+            const isComponentFile = filePath.includes("/components/") ||
+                filePath.includes("\\components\\") ||
+                filePath.includes("/app/") ||
+                filePath.includes("\\app\\");
+            // Only flag as error if it's clearly a client module (hooks or components)
+            if (isHooksFile || isComponentFile) {
+                issues.push({
+                    file: filePath,
+                    line: firstAPI.line,
+                    type: "missing-use-client-directive",
+                    severity: "error",
+                    message: `${isHooksFile ? "Hook" : "Component"} uses client-only APIs (${allAPIs}) without "use client" directive`,
+                    suggestion: 'Add "use client" at the top of the file, or refactor to be SSR-compatible',
+                    snippet: lines[firstAPI.line - 1]?.trim(),
+                    fixable: true,
+                    fixType: "add-use-client",
+                });
+            }
+        }
+    }
+    // Check for "use client" components that could be Server Components
+    // (no client-only APIs detected - informational only)
+    if (hasUseClient) {
+        let hasClientAPI = false;
+        for (const line of lines) {
+            if (line.trim().startsWith("import ") || line.trim().startsWith("//"))
+                continue;
+            for (const { pattern } of clientOnlyPatterns) {
+                if (pattern.test(line)) {
+                    hasClientAPI = true;
+                    break;
+                }
+            }
+            if (hasClientAPI)
+                break;
+        }
+        if (!hasClientAPI && filePath.includes("components/")) {
+            issues.push({
+                file: filePath,
+                line: 1,
+                type: "unnecessary-use-client",
+                severity: "info",
+                message: 'Component has "use client" but no client-only APIs detected',
+                suggestion: 'Consider removing "use client" to enable Server Component rendering',
+            });
+        }
+    }
+    return issues;
+}
+// CHECK 9: Runtime export conflicts with cacheComponents
+function checkRuntimeExportConflict(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check route files (route.ts, route.js) and page files
+    // Normalize path separators for cross-platform compatibility
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (!normalizedPath.match(/\/(route|page)\.(ts|tsx|js|jsx)$/)) {
+        return issues;
+    }
+    lines.forEach((line, idx) => {
+        // Check for export const runtime = "nodejs" or "edge"
+        if (/export\s+const\s+runtime\s*=/.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "runtime-export-cacheComponents-conflict",
+                severity: "error",
+                message: 'Route segment config "runtime" is incompatible with nextConfig.cacheComponents',
+                suggestion: 'Remove "export const runtime" - Next.js will auto-detect runtime based on APIs used',
+                snippet: line.trim(),
+            });
+        }
+        // Check for export const revalidate (incompatible with cacheComponents)
+        if (/export\s+const\s+revalidate\s*=/.test(line)) {
+            issues.push({
+                file: filePath,
+                line: idx + 1,
+                type: "revalidate-export-cacheComponents-conflict",
+                severity: "error",
+                message: 'Route segment config "revalidate" is incompatible with nextConfig.cacheComponents',
+                suggestion: 'Remove "export const revalidate" - use "use cache" directive with cacheLife() instead',
+                snippet: line.trim(),
+            });
+        }
+    });
+    return issues;
+}
+// CHECK 10: Date.now() / new Date() in Client Components without Suspense
+// NOTE: This check is DISABLED because accurate detection requires AST parsing.
+// Without AST, we can't reliably distinguish render-time calls from callback calls.
+// All Date.now() usages in this codebase are in callbacks/handlers, not render.
+// Re-enable when AST-based analysis is implemented.
+function checkDateInClientComponents(_filePath, _content) {
+    // Disabled - too many false positives without AST parsing
+    return [];
+}
+// CHECK 11: React Compiler readiness
+function checkReactCompilerReadiness(filePath, content) {
+    const issues = [];
+    // Skip non-React files - scripts, lib utilities, prisma, etc.
+    // React Compiler only applies to React components
+    if (filePath.includes("scripts/") ||
+        filePath.includes("prisma/") ||
+        filePath.includes("__mocks__/") ||
+        filePath.includes(".test.") ||
+        filePath.includes(".spec.") ||
+        filePath.includes("lib/logger") ||
+        !filePath.match(/\.(tsx|jsx)$/)) {
+        return issues;
+    }
+    const lines = content.split("\n");
+    // Patterns that may cause issues with React Compiler
+    // Note: Only match actual mutations (assignment), not property access
+    const problematicPatterns = [
+        // Mutating props directly - must be assignment TO props, not reading FROM props
+        // e.g., props.foo = bar (bad) vs const x = props.foo (ok)
+        {
+            pattern: /^\s*props\.\w+\s*=\s*[^=]/,
+            message: "Direct prop mutation may break React Compiler",
+        },
+        // Mutating state directly
+        {
+            pattern: /this\.state\.\w+\s*=\s*[^=]/,
+            message: "Direct state mutation may break React Compiler",
+        },
+    ];
+    lines.forEach((line, idx) => {
+        // Skip comments
+        if (line.trim().startsWith("//") || line.trim().startsWith("*")) {
+            return;
+        }
+        for (const { pattern, message } of problematicPatterns) {
+            if (pattern.test(line)) {
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "react-compiler-incompatible",
+                    severity: "info",
+                    message,
+                    suggestion: "Refactor to use immutable patterns for React Compiler compatibility",
+                    snippet: line.trim(),
+                });
+            }
+        }
+    });
+    return issues;
+}
+// CHECK 12: Prisma Decimal in "use cache" functions
+function checkDecimalInCachedFunctions(filePath, content) {
+    const issues = [];
+    const lines = content.split("\n");
+    // Only check files that use "use cache"
+    if (!content.includes('"use cache"') && !content.includes("'use cache'")) {
+        return issues;
+    }
+    // Skip test files
+    if (filePath.includes(".test.") || filePath.includes(".spec.")) {
+        return issues;
+    }
+    // Find functions with "use cache" that return Prisma queries with price/Decimal fields
+    // without serialization
+    let inCachedFunction = false;
+    let cachedFunctionStart = 0;
+    let braceCount = 0;
+    let hasPrismaQuery = false;
+    let hasDecimalField = false;
+    let hasNumberConversion = false;
+    let functionName = "";
+    const decimalFields = [
+        "price",
+        "amount",
+        "total",
+        "subtotal",
+        "fee",
+        "cost",
+        "balance",
+        "tax",
+        "discount",
+        "shipping",
+        "rate",
+        "commission",
+        "payout",
+        "refund",
+        "marketPrice",
+        "shippingCost",
+    ];
+    for (let idx = 0; idx < lines.length; idx++) {
+        const line = lines[idx];
+        const trimmed = line.trim();
+        // Detect start of cached function
+        if (trimmed === '"use cache";' || trimmed === "'use cache';") {
+            inCachedFunction = true;
+            cachedFunctionStart = idx + 1;
+            braceCount = 0;
+            hasPrismaQuery = false;
+            hasDecimalField = false;
+            hasNumberConversion = false;
+            // Look back to find function name
+            for (let j = idx - 1; j >= Math.max(0, idx - 5); j--) {
+                const prevLine = lines[j];
+                const funcMatch = prevLine.match(/(?:async\s+)?function\s+(\w+)|const\s+(\w+)\s*=/);
+                if (funcMatch) {
+                    functionName = funcMatch[1] || funcMatch[2] || "anonymous";
+                    break;
+                }
+            }
+            continue;
+        }
+        if (inCachedFunction) {
+            // Track brace depth
+            braceCount += (line.match(/{/g) || []).length;
+            braceCount -= (line.match(/}/g) || []).length;
+            // Check for Prisma query
+            if (/prisma\.\w+\.(findMany|findFirst|findUnique|aggregate|groupBy)/.test(line)) {
+                hasPrismaQuery = true;
+            }
+            // Check for Decimal field selection
+            for (const field of decimalFields) {
+                if (new RegExp(`\\b${field}:\\s*true`).test(line) ||
+                    new RegExp(`select:\\s*{[^}]*${field}`).test(content.slice(lines.slice(0, idx).join("\n").length))) {
+                    hasDecimalField = true;
+                    break;
+                }
+            }
+            // Check for Number() conversion before return
+            if (/Number\s*\(.*(?:price|amount|total|fee|cost|marketPrice|shippingCost)/.test(line) ||
+                /\.map\s*\([^)]*Number\s*\(/.test(line) ||
+                /price:\s*Number\(/.test(line)) {
+                hasNumberConversion = true;
+            }
+            // Check for direct return of Prisma query (without serialization)
+            if (/return\s+await\s+prisma\./.test(line) && hasDecimalField) {
+                issues.push({
+                    file: filePath,
+                    line: idx + 1,
+                    type: "decimal-in-cached-function",
+                    severity: "error",
+                    message: `Cached function "${functionName}" returns Prisma Decimal without serialization`,
+                    suggestion: "Serialize Decimal fields to Number before returning: .map(item => ({ ...item, price: Number(item.price) }))",
+                    snippet: line.trim(),
+                });
+            }
+            // End of cached function
+            if (braceCount <= 0 && idx > cachedFunctionStart) {
+                // Check if function has Prisma query with Decimal but no conversion
+                if (hasPrismaQuery && hasDecimalField && !hasNumberConversion) {
+                    // Only report if we haven't already reported a direct return issue
+                    const alreadyReported = issues.some((i) => i.file === filePath &&
+                        i.type === "decimal-in-cached-function" &&
+                        i.line > cachedFunctionStart &&
+                        i.line <= idx);
+                    if (!alreadyReported) {
+                        issues.push({
+                            file: filePath,
+                            line: cachedFunctionStart,
+                            type: "decimal-in-cached-function",
+                            severity: "warning",
+                            message: `Cached function "${functionName}" may return Prisma Decimal without serialization`,
+                            suggestion: "Ensure Decimal fields (price, amount, etc.) are converted to Number before caching",
+                        });
+                    }
+                }
+                inCachedFunction = false;
+            }
+        }
+    }
+    return issues;
+}
+// CACHING UTILITIES
+function getFileHash(content) {
+    return (0, crypto_1.createHash)("md5").update(content).digest("hex");
+}
+function loadCache() {
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // Cache corrupted, start fresh
+    }
+    return {};
+}
+function saveCache(cache) {
+    try {
+        const cacheDir = path.dirname(CACHE_FILE);
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // Cache write failed, non-critical
+    }
+}
+// AUTO-FIX UTILITIES
+function applyFixes(issues) {
+    const results = [];
+    const fixableIssues = issues.filter((i) => i.fixable);
+    // Group by file to batch fixes
+    const byFile = new Map();
+    for (const issue of fixableIssues) {
+        const existing = byFile.get(issue.file) || [];
+        existing.push(issue);
+        byFile.set(issue.file, existing);
+    }
+    for (const [filePath, fileIssues] of byFile) {
+        try {
+            let content = fs.readFileSync(filePath, "utf-8");
+            let modified = false;
+            for (const issue of fileIssues) {
+                switch (issue.fixType) {
+                    case "add-use-client": {
+                        // Add "use client" at the top of the file
+                        if (!content.includes('"use client"') && !content.includes("'use client'")) {
+                            content = '"use client";\n\n' + content;
+                            modified = true;
+                            results.push({
+                                file: filePath,
+                                type: issue.type,
+                                success: true,
+                                message: 'Added "use client" directive',
+                            });
+                        }
+                        break;
+                    }
+                    case "replace-import": {
+                        // Replace next/router with next/navigation
+                        if (content.includes("from 'next/router'") || content.includes('from "next/router"')) {
+                            content = content.replace(/from ['"]next\/router['"]/g, "from 'next/navigation'");
+                            modified = true;
+                            results.push({
+                                file: filePath,
+                                type: issue.type,
+                                success: true,
+                                message: "Replaced next/router with next/navigation",
+                            });
+                        }
+                        // Replace @next/font with next/font
+                        if (content.includes("@next/font/")) {
+                            content = content.replace(/@next\/font\//g, "next/font/");
+                            modified = true;
+                            results.push({
+                                file: filePath,
+                                type: issue.type,
+                                success: true,
+                                message: "Replaced @next/font with next/font",
+                            });
+                        }
+                        break;
+                    }
+                    case "rename-api": {
+                        // Fix generateStaticParams to be async
+                        if (issue.type === "sync-generateStaticParams") {
+                            content = content.replace(/export\s+function\s+generateStaticParams/g, "export async function generateStaticParams");
+                            content = content.replace(/export\s+const\s+generateStaticParams\s*=\s*\(/g, "export const generateStaticParams = async (");
+                            modified = true;
+                            results.push({
+                                file: filePath,
+                                type: issue.type,
+                                success: true,
+                                message: "Made generateStaticParams async",
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            if (modified) {
+                fs.writeFileSync(filePath, content);
+            }
+        }
+        catch (error) {
+            results.push({
+                file: filePath,
+                type: "fix-error",
+                success: false,
+                message: `Failed to apply fix: ${error.message}`,
+            });
+        }
+    }
+    return results;
+}
+// MAIN RUNNER
+async function run() {
+    const args = process.argv.slice(2);
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const warnOnly = args.includes("--warn") || args.includes("-w");
+    const jsonOutput = args.includes("--json") || args.includes("-j");
+    const autoFix = args.includes("--fix") || args.includes("-f");
+    const noCache = args.includes("--no-cache");
+    if (!jsonOutput) {
+        console.log(`\n${console_chars_1.emoji.lightning} Next.js 16+ Compatibility Preflight`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    }
+    const startTime = Date.now();
+    const allIssues = [];
+    const cache = noCache ? {} : loadCache();
+    const newCache = {};
+    // Find all relevant files
+    const files = await getAllCodeFiles();
+    let filesScanned = 0;
+    let cacheHits = 0;
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            const hash = getFileHash(content);
+            filesScanned++;
+            // Check cache
+            if (cache[file] && cache[file].hash === hash) {
+                allIssues.push(...cache[file].issues);
+                newCache[file] = cache[file];
+                cacheHits++;
+                continue;
+            }
+            // Run all checks
+            const fileIssues = [];
+            fileIssues.push(...checkAsyncRequestAPIs(file, content));
+            fileIssues.push(...checkUnstablePrefixes(file, content));
+            fileIssues.push(...checkLegacyImage(file, content));
+            fileIssues.push(...checkUseFormState(file, content));
+            fileIssues.push(...checkSSRClientBoundary(file, content));
+            fileIssues.push(...checkRuntimeExportConflict(file, content));
+            fileIssues.push(...checkDateInClientComponents(file, content));
+            fileIssues.push(...checkReactCompilerReadiness(file, content));
+            fileIssues.push(...checkDecimalInCachedFunctions(file, content));
+            fileIssues.push(...checkGenerateStaticParams(file, content));
+            fileIssues.push(...checkNextRouter(file, content));
+            fileIssues.push(...checkNextFont(file, content));
+            fileIssues.push(...checkPagesRouterAPIs(file, content));
+            allIssues.push(...fileIssues);
+            newCache[file] = { hash, issues: fileIssues };
+        }
+        catch (error) {
+            if (verbose && !jsonOutput) {
+                console.error(`${console_chars_1.emoji.warning}  Error reading ${file}: ${error.message}`);
+            }
+        }
+    }
+    // Run file-level checks (not cached)
+    allIssues.push(...(await checkMiddlewareFile()));
+    allIssues.push(...(await checkParallelRoutes()));
+    allIssues.push(...checkNextConfig());
+    allIssues.push(...(await checkInstrumentationFile()));
+    allIssues.push(...(await checkMetadataFiles()));
+    // Save cache
+    if (!noCache) {
+        saveCache(newCache);
+    }
+    const duration = Date.now() - startTime;
+    // Apply fixes if requested
+    let fixResults = [];
+    if (autoFix) {
+        fixResults = applyFixes(allIssues);
+        // Remove fixed issues from the list
+        const fixedTypes = new Set(fixResults.filter((r) => r.success).map((r) => `${r.file}:${r.type}`));
+        const remainingIssues = allIssues.filter((i) => !fixedTypes.has(`${i.file}:${i.type}`));
+        allIssues.length = 0;
+        allIssues.push(...remainingIssues);
+    }
+    const errors = allIssues.filter((i) => i.severity === "error");
+    const warnings = allIssues.filter((i) => i.severity === "warning");
+    const infos = allIssues.filter((i) => i.severity === "info");
+    // JSON output mode
+    if (jsonOutput) {
+        const output = {
+            summary: {
+                filesScanned,
+                cacheHits,
+                duration,
+                errors: errors.length,
+                warnings: warnings.length,
+                infos: infos.length,
+                fixesApplied: fixResults.filter((r) => r.success).length,
+            },
+            issues: allIssues,
+            fixes: fixResults,
+            exitCode: warnOnly ? 0 : errors.length > 0 ? 1 : 0,
+        };
+        console.log(JSON.stringify(output, null, 2));
+        process.exit(output.exitCode);
+    }
+    // Report results
+    console.log(`\n${console_chars_1.emoji.chart} Scan Summary:`);
+    console.log(`   Files scanned: ${filesScanned}`);
+    console.log(`   Cache hits: ${cacheHits} (${Math.round((cacheHits / filesScanned) * 100)}%)`);
+    console.log(`   Duration: ${duration}ms`);
+    // Report fixes
+    if (autoFix && fixResults.length > 0) {
+        const successfulFixes = fixResults.filter((r) => r.success);
+        const failedFixes = fixResults.filter((r) => !r.success);
+        console.log(`\n${console_chars_1.emoji.wrench} Auto-Fix Results:`);
+        console.log(`   ${console_chars_1.emoji.success} Fixed: ${successfulFixes.length}`);
+        if (failedFixes.length > 0) {
+            console.log(`   ${console_chars_1.emoji.error} Failed: ${failedFixes.length}`);
+        }
+        if (verbose) {
+            for (const fix of successfulFixes) {
+                console.log(`   ${console_chars_1.emoji.success} ${fix.file}: ${fix.message}`);
+            }
+            for (const fix of failedFixes) {
+                console.log(`   ${console_chars_1.emoji.error} ${fix.file}: ${fix.message}`);
+            }
+        }
+    }
+    if (allIssues.length === 0) {
+        console.log(`\n${console_chars_1.emoji.success} No Next.js 16 compatibility issues found`);
+        process.exit(0);
+    }
+    // Group by type
+    const byType = new Map();
+    for (const issue of allIssues) {
+        const existing = byType.get(issue.type) || [];
+        existing.push(issue);
+        byType.set(issue.type, existing);
+    }
+    console.log(`\n${console_chars_1.emoji.clipboard} Issues Found:`);
+    console.log(`   ${console_chars_1.emoji.error} Errors: ${errors.length}`);
+    console.log(`   ${console_chars_1.emoji.warning}  Warnings: ${warnings.length}`);
+    console.log(`   ${console_chars_1.emoji.info}  Info: ${infos.length}`);
+    const fixableCount = allIssues.filter((i) => i.fixable).length;
+    if (fixableCount > 0 && !autoFix) {
+        console.log(`   ${console_chars_1.emoji.wrench} Fixable: ${fixableCount} (run with --fix)`);
+    }
+    // Print issues by type
+    for (const [type, issues] of byType) {
+        const icon = issues[0].severity === "error"
+            ? `${console_chars_1.emoji.error}`
+            : issues[0].severity === "warning"
+                ? `${console_chars_1.emoji.warning}`
+                : `${console_chars_1.emoji.info}`;
+        const fixableTag = issues[0].fixable ? ` ${console_chars_1.emoji.wrench}` : "";
+        console.log(`\n${icon} ${type}${fixableTag} (${issues.length} occurrences)`);
+        if (verbose) {
+            for (const issue of issues.slice(0, 5)) {
+                console.log(`   ${issue.file}:${issue.line}`);
+                console.log(`   ${issue.message}`);
+                console.log(`   ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+                if (issue.snippet) {
+                    console.log(`   ${console_chars_1.emoji.memo} ${issue.snippet.substring(0, 80)}`);
+                }
+                console.log("");
+            }
+            if (issues.length > 5) {
+                console.log(`   ... and ${issues.length - 5} more`);
+            }
+        }
+        else {
+            console.log(`   ${issues[0].message}`);
+            console.log(`   ${console_chars_1.emoji.hint} ${issues[0].suggestion}`);
+        }
+    }
+    // Exit code
+    if (warnOnly) {
+        console.log(`\n${console_chars_1.emoji.warning}  Running in warning mode - not blocking`);
+        process.exit(0);
+    }
+    if (errors.length > 0) {
+        console.log(`\n⛔ ${errors.length} blocking issue(s) found. Fix before deploying.`);
+        process.exit(1);
+    }
+    console.log(`\n${console_chars_1.emoji.success} No blocking issues (warnings/info only)`);
+    process.exit(0);
+}
+run().catch((error) => {
+    console.error(`${console_chars_1.emoji.error} Next.js 16 compatibility check failed:`, error);
+    process.exit(1);
+});
+//# sourceMappingURL=nextjs16-compatibility.js.map