laxy-verify 1.2.2 → 1.3.0

package/dist/lighthouse.js

@@ -1,75 +1,77 @@
-"use strict";
-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.runLighthouse = runLighthouse;
-const node_child_process_1 = require("node:child_process");
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-// laxy-verify 패키지의 node_modules 절대 경로
-// runner script를 CJS로 실행하고 NODE_PATH에 이 경로를 추가해서
-// 어느 프로젝트 디렉토리에서 실행해도 lighthouse/chrome-launcher를 찾도록 함
-// __dirname = dist/ 이므로 한 단계 올라가서 node_modules를 가리킴
-const LH_NODE_MODULES_DIR = path.resolve(__dirname, "..", "node_modules");
-function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 !== 0
-        ? sorted[mid]
-        : (sorted[mid - 1] + sorted[mid]) / 2;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function removeDirWithRetries(dirPath, retries = 5) {
-    for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            if (fs.existsSync(dirPath)) {
-                fs.rmSync(dirPath, { recursive: true, force: true });
-            }
-            return;
-        }
-        catch {
-            if (attempt === retries - 1)
-                return;
-            await sleep(250);
-        }
-    }
-}
-// CJS 방식으로 runner script를 작성
-// NODE_PATH를 통해 laxy-verify node_modules를 참조
-function writeRunnerScript(runnerPath) {
+"use strict";
+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.runLighthouse = runLighthouse;
+exports.runLighthouseOnUrl = runLighthouseOnUrl;
+exports.runLighthouseOnRoutes = runLighthouseOnRoutes;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+// laxy-verify 패키지의 node_modules 절대 경로
+// runner script를 CJS로 실행하고 NODE_PATH에 이 경로를 추가해서
+// 어느 프로젝트 디렉토리에서 실행해도 lighthouse/chrome-launcher를 찾도록 함
+// __dirname = dist/ 이므로 한 단계 올라가서 node_modules를 가리킴
+const LH_NODE_MODULES_DIR = path.resolve(__dirname, "..", "node_modules");
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0
+        ? sorted[mid]
+        : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function removeDirWithRetries(dirPath, retries = 5) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+        try {
+            if (fs.existsSync(dirPath)) {
+                fs.rmSync(dirPath, { recursive: true, force: true });
+            }
+            return;
+        }
+        catch {
+            if (attempt === retries - 1)
+                return;
+            await sleep(250);
+        }
+    }
+}
+// CJS 방식으로 runner script를 작성
+// NODE_PATH를 통해 laxy-verify node_modules를 참조
+function writeRunnerScript(runnerPath) {
     const source = `"use strict";
 const fs = require("node:fs/promises");
 const _lhModule = require("lighthouse");
@@ -110,89 +112,160 @@ const [url, reportPath, chromeDir] = process.argv.slice(2);
   process.stderr.write(err.message + "\\n");
   process.exit(1);
 });
-`;
-    // .cjs 확장자로 저장해서 Node가 CommonJS로 실행하도록 함
-    fs.writeFileSync(runnerPath, source, "utf-8");
-}
-async function runLighthouse(port, runs) {
-    const baseTmpDir = path.join(process.cwd(), ".laxy-tmp", `lighthouse-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-    const reportsDir = path.join(baseTmpDir, "reports");
-    const runnerPath = path.join(baseTmpDir, "run-lighthouse.cjs");
-    fs.mkdirSync(reportsDir, { recursive: true });
-    writeRunnerScript(runnerPath);
-    console.log(`\n  Running Lighthouse (${runs} run${runs > 1 ? "s" : ""})...`);
-    const errors = [];
-    const allScores = [];
-    for (let runIndex = 0; runIndex < runs; runIndex++) {
-        const runNumber = runIndex + 1;
-        const reportPath = path.join(reportsDir, `lhr-${runNumber}.json`);
-        const chromeDir = path.join(baseTmpDir, `chrome-${runNumber}`);
-        fs.mkdirSync(chromeDir, { recursive: true });
-        console.log(`  [lh] Run ${runNumber}/${runs}`);
-        const child = (0, node_child_process_1.spawn)("node", [runnerPath, `http://127.0.0.1:${port}/`, reportPath, chromeDir], {
-            shell: false,
-            stdio: ["ignore", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                // NODE_PATH를 추가해서 laxy-verify node_modules에서 패키지를 찾도록 함
-                NODE_PATH: [LH_NODE_MODULES_DIR, process.env.NODE_PATH].filter(Boolean).join(path.delimiter),
-                TEMP: baseTmpDir,
-                TMP: baseTmpDir,
-                TMPDIR: baseTmpDir,
-            },
-        });
-        child.stdout?.on("data", (chunk) => {
-            const lines = chunk.toString().split("\n").filter(Boolean);
-            for (const line of lines)
-                console.log(`  [lh] ${line}`);
-        });
-        child.stderr?.on("data", (chunk) => {
-            const lines = chunk.toString().split("\n").filter(Boolean);
-            errors.push(...lines);
-            for (const line of lines)
-                console.error(`  [lh] ${line}`);
-        });
-        const exitCode = await new Promise((resolve) => {
-            child.on("exit", (code) => resolve(code ?? 1));
-        });
-        try {
-            if (!fs.existsSync(reportPath)) {
-                errors.push(`Run ${runNumber}: Lighthouse exited with code ${exitCode} and produced no JSON report.`);
-                continue;
-            }
-            const report = JSON.parse(fs.readFileSync(reportPath, "utf8"));
-            allScores.push({
-                performance: Math.round((report.categories.performance?.score ?? 0) * 100),
-                accessibility: Math.round((report.categories.accessibility?.score ?? 0) * 100),
-                seo: Math.round((report.categories.seo?.score ?? 0) * 100),
-                bestPractices: Math.round((report.categories["best-practices"]?.score ?? 0) * 100),
-            });
-            if (exitCode !== 0) {
-                errors.push(`Run ${runNumber}: Lighthouse exited with code ${exitCode}, but the JSON report was recovered.`);
-            }
-        }
-        catch (error) {
-            errors.push(`Run ${runNumber}: Failed to read Lighthouse report: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        finally {
-            await removeDirWithRetries(chromeDir);
-        }
-    }
-    try {
-        if (allScores.length === 0) {
-            console.error("  Lighthouse exited without usable reports.");
-            return { scores: null, errors };
-        }
-        const scores = {
-            performance: Math.round(median(allScores.map((score) => score.performance))),
-            accessibility: Math.round(median(allScores.map((score) => score.accessibility))),
-            seo: Math.round(median(allScores.map((score) => score.seo))),
-            bestPractices: Math.round(median(allScores.map((score) => score.bestPractices))),
-        };
-        console.log(`  Lighthouse median: P=${scores.performance} A=${scores.accessibility} S=${scores.seo} BP=${scores.bestPractices}`);
-        return { scores, errors };
-    }
-    finally {
-        await removeDirWithRetries(baseTmpDir);
-    }
-}
+`;
+    // .cjs 확장자로 저장해서 Node가 CommonJS로 실행하도록 함
+    fs.writeFileSync(runnerPath, source, "utf-8");
+}
+async function runLighthouseCore(fullUrl, runs, label) {
+    const baseTmpDir = path.join(process.cwd(), ".laxy-tmp", `lighthouse-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    const reportsDir = path.join(baseTmpDir, "reports");
+    const runnerPath = path.join(baseTmpDir, "run-lighthouse.cjs");
+    fs.mkdirSync(reportsDir, { recursive: true });
+    writeRunnerScript(runnerPath);
+    console.log(`\n  Running Lighthouse on ${label} (${runs} run${runs > 1 ? "s" : ""})...`);
+    const errors = [];
+    const allScores = [];
+    for (let runIndex = 0; runIndex < runs; runIndex++) {
+        const runNumber = runIndex + 1;
+        const reportPath = path.join(reportsDir, `lhr-${runNumber}.json`);
+        const chromeDir = path.join(baseTmpDir, `chrome-${runNumber}`);
+        fs.mkdirSync(chromeDir, { recursive: true });
+        console.log(`  [lh] Run ${runNumber}/${runs}`);
+        const child = (0, node_child_process_1.spawn)("node", [runnerPath, fullUrl, reportPath, chromeDir], {
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                // NODE_PATH를 추가해서 laxy-verify node_modules에서 패키지를 찾도록 함
+                NODE_PATH: [LH_NODE_MODULES_DIR, process.env.NODE_PATH].filter(Boolean).join(path.delimiter),
+                TEMP: baseTmpDir,
+                TMP: baseTmpDir,
+                TMPDIR: baseTmpDir,
+            },
+        });
+        child.stdout?.on("data", (chunk) => {
+            const lines = chunk.toString().split("\n").filter(Boolean);
+            for (const line of lines)
+                console.log(`  [lh] ${line}`);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const lines = chunk.toString().split("\n").filter(Boolean);
+            errors.push(...lines);
+            for (const line of lines)
+                console.error(`  [lh] ${line}`);
+        });
+        const exitCode = await new Promise((resolve) => {
+            child.on("exit", (code) => resolve(code ?? 1));
+        });
+        try {
+            if (!fs.existsSync(reportPath)) {
+                errors.push(`Run ${runNumber}: Lighthouse exited with code ${exitCode} and produced no JSON report.`);
+                continue;
+            }
+            const report = JSON.parse(fs.readFileSync(reportPath, "utf8"));
+            allScores.push({
+                performance: Math.round((report.categories.performance?.score ?? 0) * 100),
+                accessibility: Math.round((report.categories.accessibility?.score ?? 0) * 100),
+                seo: Math.round((report.categories.seo?.score ?? 0) * 100),
+                bestPractices: Math.round((report.categories["best-practices"]?.score ?? 0) * 100),
+            });
+            if (exitCode !== 0) {
+                errors.push(`Run ${runNumber}: Lighthouse exited with code ${exitCode}, but the JSON report was recovered.`);
+            }
+        }
+        catch (error) {
+            errors.push(`Run ${runNumber}: Failed to read Lighthouse report: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            await removeDirWithRetries(chromeDir);
+        }
+    }
+    try {
+        if (allScores.length === 0) {
+            console.error("  Lighthouse exited without usable reports.");
+            return { scores: null, errors };
+        }
+        const scores = {
+            performance: Math.round(median(allScores.map((score) => score.performance))),
+            accessibility: Math.round(median(allScores.map((score) => score.accessibility))),
+            seo: Math.round(median(allScores.map((score) => score.seo))),
+            bestPractices: Math.round(median(allScores.map((score) => score.bestPractices))),
+        };
+        console.log(`  Lighthouse median: P=${scores.performance} A=${scores.accessibility} S=${scores.seo} BP=${scores.bestPractices}`);
+        return { scores, errors };
+    }
+    finally {
+        await removeDirWithRetries(baseTmpDir);
+    }
+}
+async function runLighthouse(port, runs, routePath = "/") {
+    const normalizedPath = routePath.startsWith("/") ? routePath : `/${routePath}`;
+    const label = normalizedPath === "/" ? "/" : normalizedPath;
+    return runLighthouseCore(`http://127.0.0.1:${port}${normalizedPath}`, runs, label);
+}
+/** Run Lighthouse against an arbitrary external URL (Pro: compare-env feature). */
+async function runLighthouseOnUrl(fullUrl, runs) {
+    return runLighthouseCore(fullUrl, runs, fullUrl);
+}
+/**
+ * Run Lighthouse on multiple routes and aggregate results.
+ *
+ * Aggregation strategy (weighted average):
+ *   - Root route "/" receives weight 2 (most visible page)
+ *   - All other routes receive weight 1
+ *
+ * Gold eligibility: every route must individually pass all thresholds.
+ * Silver/Bronze eligibility: based on the weighted-average aggregate score.
+ */
+async function runLighthouseOnRoutes(port, runs, routes) {
+    // Deduplicate and ensure "/" comes first
+    const seen = new Set();
+    const ordered = [];
+    for (const r of ["/", ...routes]) {
+        const normalized = r.startsWith("/") ? r : `/${r}`;
+        if (!seen.has(normalized)) {
+            seen.add(normalized);
+            ordered.push(normalized);
+        }
+    }
+    const perRoute = [];
+    for (const route of ordered) {
+        const result = await runLighthouse(port, runs, route);
+        perRoute.push({ route, scores: result.scores, errors: result.errors });
+    }
+    // Weighted average across routes that produced scores
+    const withScores = perRoute.filter((r) => r.scores !== null);
+    let aggregated = null;
+    if (withScores.length > 0) {
+        let totalWeight = 0;
+        let sumPerf = 0;
+        let sumA11y = 0;
+        let sumSeo = 0;
+        let sumBp = 0;
+        for (const r of withScores) {
+            const weight = r.route === "/" ? 2 : 1;
+            totalWeight += weight;
+            sumPerf += r.scores.performance * weight;
+            sumA11y += r.scores.accessibility * weight;
+            sumSeo += r.scores.seo * weight;
+            sumBp += r.scores.bestPractices * weight;
+        }
+        aggregated = {
+            performance: Math.round(sumPerf / totalWeight),
+            accessibility: Math.round(sumA11y / totalWeight),
+            seo: Math.round(sumSeo / totalWeight),
+            bestPractices: Math.round(sumBp / totalWeight),
+        };
+        console.log(`  Lighthouse aggregate (weighted avg): P=${aggregated.performance} A=${aggregated.accessibility} S=${aggregated.seo} BP=${aggregated.bestPractices}`);
+    }
+    return {
+        aggregated,
+        perRoute,
+        allRoutesPass(thresholds) {
+            return withScores.every((r) => r.scores.performance >= thresholds.performance &&
+                r.scores.accessibility >= thresholds.accessibility &&
+                r.scores.seo >= thresholds.seo &&
+                r.scores.bestPractices >= thresholds.bestPractices);
+        },
+    };
+}

