laxy-verify 1.2.2 → 1.2.3

package/dist/config.d.ts

@@ -18,6 +18,13 @@ export interface UserScenario {
     name: string;
     steps: UserScenarioStep[];
 }
+export interface VisualDiffConfig {
+    pixelmatchThreshold: number;
+    warnThreshold: number;
+    rollbackThreshold: number;
+    ignoreSelectors: string[];
+    disableAnimations: boolean;
+}
 export interface LaxyConfig {
     framework: string;
     build_command: string;
@@ -34,6 +41,29 @@ export interface LaxyConfig {
     max_crawl_depth: number;
     max_crawl_pages: number;
     browsers: string[];
+    /** Explicit list of routes to audit with Lighthouse (e.g. ["/", "/about", "/pricing"]). */
+    lighthouse_routes?: string[];
+    /** Extra routes to audit even if the crawler cannot discover them (e.g. SPA router.push routes). */
+    extra_routes?: string[];
+    /** Maximum number of crawl-discovered routes to run Lighthouse on. Default: 5. */
+    max_lighthouse_routes: number;
+    visual_diff: VisualDiffConfig;
+    /** Run TypeScript type check (tsc --noEmit). Default: false. */
+    typecheck: boolean;
+    /** Run secret/credential leak scan. Default: false. */
+    secret_scan: boolean;
+    /** Paths to ignore during secret scan. */
+    secret_scan_ignore_paths: string[];
+    /** Run bundle size analysis. Default: false. */
+    bundle_size: boolean;
+    /** Run outdated dependency check. Default: false. */
+    outdated_check: boolean;
+    /** Run deep accessibility audit (axe-core). Default: false. */
+    a11y_deep: boolean;
+    /** Run deep SEO audit. Default: false. */
+    seo_deep: boolean;
+    /** Run Core Web Vitals budget check. Default: false. */
+    vitals_budget: boolean;
 }
 export declare class ConfigParseError extends Error {
     constructor(msg: string);
@@ -56,6 +86,13 @@ export interface LoadConfigOptions {
     cliFlags?: {
         failOn?: FailOn;
         skipLighthouse?: boolean;
+        typecheck?: boolean;
+        secretScan?: boolean;
+        bundleSize?: boolean;
+        outdatedCheck?: boolean;
+        a11yDeep?: boolean;
+        seoDeep?: boolean;
+        vitalsBudget?: boolean;
     };
     ciMode: boolean;
     teamThresholds?: TeamThresholdsConfig | null;

package/dist/config.js

@@ -48,7 +48,7 @@ const DEFAULT_CONFIG = {
     port: 3000,
     build_timeout: 300,
     dev_timeout: 60,
-    lighthouse_runs: 1,
+    lighthouse_runs: 3,
     thresholds: {
         performance: 70,
         accessibility: 85,
@@ -60,6 +60,22 @@ const DEFAULT_CONFIG = {
     max_crawl_depth: 3,
     max_crawl_pages: 10,
     browsers: ["chromium"],
+    max_lighthouse_routes: 5,
+    visual_diff: {
+        pixelmatchThreshold: 0.1,
+        warnThreshold: 30,
+        rollbackThreshold: 60,
+        ignoreSelectors: [],
+        disableAnimations: true,
+    },
+    typecheck: false,
+    secret_scan: false,
+    secret_scan_ignore_paths: [],
+    bundle_size: false,
+    outdated_check: false,
+    a11y_deep: false,
+    seo_deep: false,
+    vitals_budget: false,
 };
 const VALID_FAIL_ON = ["unverified", "bronze", "silver", "gold"];
 class ConfigParseError extends Error {
@@ -105,6 +121,47 @@ function parseYaml(filePath) {
         if (browsers.length > 0)
             result.browsers = browsers;
     }
+    if (Array.isArray(raw.lighthouse_routes)) {
+        const routes = raw.lighthouse_routes
+            .filter((r) => typeof r === "string" && r.startsWith("/"))
+            .slice(0, 20);
+        if (routes.length > 0)
+            result.lighthouse_routes = routes;
+    }
+    if (Array.isArray(raw.extra_routes)) {
+        const routes = raw.extra_routes
+            .filter((r) => typeof r === "string" && r.startsWith("/"))
+            .slice(0, 20);
+        if (routes.length > 0)
+            result.extra_routes = routes;
+    }
+    if (typeof raw.max_lighthouse_routes === "number") {
+        result.max_lighthouse_routes = Math.max(1, Math.min(20, raw.max_lighthouse_routes));
+    }
+    if (typeof raw.visual_diff === "object" &&
+        raw.visual_diff !== null &&
+        !Array.isArray(raw.visual_diff)) {
+        const vd = raw.visual_diff;
+        const visualDiff = {};
+        if (typeof vd.pixelmatch_threshold === "number") {
+            visualDiff.pixelmatchThreshold = Math.max(0, Math.min(1, vd.pixelmatch_threshold));
+        }
+        if (typeof vd.warn_threshold === "number") {
+            visualDiff.warnThreshold = Math.max(0, Math.min(100, vd.warn_threshold));
+        }
+        if (typeof vd.rollback_threshold === "number") {
+            visualDiff.rollbackThreshold = Math.max(0, Math.min(100, vd.rollback_threshold));
+        }
+        if (Array.isArray(vd.ignore_selectors)) {
+            visualDiff.ignoreSelectors = vd.ignore_selectors
+                .filter((selector) => typeof selector === "string" && selector.trim().length > 0)
+                .slice(0, 30);
+        }
+        if (typeof vd.disable_animations === "boolean") {
+            visualDiff.disableAnimations = vd.disable_animations;
+        }
+        result.visual_diff = visualDiff;
+    }
     if (typeof raw.fail_on === "string") {
         const f = raw.fail_on;
         if (!VALID_FAIL_ON.includes(f)) {
@@ -164,6 +221,24 @@ function parseYaml(filePath) {
             result.scenarios = scenarios;
         }
     }
+    if (typeof raw.typecheck === "boolean")
+        result.typecheck = raw.typecheck;
+    if (typeof raw.secret_scan === "boolean")
+        result.secret_scan = raw.secret_scan;
+    if (Array.isArray(raw.secret_scan_ignore_paths)) {
+        result.secret_scan_ignore_paths = raw.secret_scan_ignore_paths
+            .filter((p) => typeof p === "string");
+    }
+    if (typeof raw.bundle_size === "boolean")
+        result.bundle_size = raw.bundle_size;
+    if (typeof raw.outdated_check === "boolean")
+        result.outdated_check = raw.outdated_check;
+    if (typeof raw.a11y_deep === "boolean")
+        result.a11y_deep = raw.a11y_deep;
+    if (typeof raw.seo_deep === "boolean")
+        result.seo_deep = raw.seo_deep;
+    if (typeof raw.vitals_budget === "boolean")
+        result.vitals_budget = raw.vitals_budget;
     return result;
 }
 /**
@@ -222,6 +297,21 @@ function loadConfig(options) {
         max_crawl_depth: base.max_crawl_depth ?? DEFAULT_CONFIG.max_crawl_depth,
         max_crawl_pages: base.max_crawl_pages ?? DEFAULT_CONFIG.max_crawl_pages,
         browsers: base.browsers ?? DEFAULT_CONFIG.browsers,
+        lighthouse_routes: base.lighthouse_routes,
+        extra_routes: base.extra_routes,
+        max_lighthouse_routes: base.max_lighthouse_routes ?? DEFAULT_CONFIG.max_lighthouse_routes,
+        visual_diff: {
+            ...DEFAULT_CONFIG.visual_diff,
+            ...(base.visual_diff ?? {}),
+        },
+        typecheck: base.typecheck ?? DEFAULT_CONFIG.typecheck,
+        secret_scan: base.secret_scan ?? DEFAULT_CONFIG.secret_scan,
+        secret_scan_ignore_paths: base.secret_scan_ignore_paths ?? DEFAULT_CONFIG.secret_scan_ignore_paths,
+        bundle_size: base.bundle_size ?? DEFAULT_CONFIG.bundle_size,
+        outdated_check: base.outdated_check ?? DEFAULT_CONFIG.outdated_check,
+        a11y_deep: base.a11y_deep ?? DEFAULT_CONFIG.a11y_deep,
+        seo_deep: base.seo_deep ?? DEFAULT_CONFIG.seo_deep,
+        vitals_budget: base.vitals_budget ?? DEFAULT_CONFIG.vitals_budget,
     };
     config.thresholds = {
         ...DEFAULT_CONFIG.thresholds,
@@ -251,5 +341,20 @@ function loadConfig(options) {
     if (options.cliFlags?.skipLighthouse) {
         // Effectively disables Lighthouse grading
     }
+    // CLI flag overrides for new checks
+    if (options.cliFlags?.typecheck !== undefined)
+        config.typecheck = options.cliFlags.typecheck;
+    if (options.cliFlags?.secretScan !== undefined)
+        config.secret_scan = options.cliFlags.secretScan;
+    if (options.cliFlags?.bundleSize !== undefined)
+        config.bundle_size = options.cliFlags.bundleSize;
+    if (options.cliFlags?.outdatedCheck !== undefined)
+        config.outdated_check = options.cliFlags.outdatedCheck;
+    if (options.cliFlags?.a11yDeep !== undefined)
+        config.a11y_deep = options.cliFlags.a11yDeep;
+    if (options.cliFlags?.seoDeep !== undefined)
+        config.seo_deep = options.cliFlags.seoDeep;
+    if (options.cliFlags?.vitalsBudget !== undefined)
+        config.vitals_budget = options.cliFlags.vitalsBudget;
     return { ...config, ciMode };
 }

package/dist/entitlement.d.ts

@@ -3,6 +3,8 @@ export interface EntitlementFeatures {
     github_actions: boolean;
     queue_priority: boolean;
     parallel_execution: boolean;
+    ai_failure_analysis: boolean;
+    compare_env: boolean;
 }
 export type TestablePlan = "free" | "pro" | "team";
 export declare function normalizePlan(plan?: string | null): TestablePlan;

package/dist/entitlement.js

@@ -18,6 +18,8 @@ const FREE_FEATURES = {
     github_actions: false,
     queue_priority: false,
     parallel_execution: false,
+    ai_failure_analysis: false,
+    compare_env: false,
 };
 let cache = null;
 const CACHE_TTL_MS = 5 * 60 * 1000;
@@ -70,8 +72,10 @@ function applyPlanOverride(features, overridePlan) {
         ...features,
         plan: overridePlan,
         // All verification features run on every plan
-        // github_actions — Pro and Team
+        // github_actions, ai_failure_analysis, compare_env — Pro and Team
         github_actions: isPro,
+        ai_failure_analysis: isPro,
+        compare_env: isPro,
         // queue_priority, parallel_execution — Team only
         queue_priority: isTeam,
         parallel_execution: isTeam,

package/dist/init-analysis.d.ts

@@ -0,0 +1,6 @@
+import type { UserScenario } from "./config.js";
+export interface InitAnalysisResult {
+    scenarios: UserScenario[];
+    extraRoutes: string[];
+}
+export declare function analyzeProjectForInit(dir: string): InitAnalysisResult;

package/dist/init-analysis.js

@@ -0,0 +1,302 @@
+"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.analyzeProjectForInit = analyzeProjectForInit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+const IGNORED_DIRS = new Set([
+    ".git",
+    ".next",
+    ".turbo",
+    ".vercel",
+    ".output",
+    ".laxy-verify",
+    "coverage",
+    "dist",
+    "build",
+    "node_modules",
+]);
+function isSourceFile(filePath) {
+    return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function normalizeRoute(route) {
+    const cleaned = route
+        .replace(/\\u002F/gi, "/")
+        .replace(/\\\//g, "/")
+        .trim();
+    if (!cleaned.startsWith("/"))
+        return null;
+    const normalized = cleaned.split("?")[0]?.split("#")[0]?.replace(/\/+/g, "/") ?? "/";
+    if (!normalized || normalized === "/")
+        return "/";
+    if (normalized.startsWith("/_next/") || normalized.startsWith("/api/"))
+        return null;
+    if (/[.*:[\]]/.test(normalized))
+        return null;
+    if (/\.[a-z0-9]{2,8}$/i.test(normalized))
+        return null;
+    if (/\s/.test(normalized))
+        return null;
+    return normalized.endsWith("/") && normalized !== "/" ? normalized.slice(0, -1) : normalized;
+}
+function collectSourceFiles(rootDir, currentDir = rootDir, acc = []) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            collectSourceFiles(rootDir, fullPath, acc);
+            continue;
+        }
+        if (entry.isFile() && isSourceFile(fullPath)) {
+            acc.push(fullPath);
+        }
+    }
+    return acc;
+}
+function readFileSafe(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function routeFromNextAppFile(filePath, baseDir) {
+    const relative = path.relative(baseDir, filePath).replace(/\\/g, "/");
+    if (!relative.startsWith("app/"))
+        return null;
+    if (!/\/page\.(t|j)sx?$/.test(relative) && !relative.endsWith("/page.mdx"))
+        return null;
+    const segments = relative
+        .replace(/^app\//, "")
+        .replace(/\/page\.(t|j)sx?$/, "")
+        .replace(/\/page\.mdx$/, "")
+        .split("/")
+        .filter(Boolean)
+        .filter((segment) => !segment.startsWith("("))
+        .filter((segment) => !segment.startsWith("@"))
+        .filter((segment) => segment !== "page")
+        .flatMap((segment) => {
+        if (segment === "index")
+            return [];
+        const cleaned = segment.replace(/\.(t|j)sx?$/, "");
+        if (cleaned.startsWith("(") || cleaned.startsWith("[["))
+            return [];
+        if (cleaned.startsWith("["))
+            return [];
+        return cleaned ? [cleaned] : [];
+    });
+    const route = `/${segments.join("/")}`;
+    return normalizeRoute(route);
+}
+function routeFromNextPagesFile(filePath, baseDir) {
+    const relative = path.relative(baseDir, filePath).replace(/\\/g, "/");
+    if (!relative.startsWith("pages/"))
+        return null;
+    if (!/\.(t|j)sx?$/.test(relative))
+        return null;
+    if (/^pages\/api\//.test(relative))
+        return null;
+    const withoutExt = relative.replace(/^pages\//, "").replace(/\.(t|j)sx?$/, "");
+    const segments = withoutExt
+        .split("/")
+        .filter(Boolean)
+        .filter((segment) => segment !== "index")
+        .filter((segment) => !segment.startsWith("["));
+    const route = `/${segments.join("/")}`;
+    return normalizeRoute(route);
+}
+function collectRoutesFromFiles(rootDir, files) {
+    const routes = new Map();
+    for (const filePath of files) {
+        const nextAppRoute = routeFromNextAppFile(filePath, rootDir);
+        if (nextAppRoute)
+            routes.set(nextAppRoute, filePath);
+        const nextPagesRoute = routeFromNextPagesFile(filePath, rootDir);
+        if (nextPagesRoute)
+            routes.set(nextPagesRoute, filePath);
+        const content = readFileSafe(filePath);
+        if (!content)
+            continue;
+        const routeRegexes = [
+            /(?:path|to|href|router\.push|navigate)\s*\(?\s*[:=]?\s*["'`]((?:\/(?!\/)[^"'`?#]+))["'`]/g,
+            /<Route[^>]*path=["'`]((?:\/(?!\/)[^"'`?#]+))["'`]/g,
+        ];
+        for (const regex of routeRegexes) {
+            for (const match of content.matchAll(regex)) {
+                const route = normalizeRoute(match[1] ?? "");
+                if (route)
+                    routes.set(route, filePath);
+            }
+        }
+    }
+    return Array.from(routes.entries())
+        .map(([route, source]) => ({ route, source }))
+        .sort((a, b) => a.route.localeCompare(b.route));
+}
+function buildSelectorHints(files) {
+    const contents = files.map(readFileSafe).join("\n");
+    const has = (pattern) => pattern.test(contents);
+    const dataTestIds = Array.from(contents.matchAll(/data-testid=["'`]([^"'`]+)["'`]/g)).map((match) => match[1]);
+    const dashboardDataTestId = dataTestIds.find((id) => /(dashboard|workspace|overview|app)/i.test(id));
+    const authDataTestId = dataTestIds.find((id) => /(login|signin|auth|account)/i.test(id));
+    return {
+        email: has(/name=["'`]email["'`]/i)
+            ? "input[name=email]"
+            : has(/type=["'`]email["'`]/i)
+                ? "input[type=email]"
+                : "input[name=email]",
+        password: has(/name=["'`](password|passcode)["'`]/i)
+            ? "input[name=password]"
+            : has(/type=["'`]password["'`]/i)
+                ? "input[type=password]"
+                : "input[name=password]",
+        submit: has(/type=["'`]submit["'`]/i)
+            ? "button[type=submit]"
+            : has(/(sign in|login|continue|submit)/i)
+                ? "button"
+                : "button[type=submit]",
+        search: has(/name=["'`](q|query|search)["'`]/i)
+            ? "input[name=search]"
+            : has(/placeholder=["'`][^"'`]*(search|검색)[^"'`]*["'`]/i)
+                ? "input[type=search]"
+                : "input[type=search]",
+        primaryInput: has(/textarea/i) ? "textarea" : "input",
+        dashboardVisible: dashboardDataTestId ? `[data-testid=${dashboardDataTestId}]` : "main",
+        authVisible: authDataTestId ? `[data-testid=${authDataTestId}]` : "main",
+    };
+}
+function pickFirstRoute(routes, patterns) {
+    return routes.find((route) => patterns.some((pattern) => pattern.test(route)));
+}
+function uniqueRoutes(routes) {
+    const seen = new Set();
+    const result = [];
+    for (const route of routes) {
+        if (!route)
+            continue;
+        const normalized = normalizeRoute(route);
+        if (!normalized || normalized === "/" || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function analyzeProjectForInit(dir) {
+    const files = collectSourceFiles(dir);
+    const routeEntries = collectRoutesFromFiles(dir, files);
+    const routes = uniqueRoutes(routeEntries.map((entry) => entry.route));
+    const selectors = buildSelectorHints(files);
+    const loginRoute = pickFirstRoute(routes, [/\/login$/, /\/signin$/, /\/sign-in$/, /\/auth/]);
+    const dashboardRoute = pickFirstRoute(routes, [/\/dashboard$/, /\/app$/, /\/workspace$/, /\/overview$/, /\/home$/, /\/projects?$/]);
+    const signupRoute = pickFirstRoute(routes, [/\/signup$/, /\/register$/, /\/join$/, /\/sign-up$/]);
+    const searchRoute = pickFirstRoute(routes, [/\/search$/, /\/discover$/, /\/explore$/, /\/products$/, /\/items$/]);
+    const settingsRoute = pickFirstRoute(routes, [/\/settings$/, /\/profile$/, /\/account$/, /\/billing$/]);
+    const scenarios = [];
+    if (loginRoute) {
+        scenarios.push({
+            name: "로그인 후 보호 페이지 접근",
+            steps: [
+                { goto: loginRoute },
+                { fill: selectors.email, with: "test@example.com" },
+                { fill: selectors.password, with: "testpass123!" },
+                { click: selectors.submit },
+                dashboardRoute
+                    ? { goto: dashboardRoute }
+                    : { wait: 1200 },
+                { expect_visible: dashboardRoute ? selectors.dashboardVisible : "body" },
+            ],
+        });
+    }
+    if (signupRoute && scenarios.length < 3) {
+        scenarios.push({
+            name: "회원가입 주요 폼 제출",
+            steps: [
+                { goto: signupRoute },
+                { fill: selectors.email, with: "test@example.com" },
+                { fill: selectors.password, with: "testpass123!" },
+                { click: selectors.submit },
+                { expect_visible: selectors.authVisible || "body" },
+            ],
+        });
+    }
+    if (searchRoute && scenarios.length < 3) {
+        scenarios.push({
+            name: "핵심 탐색 흐름 확인",
+            steps: [
+                { goto: searchRoute },
+                { fill: selectors.search, with: "test query" },
+                { click: selectors.submit },
+                { expect_visible: "body" },
+            ],
+        });
+    }
+    if (settingsRoute && scenarios.length < 3) {
+        scenarios.push({
+            name: "설정 화면 렌더 확인",
+            steps: [
+                { goto: settingsRoute },
+                { expect_visible: "body" },
+            ],
+        });
+    }
+    if (dashboardRoute && scenarios.length < 3) {
+        scenarios.push({
+            name: "대시보드 기본 렌더",
+            steps: [
+                { goto: dashboardRoute },
+                { expect_visible: selectors.dashboardVisible || "main" },
+            ],
+        });
+    }
+    if (scenarios.length === 0) {
+        const firstRoute = routes[0] ?? "/";
+        scenarios.push({
+            name: "핵심 페이지 기본 렌더",
+            steps: [
+                { goto: firstRoute },
+                { expect_visible: "body" },
+            ],
+        });
+    }
+    return {
+        scenarios: scenarios.slice(0, 3),
+        extraRoutes: routes.slice(0, 10),
+    };
+}

package/dist/init.js

@@ -37,6 +37,22 @@ exports.runInit = runInit;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const detect_js_1 = require("./detect.js");
+const init_analysis_js_1 = require("./init-analysis.js");
+function renderStringList(items, indent = "  ") {
+    return items.map((item) => `${indent}- ${item}`).join("\n");
+}
+function renderScenarios() {
+    return `scenarios:
+  - name: "로그인 후 대시보드 접근"
+    steps:
+      - goto: /login
+      - fill: input[name=email]
+        with: test@example.com
+      - fill: input[name=password]
+        with: testpass123!
+      - click: button[type=submit]
+      - expect_visible: main`;
+}
 function runInit(dir) {
     const laxyYmlPath = path.join(dir, ".laxy.yml");
     const workflowDir = path.join(dir, ".github", "workflows");
@@ -48,6 +64,7 @@ function runInit(dir) {
     else {
         let detectedFramework = null;
         let detectedPort = 3000;
+        const initAnalysis = (0, init_analysis_js_1.analyzeProjectForInit)(dir);
         try {
             const detected = (0, detect_js_1.detect)(dir);
             detectedFramework = detected.framework ?? "auto";
@@ -56,20 +73,69 @@ function runInit(dir) {
         catch {
             // Keep defaults when auto-detection fails.
         }
+        const extraRoutesBlock = initAnalysis.extraRoutes.length > 0
+            ? `extra_routes:\n${renderStringList(initAnalysis.extraRoutes)}\n\n`
+            : "";
+        const scenarioBlocks = initAnalysis.scenarios.length > 0
+            ? [
+                "scenarios:",
+                ...initAnalysis.scenarios.flatMap((scenario) => [
+                    `  - name: "${scenario.name.replace(/"/g, '\\"')}"`,
+                    "    steps:",
+                    ...scenario.steps.flatMap((step) => {
+                        if (step.goto)
+                            return [`      - goto: ${step.goto}`];
+                        if (step.fill && step.with !== undefined) {
+                            return [
+                                `      - fill: ${step.fill}`,
+                                `        with: ${step.with}`,
+                            ];
+                        }
+                        if (step.click)
+                            return [`      - click: ${step.click}`];
+                        if (step.expect_visible)
+                            return [`      - expect_visible: ${step.expect_visible}`];
+                        if (step.expect_text)
+                            return [`      - expect_text: ${step.expect_text}`];
+                        if (step.wait !== undefined)
+                            return [`      - wait: ${step.wait}`];
+                        return [];
+                    }),
+                ]),
+            ].join("\n")
+            : renderScenarios();
         const ymlContent = `# Generated by laxy-verify --init
 # See https://github.com/SUNgm24/Laxy/tree/main/laxy-verify for full docs
 framework: ${detectedFramework}   # auto-detected
 port: ${detectedPort}
 fail_on: bronze
+lighthouse_runs: 3
 
 thresholds:
   performance: 70
   accessibility: 85
   seo: 80
   best_practices: 80
+
+${extraRoutesBlock}visual_diff:
+  pixelmatch_threshold: 0.1
+  warn_threshold: 30
+  rollback_threshold: 60
+  disable_animations: true
+  ignore_selectors:
+    - "[data-dynamic]"
+    - "[data-ignore-diff]"
+
+${scenarioBlocks}
 `;
         fs.writeFileSync(laxyYmlPath, ymlContent, "utf-8");
         console.log("Created .laxy.yml");
+        if (initAnalysis.scenarios.length > 0) {
+            console.log(`Seeded ${initAnalysis.scenarios.length} draft E2E scenario(s) from your app structure.`);
+        }
+        if (initAnalysis.extraRoutes.length > 0) {
+            console.log(`Detected ${initAnalysis.extraRoutes.length} extra route(s) for SPA / multi-page coverage.`);
+        }
     }
     if (fs.existsSync(workflowPath)) {
         console.log(".github/workflows/laxy-verify.yml already exists. Skipping.");

package/dist/lighthouse.d.ts

@@ -3,5 +3,35 @@ interface LhResult {
     scores: LighthouseScores | null;
     errors: string[];
 }
-export declare function runLighthouse(port: number, runs: number): Promise<LhResult>;
+export interface RouteScoreResult {
+    route: string;
+    scores: LighthouseScores | null;
+    errors: string[];
+}
+export interface MultiRouteLhResult {
+    /** Weighted average: root (/) = 2x weight, other routes = 1x */
+    aggregated: LighthouseScores | null;
+    perRoute: RouteScoreResult[];
+    /** True if every route that produced scores individually passed all thresholds */
+    allRoutesPass(thresholds: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    }): boolean;
+}
+export declare function runLighthouse(port: number, runs: number, routePath?: string): Promise<LhResult>;
+/** Run Lighthouse against an arbitrary external URL (Pro: compare-env feature). */
+export declare function runLighthouseOnUrl(fullUrl: string, runs: number): Promise<LhResult>;
+/**
+ * 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.
+ */
+export declare function runLighthouseOnRoutes(port: number, runs: number, routes: string[]): Promise<MultiRouteLhResult>;
 export {};