@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/performance.js

@@ -0,0 +1,1546 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated Performance Preflight
+ *
+ * Combines 10 performance checks into one module:
+ * - bundle (bundle size & large dependencies)
+ * - images (image optimization & lazy loading & LCP priority)
+ * - lazy (heavy component lazy loading)
+ * - skeleton (skeleton loader usage)
+ * - virtual (virtual scroll candidates)
+ * - zindex (z-index design token usage)
+ * - recharts (recharts lazy loading)
+ * - dialogs (dialog lazy loading)
+ * - queries (N+1 patterns & force-dynamic without caching)
+ *
+ * Usage:
+ *   pnpm preflight:perf                    # All checks
+ *   pnpm preflight:perf bundle             # Bundle size only
+ *   pnpm preflight:perf images             # Image optimization only
+ *   pnpm preflight:perf lazy               # Lazy loading only
+ *   pnpm preflight:perf skeleton           # Skeleton loaders only
+ *   pnpm preflight:perf virtual            # Virtual scroll only
+ *   pnpm preflight:perf zindex             # Z-index tokens only
+ *   pnpm preflight:perf recharts           # Recharts lazy loading only
+ *   pnpm preflight:perf dialogs            # Dialog lazy loading only
+ *   pnpm preflight:perf queries            # Database query efficiency only
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformancePreflightModule = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const playwright_1 = require("playwright");
+const promises_1 = require("timers/promises");
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+const EXCLUDED = [...glob_patterns_1.STANDARD_EXCLUDES];
+const PREFLIGHT_PORT = Number(process.env.PREFLIGHT_PORT || process.env.PORT || 3000);
+const HOMEPAGE_URL = process.env.PREFLIGHT_BASE_URL || `http://localhost:${PREFLIGHT_PORT}`;
+const DEV_SERVER_START_TIMEOUT = 30_000;
+const PROD_SERVER_START_TIMEOUT = 90_000;
+const PAGELOAD_SERVER_MODE = (process.env.PREFLIGHT_PAGELOAD_SERVER_MODE || "dev");
+const PAGELOAD_NAVIGATION_BUDGET_MS = Number(process.env.PREFLIGHT_PAGELOAD_NAVIGATION_BUDGET_MS || 4_000);
+const PAGELOAD_REQUEST_BUDGET = Number(process.env.PREFLIGHT_PAGELOAD_REQUEST_BUDGET || 14);
+const PAGELOAD_API_DUPLICATE_LIMIT = Number(process.env.PREFLIGHT_PAGELOAD_API_DUPLICATE_LIMIT || 1); // Allow one hit per endpoint by default
+const PAGELOAD_SESSION_DUPLICATE_LIMIT = Number(process.env.PREFLIGHT_PAGELOAD_SESSION_DUPLICATE_LIMIT || 1);
+const PAGELOAD_NOTIFICATION_DUPLICATE_LIMIT = Number(process.env.PREFLIGHT_PAGELOAD_NOTIFICATION_DUPLICATE_LIMIT || 1);
+const PAGELOAD_PRISMA_QUERY_BUDGET = Number(process.env.PREFLIGHT_PAGELOAD_PRISMA_QUERY_BUDGET || 40);
+const PAGELOAD_PRISMA_DUPLICATE_THRESHOLD = Number(process.env.PREFLIGHT_PAGELOAD_PRISMA_DUPLICATE_THRESHOLD || 3);
+const WAIT_FOR_STABLE_NETWORK_MS = Number(process.env.PREFLIGHT_PAGELOAD_STABLE_NETWORK_MS || 1_000);
+const PAGELOAD_TRANSFER_BUDGET_BYTES = Number(process.env.PREFLIGHT_PAGELOAD_TRANSFER_BUDGET_BYTES || 1_000_000); // ~1MB
+const PAGELOAD_ROUTE_TIMEOUT_MS = Number(process.env.PREFLIGHT_PAGELOAD_ROUTE_TIMEOUT_MS || 8_000);
+const PAGELOAD_LOAD_TIMEOUT_MS = Number(process.env.PREFLIGHT_PAGELOAD_LOAD_TIMEOUT_MS || 6_000);
+const PAGELOAD_NETWORKIDLE_TIMEOUT_MS = Number(process.env.PREFLIGHT_PAGELOAD_NETWORKIDLE_TIMEOUT_MS || 2_000);
+const PAGELOAD_PROGRESS_EVERY = Number(process.env.PREFLIGHT_PAGELOAD_PROGRESS_EVERY || 10);
+const PAGELOAD_CONCURRENCY = Math.max(1, Number(process.env.PREFLIGHT_PAGELOAD_CONCURRENCY || 1));
+const PAGELOAD_STRICT = process.env.PREFLIGHT_PAGELOAD_STRICT === "1";
+const PAGELOAD_INCLUDE_SITEMAP = process.env.PREFLIGHT_PAGELOAD_INCLUDE_SITEMAP === "1";
+const PAGELOAD_SITEMAP_MAX_URLS = Math.max(0, Number(process.env.PREFLIGHT_PAGELOAD_SITEMAP_MAX_URLS || 2000));
+const PAGELOAD_ROUTES_CONFIG = process.env.PREFLIGHT_PAGELOAD_ROUTES_CONFIG ||
+    path.join(process.cwd(), "scripts/active/preflights/config/page-load-routes.json");
+const DEFAULT_PAGE_ROUTES = ["/"];
+const PNPM_CMD = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+function normalizeRoute(route) {
+    if (!route)
+        return "/";
+    let normalized = route.trim();
+    if (!normalized.startsWith("http")) {
+        normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    }
+    if (normalized.endsWith("/") && normalized !== "/") {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+function normalizeExampleRoutes(examples) {
+    const normalized = {};
+    if (!examples)
+        return normalized;
+    for (const [pattern, value] of Object.entries(examples)) {
+        const values = Array.isArray(value) ? value : [value];
+        const routes = values.map((v) => normalizeRoute(v)).filter(Boolean);
+        if (routes.length > 0)
+            normalized[normalizeRoute(pattern)] = routes;
+    }
+    return normalized;
+}
+function substituteDynamicRoute(template, example) {
+    // Replace each [param] segment with example segments in order.
+    const templateParts = template.split("/").filter(Boolean);
+    const exampleParts = example.split("/").filter(Boolean);
+    const out = [];
+    let exampleIndex = 0;
+    for (const part of templateParts) {
+        if (part.startsWith("[") && part.endsWith("]")) {
+            if (exampleIndex >= exampleParts.length)
+                return null;
+            out.push(exampleParts[exampleIndex++]);
+            continue;
+        }
+        out.push(part);
+        if (exampleParts[exampleIndex] === part)
+            exampleIndex++;
+    }
+    return `/${out.join("/")}`.replace(/\/+$/, "") || "/";
+}
+function matchRoutePattern(pattern, route) {
+    const normalizedPattern = (pattern || "").trim();
+    if (!normalizedPattern)
+        return false;
+    if (normalizedPattern.startsWith("re:")) {
+        try {
+            return new RegExp(normalizedPattern.slice(3)).test(route);
+        }
+        catch {
+            return false;
+        }
+    }
+    // Simple glob-ish support: '*' means any chars.
+    if (normalizedPattern.includes("*")) {
+        const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`);
+        return regex.test(route);
+    }
+    // Prefix match support for directory-like patterns.
+    if (normalizedPattern.endsWith("/")) {
+        return route.startsWith(normalizedPattern);
+    }
+    return route === normalizedPattern;
+}
+function dynamicTemplateMatchesRoute(template, route) {
+    if (!template.includes("["))
+        return template === route;
+    const escaped = template.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regexStr = `^${escaped.replace(/\\\[[^\]]+\\\]/g, "[^/]+")}$`;
+    try {
+        return new RegExp(regexStr).test(route);
+    }
+    catch {
+        return false;
+    }
+}
+function extractSitemapLocs(xml) {
+    const locs = [];
+    const re = /<loc>([^<]+)<\/loc>/gim;
+    let match;
+    while ((match = re.exec(xml))) {
+        const loc = (match[1] || "").trim();
+        if (loc)
+            locs.push(loc);
+    }
+    return locs;
+}
+async function fetchText(url) {
+    try {
+        const res = await fetch(url, { redirect: "follow" });
+        if (!res.ok)
+            return null;
+        return await res.text();
+    }
+    catch {
+        return null;
+    }
+}
+async function discoverRoutesFromSitemaps() {
+    if (!PAGELOAD_INCLUDE_SITEMAP)
+        return [];
+    const base = HOMEPAGE_URL.replace(/\/$/, "");
+    // On some Windows setups `localhost` resolves to IPv6 first; use IPv4 loopback for fetch to avoid connection issues.
+    const fetchBase = base.replace("://localhost", "://127.0.0.1");
+    const primaryCandidates = [`${fetchBase}/sitemap.xml`, `${fetchBase}/sitemap/0.xml`];
+    let xml = null;
+    for (const candidate of primaryCandidates) {
+        xml = await fetchText(candidate);
+        if (xml)
+            break;
+    }
+    if (!xml)
+        return [];
+    const locs = extractSitemapLocs(xml);
+    const sitemapXmlUrls = locs.filter((l) => l.toLowerCase().endsWith(".xml"));
+    const urlLocs = [];
+    if (sitemapXmlUrls.length > 0) {
+        for (const sitemapUrl of sitemapXmlUrls.slice(0, 25)) {
+            const childXml = await fetchText(sitemapUrl);
+            if (!childXml)
+                continue;
+            urlLocs.push(...extractSitemapLocs(childXml));
+            if (PAGELOAD_SITEMAP_MAX_URLS > 0 && urlLocs.length >= PAGELOAD_SITEMAP_MAX_URLS)
+                break;
+        }
+    }
+    else {
+        urlLocs.push(...locs);
+    }
+    const paths = [];
+    for (const loc of urlLocs) {
+        try {
+            const u = new URL(loc);
+            const pathOnly = normalizeRoute(u.pathname);
+            if (pathOnly.startsWith("/_next"))
+                continue;
+            paths.push(pathOnly);
+            if (PAGELOAD_SITEMAP_MAX_URLS > 0 && paths.length >= PAGELOAD_SITEMAP_MAX_URLS)
+                break;
+        }
+        catch {
+            // ignore invalid loc
+        }
+    }
+    return Array.from(new Set(paths)).sort();
+}
+async function discoverRoutesFromApp() {
+    const files = await file_cache_1.fileCache.getFiles("app/**/page.{ts,tsx,js,jsx}", { ignore: EXCLUDED });
+    const routes = [];
+    const skippedDynamic = [];
+    for (const file of files) {
+        const rel = file.replace(/\\/g, "/");
+        const withoutApp = rel.replace(/^app\//, "");
+        const withoutPage = withoutApp.replace(/(^|[\\/])page\.(ts|tsx|js|jsx)$/i, "");
+        // Empty => root
+        const segments = withoutPage ? withoutPage.split("/") : [];
+        // Skip route groups, parallel routes, and intercepting routes in path computation.
+        const cleaned = [];
+        let isDynamic = false;
+        for (const seg of segments) {
+            if (!seg)
+                continue;
+            if (seg.startsWith("(") && seg.endsWith(")"))
+                continue; // route group
+            if (seg.startsWith("@"))
+                continue; // parallel route
+            if (seg.startsWith("(..") || seg.startsWith("(.)"))
+                continue; // intercepting
+            if (seg.startsWith("[") && seg.endsWith("]")) {
+                isDynamic = true;
+                cleaned.push(seg);
+                continue;
+            }
+            cleaned.push(seg);
+        }
+        const route = `/${cleaned.filter(Boolean).join("/")}`.replace(/\/+$/, "") || "/";
+        const normalized = normalizeRoute(route);
+        if (isDynamic) {
+            skippedDynamic.push(normalized);
+            continue;
+        }
+        routes.push(normalized);
+    }
+    return {
+        routes: Array.from(new Set(routes)).sort(),
+        skippedDynamic: Array.from(new Set(skippedDynamic)).sort(),
+    };
+}
+async function loadPageRoutes() {
+    const envRoutes = process.env.PREFLIGHT_PAGE_ROUTES;
+    const envMaxRoutes = Number(process.env.PREFLIGHT_PAGELOAD_MAX_ROUTES || 0);
+    const envAllowPartial = process.env.PREFLIGHT_PAGELOAD_ALLOW_PARTIAL === "1";
+    if (envRoutes) {
+        const parts = envRoutes.split(",").map((r) => normalizeRoute(r));
+        const dedupedParts = Array.from(new Set(parts)).filter(Boolean);
+        return {
+            routes: dedupedParts.length > 0 ? dedupedParts : DEFAULT_PAGE_ROUTES,
+            skippedDynamic: [],
+            maxRoutes: envMaxRoutes > 0 ? envMaxRoutes : 250,
+            allowPartial: envAllowPartial,
+            exclude: [],
+        };
+    }
+    let cfg;
+    if (fs.existsSync(PAGELOAD_ROUTES_CONFIG)) {
+        try {
+            cfg = JSON.parse(fs.readFileSync(PAGELOAD_ROUTES_CONFIG, "utf8"));
+        }
+        catch (err) {
+            console.warn("Unable to parse page-load-routes config, falling back to discovery:", err);
+        }
+    }
+    // Back-compat: array = explicit list.
+    if (Array.isArray(cfg)) {
+        const normalized = Array.from(new Set((cfg || []).map((r) => normalizeRoute(r)))).filter(Boolean);
+        return {
+            routes: normalized.length > 0 ? normalized : DEFAULT_PAGE_ROUTES,
+            skippedDynamic: [],
+            maxRoutes: envMaxRoutes > 0 ? envMaxRoutes : 250,
+            allowPartial: envAllowPartial,
+            exclude: [],
+        };
+    }
+    const mode = cfg?.mode || "discover";
+    const exclude = (cfg?.exclude || []).map((r) => normalizeRoute(r));
+    const allowPartial = process.env.PREFLIGHT_PAGELOAD_ALLOW_PARTIAL === "1"
+        ? true
+        : (cfg?.allowPartial ?? envAllowPartial);
+    const maxRoutes = envMaxRoutes > 0 ? envMaxRoutes : cfg?.maxRoutes || 250;
+    const requireDynamicExamples = process.env.PREFLIGHT_PAGELOAD_REQUIRE_DYNAMIC_EXAMPLES === "1";
+    const dynamicExamples = normalizeExampleRoutes(cfg?.dynamicExamples);
+    const storageStatePath = process.env.PREFLIGHT_PLAYWRIGHT_STORAGE_STATE;
+    const includeProtected = process.env.PREFLIGHT_PAGELOAD_INCLUDE_PROTECTED === "1";
+    const defaultProtectedPrefixes = ["/account/", "/admin/", "/seller/", "/store/"];
+    const effectiveExclude = [...exclude];
+    if (!storageStatePath && !includeProtected) {
+        // Skip protected areas by default when we don't have auth state.
+        defaultProtectedPrefixes.forEach((p) => effectiveExclude.push(`${p}*`));
+    }
+    if (mode === "list") {
+        const configured = (cfg?.routes || []).map((r) => normalizeRoute(r));
+        const include = (cfg?.include || []).map((r) => normalizeRoute(r));
+        const routes = Array.from(new Set([...configured, ...include])).filter(Boolean);
+        const filtered = effectiveExclude.length > 0
+            ? routes.filter((r) => !effectiveExclude.some((p) => matchRoutePattern(p, r)))
+            : routes;
+        return {
+            routes: filtered.length > 0 ? filtered : DEFAULT_PAGE_ROUTES,
+            skippedDynamic: [],
+            maxRoutes,
+            allowPartial,
+            exclude: effectiveExclude,
+        };
+    }
+    const discovered = await discoverRoutesFromApp();
+    const include = (cfg?.include || []).map((r) => normalizeRoute(r));
+    let merged = Array.from(new Set([...discovered.routes, ...include])).filter(Boolean);
+    // Expand dynamic routes with user-provided examples.
+    const expandedDynamic = [];
+    const stillSkipped = [];
+    for (const dyn of discovered.skippedDynamic) {
+        const matches = Object.entries(dynamicExamples).find(([pattern]) => matchRoutePattern(pattern, dyn) || pattern === dyn);
+        const exampleList = matches ? matches[1] : undefined;
+        if (exampleList && exampleList.length > 0) {
+            for (const ex of exampleList) {
+                // If user provides a full example route, accept it. If they provide only segments, best-effort substitute.
+                const resolved = ex.includes("[")
+                    ? null
+                    : ex.startsWith("/")
+                        ? ex
+                        : substituteDynamicRoute(dyn, ex);
+                const route = resolved ? normalizeRoute(resolved) : normalizeRoute(ex);
+                if (route && !route.includes("["))
+                    expandedDynamic.push(route);
+            }
+        }
+        else {
+            stillSkipped.push(dyn);
+        }
+    }
+    if (expandedDynamic.length > 0) {
+        merged = Array.from(new Set([...merged, ...expandedDynamic]));
+    }
+    if (effectiveExclude.length > 0) {
+        merged = merged.filter((route) => !effectiveExclude.some((pattern) => matchRoutePattern(pattern, route)));
+    }
+    const finalSkippedDynamic = stillSkipped;
+    if (requireDynamicExamples && finalSkippedDynamic.length > 0) {
+        // Keep them in the skipped list; the checker will convert this into a blocking error.
+    }
+    return {
+        routes: merged.length > 0 ? merged : DEFAULT_PAGE_ROUTES,
+        skippedDynamic: finalSkippedDynamic,
+        maxRoutes,
+        allowPartial,
+        exclude: effectiveExclude,
+    };
+}
+function buildUrl(route) {
+    try {
+        return new URL(route, HOMEPAGE_URL).toString();
+    }
+    catch (_err) {
+        return `${HOMEPAGE_URL.replace(/\/$/, "")}${route.startsWith("/") ? route : `/${route}`}`;
+    }
+}
+async function isPortOpen(port) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ port, host: "127.0.0.1" });
+        socket.once("connect", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", () => resolve(false));
+    });
+}
+async function waitForPort(port, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isPortOpen(port))
+            return true;
+        await (0, promises_1.setTimeout)(300);
+    }
+    return false;
+}
+function startServer(logs) {
+    const args = PAGELOAD_SERVER_MODE === "prod" ? ["start"] : ["dev"];
+    const env = {
+        ...process.env,
+        PORT: String(PREFLIGHT_PORT),
+        NEXT_TELEMETRY_DISABLED: "1",
+        TURBO_NO_PERSISTENCE: "1",
+        ...(process.env.NODE_NO_WARNINGS ? {} : { NODE_NO_WARNINGS: "1" }),
+        ...(PAGELOAD_SERVER_MODE === "prod" ? { NODE_ENV: "production" } : {}),
+    };
+    if (PAGELOAD_SERVER_MODE === "prod") {
+        // next start requires a build output
+        const nextDir = path.join(process.cwd(), ".next");
+        if (!fs.existsSync(nextDir)) {
+            throw new Error("Production page-load budgets require a built .next directory. Run `pnpm build` first or use PREFLIGHT_PAGELOAD_SERVER_MODE=dev.");
+        }
+        const buildIdPath = path.join(nextDir, "BUILD_ID");
+        if (!fs.existsSync(buildIdPath)) {
+            throw new Error("Production page-load budgets require a complete Next.js production build (.next/BUILD_ID missing). Run `pnpm build` (or at least `pnpm next build`) before running PREFLIGHT_PAGELOAD_SERVER_MODE=prod.");
+        }
+    }
+    // Windows quirks:
+    // - npm_execpath may be pnpm.exe (native) or a JS entrypoint. Don't try to run pnpm.exe as JS.
+    // - Spawning .cmd can be flaky in some environments; prefer pnpm.exe when available.
+    const pnpmExecPath = process.platform === "win32" ? process.env.npm_execpath : undefined;
+    const pnpmExecLooksLikeExe = !!pnpmExecPath && /\.exe$/i.test(pnpmExecPath);
+    const pnpmExecLooksLikeNodeScript = !!pnpmExecPath && /\.(c?js|mjs)$/i.test(pnpmExecPath);
+    const spawnCommand = process.platform === "win32" && pnpmExecLooksLikeNodeScript
+        ? process.execPath
+        : process.platform === "win32" && pnpmExecLooksLikeExe
+            ? pnpmExecPath
+            : PNPM_CMD;
+    const spawnArgs = process.platform === "win32" && pnpmExecLooksLikeNodeScript ? [pnpmExecPath, ...args] : args;
+    const server = (0, child_process_1.spawn)(spawnCommand, spawnArgs, {
+        cwd: process.cwd(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    server.stdout.on("data", (chunk) => logs.push(chunk.toString()));
+    server.stderr.on("data", (chunk) => logs.push(chunk.toString()));
+    return server;
+}
+function stopServer(server) {
+    if (!server)
+        return;
+    try {
+        if (process.platform === "win32" && typeof server.pid === "number") {
+            (0, child_process_1.spawnSync)("taskkill", ["/PID", String(server.pid), "/T", "/F"], {
+                stdio: "ignore",
+            });
+            return;
+        }
+        server.kill();
+    }
+    catch (err) {
+        console.warn("Failed to stop server:", err);
+    }
+}
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedAppTsxFiles = null;
+async function getAppTsxFiles() {
+    if (!_cachedAppTsxFiles) {
+        _cachedAppTsxFiles = await file_cache_1.fileCache.getAppTSX();
+    }
+    return _cachedAppTsxFiles;
+}
+let _cachedAppComponentsTsxFiles = null;
+async function getAppComponentsTsxFiles() {
+    if (!_cachedAppComponentsTsxFiles) {
+        _cachedAppComponentsTsxFiles = await file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    return _cachedAppComponentsTsxFiles;
+}
+async function getAppLibFiles() {
+    return file_cache_1.fileCache.getAppLibFiles();
+}
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class PerformancePreflightModule {
+    verbose;
+    parallel = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    async ensureServer(serverLogs) {
+        const alreadyRunning = await isPortOpen(PREFLIGHT_PORT);
+        if (alreadyRunning) {
+            return { usedExisting: true };
+        }
+        const server = startServer(serverLogs);
+        const timeoutMs = PAGELOAD_SERVER_MODE === "prod" ? PROD_SERVER_START_TIMEOUT : DEV_SERVER_START_TIMEOUT;
+        const readyResult = await Promise.race([
+            waitForPort(PREFLIGHT_PORT, timeoutMs).then((ok) => ({
+                ok,
+                exited: false,
+            })),
+            new Promise((resolve) => {
+                server.once("exit", (code, signal) => resolve({ ok: false, exited: true, code, signal }));
+            }),
+        ]);
+        if (!readyResult.ok) {
+            stopServer(server);
+            const lastLogs = serverLogs.slice(-20).join("").trim();
+            const exitInfo = readyResult.exited
+                ? `Process exited early (code: ${readyResult.code ?? "unknown"}, signal: ${readyResult.signal ?? "none"}). `
+                : "";
+            throw new Error(`${exitInfo}Server did not start on port ${PREFLIGHT_PORT} within ${timeoutMs}ms.` +
+                (lastLogs ? `\n\nLast server logs:\n${lastLogs}` : ""));
+        }
+        // Let the server settle before navigation to avoid capturing cold-start noise only.
+        await (0, promises_1.setTimeout)(500);
+        return { usedExisting: false, server };
+    }
+    async capturePageTrace(context, route) {
+        const page = await context.newPage();
+        const requests = [];
+        const startTimes = new Map();
+        page.on("request", (req) => {
+            startTimes.set(req.url(), Date.now());
+        });
+        page.on("requestfinished", async (req) => {
+            const started = startTimes.get(req.url());
+            const res = await req.response();
+            requests.push({
+                url: req.url(),
+                method: req.method(),
+                status: res?.status(),
+                durationMs: started ? Date.now() - started : undefined,
+                resourceType: req.resourceType(),
+            });
+        });
+        page.on("requestfailed", (req) => {
+            const started = startTimes.get(req.url());
+            requests.push({
+                url: req.url(),
+                method: req.method(),
+                status: undefined,
+                durationMs: started ? Date.now() - started : undefined,
+                resourceType: req.resourceType(),
+            });
+        });
+        try {
+            await page.goto(buildUrl(route), {
+                waitUntil: "domcontentloaded",
+                timeout: PAGELOAD_ROUTE_TIMEOUT_MS,
+            });
+            await page
+                .waitForLoadState("load", { timeout: PAGELOAD_LOAD_TIMEOUT_MS })
+                .catch(() => undefined);
+            await page
+                .waitForLoadState("networkidle", {
+                timeout: PAGELOAD_NETWORKIDLE_TIMEOUT_MS,
+            })
+                .catch(() => undefined);
+            await (0, promises_1.setTimeout)(WAIT_FOR_STABLE_NETWORK_MS);
+            const metrics = await page.evaluate(() => {
+                const nav = performance.getEntriesByType("navigation")[0];
+                const resources = performance.getEntriesByType("resource");
+                const totalTransferBytes = resources.reduce((sum, r) => sum + (r.transferSize || 0), 0);
+                const apiTransferBytes = resources
+                    .filter((r) => typeof r.name === "string" && r.name.includes("/api/"))
+                    .reduce((sum, r) => sum + (r.transferSize || 0), 0);
+                return {
+                    navDuration: nav?.duration || 0,
+                    totalTransferBytes,
+                    apiTransferBytes,
+                };
+            });
+            return {
+                requests,
+                navDuration: metrics.navDuration,
+                totalTransferBytes: metrics.totalTransferBytes,
+                apiTransferBytes: metrics.apiTransferBytes,
+                finalUrl: page.url(),
+            };
+        }
+        finally {
+            await page.close().catch(() => undefined);
+        }
+    }
+    async checkPageLoadBudgets() {
+        const startTime = Date.now();
+        const issues = [];
+        const serverLogs = [];
+        let server;
+        let routes = [];
+        let skippedDynamic = [];
+        let maxRoutes = 250;
+        let allowPartial = false;
+        let exclude = [];
+        const pathKey = (url) => {
+            try {
+                return new URL(url).pathname;
+            }
+            catch (_err) {
+                return url.split("?")[0];
+            }
+        };
+        const evaluateRoute = (route, requests, navDuration, totalTransferBytes, apiTransferBytes, prismaLogSlice) => {
+            const routeIssues = [];
+            const apiRequests = requests.filter((r) => {
+                const path = pathKey(r.url);
+                const isApi = path.startsWith("/api");
+                const isFetchLike = r.resourceType === "fetch" ||
+                    r.resourceType === "xhr" ||
+                    r.resourceType === "document" ||
+                    !r.resourceType;
+                return isApi && isFetchLike;
+            });
+            const documentRequests = requests.filter((r) => r.resourceType === "document");
+            const meaningfulRequestCount = apiRequests.length + documentRequests.length;
+            const apiCountByPath = new Map();
+            apiRequests.forEach((req) => {
+                const key = pathKey(req.url);
+                apiCountByPath.set(key, (apiCountByPath.get(key) || 0) + 1);
+            });
+            const duplicateApis = Array.from(apiCountByPath.entries()).filter(([, count]) => count > PAGELOAD_API_DUPLICATE_LIMIT);
+            const sessionHits = apiCountByPath.get("/api/auth/session") || 0;
+            const notificationHits = apiCountByPath.get("/api/notifications") || 0;
+            if (navDuration > PAGELOAD_NAVIGATION_BUDGET_MS) {
+                routeIssues.push({
+                    file: route,
+                    type: "page-load-duration",
+                    severity: "warning",
+                    message: `Navigation duration ${navDuration.toFixed(0)}ms exceeds budget ${PAGELOAD_NAVIGATION_BUDGET_MS}ms`,
+                    suggestion: "Reduce above-the-fold data fetching and defer non-critical API calls",
+                });
+            }
+            if (meaningfulRequestCount > PAGELOAD_REQUEST_BUDGET) {
+                routeIssues.push({
+                    file: route,
+                    type: "page-load-requests",
+                    severity: "warning",
+                    message: `Document + API requests ${meaningfulRequestCount} exceed budget ${PAGELOAD_REQUEST_BUDGET}`,
+                    suggestion: "Consolidate API calls, enable caching, and defer non-critical widgets",
+                });
+            }
+            if (duplicateApis.length > 0) {
+                duplicateApis.forEach(([path, count]) => {
+                    routeIssues.push({
+                        file: route,
+                        type: "duplicate-api-calls",
+                        severity: "warning",
+                        message: `${path} called ${count} times on first render`,
+                        suggestion: "Use server-side injection or SWR dedupe for repeated endpoints",
+                    });
+                });
+            }
+            if (sessionHits > PAGELOAD_SESSION_DUPLICATE_LIMIT) {
+                routeIssues.push({
+                    file: route,
+                    type: "session-duplication",
+                    severity: "info",
+                    message: `/api/auth/session called ${sessionHits} times`,
+                    suggestion: "Inject session server-side or memoize client fetch",
+                });
+            }
+            if (notificationHits > PAGELOAD_NOTIFICATION_DUPLICATE_LIMIT) {
+                routeIssues.push({
+                    file: route,
+                    type: "notification-duplication",
+                    severity: "info",
+                    message: `/api/notifications called ${notificationHits} times`,
+                    suggestion: "Combine counts + list into one query or cache the list server-side",
+                });
+            }
+            if (apiTransferBytes > PAGELOAD_TRANSFER_BUDGET_BYTES) {
+                routeIssues.push({
+                    file: route,
+                    type: "transfer-size",
+                    severity: "info",
+                    message: `API transfer ${(apiTransferBytes / 1024 / 1024).toFixed(2)}MB exceeds ${(PAGELOAD_TRANSFER_BUDGET_BYTES / 1024 / 1024).toFixed(2)}MB budget`,
+                    suggestion: "Reduce initial API payloads and avoid overfetching",
+                });
+            }
+            if (totalTransferBytes > PAGELOAD_TRANSFER_BUDGET_BYTES * 4) {
+                routeIssues.push({
+                    file: route,
+                    type: "total-transfer-size",
+                    severity: "info",
+                    message: `Total transfer ${(totalTransferBytes / 1024 / 1024).toFixed(2)}MB (assets + API)`,
+                    suggestion: "If this stays high in production, review bundle splitting and image optimization",
+                });
+            }
+            if (prismaLogSlice.length > 0) {
+                if (prismaLogSlice.length > PAGELOAD_PRISMA_QUERY_BUDGET) {
+                    routeIssues.push({
+                        file: route,
+                        type: "prisma-query-volume",
+                        severity: "warning",
+                        message: `Prisma queries during first paint: ${prismaLogSlice.length} (budget ${PAGELOAD_PRISMA_QUERY_BUDGET})`,
+                        suggestion: "Batch page queries and cache counts",
+                    });
+                }
+                const prismaStatements = prismaLogSlice.map((line) => line.replace(/^.*prisma:query\s+/i, "").trim());
+                const prismaCounts = prismaStatements.reduce((acc, stmt) => {
+                    acc[stmt] = (acc[stmt] || 0) + 1;
+                    return acc;
+                }, {});
+                Object.entries(prismaCounts)
+                    .filter(([, count]) => count >= PAGELOAD_PRISMA_DUPLICATE_THRESHOLD)
+                    .slice(0, 5)
+                    .forEach(([stmt, count]) => {
+                    routeIssues.push({
+                        file: route,
+                        type: "prisma-duplicate-query",
+                        severity: "warning",
+                        message: `Repeated Prisma query (${count}x): ${stmt.slice(0, 160)}...`,
+                        suggestion: "Cache notification counts and reuse results across components",
+                    });
+                });
+                const nullInPatterns = prismaLogSlice.filter((line) => /IN\s*\(NULL\)/i.test(line));
+                if (nullInPatterns.length > 0) {
+                    routeIssues.push({
+                        file: route,
+                        type: "prisma-null-in",
+                        severity: "info",
+                        message: `Prisma executed ${nullInPatterns.length} queries with IN (NULL)`,
+                        suggestion: "Guard empty ID lists before querying to avoid wasted queries",
+                    });
+                }
+            }
+            return routeIssues;
+        };
+        let browser;
+        let context;
+        try {
+            const { usedExisting, server: started } = await this.ensureServer(serverLogs);
+            server = started;
+            const loaded = await loadPageRoutes();
+            routes = loaded.routes;
+            skippedDynamic = loaded.skippedDynamic;
+            maxRoutes = loaded.maxRoutes;
+            allowPartial = loaded.allowPartial;
+            exclude = loaded.exclude;
+            browser = await playwright_1.chromium.launch({ headless: true });
+            const storageStatePath = process.env.PREFLIGHT_PLAYWRIGHT_STORAGE_STATE;
+            context = storageStatePath
+                ? await browser.newContext({ storageState: storageStatePath })
+                : await browser.newContext();
+            if (!context) {
+                throw new Error("Failed to create Playwright browser context");
+            }
+            // Augment with sitemap URLs (helps cover dynamic routes without manual examples).
+            if (PAGELOAD_INCLUDE_SITEMAP) {
+                const sitemapRoutes = await discoverRoutesFromSitemaps();
+                if (sitemapRoutes.length > 0) {
+                    routes = Array.from(new Set([...routes, ...sitemapRoutes]));
+                    issues.push({
+                        file: "sitemap",
+                        type: "sitemap-discovery",
+                        severity: "info",
+                        message: `Discovered ${sitemapRoutes.length} routes from sitemap`,
+                        suggestion: "Disable PREFLIGHT_PAGELOAD_INCLUDE_SITEMAP if you only want filesystem-discovered routes",
+                    });
+                }
+                else {
+                    issues.push({
+                        file: "sitemap",
+                        type: "sitemap-discovery",
+                        severity: "info",
+                        message: "Sitemap discovery enabled but no sitemap URLs were found",
+                        suggestion: "Ensure your app serves /sitemap.xml or /sitemap/0.xml in production mode",
+                    });
+                }
+            }
+            // Enforce true dynamic coverage when requested.
+            if (process.env.PREFLIGHT_PAGELOAD_REQUIRE_DYNAMIC_EXAMPLES === "1" &&
+                skippedDynamic.length > 0) {
+                const missing = skippedDynamic.filter((tpl) => !routes.some((r) => dynamicTemplateMatchesRoute(tpl, r)));
+                if (missing.length > 0) {
+                    issues.push({
+                        file: PAGELOAD_ROUTES_CONFIG,
+                        type: "dynamic-routes-missing-examples",
+                        severity: "error",
+                        message: `Dynamic routes require examples but ${missing.length} are still missing coverage: ${missing.slice(0, 10).join(", ")}${missing.length > 10 ? "${chars.ellipsis}" : ""}`,
+                        suggestion: "Add dynamicExamples entries to the configured routes JSON, or enable PREFLIGHT_PAGELOAD_INCLUDE_SITEMAP to pick up real URLs.",
+                    });
+                    return {
+                        name: "Page Load Budgets",
+                        passed: false,
+                        blocking: true,
+                        issues,
+                        duration: Date.now() - startTime,
+                    };
+                }
+            }
+            // Warm up a freshly started server to avoid penalizing cold-start compilation/caching.
+            if (!usedExisting) {
+                try {
+                    await this.capturePageTrace(context, "/");
+                }
+                catch {
+                    // ignore warmup failures
+                }
+            }
+            if (skippedDynamic.length > 0) {
+                issues.push({
+                    file: "app",
+                    type: "dynamic-routes-skipped",
+                    severity: "info",
+                    message: `Skipped ${skippedDynamic.length} dynamic routes (require params): ${skippedDynamic.slice(0, 10).join(", ")}${skippedDynamic.length > 10 ? "${chars.ellipsis}" : ""}`,
+                    suggestion: "Add explicit examples via list-mode config if you want dynamic route coverage",
+                });
+            }
+            if (exclude.length > 0) {
+                issues.push({
+                    file: PAGELOAD_ROUTES_CONFIG,
+                    type: "route-excludes",
+                    severity: "info",
+                    message: `Excluded ${exclude.length} patterns from page-load budgets`,
+                    suggestion: "Remove excludes if you want stricter coverage",
+                });
+            }
+            if (routes.length > maxRoutes) {
+                const msg = `Discovered ${routes.length} routes but maxRoutes is ${maxRoutes}`;
+                if (!allowPartial) {
+                    issues.push({
+                        file: PAGELOAD_ROUTES_CONFIG,
+                        type: "too-many-routes",
+                        severity: "error",
+                        message: msg,
+                        suggestion: "Increase maxRoutes or set PREFLIGHT_PAGELOAD_ALLOW_PARTIAL=1 to sample",
+                    });
+                    return {
+                        name: "Page Load Budgets",
+                        passed: false,
+                        blocking: true,
+                        issues,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                issues.push({
+                    file: PAGELOAD_ROUTES_CONFIG,
+                    type: "route-sampling",
+                    severity: "warning",
+                    message: `${msg}; sampling first ${maxRoutes}`,
+                    suggestion: "Increase maxRoutes to cover more pages",
+                });
+                routes = routes.slice(0, maxRoutes);
+            }
+            if (PAGELOAD_CONCURRENCY > 1) {
+                issues.push({
+                    file: "page-load",
+                    type: "concurrency-enabled",
+                    severity: "info",
+                    message: `Running page-load budgets with concurrency=${PAGELOAD_CONCURRENCY}`,
+                    suggestion: "Set PREFLIGHT_PAGELOAD_CONCURRENCY=1 for deterministic per-route Prisma attribution",
+                });
+            }
+            let completed = 0;
+            let nextIndex = 0;
+            const runOne = async () => {
+                while (nextIndex < routes.length) {
+                    const index = nextIndex++;
+                    if (index >= routes.length) {
+                        return;
+                    }
+                    const route = routes[index];
+                    if (this.verbose) {
+                        console.log(`   ↪︎ pageload ${route}`);
+                    }
+                    const { requests, navDuration, totalTransferBytes, apiTransferBytes, finalUrl } = await this.capturePageTrace(context, route);
+                    // When running concurrently we can't reliably slice logs per-route.
+                    const prismaLogSlice = PAGELOAD_CONCURRENCY > 1
+                        ? []
+                        : serverLogs.filter((line) => line.includes("prisma:query"));
+                    let intendedPath;
+                    let finalPath;
+                    try {
+                        intendedPath = new URL(buildUrl(route)).pathname;
+                        finalPath = new URL(finalUrl).pathname;
+                    }
+                    catch {
+                        // ignore url parse issues
+                    }
+                    if (intendedPath && finalPath && intendedPath !== finalPath) {
+                        issues.push({
+                            file: route,
+                            type: "redirect-detected",
+                            severity: "info",
+                            message: `Route redirected: ${intendedPath} ${console_chars_1.chars.arrow} ${finalPath}`,
+                            suggestion: "Provide PREFLIGHT_PLAYWRIGHT_STORAGE_STATE to test authenticated pages (or list-mode config to exclude protected routes)",
+                        });
+                        const authRedirect = finalPath === "/login" ||
+                            finalPath.startsWith("/login/") ||
+                            finalPath.startsWith("/auth/signin") ||
+                            finalPath.startsWith("/auth/error") ||
+                            finalPath === "/forbidden" ||
+                            finalPath.startsWith("/forbidden/");
+                        if (authRedirect) {
+                            continue; // Don't apply budgets to protected routes when unauthenticated.
+                        }
+                    }
+                    issues.push(...evaluateRoute(route, requests, navDuration, totalTransferBytes, apiTransferBytes, prismaLogSlice));
+                    if (usedExisting && prismaLogSlice.length === 0) {
+                        issues.push({
+                            file: route,
+                            type: "log-capture",
+                            severity: "info",
+                            message: "Prisma logs not captured (dev server already running)",
+                            suggestion: "Run preflight on a fresh dev server to capture query counts",
+                        });
+                    }
+                    completed++;
+                    if (!this.verbose &&
+                        PAGELOAD_PROGRESS_EVERY > 0 &&
+                        completed % PAGELOAD_PROGRESS_EVERY === 0) {
+                        console.log(`   pageload progress ${completed}/${routes.length}`);
+                    }
+                }
+            };
+            const workerCount = Math.min(PAGELOAD_CONCURRENCY, routes.length);
+            await Promise.all(Array.from({ length: workerCount }, () => runOne()));
+        }
+        catch (err) {
+            issues.push({
+                file: "page-load",
+                type: "page-load-check",
+                severity: "error",
+                message: `Failed to run page load budget: ${err?.message || err}`,
+                suggestion: "Ensure pnpm dev can start and Playwright is installed",
+            });
+        }
+        finally {
+            await context?.close().catch(() => undefined);
+            await browser?.close().catch(() => undefined);
+            stopServer(server);
+        }
+        const failedIssues = issues.filter((i) => i.severity === "error" || (PAGELOAD_STRICT && i.severity === "warning"));
+        return {
+            name: "Page Load Budgets",
+            passed: failedIssues.length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Bundle Size Check
+     */
+    async checkBundleSize() {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for large dependencies
+        const largeDeps = [
+            { name: "moment", suggestion: "Use date-fns (90% smaller)" },
+            { name: "lodash", suggestion: "Use lodash-es or individual imports" },
+            { name: "@mui/material", suggestion: "Use @supercatch/ui (98% smaller)" },
+        ];
+        if (fs.existsSync("package.json")) {
+            const pkg = JSON.parse(fs.readFileSync("package.json", "utf8"));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            for (const { name, suggestion } of largeDeps) {
+                if (deps[name]) {
+                    issues.push({
+                        file: "package.json",
+                        type: "large-dep",
+                        severity: "warning",
+                        message: `Large dependency: ${name}`,
+                        suggestion,
+                    });
+                }
+            }
+        }
+        return {
+            name: "Bundle Size",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Image Optimization Check
+     * Detects:
+     * - Images without width/height (causes CLS)
+     * - Missing loading="lazy" on below-fold images
+     * - Missing priority prop on above-fold/hero/featured images
+     * - ListingShowcaseCard without priority prop in homepage/featured contexts
+     */
+    async checkImageOptimization() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for img without width/height
+                if (/<img[^>]*src=/i.test(line) && !/<img[^>]*(?:width|height)=/i.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "img-no-dimensions",
+                        severity: "warning",
+                        message: "img without width/height (causes CLS)",
+                        suggestion: "Add width and height attributes",
+                    });
+                }
+                // Check for img without loading="lazy"
+                if (/<img[^>]*src=/i.test(line) && !line.includes("loading=")) {
+                    const context = lines.slice(Math.max(0, index - 5), index).join("\n");
+                    if (!context.includes("priority") && !context.includes("above-fold")) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "img-no-lazy",
+                            severity: "info",
+                            message: 'img without loading="lazy"',
+                            suggestion: 'Add loading="lazy" for below-fold images',
+                        });
+                    }
+                }
+                // Check for Next.js Image in hero/featured/banner contexts without priority
+                if (/<Image[^>]*src=/i.test(line)) {
+                    const contextBefore = lines
+                        .slice(Math.max(0, index - 10), index + 1)
+                        .join("\n")
+                        .toLowerCase();
+                    const contextAfter = lines
+                        .slice(index, Math.min(lines.length, index + 5))
+                        .join("\n")
+                        .toLowerCase();
+                    const fullContext = contextBefore + contextAfter;
+                    const isAboveFold = /hero|banner|featured|showcase|primary|main.*image|first.*card/i.test(fullContext);
+                    const hasPriority = /priority/i.test(line) || /priority/i.test(contextAfter);
+                    if (isAboveFold && !hasPriority) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "lcp-no-priority",
+                            severity: "warning",
+                            message: "Above-fold Image missing priority prop (hurts LCP)",
+                            suggestion: "Add priority prop to above-fold images for better LCP",
+                        });
+                    }
+                }
+                // Check for ListingShowcaseCard in homepage/featured without priority
+                if (/ListingShowcaseCard/i.test(line) && !line.includes("priority")) {
+                    const contextBefore = lines
+                        .slice(Math.max(0, index - 15), index)
+                        .join("\n")
+                        .toLowerCase();
+                    const isHomepageOrFeatured = /featured|homepage|hero|showcase|first/i.test(contextBefore) ||
+                        file.includes("page.tsx") ||
+                        file.includes("HomePageClient");
+                    if (isHomepageOrFeatured) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "showcase-no-priority",
+                            severity: "info",
+                            message: "ListingShowcaseCard in featured context without priority prop",
+                            suggestion: "Add priority={true} for first few visible cards to improve LCP",
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Image Optimization",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Lazy Loading Check
+     */
+    async checkLazyLoading() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        const heavyComponents = ["Chart", "Editor", "Map", "Calendar", "DataGrid", "RichText"];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            for (const component of heavyComponents) {
+                const staticImport = new RegExp(`import\\s+.*${component}.*from`);
+                if (staticImport.test(content) && !content.includes("dynamic(")) {
+                    const lineNumber = content.split("\n").findIndex((l) => staticImport.test(l)) + 1;
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "static-heavy-import",
+                        severity: "info",
+                        message: `Heavy component ${component} imported statically`,
+                        suggestion: `Use dynamic(() => import('...'))`,
+                    });
+                }
+            }
+        }
+        return {
+            name: "Lazy Loading",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Skeleton Loader Usage Check
+     */
+    async checkSkeletonLoaders() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Check for loading states without skeleton
+            if (content.includes("isLoading") || content.includes("loading")) {
+                if (content.includes("Loading...") || content.includes('"Loading"')) {
+                    const lineNumber = content.split("\n").findIndex((l) => /Loading\.\.\./.test(l) || /"Loading"/.test(l)) +
+                        1;
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "text-loading",
+                        severity: "info",
+                        message: "Text-based loading indicator",
+                        suggestion: "Use SkeletonLoader for better UX",
+                    });
+                }
+            }
+        }
+        return {
+            name: "Skeleton Loaders",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Virtual Scroll Candidates Check
+     */
+    async checkVirtualScroll() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for .map() on potentially large arrays
+                if (/\.(map|forEach)\s*\(\s*\([^)]*\)\s*=>/i.test(line)) {
+                    const context = lines.slice(Math.max(0, index - 10), index + 1).join("\n");
+                    if (/items|products|listings|results|data/i.test(context) &&
+                        !context.includes("slice(") &&
+                        !context.includes("VirtualList")) {
+                        // Only flag if it looks like a large list render
+                        if (context.includes("return") &&
+                            (context.includes("<li") || context.includes("<div") || context.includes("<Card"))) {
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                type: "large-list",
+                                severity: "info",
+                                message: "Potentially large list without virtualization",
+                                suggestion: "Consider VirtualTable or VirtualList from @/components/shared",
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        return {
+            name: "Virtual Scroll Candidates",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Z-Index Token Usage Check
+     */
+    async checkZIndexTokens() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Skip comments
+                if (line.trim().startsWith("//") || line.trim().startsWith("*"))
+                    return;
+                // Check for hardcoded z-index values >= 100
+                const zIndexMatch = line.match(/zIndex:\s*(\d+)/);
+                if (zIndexMatch) {
+                    const value = parseInt(zIndexMatch[1], 10);
+                    if (value >= 100) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "hardcoded-zindex",
+                            severity: "warning",
+                            message: `Hardcoded z-index: ${value}`,
+                            suggestion: "Use design tokens: var(--z-modal), var(--z-dropdown), var(--z-sticky), etc.",
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Z-Index Tokens",
+            passed: issues.length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Recharts Lazy Loading Check
+     */
+    async checkRechartsLazyLoading() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Check for static recharts imports
+            const rechartsImport = /import\s+\{[^}]+\}\s+from\s+["']recharts["']/;
+            if (rechartsImport.test(content)) {
+                // Check if it's using dynamic import
+                if (!content.includes("dynamic(") || !content.includes("recharts")) {
+                    const lineNumber = content.split("\n").findIndex((l) => rechartsImport.test(l)) + 1;
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "static-recharts",
+                        severity: "warning",
+                        message: "Static recharts import (~200KB)",
+                        suggestion: 'Use dynamic(() => import("recharts").then(mod => mod.Component), { ssr: false })',
+                    });
+                }
+            }
+        }
+        return {
+            name: "Recharts Lazy Loading",
+            passed: issues.length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Dialog Lazy Loading Check
+     */
+    async checkDialogLazyLoading() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Check for static dialog imports from local components
+            const dialogImport = /import\s+\{[^}]*Dialog[^}]*\}\s+from\s+["']\.\/components/;
+            if (dialogImport.test(content)) {
+                const lineNumber = content.split("\n").findIndex((l) => dialogImport.test(l)) + 1;
+                issues.push({
+                    file,
+                    line: lineNumber,
+                    type: "static-dialog",
+                    severity: "info",
+                    message: "Static dialog import - consider lazy loading",
+                    suggestion: "Use DynamicXxxDialog from @/lib/dynamic-imports for dialogs that are not immediately visible",
+                });
+            }
+        }
+        return {
+            name: "Dialog Lazy Loading",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Database Query Efficiency Check
+     * Detects N+1 query patterns and suggests Prisma include
+     */
+    async checkDatabaseQueryEfficiency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppLibFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check for N+1 pattern: findMany followed by separate queries for related data
+            const hasFindMany = /prisma\.\w+\.findMany/.test(content);
+            const hasManualStitching = /\.map\s*\(\s*\([^)]*\)\s*=>\s*[^)]*\.get\s*\(/.test(content);
+            const hasParallelQueries = /Promise\.all\s*\(\s*\[[\s\S]*?prisma\.\w+\.findMany[\s\S]*?\]\s*\)/.test(content);
+            if (hasFindMany && hasManualStitching && hasParallelQueries) {
+                // Find the line with findMany
+                const lineNumber = lines.findIndex((l) => /prisma\.\w+\.findMany/.test(l)) + 1;
+                issues.push({
+                    file,
+                    line: lineNumber,
+                    type: "n-plus-1-pattern",
+                    severity: "warning",
+                    message: "Potential N+1 query pattern detected (findMany + separate relation queries)",
+                    suggestion: "Use Prisma include: { relatedModel: true } for single optimized query",
+                });
+            }
+            // Check for force-dynamic without caching
+            if (content.includes("dynamic = 'force-dynamic'") ||
+                content.includes('dynamic = "force-dynamic"')) {
+                const hasUnstableCache = content.includes("unstable_cache");
+                const lineNumber = lines.findIndex((l) => /dynamic\s*=\s*['"]force-dynamic['"]/.test(l)) + 1;
+                // Skip layout.tsx which has a documented reason
+                if (!file.includes("layout.tsx") && !hasUnstableCache) {
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "force-dynamic-no-cache",
+                        severity: "warning",
+                        message: "force-dynamic without unstable_cache disables all caching",
+                        suggestion: "Remove force-dynamic and use unstable_cache for data fetching, or add caching if dynamic is required",
+                    });
+                }
+            }
+        }
+        return {
+            name: "Database Query Efficiency",
+            passed: issues.length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll() {
+        const startTime = Date.now();
+        console.log(`\n${console_chars_1.emoji.lightning} CONSOLIDATED PERFORMANCE PREFLIGHT`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const checkPromises = [
+            this.checkBundleSize(),
+            this.checkImageOptimization(),
+            this.checkLazyLoading(),
+            this.checkSkeletonLoaders(),
+            this.checkVirtualScroll(),
+            this.checkZIndexTokens(),
+            this.checkRechartsLazyLoading(),
+            this.checkDialogLazyLoading(),
+            this.checkDatabaseQueryEfficiency(),
+        ];
+        if (process.env.PREFLIGHT_ENABLE_PAGELOAD_BUDGETS === "1") {
+            checkPromises.push(this.checkPageLoadBudgets());
+        }
+        const checks = await Promise.all(checkPromises);
+        const totalDuration = Date.now() - startTime;
+        const allIssues = checks.flatMap((c) => c.issues);
+        const hasBlockingFailure = checks.some((c) => !c.passed && c.blocking);
+        const summary = {
+            total: checks.length,
+            passed: checks.filter((c) => c.passed).length,
+            failed: checks.filter((c) => !c.passed).length,
+            errors: allIssues.filter((i) => i.severity === "error").length,
+            warnings: allIssues.filter((i) => i.severity === "warning").length,
+        };
+        this.printResults(checks, totalDuration, summary, hasBlockingFailure);
+        return {
+            module: "performance",
+            passed: !hasBlockingFailure,
+            totalDuration,
+            checks,
+            summary,
+        };
+    }
+    printResults(checks, totalDuration, summary, hasBlockingFailure) {
+        console.log("\n" + (0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`${console_chars_1.emoji.chart} PERFORMANCE RESULTS`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const allIssues = checks.flatMap((c) => c.issues);
+        checks.forEach((check) => {
+            const icon = check.passed
+                ? `${console_chars_1.emoji.success}`
+                : check.blocking
+                    ? `${console_chars_1.emoji.error}`
+                    : `${console_chars_1.emoji.warning}`;
+            const count = check.issues.length > 0 ? ` (${check.issues.length} issues)` : "";
+            console.log(`${icon} ${check.name.padEnd(30)} ${(check.duration / 1000).toFixed(1)}s${count}`);
+        });
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`Warnings: ${summary.warnings} | Info: ${allIssues.filter((i) => i.severity === "info").length} | Time: ${(totalDuration / 1000).toFixed(1)}s`);
+        const shouldPrintDetails = hasBlockingFailure || this.verbose || process.env.PREFLIGHT_VERBOSE === "1";
+        if (shouldPrintDetails) {
+            console.log("\n📌 Details (top findings)");
+            console.log((0, console_chars_1.createDivider)(80, "heavy"));
+            for (const check of checks) {
+                if (check.issues.length === 0)
+                    continue;
+                console.log(`\n${console_chars_1.chars.bullet} ${check.name} (${check.issues.length})`);
+                // Special formatting for page routes
+                if (check.name === "Page Load Budgets") {
+                    const byRoute = new Map();
+                    for (const issue of check.issues) {
+                        const key = issue.file || "unknown";
+                        if (!byRoute.has(key))
+                            byRoute.set(key, []);
+                        byRoute.get(key).push(issue);
+                    }
+                    const sorted = Array.from(byRoute.entries()).sort((a, b) => b[1].filter((i) => i.severity !== "info").length -
+                        a[1].filter((i) => i.severity !== "info").length);
+                    for (const [route, routeIssues] of sorted.slice(0, 15)) {
+                        const failing = routeIssues.filter((i) => i.severity !== "info");
+                        const info = routeIssues.filter((i) => i.severity === "info");
+                        const label = failing.length > 0 ? `${console_chars_1.emoji.error}` : `${console_chars_1.emoji.info}`;
+                        console.log(`  ${label} ${route} (${failing.length} blocking/warn, ${info.length} info)`);
+                        routeIssues.slice(0, 6).forEach((i) => {
+                            const sev = i.severity === "error" ? "ERROR" : i.severity === "warning" ? "WARN" : "INFO";
+                            console.log(`     - [${sev}] ${i.message}`);
+                        });
+                        if (routeIssues.length > 6)
+                            console.log(`     - ... +${routeIssues.length - 6} more`);
+                    }
+                }
+                else {
+                    check.issues.slice(0, 15).forEach((i) => {
+                        const sev = i.severity === "error" ? "ERROR" : i.severity === "warning" ? "WARN" : "INFO";
+                        console.log(`  - [${sev}] ${i.file}${i.line ? `:${i.line}` : ""} ${i.message}`);
+                    });
+                    if (check.issues.length > 15)
+                        console.log(`  - ... +${check.issues.length - 15} more`);
+                }
+            }
+        }
+        if (hasBlockingFailure) {
+            console.log(`\n${console_chars_1.emoji.error} PERFORMANCE FAILED (blocking)`);
+        }
+        else if (summary.warnings > 0) {
+            console.log(`\n${console_chars_1.emoji.warning}  PERFORMANCE PASSED WITH WARNINGS`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} PERFORMANCE PASSED`);
+        }
+    }
+}
+exports.PerformancePreflightModule = PerformancePreflightModule;
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const args = process.argv.slice(2);
+    const mode = args[0] || "all";
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const parallel = args.includes("--parallel") || args.includes("-p");
+    const module = new PerformancePreflightModule({ verbose, parallel });
+    const runSingle = async (name, fn) => {
+        const check = await fn();
+        console.log(`\n${check.passed ? "${emoji.success}" : "${emoji.warning}"} ${check.name}: ${check.issues.length} issues`);
+        if (check.issues.length > 0) {
+            const shouldPrintMore = !check.passed || check.blocking || verbose || process.env.PREFLIGHT_VERBOSE === "1";
+            const limit = shouldPrintMore ? 30 : 5;
+            check.issues
+                .slice(0, limit)
+                .forEach((i) => console.log(`   ${i.file}${i.line ? `:${i.line}` : ""} - ${i.message}`));
+            if (check.issues.length > limit)
+                console.log(`   ... and ${check.issues.length - limit} more`);
+        }
+        const hasBlockingFailure = !check.passed && check.blocking;
+        return {
+            module: `performance:${name}`,
+            passed: !hasBlockingFailure,
+            totalDuration: check.duration,
+            checks: [check],
+            summary: {
+                total: 1,
+                passed: check.passed ? 1 : 0,
+                failed: check.passed ? 0 : 1,
+                errors: check.issues.filter((i) => i.severity === "error").length,
+                warnings: check.issues.filter((i) => i.severity === "warning").length,
+            },
+        };
+    };
+    let result;
+    switch (mode) {
+        case "bundle":
+            result = await runSingle("bundle", () => module.checkBundleSize());
+            break;
+        case "images":
+            result = await runSingle("images", () => module.checkImageOptimization());
+            break;
+        case "lazy":
+            result = await runSingle("lazy", () => module.checkLazyLoading());
+            break;
+        case "skeleton":
+            result = await runSingle("skeleton", () => module.checkSkeletonLoaders());
+            break;
+        case "virtual":
+            result = await runSingle("virtual", () => module.checkVirtualScroll());
+            break;
+        case "zindex":
+            result = await runSingle("zindex", () => module.checkZIndexTokens());
+            break;
+        case "recharts":
+            result = await runSingle("recharts", () => module.checkRechartsLazyLoading());
+            break;
+        case "dialogs":
+            result = await runSingle("dialogs", () => module.checkDialogLazyLoading());
+            break;
+        case "queries":
+            result = await runSingle("queries", () => module.checkDatabaseQueryEfficiency());
+            break;
+        case "pageload":
+            result = await runSingle("pageload", () => module.checkPageLoadBudgets());
+            break;
+        default:
+            result = await module.runAll();
+            break;
+    }
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=performance.js.map