laxy-verify 1.1.31 → 1.1.33

package/README.md

@@ -143,7 +143,7 @@ env:
 ## Example output
 
 ```text
-Decision: release-ready
+Decision: client-ready
 Grade: Gold
 
 Passed:

package/dist/cli.js

@@ -59,7 +59,34 @@ const visual_diff_js_1 = require("./visual-diff.js");
 const security_audit_js_1 = require("./security-audit.js");
 const broken_links_js_1 = require("./audit/broken-links.js");
 const index_js_1 = require("./verification-core/index.js");
+const trend_js_1 = require("./trend.js");
 const package_json_1 = __importDefault(require("../package.json"));
+let activeDevServerPid;
+let activeDevServerCleanup = null;
+async function cleanupActiveDevServer() {
+    if (activeDevServerPid === undefined)
+        return;
+    if (activeDevServerCleanup) {
+        await activeDevServerCleanup;
+        return;
+    }
+    const pid = activeDevServerPid;
+    activeDevServerPid = undefined;
+    activeDevServerCleanup = (0, serve_js_1.stopDevServer)(pid).finally(() => {
+        activeDevServerCleanup = null;
+    });
+    await activeDevServerCleanup;
+}
+function installSignalCleanupHandlers() {
+    const handleSignal = (signal) => {
+        void cleanupActiveDevServer().finally(() => {
+            const exitCode = signal === "SIGINT" ? 130 : 143;
+            exitGracefully(exitCode);
+        });
+    };
+    process.once("SIGINT", () => handleSignal("SIGINT"));
+    process.once("SIGTERM", () => handleSignal("SIGTERM"));
+}
 function shouldFailVerificationResult(report, failOn) {
     if (failOn === "unverified")
         return false;
@@ -200,7 +227,7 @@ function consoleOutput(result) {
         }
     }
     if (result.visualDiff) {
-        console.log(`  Visual diff: ${result.visualDiff.diffPercentage}% (${result.visualDiff.verdict})`);
+        console.log(`  Visual diff: ${(0, visual_diff_js_1.formatVisualDiffSummary)(result.visualDiff)}`);
     }
     if (result.security) {
         console.log(`  Security: ${result.security.summary}`);
@@ -271,6 +298,7 @@ function consoleOutput(result) {
     console.log(`  Exit code: ${result.exitCode}`);
 }
 async function run() {
+    installSignalCleanupHandlers();
     const args = parseArgs();
     if (args.help) {
         console.log(`