package/dist/outdated-check.d.ts

@@ -0,0 +1,17 @@
+export interface OutdatedPackage {
+    name: string;
+    current: string;
+    wanted: string;
+    latest: string;
+    severity: "major" | "minor" | "patch";
+}
+export interface OutdatedCheckResult {
+    passed: boolean;
+    totalChecked: number;
+    outdatedCount: number;
+    majorOutdated: number;
+    packages: OutdatedPackage[];
+    advisory: string;
+    skipped: boolean;
+}
+export declare function runOutdatedCheck(projectDir: string, timeoutMs?: number): Promise<OutdatedCheckResult>;

package/dist/outdated-check.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOutdatedCheck = runOutdatedCheck;
+/**
+ * Outdated dependency checker.
+ *
+ * Runs `npm outdated --json` and reports packages that are behind
+ * their latest version. Advisory-only — does not block deployment.
+ */
+const node_child_process_1 = require("node:child_process");
+function classifySemverDiff(current, latest) {
+    const parseVer = (v) => {
+        const cleaned = v.replace(/^\^|~|>=?|v/g, "").split(".")[0] ?? "0";
+        return parseInt(cleaned, 10) || 0;
+    };
+    const parseMinor = (v) => {
+        const parts = v.replace(/^\^|~|>=?|v/g, "").split(".");
+        return parseInt(parts[1] ?? "0", 10) || 0;
+    };
+    const curMajor = parseVer(current);
+    const latMajor = parseVer(latest);
+    if (latMajor > curMajor)
+        return "major";
+    const curMinor = parseMinor(current);
+    const latMinor = parseMinor(latest);
+    if (latMinor > curMinor)
+        return "minor";
+    return "patch";
+}
+async function runOutdatedCheck(projectDir, timeoutMs = 30000) {
+    console.log("  Running outdated dependency check...");
+    return new Promise((resolve) => {
+        const chunks = [];
+        const proc = process.platform === "win32"
+            ? (0, node_child_process_1.spawn)(process.env.ComSpec || "cmd.exe", ["/d", "/c", "npm outdated --json"], { stdio: ["ignore", "pipe", "pipe"], cwd: projectDir, shell: false })
+            : (0, node_child_process_1.spawn)("npm", ["outdated", "--json"], {
+                shell: true,
+                stdio: ["ignore", "pipe", "pipe"],
+                cwd: projectDir,
+            });
+        const timer = setTimeout(() => {
+            try {
+                proc.kill();
+            }
+            catch { }
+            resolve({
+                passed: true,
+                totalChecked: 0,
+                outdatedCount: 0,
+                majorOutdated: 0,
+                packages: [],
+                advisory: "Outdated check timed out",
+                skipped: false,
+            });
+        }, timeoutMs);
+        proc.stdout?.on("data", (chunk) => chunks.push(chunk.toString()));
+        proc.stderr?.on("data", () => { });
+        proc.on("exit", (code) => {
+            clearTimeout(timer);
+            const output = chunks.join("");
+            // npm outdated exits with code 1 when outdated packages exist
+            // and code 0 when everything is up to date
+            if (code === 0 || !output.trim()) {
+                console.log("  Outdated: all packages up to date");
+                resolve({
+                    passed: true,
+                    totalChecked: 0,
+                    outdatedCount: 0,
+                    majorOutdated: 0,
+                    packages: [],
+                    advisory: "All packages up to date",
+                    skipped: false,
+                });
+                return;
+            }
+            try {
+                const data = JSON.parse(output);
+                const packages = [];
+                for (const [name, info] of Object.entries(data)) {
+                    if (!info.current || !info.latest)
+                        continue;
+                    const severity = classifySemverDiff(info.current, info.latest);
+                    packages.push({
+                        name,
+                        current: info.current,
+                        wanted: info.wanted ?? info.current,
+                        latest: info.latest,
+                        severity,
+                    });
+                }
+                const majorOutdated = packages.filter((p) => p.severity === "major").length;
+                const outdatedCount = packages.length;
+                const advisory = majorOutdated > 0
+                    ? `${majorOutdated} major version(s) behind latest; ${outdatedCount} total outdated`
+                    : `${outdatedCount} package(s) behind latest (no major)`;
+                console.log(`  Outdated: ${advisory}`);
+                for (const pkg of packages.filter((p) => p.severity === "major").slice(0, 5)) {
+                    console.log(`    ${pkg.name}: ${pkg.current} → ${pkg.latest} (${pkg.severity})`);
+                }
+                resolve({
+                    passed: majorOutdated === 0,
+                    totalChecked: 0,
+                    outdatedCount,
+                    majorOutdated,
+                    packages,
+                    advisory,
+                    skipped: false,
+                });
+            }
+            catch {
+                resolve({
+                    passed: true,
+                    totalChecked: 0,
+                    outdatedCount: 0,
+                    majorOutdated: 0,
+                    packages: [],
+                    advisory: "Could not parse npm outdated output",
+                    skipped: false,
+                });
+            }
+        });
+    });
+}

