@vertaaux/cli 0.2.0

package/dist/baseline/manager.js

@@ -0,0 +1,157 @@
+/**
+ * Baseline file management for tracking technical debt.
+ *
+ * Enables teams to:
+ * - Create baselines from audit results
+ * - Add individual issues to baseline (ignore)
+ * - Load and save baseline files
+ *
+ * Baseline is stored in .vertaaux/baseline.json and committed to git.
+ */
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { execSync } from "child_process";
+import { generateFingerprint } from "./hash.js";
+/**
+ * Current baseline file format version.
+ */
+export const BASELINE_VERSION = 1;
+/**
+ * Default baseline file path.
+ */
+export const DEFAULT_BASELINE_PATH = ".vertaaux/baseline.json";
+/**
+ * Get the current user from git config.
+ *
+ * @returns Git user name or undefined if not available
+ */
+function getGitUser() {
+    try {
+        const name = execSync("git config user.name", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return name || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get the rule ID from an issue, checking multiple field names.
+ */
+function getRuleId(issue) {
+    return issue.ruleId || issue.rule_id || issue.id || "unknown";
+}
+/**
+ * Load a baseline file from disk.
+ *
+ * @param path - Path to baseline file (default: .vertaaux/baseline.json)
+ * @returns Baseline file contents or null if file doesn't exist
+ */
+export async function loadBaseline(path = DEFAULT_BASELINE_PATH) {
+    const resolvedPath = resolve(process.cwd(), path);
+    if (!existsSync(resolvedPath)) {
+        return null;
+    }
+    try {
+        const content = await readFile(resolvedPath, "utf-8");
+        const baseline = JSON.parse(content);
+        // Validate version
+        if (baseline.version !== BASELINE_VERSION) {
+            console.warn(`Warning: Baseline version ${baseline.version} may not be fully compatible`);
+        }
+        return baseline;
+    }
+    catch (error) {
+        throw new Error(`Failed to load baseline: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Save a baseline file to disk.
+ *
+ * @param baseline - Baseline file contents
+ * @param path - Path to baseline file (default: .vertaaux/baseline.json)
+ */
+export async function saveBaseline(baseline, path = DEFAULT_BASELINE_PATH) {
+    const resolvedPath = resolve(process.cwd(), path);
+    const dir = dirname(resolvedPath);
+    // Create directory if needed
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    // Write with pretty JSON
+    const content = JSON.stringify(baseline, null, 2);
+    await writeFile(resolvedPath, content + "\n", "utf-8");
+}
+/**
+ * Create a new baseline from audit issues.
+ *
+ * @param issues - Issues from audit results
+ * @param url - URL that was audited
+ * @returns New baseline file
+ */
+export function createBaseline(issues, url) {
+    const now = new Date().toISOString();
+    const baselinedBy = getGitUser();
+    const baselineIssues = issues.map((issue) => ({
+        fingerprint: generateFingerprint(issue),
+        ruleId: getRuleId(issue),
+        severity: issue.severity || "warning",
+        category: issue.category || "general",
+        description: issue.description || issue.title || "",
+        selector: issue.selector,
+        baselinedAt: now,
+        baselinedBy,
+    }));
+    return {
+        version: BASELINE_VERSION,
+        created: now,
+        updated: now,
+        url,
+        issues: baselineIssues,
+    };
+}
+/**
+ * Add an issue to an existing baseline.
+ *
+ * @param baseline - Existing baseline file
+ * @param issue - Issue to add
+ * @param reason - Optional reason for baselining
+ * @returns Updated baseline file
+ */
+export function addToBaseline(baseline, issue, reason) {
+    const now = new Date().toISOString();
+    const baselinedBy = getGitUser();
+    const fingerprint = generateFingerprint(issue);
+    // Check if already baselined
+    const existing = baseline.issues.find((i) => i.fingerprint === fingerprint);
+    if (existing) {
+        // Update reason if provided
+        if (reason) {
+            existing.reason = reason;
+        }
+        return {
+            ...baseline,
+            updated: now,
+        };
+    }
+    // Add new issue
+    const newIssue = {
+        fingerprint,
+        ruleId: getRuleId(issue),
+        severity: issue.severity || "warning",
+        category: issue.category || "general",
+        description: issue.description || issue.title || "",
+        selector: issue.selector,
+        reason,
+        baselinedAt: now,
+        baselinedBy,
+    };
+    return {
+        ...baseline,
+        updated: now,
+        issues: [...baseline.issues, newIssue],
+    };
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Caching module for VertaaUX CLI.
+ *
+ * Provides route-level caching to speed up repeated audits
+ * by skipping unchanged routes.
+ */
+export { loadRouteCache, saveRouteCache, getCacheKey, generateContentHash, isCacheValid, getCachedIssues, updateCache, clearExpiredEntries, getCacheStats, type RouteCache, type RouteCacheEntry, } from "./route-cache.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,KAAK,UAAU,EACf,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,7 @@
+/**
+ * Caching module for VertaaUX CLI.
+ *
+ * Provides route-level caching to speed up repeated audits
+ * by skipping unchanged routes.
+ */
+export { loadRouteCache, saveRouteCache, getCacheKey, generateContentHash, isCacheValid, getCachedIssues, updateCache, clearExpiredEntries, getCacheStats, } from "./route-cache.js";

package/dist/cache/route-cache.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Route-level caching for incremental audits.
+ *
+ * Caches audit results per route with content-based invalidation.
+ * This enables skipping audits for routes that haven't changed,
+ * significantly reducing CI time for repeated runs.
+ */
+/**
+ * Cache entry for a single route.
+ */
+export interface RouteCacheEntry {
+    /** Route URL that was audited */
+    route: string;
+    /** Content hash of the page (for invalidation) */
+    contentHash: string;
+    /** Fingerprints of issues found (for reconstruction) */
+    issueFingerprints: string[];
+    /** When this entry was cached */
+    cachedAt: string;
+    /** CLI version that produced this cache entry */
+    cliVersion: string;
+    /** Time taken to audit this route (for metrics) */
+    auditDuration?: number;
+}
+/**
+ * Full route cache structure.
+ */
+export interface RouteCache {
+    /** Cache format version for migration handling */
+    version: number;
+    /** Cached entries keyed by route URL */
+    entries: Record<string, RouteCacheEntry>;
+    /** When cache was last written */
+    lastUpdated?: string;
+}
+/**
+ * Load route cache from disk.
+ *
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns RouteCache object (empty if file doesn't exist or is invalid)
+ */
+export declare function loadRouteCache(projectRoot?: string): RouteCache;
+/**
+ * Save route cache to disk.
+ *
+ * @param cache - RouteCache to save
+ * @param projectRoot - Project root directory (defaults to cwd)
+ */
+export declare function saveRouteCache(cache: RouteCache, projectRoot?: string): void;
+/**
+ * Get cache key for a route based on content hash.
+ *
+ * The cache key combines route URL and content hash to uniquely
+ * identify a specific version of a page.
+ *
+ * @param route - Route URL
+ * @param contentHash - Hash of page content
+ * @returns Cache key string
+ */
+export declare function getCacheKey(route: string, contentHash: string): string;
+/**
+ * Generate content hash from HTML content.
+ *
+ * Normalizes the content to reduce false cache invalidations
+ * from irrelevant changes (timestamps, random IDs, etc.).
+ *
+ * @param html - HTML content of the page
+ * @returns Content hash string
+ */
+export declare function generateContentHash(html: string): string;
+/**
+ * Check if a cached entry is valid for the given content.
+ *
+ * @param entry - Cached entry to validate
+ * @param contentHash - Current content hash
+ * @returns true if cache is valid
+ */
+export declare function isCacheValid(entry: RouteCacheEntry, contentHash: string): boolean;
+/**
+ * Get cached issue fingerprints for a route if cache is valid.
+ *
+ * @param cache - Route cache to check
+ * @param route - Route URL to look up
+ * @param contentHash - Current content hash for validation
+ * @returns Array of issue fingerprints if cached, null otherwise
+ */
+export declare function getCachedIssues(cache: RouteCache, route: string, contentHash: string): string[] | null;
+/**
+ * Update cache with new audit results for a route.
+ *
+ * @param cache - Route cache to update (mutated in place)
+ * @param route - Route URL that was audited
+ * @param contentHash - Content hash of the page
+ * @param issueFingerprints - Fingerprints of issues found
+ * @param auditDuration - Time taken to audit (optional)
+ */
+export declare function updateCache(cache: RouteCache, route: string, contentHash: string, issueFingerprints: string[], auditDuration?: number): void;
+/**
+ * Clear expired or invalid cache entries.
+ *
+ * @param cache - Route cache to clean (mutated in place)
+ * @param maxAge - Maximum age in milliseconds (default: 7 days)
+ * @returns Number of entries removed
+ */
+export declare function clearExpiredEntries(cache: RouteCache, maxAge?: number): number;
+/**
+ * Get cache statistics.
+ *
+ * @param cache - Route cache to analyze
+ * @returns Statistics object
+ */
+export declare function getCacheStats(cache: RouteCache): {
+    totalEntries: number;
+    totalIssues: number;
+    oldestEntry: string | null;
+    newestEntry: string | null;
+    averageAuditDuration: number | null;
+};
+//# sourceMappingURL=route-cache.d.ts.map

package/dist/cache/route-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-cache.d.ts","sourceRoot":"","sources":["../../src/cache/route-cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACzC,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAQD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,CAsB/D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAiB5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAexD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAiBT;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,MAAM,EAAE,GAAG,IAAI,CAYjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,EAAE,EAC3B,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CASN;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,UAAU,EACjB,MAAM,SAA0B,GAC/B,MAAM,CAeR;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,CA+BA"}

package/dist/cache/route-cache.js

@@ -0,0 +1,213 @@
+/**
+ * Route-level caching for incremental audits.
+ *
+ * Caches audit results per route with content-based invalidation.
+ * This enables skipping audits for routes that haven't changed,
+ * significantly reducing CI time for repeated runs.
+ */
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+// Get CLI version for cache invalidation
+const CLI_VERSION = "0.1.0";
+/** Default cache file location */
+const CACHE_FILE = ".vertaaux/route-cache.json";
+/** Current cache format version */
+const CACHE_VERSION = 1;
+/**
+ * Load route cache from disk.
+ *
+ * @param projectRoot - Project root directory (defaults to cwd)
+ * @returns RouteCache object (empty if file doesn't exist or is invalid)
+ */
+export function loadRouteCache(projectRoot) {
+    const root = projectRoot || process.cwd();
+    const cachePath = path.join(root, CACHE_FILE);
+    try {
+        if (fs.existsSync(cachePath)) {
+            const content = fs.readFileSync(cachePath, "utf-8");
+            const cache = JSON.parse(content);
+            // Validate cache version
+            if (cache.version !== CACHE_VERSION) {
+                // Version mismatch, return empty cache
+                return { version: CACHE_VERSION, entries: {} };
+            }
+            return cache;
+        }
+    }
+    catch {
+        // Invalid cache file, return empty
+    }
+    return { version: CACHE_VERSION, entries: {} };
+}
+/**
+ * Save route cache to disk.
+ *
+ * @param cache - RouteCache to save
+ * @param projectRoot - Project root directory (defaults to cwd)
+ */
+export function saveRouteCache(cache, projectRoot) {
+    const root = projectRoot || process.cwd();
+    const cachePath = path.join(root, CACHE_FILE);
+    // Ensure directory exists
+    const dir = path.dirname(cachePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Update timestamp
+    cache.lastUpdated = new Date().toISOString();
+    // Write atomically (write to temp, then rename)
+    const tempPath = `${cachePath}.tmp`;
+    fs.writeFileSync(tempPath, JSON.stringify(cache, null, 2), "utf-8");
+    fs.renameSync(tempPath, cachePath);
+}
+/**
+ * Get cache key for a route based on content hash.
+ *
+ * The cache key combines route URL and content hash to uniquely
+ * identify a specific version of a page.
+ *
+ * @param route - Route URL
+ * @param contentHash - Hash of page content
+ * @returns Cache key string
+ */
+export function getCacheKey(route, contentHash) {
+    return createHash("sha256")
+        .update(`${route}:${contentHash}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+/**
+ * Generate content hash from HTML content.
+ *
+ * Normalizes the content to reduce false cache invalidations
+ * from irrelevant changes (timestamps, random IDs, etc.).
+ *
+ * @param html - HTML content of the page
+ * @returns Content hash string
+ */
+export function generateContentHash(html) {
+    // Normalize content for hashing
+    const normalized = html
+        // Remove inline timestamps/dates
+        .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/g, "TIMESTAMP")
+        // Remove random IDs (common patterns)
+        .replace(/id="[a-f0-9-]{36}"/g, 'id="UUID"')
+        .replace(/data-id="[^"]+"/g, 'data-id="ID"')
+        // Remove nonce attributes (CSP)
+        .replace(/nonce="[^"]+"/g, 'nonce="NONCE"')
+        // Normalize whitespace
+        .replace(/\s+/g, " ")
+        .trim();
+    return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
+}
+/**
+ * Check if a cached entry is valid for the given content.
+ *
+ * @param entry - Cached entry to validate
+ * @param contentHash - Current content hash
+ * @returns true if cache is valid
+ */
+export function isCacheValid(entry, contentHash) {
+    // Content must match
+    if (entry.contentHash !== contentHash) {
+        return false;
+    }
+    // CLI version must match (avoid using old results with new rules)
+    if (entry.cliVersion !== CLI_VERSION) {
+        return false;
+    }
+    // Could add TTL check here if desired:
+    // const cachedTime = new Date(entry.cachedAt).getTime();
+    // const maxAge = 24 * 60 * 60 * 1000; // 24 hours
+    // if (Date.now() - cachedTime > maxAge) return false;
+    return true;
+}
+/**
+ * Get cached issue fingerprints for a route if cache is valid.
+ *
+ * @param cache - Route cache to check
+ * @param route - Route URL to look up
+ * @param contentHash - Current content hash for validation
+ * @returns Array of issue fingerprints if cached, null otherwise
+ */
+export function getCachedIssues(cache, route, contentHash) {
+    const entry = cache.entries[route];
+    if (!entry) {
+        return null;
+    }
+    if (!isCacheValid(entry, contentHash)) {
+        return null;
+    }
+    return entry.issueFingerprints;
+}
+/**
+ * Update cache with new audit results for a route.
+ *
+ * @param cache - Route cache to update (mutated in place)
+ * @param route - Route URL that was audited
+ * @param contentHash - Content hash of the page
+ * @param issueFingerprints - Fingerprints of issues found
+ * @param auditDuration - Time taken to audit (optional)
+ */
+export function updateCache(cache, route, contentHash, issueFingerprints, auditDuration) {
+    cache.entries[route] = {
+        route,
+        contentHash,
+        issueFingerprints,
+        cachedAt: new Date().toISOString(),
+        cliVersion: CLI_VERSION,
+        auditDuration,
+    };
+}
+/**
+ * Clear expired or invalid cache entries.
+ *
+ * @param cache - Route cache to clean (mutated in place)
+ * @param maxAge - Maximum age in milliseconds (default: 7 days)
+ * @returns Number of entries removed
+ */
+export function clearExpiredEntries(cache, maxAge = 7 * 24 * 60 * 60 * 1000) {
+    const now = Date.now();
+    let removed = 0;
+    for (const [route, entry] of Object.entries(cache.entries)) {
+        const entryAge = now - new Date(entry.cachedAt).getTime();
+        // Remove if too old or wrong CLI version
+        if (entryAge > maxAge || entry.cliVersion !== CLI_VERSION) {
+            delete cache.entries[route];
+            removed++;
+        }
+    }
+    return removed;
+}
+/**
+ * Get cache statistics.
+ *
+ * @param cache - Route cache to analyze
+ * @returns Statistics object
+ */
+export function getCacheStats(cache) {
+    const entries = Object.values(cache.entries);
+    if (entries.length === 0) {
+        return {
+            totalEntries: 0,
+            totalIssues: 0,
+            oldestEntry: null,
+            newestEntry: null,
+            averageAuditDuration: null,
+        };
+    }
+    const sorted = entries.sort((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
+    const durations = entries
+        .map((e) => e.auditDuration)
+        .filter((d) => d !== undefined);
+    return {
+        totalEntries: entries.length,
+        totalIssues: entries.reduce((sum, e) => sum + e.issueFingerprints.length, 0),
+        oldestEntry: sorted[0].cachedAt,
+        newestEntry: sorted[sorted.length - 1].cachedAt,
+        averageAuditDuration: durations.length > 0
+            ? durations.reduce((a, b) => a + b, 0) / durations.length
+            : null,
+    };
+}

package/dist/ci/changed-routes.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Detect routes changed in PR for incremental auditing.
+ *
+ * Uses git diff to find changed files, then maps them to routes.
+ * This enables efficient CI by only auditing what changed.
+ *
+ * Implements CICD-07: Incremental mode audits only routes touched in PR.
+ */
+/**
+ * Options for detecting changed routes.
+ */
+export interface ChangedRoutesOptions {
+    /** Base branch to compare against */
+    baseBranch: string;
+    /** Route patterns to watch (glob patterns for file paths) */
+    routePatterns: string[];
+    /** Mapping from file glob patterns to route URLs */
+    fileToRouteMap?: Record<string, string[]>;
+}
+/**
+ * Result of changed routes detection.
+ */
+export interface ChangedRoutesResult {
+    /** Routes that were changed */
+    routes: string[];
+    /** Files that were changed (for debugging) */
+    changedFiles: string[];
+    /** Whether any relevant changes were found */
+    hasChanges: boolean;
+}
+/**
+ * Convert a file path to a route URL.
+ *
+ * Supports common framework conventions:
+ * - Next.js App Router: src/app/about/page.tsx -> /about
+ * - Next.js Pages Router: src/pages/blog/index.tsx -> /blog
+ * - SvelteKit: src/routes/blog/+page.svelte -> /blog
+ *
+ * @param filePath - The changed file path
+ * @returns The route URL or null if not a route file
+ */
+export declare function filePathToRoute(filePath: string): string | null;
+/**
+ * Detect base branch from CI environment variables.
+ *
+ * Supports:
+ * - GitHub Actions: GITHUB_BASE_REF
+ * - GitLab CI: CI_MERGE_REQUEST_TARGET_BRANCH_NAME
+ * - Azure DevOps: SYSTEM_PULLREQUEST_TARGETBRANCH
+ * - Jenkins: CHANGE_TARGET
+ * - CircleCI: CIRCLE_BRANCH (for base, uses main as fallback)
+ *
+ * @returns Detected base branch or "main" as default
+ */
+export declare function detectBaseBranch(): string;
+/**
+ * Get list of routes affected by changed files.
+ *
+ * Uses git diff to find changed files, then maps to routes.
+ *
+ * @param options - Detection options
+ * @returns Changed routes result
+ */
+export declare function getChangedRoutes(options: ChangedRoutesOptions): Promise<ChangedRoutesResult>;
+/**
+ * Budget modes for controlling audit scope.
+ *
+ * CICD-13: Default mode runs under sane budget; full scan is opt-in.
+ */
+export declare const BUDGET_MODES: {
+    /** Quick scan: 5 pages, 30s timeout, 2 concurrent */
+    readonly quick: {
+        readonly maxPages: 5;
+        readonly maxTime: 30000;
+        readonly concurrency: 2;
+    };
+    /** Standard scan: 20 pages, 2min timeout, 4 concurrent */
+    readonly standard: {
+        readonly maxPages: 20;
+        readonly maxTime: 120000;
+        readonly concurrency: 4;
+    };
+    /** Full scan: unlimited pages, 10min timeout, 8 concurrent */
+    readonly full: {
+        readonly maxPages: number;
+        readonly maxTime: 600000;
+        readonly concurrency: 8;
+    };
+};
+export type BudgetMode = keyof typeof BUDGET_MODES;
+/**
+ * Get budget configuration for a mode.
+ */
+export declare function getBudgetConfig(mode: BudgetMode): (typeof BUDGET_MODES)[BudgetMode];
+//# sourceMappingURL=changed-routes.d.ts.map

package/dist/ci/changed-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-routes.d.ts","sourceRoot":"","sources":["../../src/ci/changed-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,oDAAoD;IACpD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,+BAA+B;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,8CAA8C;IAC9C,UAAU,EAAE,OAAO,CAAC;CACrB;AAqCD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyE/D;AA8DD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAsDzC;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAoD9B;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,qDAAqD;;;;;;IAErD,0DAA0D;;;;;;IAE1D,8DAA8D;;;;;;CAEtD,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,YAAY,CAAC;AAEnD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GACf,CAAC,OAAO,YAAY,CAAC,CAAC,UAAU,CAAC,CAEnC"}