@@ -281,10 +309,10 @@ async function run() {
     npx laxy-verify [project-dir] [options]
     npx laxy-verify <subcommand>
 
-  Subcommands:
-    login [email]     Log in to connect this CLI to your Laxy account
-    logout            Remove saved credentials
-    whoami            Show current login status
+  Subcommands:
+    login [email]     Log in to connect this CLI to your Laxy account
+    logout            Remove saved credentials
+    whoami            Show current login status
 
   Options:
     --init            Generate .laxy.yml + GitHub workflow file
@@ -294,8 +322,8 @@ async function run() {
     --config <path>   Path to .laxy.yml
     --fail-on         unverified | bronze | silver | gold
     --skip-lighthouse Skip Lighthouse but still run build and E2E
-    --plan-override   free | pro | team (testing metadata only)
-    --multi-viewport  Lighthouse on desktop/tablet/mobile
+    --plan-override   free | pro | team (testing metadata only)
+    --multi-viewport  Lighthouse on desktop/tablet/mobile
     --crawl           Crawl the app to discover routes before E2E
     --badge           Print shields.io badge markdown
     --help            Show this help
@@ -311,7 +339,7 @@ async function run() {
     npx laxy-verify . --ci              # CI mode
     npx laxy-verify . --fail-on silver  # Block Bronze or worse
 
-  Docs: https://github.com/psungmin24/laxy-verify
+  Docs: https://github.com/SUNgm24/Laxy/tree/main/laxy-verify
 `);
         exitGracefully(0);
         return;
@@ -459,6 +487,7 @@ async function run() {
         try {
             const serve = await (0, serve_js_1.startDevServer)(devCmd, port, config.dev_timeout, args.projectDir);
             servePid = serve.pid;
+            activeDevServerPid = serve.pid;
             const verifyUrl = `http://127.0.0.1:${port}/`;
             const verificationTier = (0, index_js_1.planToVerificationTier)(effectiveFeatures.plan);
             if (!args.skipLighthouse) {
@@ -597,7 +626,7 @@ async function run() {
         }
         finally {
             if (servePid) {
-                (0, serve_js_1.stopDevServer)(servePid);
+                await cleanupActiveDevServer();
             }
         }
     }
@@ -610,9 +639,7 @@ async function run() {
             .map((scenario) => `E2E: ${scenario.name}${scenario.error ? ` - ${scenario.error}` : ""}`)
         : []), ...e2eConsoleErrors.slice(0, 2).map((e) => `Console: ${e}`), ...e2eCoverageGaps.slice(0, 2).map((gap) => `E2E coverage: ${gap}`), ...(viewportSummary.count > 0 && viewportSummary.summary ? [`Viewport: ${viewportSummary.summary}`] : []), ...(visualDiffResult
         ? [
-            visualDiffResult.hasBaseline
-                ? `Visual diff: ${visualDiffResult.diffPercentage}% (${visualDiffResult.verdict})`
-                : "Visual diff: baseline seeded",
+            `Visual diff: ${(0, visual_diff_js_1.formatVisualDiffSummary)(visualDiffResult)}`,
         ]
         : []));
     const verificationReport = (0, index_js_1.buildVerificationReport)({
@@ -697,7 +724,18 @@ async function run() {
     if (inGitHubActions) {
         try {
             if (process.env.GITHUB_EVENT_NAME === "pull_request") {
-                await (0, comment_js_1.postPRComment)(resultObj);
+                let trendDelta = null;
+                const baseSnapshot = (0, trend_js_1.loadBaseSnapshot)((0, trend_js_1.getBaseResultPath)(args.projectDir));
+                if (baseSnapshot) {
+                    const currentSnapshot = {
+                        grade: resultObj.grade,
+                        lighthouse: resultObj.lighthouse,
+                        e2e: resultObj.e2e ? { passed: resultObj.e2e.passed, total: resultObj.e2e.total } : null,
+                        timestamp: resultObj.timestamp,
+                    };
+                    trendDelta = (0, trend_js_1.computeTrendDelta)(currentSnapshot, baseSnapshot);
+                }
+                await (0, comment_js_1.postPRComment)(resultObj, trendDelta);
                 resultObj.github = { status: "comment_posted", grade: resultObj.grade };
             }
             await (0, status_js_1.createStatusCheck)({ grade: resultObj.grade, exitCode: resultObj.exitCode });

package/dist/comment.d.ts

@@ -1,3 +1,4 @@
+import type { TrendDelta } from "./trend.js";
 interface LaxyResult {
     grade: string;
     lighthouse: {
@@ -16,5 +17,5 @@ interface LaxyResult {
     exitCode: number;
     config_fail_on: string;
 }
-export declare function postPRComment(result: LaxyResult): Promise<void>;
+export declare function postPRComment(result: LaxyResult, trend?: TrendDelta | null): Promise<void>;
 export {};

package/dist/comment.js

@@ -36,7 +36,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.postPRComment = postPRComment;
 const fs = __importStar(require("node:fs"));
 const github_js_1 = require("./github.js");
-async function postPRComment(result) {
+function renderTrendTable(delta) {
+    const lines = [
+        "| Check | This PR | vs Base |",
+        "|---|---|---|",
+    ];
+    const gradeTrendStr = delta.grade.current !== delta.grade.base
+        ? ` (was ${delta.grade.base})`
+        : "";
+    lines.push(`| Grade | **${delta.grade.current}**${gradeTrendStr} | ${delta.grade.base} |`);
+    function fmtDelta(d) {
+        if (d === null)
+            return "—";
+        if (d > 0)
+            return `+${d}`;
+        if (d < 0)
+            return `${d}`;
+        return "—";
+    }
+    if (delta.performance.current !== null) {
+        lines.push(`| Performance | ${delta.performance.current} | ${fmtDelta(delta.performance.delta)} |`);
+    }
+    if (delta.accessibility.current !== null) {
+        lines.push(`| Accessibility | ${delta.accessibility.current} | ${fmtDelta(delta.accessibility.delta)} |`);
+    }
+    if (delta.seo.current !== null) {
+        lines.push(`| SEO | ${delta.seo.current} | ${fmtDelta(delta.seo.delta)} |`);
+    }
+    if (delta.bestPractices.current !== null) {
+        lines.push(`| Best Practices | ${delta.bestPractices.current} | ${fmtDelta(delta.bestPractices.delta)} |`);
+    }
+    if (delta.e2e.current !== null) {
+        lines.push(`| E2E | ${delta.e2e.current} | ${delta.e2e.base ?? "—"} (base) |`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function postPRComment(result, trend) {
     const ctx = (0, github_js_1.getGitHubContext)();
     if (!ctx || ctx.eventName !== "pull_request")
         return;
@@ -54,6 +89,7 @@ async function postPRComment(result) {
     if (lh) {
         lhTable = `| Performance | Accessibility | SEO | Best Practices |\n|---|---|---|---|\n| ${lh.performance} / ${t.performance} | ${lh.accessibility} / ${t.accessibility} | ${lh.seo} / ${t.seo} | ${lh.bestPractices} / ${t.bestPractices} |\n\n`;
     }
+    const trendTable = trend ? `${renderTrendTable(trend)}\n` : "";
     const passed = result.exitCode === 0;
     const statusLabel = passed ? "[PASS]" : "[HOLD]";
     const headline = passed ? "No deployment blockers found" : "Deployment blockers found";
@@ -66,12 +102,12 @@ async function postPRComment(result) {
 
 ${summary}
 
-${lhTable}**Fail-on threshold**: ${result.config_fail_on ?? "bronze"}
+${trendTable}${lhTable}**Fail-on threshold**: ${result.config_fail_on ?? "bronze"}
 
 Grade remains available for automation, but this check should be read first as a merge and release blocker gate.
 
 ---
-[Open laxy-verify docs](https://github.com/psungmin24/laxy-verify)`;
+[Open laxy-verify docs](https://github.com/SUNgm24/Laxy/tree/main/laxy-verify)`;
     const [owner, repo] = ctx.repository.split("/");
     const url = `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`;
     try {

package/dist/e2e.js

@@ -82,6 +82,30 @@ function getRequiredFillTarget(selectors) {
         /^textarea\[aria-required=['"]true['"]\]$/,
     ]);
 }
+function getFillValue(selector) {
+    const s = selector.toLowerCase();
+    if (/type=['"]email['"]|name.*email|placeholder.*email/.test(s))
+        return "test@example.com";
+    if (/type=['"]tel['"]|name.*(phone|tel)|placeholder.*(phone|tel)/.test(s))
+        return "555-0100";
+    if (/type=['"]number['"]/.test(s))
+        return "42";
+    if (/type=['"]password['"]/.test(s))
+        return "TestPass123!";
+    if (/type=['"]url['"]/.test(s))
+        return "https://example.com";
+    if (/type=['"]search['"]|name.*(query|search)|placeholder.*(search|query)/.test(s))
+        return "test query";
+    if (/name.*username|placeholder.*username/.test(s))
+        return "testuser";
+    if (/name.*name|placeholder.*name/.test(s))
+        return "Test User";
+    if (/textarea|name.*message|placeholder.*message/.test(s))
+        return "This is a test message.";
+    if (/name.*title|placeholder.*title/.test(s))
+        return "Test Title";
+    return "test input";
+}
 function getVerificationCoverageGaps(scenarios, tier) {
     void tier;
     const names = new Set(scenarios.map((scenario) => scenario.name));
@@ -117,11 +141,12 @@ function buildVerifyScenarios(snapshot, tier) {
         },
     ];
     if (fillTarget && likelyFormSurface) {
+        const fillValue = getFillValue(fillTarget);
         const formScenario = {
             name: "Primary form interaction",
             steps: [
                 { type: "check_visible", selector: fillTarget, description: "Input surface should be visible" },
-                { type: "clear_fill", selector: fillTarget, value: "laxy verify", description: "Fill a core input field" },
+                { type: "clear_fill", selector: fillTarget, value: fillValue, description: `Fill a core input field with ${fillValue}` },
             ],
         };
         if (clickTarget) {
@@ -164,11 +189,12 @@ function buildVerifyScenarios(snapshot, tier) {
         });
     }
     if (clickTarget && fillTarget && clickTarget !== fillTarget) {
+        const fillValue = getFillValue(fillTarget);
         scenarios.push({
             name: "Repeated interaction stability",
             steps: [
                 { type: "check_visible", selector: fillTarget, description: "Input surface should still exist" },
-                { type: "clear_fill", selector: fillTarget, value: "release confidence", description: "Repeat the core input" },
+                { type: "clear_fill", selector: fillTarget, value: fillValue, description: `Repeat the core input with ${fillValue}` },
                 { type: "click", selector: clickTarget, description: "Trigger the CTA again" },
                 { type: "wait", duration: 800, description: "Wait for repeated interaction response" },
                 { type: "check_visible", selector: feedbackTarget || visibleAnchor, description: "Surface should still hold after repeat" },

package/dist/entitlement.js

@@ -13,7 +13,7 @@ exports.printPlanBanner = printPlanBanner;
  */
 const auth_js_1 = require("./auth.js");
 const FREE_FEATURES = {
-    plan: "team", // Free users get Pro+ features by default
+    plan: "free",
     // Automation features — not available without login
     github_actions: false,
     queue_priority: false,

package/dist/init.js

@@ -57,7 +57,7 @@ function runInit(dir) {
             // Keep defaults when auto-detection fails.
         }
         const ymlContent = `# Generated by laxy-verify --init
-# See https://github.com/psungmin24/laxy-verify for full docs
+# See https://github.com/SUNgm24/Laxy/tree/main/laxy-verify for full docs
 framework: ${detectedFramework}   # auto-detected
 port: ${detectedPort}
 fail_on: bronze
@@ -92,9 +92,46 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: psungmin24/laxy-verify@v1
+      - uses: browser-actions/setup-chrome@v1.7.2
+      - uses: actions/setup-node@v4
         with:
-          github-token: \${{ secrets.GITHUB_TOKEN }}
+          node-version: "20"
+      - name: Install app dependencies
+        shell: bash
+        run: |
+          if [ -f "pnpm-lock.yaml" ]; then npm i -g pnpm && pnpm install --frozen-lockfile
+          elif [ -f "yarn.lock" ]; then yarn install --frozen-lockfile
+          elif [ -f "bun.lockb" ]; then npm i -g bun && bun install --frozen-lockfile
+          else npm ci
+          fi
+      - name: Download base branch result
+        if: github.event_name == 'pull_request'
+        uses: actions/download-artifact@v4
+        with:
+          name: laxy-result-base
+          path: .
+        continue-on-error: true
+      - name: Rename base result for trend comparison
+        if: github.event_name == 'pull_request'
+        shell: bash
+        run: |
+          if [ -f .laxy-result.json ]; then
+            mv .laxy-result.json .laxy-result-base.json
+          fi
+        continue-on-error: true
+      - name: Run laxy-verify
+        shell: bash
+        run: npx laxy-verify@latest . --format json --ci
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+      - name: Upload result for trend tracking
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: laxy-result-base
+          path: .laxy-result.json
+          retention-days: 30
+          overwrite: true
 `;
         fs.writeFileSync(workflowPath, workflowContent, "utf-8");
         console.log("Created .github/workflows/laxy-verify.yml");

package/dist/report-markdown.d.ts

@@ -1,7 +1,7 @@
 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 VisualDiffResult } from "./visual-diff.js";
 export interface MarkdownReportResult {
     grade: string;
     timestamp: string;

package/dist/report-markdown.js

@@ -37,6 +37,7 @@ exports.shouldWriteMarkdownReport = shouldWriteMarkdownReport;
 exports.getMarkdownReportPath = getMarkdownReportPath;
 exports.buildMarkdownReport = buildMarkdownReport;
 const path = __importStar(require("node:path"));
+const visual_diff_js_1 = require("./visual-diff.js");
 function titleCasePlan(plan) {
     switch (plan) {
         case "pro":
@@ -159,7 +160,7 @@ function renderMetrics(result) {
         lines.push(`| Multi-viewport | ${reportInput.multiViewportPassed ? "Passed" : "Needs work"}${reportInput.multiViewportSummary ? `, ${reportInput.multiViewportSummary}` : ""} |`);
     }
     if (result.visualDiff) {
-        lines.push(`| Visual diff | ${result.visualDiff.hasBaseline ? `${result.visualDiff.diffPercentage}% (${result.visualDiff.verdict})` : "Baseline seeded"} |`);
+        lines.push(`| Visual diff | ${(0, visual_diff_js_1.formatVisualDiffSummary)(result.visualDiff)} |`);
     }
     lines.push("");
     return `${lines.join("\n")}\n`;

package/dist/serve.d.ts

@@ -10,4 +10,4 @@ export interface ServeResult {
 }
 export declare function probeServerStatus(port: number): Promise<number | null>;
 export declare function startDevServer(command: string, port: number, timeoutSec: number, cwd?: string): Promise<ServeResult>;
-export declare function stopDevServer(pid: number): void;
+export declare function stopDevServer(pid: number): Promise<void>;

package/dist/serve.js

@@ -41,7 +41,10 @@ exports.probeServerStatus = probeServerStatus;
 exports.startDevServer = startDevServer;
 exports.stopDevServer = stopDevServer;
 const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 const tree_kill_1 = __importDefault(require("tree-kill"));
 class PortConflictError extends Error {
     constructor(port) {
@@ -57,6 +60,90 @@ class DevServerTimeoutError extends Error {
     }
 }
 exports.DevServerTimeoutError = DevServerTimeoutError;
+async function killProcessTree(pid) {
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve();
+        };
+        const fallbackTimer = setTimeout(finish, 5000);
+        fallbackTimer.unref?.();
+        try {
+            (0, tree_kill_1.default)(pid, "SIGKILL", () => {
+                clearTimeout(fallbackTimer);
+                finish();
+            });
+        }
+        catch {
+            clearTimeout(fallbackTimer);
+            finish();
+        }
+    });
+}
+function writeWindowsDevWrapper(command, port, cwd) {
+    const wrapperDir = path.join(os.tmpdir(), "laxy-verify");
+    fs.mkdirSync(wrapperDir, { recursive: true });
+    const wrapperPath = path.join(wrapperDir, `dev-wrapper-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.cjs`);
+    const source = `"use strict";
+const { spawn } = require("node:child_process");
+
+const parentPid = Number(process.env.LAXY_VERIFY_PARENT_PID || "0");
+const command = ${JSON.stringify(command)};
+const childCwd = ${JSON.stringify(cwd ?? null)};
+const port = ${JSON.stringify(String(port))};
+
+function killChildTree(pid) {
+  try {
+    const killer = spawn(process.env.ComSpec || "cmd.exe", ["/d", "/c", "taskkill /T /F /PID " + pid], {
+      stdio: "ignore",
+    });
+    killer.on("exit", () => process.exit(1));
+  } catch {
+    process.exit(1);
+  }
+}
+
+const child = spawn(process.env.ComSpec || "cmd.exe", ["/d", "/c", command], {
+  stdio: ["ignore", "pipe", "pipe"],
+  cwd: childCwd || undefined,
+  env: { ...process.env, PORT: port },
+});
+
+child.stdout?.on("data", (chunk) => process.stdout.write(chunk));
+child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+
+child.on("error", (err) => {
+  process.stderr.write((err && err.message ? err.message : String(err)) + "\\n");
+  process.exit(1);
+});
+
+child.on("exit", (code) => {
+  clearInterval(watchdog);
+  process.exit(code ?? 1);
+});
+
+const watchdog = setInterval(() => {
+  if (!parentPid) return;
+  try {
+    process.kill(parentPid, 0);
+  } catch {
+    clearInterval(watchdog);
+    if (child.pid) {
+      killChildTree(child.pid);
+      return;
+    }
+    process.exit(1);
+  }
+}, 1000);
+
+watchdog.unref?.();
+`;
+    fs.writeFileSync(wrapperPath, source, "utf-8");
+    return wrapperPath;
+}
 function httpGet(url) {
     return new Promise((resolve) => {
         http
@@ -75,11 +162,17 @@ async function startDevServer(command, port, timeoutSec, cwd) {
     return new Promise((resolve, reject) => {
         console.log(`Starting dev server: ${command}${cwd ? ` (cwd: ${cwd})` : ""}`);
         let settled = false;
+        const wrapperPath = process.platform === "win32"
+            ? writeWindowsDevWrapper(command, port, cwd)
+            : null;
         const proc = process.platform === "win32"
-            ? (0, node_child_process_1.spawn)(process.env.ComSpec || "cmd.exe", ["/d", "/c", command], {
+            ? (0, node_child_process_1.spawn)("node", [wrapperPath], {
                 stdio: ["ignore", "pipe", "pipe"],
-                env: { ...process.env, PORT: String(port) },
-                cwd,
+                env: {
+                    ...process.env,
+                    PORT: String(port),
+                    LAXY_VERIFY_PARENT_PID: String(process.pid),
+                },
             })
             : (0, node_child_process_1.spawn)(command, {
                 shell: true,
@@ -109,6 +202,9 @@ async function startDevServer(command, port, timeoutSec, cwd) {
             }
         });
         proc.on("exit", (code) => {
+            if (wrapperPath) {
+                fs.rmSync(wrapperPath, { force: true });
+            }
             if (settled)
                 return;
             settled = true;
@@ -120,8 +216,9 @@ async function startDevServer(command, port, timeoutSec, cwd) {
                 if (settled)
                     return;
                 settled = true;
-                if (proc.pid)
-                    (0, tree_kill_1.default)(proc.pid, "SIGKILL");
+                if (proc.pid) {
+                    await killProcessTree(proc.pid);
+                }
                 reject(new DevServerTimeoutError(port, timeoutSec));
                 return;
             }
@@ -137,12 +234,13 @@ async function startDevServer(command, port, timeoutSec, cwd) {
                 }
                 console.log(`Dev server returned HTTP ${status}, waiting for a healthy app surface...`);
             }
-            setTimeout(poll, 500);
+            const nextPoll = setTimeout(poll, 500);
+            nextPoll.unref?.();
         };
         poll();
     });
 }
-function stopDevServer(pid) {
+async function stopDevServer(pid) {
     console.log(`Stopping dev server (PID ${pid})`);
-    (0, tree_kill_1.default)(pid, "SIGKILL");
+    await killProcessTree(pid);
 }

package/dist/trend.d.ts

@@ -0,0 +1,49 @@
+export interface TrendSnapshot {
+    grade: string;
+    lighthouse: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    } | null;
+    e2e?: {
+        passed: number;
+        total: number;
+    } | null;
+    timestamp: string;
+}
+export interface TrendDelta {
+    grade: {
+        current: string;
+        base: string;
+        changed: boolean;
+    };
+    performance: {
+        current: number | null;
+        base: number | null;
+        delta: number | null;
+    };
+    accessibility: {
+        current: number | null;
+        base: number | null;
+        delta: number | null;
+    };
+    seo: {
+        current: number | null;
+        base: number | null;
+        delta: number | null;
+    };
+    bestPractices: {
+        current: number | null;
+        base: number | null;
+        delta: number | null;
+    };
+    e2e: {
+        current: string | null;
+        base: string | null;
+    };
+}
+export declare function loadBaseSnapshot(baseResultPath: string): TrendSnapshot | null;
+export declare function computeTrendDelta(current: TrendSnapshot, base: TrendSnapshot): TrendDelta;
+export declare function renderTrendSection(delta: TrendDelta): string;
+export declare function getBaseResultPath(projectDir: string): string;

package/dist/trend.js

@@ -0,0 +1,147 @@
+"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.loadBaseSnapshot = loadBaseSnapshot;
+exports.computeTrendDelta = computeTrendDelta;
+exports.renderTrendSection = renderTrendSection;
+exports.getBaseResultPath = getBaseResultPath;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const GRADE_ORDER = ["Unverified", "Bronze", "Silver", "Gold", "Platinum"];
+function gradeIndex(grade) {
+    const idx = GRADE_ORDER.indexOf(grade);
+    return idx === -1 ? 0 : idx;
+}
+function formatDelta(delta) {
+    if (delta === null)
+        return "";
+    if (delta > 0)
+        return ` (+${delta})`;
+    if (delta < 0)
+        return ` (${delta})`;
+    return "";
+}
+function gradeTrend(current, base) {
+    const ci = gradeIndex(current);
+    const bi = gradeIndex(base);
+    if (ci > bi)
+        return ` (was ${base})`;
+    if (ci < bi)
+        return ` (was ${base})`;
+    return "";
+}
+function loadBaseSnapshot(baseResultPath) {
+    if (!fs.existsSync(baseResultPath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(baseResultPath, "utf-8"));
+        return {
+            grade: raw.grade ?? "Unverified",
+            lighthouse: raw.lighthouse ?? null,
+            e2e: raw.e2e ? { passed: raw.e2e.passed, total: raw.e2e.total } : null,
+            timestamp: raw.timestamp ?? "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function computeTrendDelta(current, base) {
+    const lhCurrent = current.lighthouse;
+    const lhBase = base.lighthouse;
+    function lhDelta(key) {
+        if (!lhCurrent || !lhBase)
+            return null;
+        return lhCurrent[key] - lhBase[key];
+    }
+    return {
+        grade: {
+            current: current.grade,
+            base: base.grade,
+            changed: current.grade !== base.grade,
+        },
+        performance: {
+            current: lhCurrent?.performance ?? null,
+            base: lhBase?.performance ?? null,
+            delta: lhDelta("performance"),
+        },
+        accessibility: {
+            current: lhCurrent?.accessibility ?? null,
+            base: lhBase?.accessibility ?? null,
+            delta: lhDelta("accessibility"),
+        },
+        seo: {
+            current: lhCurrent?.seo ?? null,
+            base: lhBase?.seo ?? null,
+            delta: lhDelta("seo"),
+        },
+        bestPractices: {
+            current: lhCurrent?.bestPractices ?? null,
+            base: lhBase?.bestPractices ?? null,
+            delta: lhDelta("bestPractices"),
+        },
+        e2e: {
+            current: current.e2e ? `${current.e2e.passed}/${current.e2e.total}` : null,
+            base: base.e2e ? `${base.e2e.passed}/${base.e2e.total}` : null,
+        },
+    };
+}
+function renderTrendSection(delta) {
+    const lines = ["## vs Base Branch", ""];
+    lines.push("| Check | This PR | Base |");
+    lines.push("|---|---|---|");
+    const gradeTrendStr = gradeTrend(delta.grade.current, delta.grade.base);
+    lines.push(`| Grade | **${delta.grade.current}**${gradeTrendStr} | ${delta.grade.base} |`);
+    if (delta.performance.current !== null) {
+        lines.push(`| Performance | ${delta.performance.current}${formatDelta(delta.performance.delta)} | ${delta.performance.base ?? "—"} |`);
+    }
+    if (delta.accessibility.current !== null) {
+        lines.push(`| Accessibility | ${delta.accessibility.current}${formatDelta(delta.accessibility.delta)} | ${delta.accessibility.base ?? "—"} |`);
+    }
+    if (delta.seo.current !== null) {
+        lines.push(`| SEO | ${delta.seo.current}${formatDelta(delta.seo.delta)} | ${delta.seo.base ?? "—"} |`);
+    }
+    if (delta.bestPractices.current !== null) {
+        lines.push(`| Best Practices | ${delta.bestPractices.current}${formatDelta(delta.bestPractices.delta)} | ${delta.bestPractices.base ?? "—"} |`);
+    }
+    if (delta.e2e.current !== null) {
+        lines.push(`| E2E | ${delta.e2e.current} | ${delta.e2e.base ?? "—"} |`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function getBaseResultPath(projectDir) {
+    return path.join(projectDir, ".laxy-result-base.json");
+}

package/dist/verification-core/report.js

@@ -29,7 +29,12 @@ function getVerificationGrade(input, thresholds = exports.DEFAULT_LH_THRESHOLDS)
         input.e2eTotal > 0 &&
         input.e2ePassed === input.e2eTotal;
     const lighthousePassed = getLighthousePass(input.lighthouseScores, thresholds);
-    if (buildPassed && e2ePassedAll && lighthousePassed)
+    // Gold disqualifiers: console errors or critical security vulnerabilities
+    // mean the app has known problems — Gold should require a clean run.
+    const hasConsoleErrors = typeof input.e2eConsoleErrorCount === "number" && input.e2eConsoleErrorCount > 0;
+    const hasCriticalSecurity = !!input.securityAudit && input.securityAudit.critical > 0;
+    const goldDisqualified = hasConsoleErrors || hasCriticalSecurity;
+    if (buildPassed && e2ePassedAll && lighthousePassed && !goldDisqualified)
         return "gold";
     if (buildPassed && e2ePassedAll)
         return "silver";
@@ -311,7 +316,7 @@ function buildVerificationReport(input, options) {
     const warnings = findings.filter((finding) => finding.severity === "medium");
     const hasWarnings = warnings.length > 0;
     const coreChecksPassed = evidence.buildPassed && evidence.e2ePassedAll && evidence.lighthousePassed;
-    const proPlusEvidenceComplete = evidence.hasMultiViewportData &&
+    const teamEvidenceComplete = evidence.hasMultiViewportData &&
         evidence.multiViewportPassed &&
         evidence.hasComparableVisualDiffData &&
         evidence.visualDiffPassed;
@@ -330,6 +335,11 @@ function buildVerificationReport(input, options) {
         confidence = "medium";
         summary = "Blocking verification issues were found. Hold release until the blockers are fixed.";
     }
+    else if (tier === "team" && coreChecksPassed && !hasWarnings && teamEvidenceComplete) {
+        verdict = "release-ready";
+        confidence = "high";
+        summary = "All core checks and release-evidence checks passed. This run is strong enough to call release-ready.";
+    }
     else if (coreChecksPassed && !hasWarnings) {
         verdict = "client-ready";
         confidence = "high";

package/dist/visual-diff.d.ts

@@ -1,3 +1,15 @@
+export type VisualDiffViewportName = "desktop" | "tablet" | "mobile";
+export interface VisualDiffViewportResult {
+    viewport: VisualDiffViewportName;
+    hasBaseline: boolean;
+    diffPercentage: number;
+    verdict: "pass" | "warn" | "rollback";
+    diffPixels: number;
+    totalPixels: number;
+    baselinePath: string;
+    currentPath: string;
+    diffPath: string;
+}
 export interface VisualDiffResult {
     hasBaseline: boolean;
     diffPercentage: number;
@@ -7,5 +19,8 @@ export interface VisualDiffResult {
     baselinePath: string;
     currentPath: string;
     diffPath: string;
+    viewports: VisualDiffViewportResult[];
+    summary: string;
 }
+export declare function formatVisualDiffSummary(result: VisualDiffResult): string;
 export declare function runVisualDiff(projectDir: string, url: string, label?: string): Promise<VisualDiffResult>;

package/dist/visual-diff.js

@@ -36,19 +36,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatVisualDiffSummary = formatVisualDiffSummary;
 exports.runVisualDiff = runVisualDiff;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const puppeteer_1 = __importDefault(require("puppeteer"));
 const pngjs_1 = require("pngjs");
+const VISUAL_DIFF_VIEWPORTS = [
+    { viewport: "desktop", width: 1280, height: 720 },
+    { viewport: "tablet", width: 768, height: 1024 },
+    { viewport: "mobile", width: 375, height: 812, isMobile: true, deviceScaleFactor: 2 },
+];
+function formatViewportResult(viewport) {
+    return viewport.hasBaseline
+        ? `${viewport.viewport} ${viewport.diffPercentage}% (${viewport.verdict})`
+        : `${viewport.viewport} baseline seeded`;
+}
+function formatVisualDiffSummary(result) {
+    return result.viewports.map(formatViewportResult).join(", ");
+}
 function ensureDir(dir) {
     fs.mkdirSync(dir, { recursive: true });
 }
-async function captureScreenshot(url, outputPath) {
+async function captureScreenshot(url, outputPath, viewport) {
     const browser = await puppeteer_1.default.launch({ headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"] });
     try {
         const page = await browser.newPage();
-        await page.setViewport({ width: 1440, height: 960 });
+        await page.setViewport({
+            width: viewport.width,
+            height: viewport.height,
+            isMobile: viewport.isMobile ?? false,
+            deviceScaleFactor: viewport.deviceScaleFactor ?? 1,
+        });
         await page.goto(url, { waitUntil: "networkidle2", timeout: 20000 });
         await page.waitForSelector("body", { timeout: 5000 });
         await page.screenshot({ path: outputPath, fullPage: true, type: "png" });
@@ -90,42 +109,70 @@ async function compareImages(baselinePath, currentPath, diffOutputPath) {
 async function runVisualDiff(projectDir, url, label = "current") {
     const dir = path.join(projectDir, ".laxy-verify", "visual");
     ensureDir(dir);
-    const baselinePath = path.join(dir, "baseline.png");
-    const currentPath = path.join(dir, `${label}.png`);
-    const diffPath = path.join(dir, `${label}.diff.png`);
-    await captureScreenshot(url, currentPath);
-    if (!fs.existsSync(baselinePath)) {
-        fs.copyFileSync(currentPath, baselinePath);
-        return {
-            hasBaseline: false,
-            diffPercentage: 0,
-            verdict: "pass",
-            diffPixels: 0,
-            totalPixels: 0,
+    const viewportResults = [];
+    for (const viewport of VISUAL_DIFF_VIEWPORTS) {
+        const baselinePath = path.join(dir, `${viewport.viewport}.baseline.png`);
+        const currentPath = path.join(dir, `${label}.${viewport.viewport}.png`);
+        const diffPath = path.join(dir, `${label}.${viewport.viewport}.diff.png`);
+        await captureScreenshot(url, currentPath, viewport);
+        if (!fs.existsSync(baselinePath)) {
+            fs.copyFileSync(currentPath, baselinePath);
+            viewportResults.push({
+                viewport: viewport.viewport,
+                hasBaseline: false,
+                diffPercentage: 0,
+                verdict: "pass",
+                diffPixels: 0,
+                totalPixels: 0,
+                baselinePath,
+                currentPath,
+                diffPath: "",
+            });
+            continue;
+        }
+        const comparison = await compareImages(baselinePath, currentPath, diffPath);
+        let verdict = "pass";
+        if (comparison.diffPercentage >= 60) {
+            verdict = "rollback";
+        }
+        else if (comparison.diffPercentage >= 30) {
+            verdict = "warn";
+        }
+        if (verdict === "pass") {
+            fs.copyFileSync(currentPath, baselinePath);
+        }
+        viewportResults.push({
+            viewport: viewport.viewport,
+            hasBaseline: true,
+            diffPercentage: comparison.diffPercentage,
+            verdict,
+            diffPixels: comparison.diffPixels,
+            totalPixels: comparison.totalPixels,
             baselinePath,
             currentPath,
-            diffPath: "",
-        };
-    }
-    const comparison = await compareImages(baselinePath, currentPath, diffPath);
-    let verdict = "pass";
-    if (comparison.diffPercentage >= 60) {
-        verdict = "rollback";
-    }
-    else if (comparison.diffPercentage >= 30) {
-        verdict = "warn";
-    }
-    if (verdict === "pass") {
-        fs.copyFileSync(currentPath, baselinePath);
+            diffPath,
+        });
     }
+    const comparableResults = viewportResults.filter((viewport) => viewport.hasBaseline);
+    const summary = viewportResults.map(formatViewportResult).join(", ");
+    const worstVerdict = comparableResults.some((viewport) => viewport.verdict === "rollback")
+        ? "rollback"
+        : comparableResults.some((viewport) => viewport.verdict === "warn")
+            ? "warn"
+            : "pass";
+    const maxDiffPercentage = comparableResults.reduce((max, viewport) => Math.max(max, viewport.diffPercentage), 0);
+    const totalDiffPixels = comparableResults.reduce((sum, viewport) => sum + viewport.diffPixels, 0);
+    const totalPixels = comparableResults.reduce((sum, viewport) => sum + viewport.totalPixels, 0);
     return {
-        hasBaseline: true,
-        diffPercentage: comparison.diffPercentage,
-        verdict,
-        diffPixels: comparison.diffPixels,
-        totalPixels: comparison.totalPixels,
-        baselinePath,
-        currentPath,
-        diffPath,
+        hasBaseline: comparableResults.length === viewportResults.length,
+        diffPercentage: Math.round(maxDiffPercentage * 100) / 100,
+        verdict: worstVerdict,
+        diffPixels: totalDiffPixels,
+        totalPixels,
+        baselinePath: viewportResults[0]?.baselinePath ?? "",
+        currentPath: viewportResults[0]?.currentPath ?? "",
+        diffPath: viewportResults[0]?.diffPath ?? "",
+        viewports: viewportResults,
+        summary,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laxy-verify",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "description": "Frontend verification CLI for build checks, Lighthouse, E2E, and release readiness",
   "license": "MIT",
   "type": "commonjs",