package/dist/report-markdown.d.ts

@@ -1,39 +1,53 @@
-import type { E2EScenarioResult } from "./e2e.js";
-import type { LighthouseScores } from "./grade.js";
-import type { TierVerificationView, VerificationReport } from "./verification-core/index.js";
-import { type VisualDiffResult } from "./visual-diff.js";
-export interface MarkdownReportResult {
-    grade: string;
-    timestamp: string;
-    build: {
-        success: boolean;
-        durationMs: number;
-        errors: string[];
-    };
-    e2e?: {
-        passed: number;
-        failed: number;
-        total: number;
-        results: E2EScenarioResult[];
-    };
-    lighthouse: (LighthouseScores & {
-        runs: number;
-    }) | null;
-    visualDiff?: VisualDiffResult | null;
-    thresholds: {
-        performance: number;
-        accessibility: number;
-        seo: number;
-        bestPractices: number;
-    };
-    framework: string | null;
-    _plan?: string;
-    verification?: {
-        tier: VerificationReport["tier"];
-        report: VerificationReport;
-        view: TierVerificationView;
-    };
-}
-export declare function shouldWriteMarkdownReport(result: MarkdownReportResult): boolean;
-export declare function getMarkdownReportPath(projectDir: string): string;
-export declare function buildMarkdownReport(projectDir: string, result: MarkdownReportResult): string;
+import type { E2EScenarioResult } from "./e2e.js";
+import type { LighthouseScores } from "./grade.js";
+import type { TierVerificationView, VerificationReport } from "./verification-core/index.js";
+import { type VisualDiffResult } from "./visual-diff.js";
+import type { TypecheckResult } from "./typecheck.js";
+import type { SecretScanResult } from "./secret-scan.js";
+import type { BundleSizeResult } from "./bundle-size.js";
+import type { OutdatedCheckResult } from "./outdated-check.js";
+import type { A11yDeepResult } from "./a11y-deep.js";
+import type { SeoDeepResult } from "./seo-deep.js";
+import type { VitalsBudgetResult } from "./vitals-budget.js";
+export interface MarkdownReportResult {
+    grade: string;
+    timestamp: string;
+    build: {
+        success: boolean;
+        durationMs: number;
+        errors: string[];
+    };
+    e2e?: {
+        passed: number;
+        failed: number;
+        total: number;
+        results: E2EScenarioResult[];
+    };
+    lighthouse: (LighthouseScores & {
+        runs: number;
+    }) | null;
+    visualDiff?: VisualDiffResult | null;
+    typecheck?: TypecheckResult | null;
+    secretScan?: SecretScanResult | null;
+    bundleSize?: BundleSizeResult | null;
+    outdatedCheck?: OutdatedCheckResult | null;
+    a11yDeep?: A11yDeepResult | null;
+    seoDeep?: SeoDeepResult | null;
+    vitalsBudget?: VitalsBudgetResult | null;
+    thresholds: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    };
+    framework: string | null;
+    _plan?: string;
+    verification?: {
+        tier: VerificationReport["tier"];
+        report: VerificationReport;
+        view: TierVerificationView;
+    };
+}
+export declare function shouldWriteMarkdownReport(result: MarkdownReportResult): boolean;
+export declare function getMarkdownReportPath(projectDir: string): string;
+export declare function buildMarkdownReport(projectDir: string, result: MarkdownReportResult): string;