agentic-qe 3.15.4 → 3.15.6

package/dist/cli/scheduler/persistent-scheduler.js

@@ -112,12 +112,17 @@ export class PersistentScheduler {
         }
         try {
             const content = fs.readFileSync(this.schedulesPath, 'utf-8');
-            const data = this.parseSchedulesFile(content);
+            const { file: data, skipped } = this.parseSchedulesFile(content);
+            if (skipped.length > 0) {
+                console.warn(`[PersistentScheduler] Skipped ${skipped.length} malformed schedule ` +
+                    `entries in ${this.schedulesPath} (not an object, no id, or duplicate id)`);
+            }
             this.log(`Loaded ${data.schedules.length} schedules`);
             return data.schedules;
         }
         catch (error) {
-            // Handle corrupt file - backup and recreate
+            // Only a genuinely unparseable file gets here (bad JSON, no schedules
+            // array, oversize); malformed entries are disabled or skipped (#991).
             await this.handleCorruptFile(error);
             return [];
         }
@@ -128,7 +133,7 @@ export class PersistentScheduler {
     async saveSchedule(schedule) {
         await this.initialize();
         await this.withFileLock(async () => {
-            const schedules = await this.loadSchedulesUnsafe();
+            const { schedules, skipped } = this.loadForWrite();
             const existingIndex = schedules.findIndex(s => s.id === schedule.id);
             if (existingIndex >= 0) {
                 schedules[existingIndex] = schedule;
@@ -138,7 +143,7 @@ export class PersistentScheduler {
                 schedules.push(schedule);
                 this.log(`Added schedule: ${schedule.id}`);
             }
-            await this.writeSchedules(schedules);
+            await this.writeSchedules(schedules, skipped);
         });
     }
     /**
@@ -147,13 +152,13 @@ export class PersistentScheduler {
     async removeSchedule(id) {
         await this.initialize();
         await this.withFileLock(async () => {
-            const schedules = await this.loadSchedulesUnsafe();
+            const { schedules, skipped } = this.loadForWrite();
             const newSchedules = schedules.filter(s => s.id !== id);
             if (newSchedules.length === schedules.length) {
                 this.log(`Schedule not found: ${id}`);
                 return;
             }
-            await this.writeSchedules(newSchedules);
+            await this.writeSchedules(newSchedules, skipped);
             this.log(`Removed schedule: ${id}`);
         });
     }
@@ -189,15 +194,20 @@ export class PersistentScheduler {
     async markExecuted(id) {
         await this.initialize();
         await this.withFileLock(async () => {
-            const schedules = await this.loadSchedulesUnsafe();
+            const { schedules, skipped } = this.loadForWrite();
             const schedule = schedules.find(s => s.id === id);
             if (!schedule) {
                 throw new Error(`Schedule not found: ${id}`);
             }
             const now = new Date();
             schedule.lastRun = now.toISOString();
-            schedule.nextRun = calculateNextRun(schedule.schedule, now).toISOString();
-            await this.writeSchedules(schedules);
+            // #913: an entry disabled on load (legacy/invalid cron, missing fields)
+            // has no computable next run. Record the run and keep it disabled
+            // instead of throwing from calculateNextRun.
+            if (!schedule.disabledReason) {
+                schedule.nextRun = calculateNextRun(schedule.schedule, now).toISOString();
+            }
+            await this.writeSchedules(schedules, skipped);
             this.log(`Marked executed: ${id}, next run: ${schedule.nextRun}`);
         });
     }
@@ -207,17 +217,22 @@ export class PersistentScheduler {
     async setEnabled(id, enabled) {
         await this.initialize();
         await this.withFileLock(async () => {
-            const schedules = await this.loadSchedulesUnsafe();
+            const { schedules, skipped } = this.loadForWrite();
             const schedule = schedules.find(s => s.id === id);
             if (!schedule) {
                 throw new Error(`Schedule not found: ${id}`);
             }
+            // #913/#991: an entry disabled on load cannot run; say why instead of
+            // failing inside calculateNextRun (or with no cron at all).
+            if (enabled && schedule.disabledReason) {
+                throw new Error(`Cannot enable schedule ${id}: ${schedule.disabledReason}`);
+            }
             schedule.enabled = enabled;
             // If re-enabling, recalculate next run from now
             if (enabled) {
                 schedule.nextRun = calculateNextRun(schedule.schedule, new Date()).toISOString();
             }
-            await this.writeSchedules(schedules);
+            await this.writeSchedules(schedules, skipped);
             this.log(`Set enabled=${enabled}: ${id}`);
         });
     }
@@ -241,7 +256,8 @@ export class PersistentScheduler {
     async clearAll() {
         await this.initialize();
         await this.withFileLock(async () => {
-            await this.writeSchedules([]);
+            const { skipped } = this.loadForWrite();
+            await this.writeSchedules([], skipped);
             this.log('Cleared all schedules');
         });
     }
@@ -262,19 +278,22 @@ export class PersistentScheduler {
     // Private Helper Methods
     // ============================================================================
     /**
-     * Load schedules without acquiring lock (for use within locked context)
+     * Load schedules for a locked read-modify-write. A genuinely unparseable
+     * file is backed up (not removed) first, so the write that follows cannot
+     * silently replace it with fewer schedules.
      */
-    async loadSchedulesUnsafe() {
+    loadForWrite() {
         if (!fs.existsSync(this.schedulesPath)) {
-            return [];
+            return { schedules: [], skipped: [] };
         }
         try {
             const content = fs.readFileSync(this.schedulesPath, 'utf-8');
-            const data = this.parseSchedulesFile(content);
-            return data.schedules;
+            const { file, skipped } = this.parseSchedulesFile(content);
+            return { schedules: file.schedules, skipped };
         }
-        catch {
-            return [];
+        catch (error) {
+            this.backupCorruptFile(error);
+            return { schedules: [], skipped: [] };
         }
     }
     /**
@@ -288,32 +307,53 @@ export class PersistentScheduler {
             throw new Error(`Schedules file exceeds maximum allowed size (${MAX_SCHEDULES_FILE_SIZE / (1024 * 1024)}MB). File is ${(contentSize / (1024 * 1024)).toFixed(2)}MB.`);
         }
         const data = safeJsonParse(content);
-        // Validate structure
-        if (!data.schedules || !Array.isArray(data.schedules)) {
+        // Validate structure: only a missing schedules array makes the file corrupt.
+        if (!isPlainObject(data) || !Array.isArray(data.schedules)) {
             throw new Error('Invalid schedules file: missing schedules array');
         }
-        // Validate each schedule has required fields
-        for (const schedule of data.schedules) {
-            if (!schedule.id || !schedule.workflowId || !Object.prototype.hasOwnProperty.call(schedule, 'schedule')) {
-                throw new Error(`Invalid schedule entry: missing required fields`);
+        // #991: validate each entry on its own. A malformed entry is disabled
+        // (when it can still be addressed by id) or skipped; it never makes the
+        // whole file "corrupt", which used to back up and REMOVE schedules.json.
+        const schedules = [];
+        const skipped = [];
+        const seen = new Set();
+        for (const entry of data.schedules) {
+            if (!isPlainObject(entry) || typeof entry.id !== 'string' || entry.id.length === 0 || seen.has(entry.id)) {
+                skipped.push(entry);
+                continue;
             }
-            if (typeof schedule.schedule !== 'string' || !isValidCronExpression(schedule.schedule)) {
-                schedule.disabledReason = `Invalid cron expression: ${schedule.schedule}`;
+            const schedule = entry;
+            seen.add(schedule.id);
+            const reason = scheduleDisabledReason(entry);
+            if (reason) {
+                schedule.disabledReason = reason;
                 if (schedule.enabled) {
-                    console.warn(`[PersistentScheduler] Disabled schedule ${schedule.id}: ${schedule.disabledReason}`);
+                    console.warn(`[PersistentScheduler] Disabled schedule ${schedule.id}: ${reason}`);
                 }
                 schedule.enabled = false;
             }
             else {
                 delete schedule.disabledReason;
             }
+            schedules.push(schedule);
         }
-        return data;
+        return { file: { ...data, schedules }, skipped };
     }
     /**
      * Write schedules to disk
      */
-    async writeSchedules(schedules) {
+    async writeSchedules(schedules, skipped = []) {
+        // #991: entries skipped on load are not written back; keep a copy next to
+        // the file first so nothing a user stored is lost silently.
+        if (skipped.length > 0) {
+            const quarantinePath = `${this.schedulesPath}.quarantine.${Date.now()}.json`;
+            fs.writeFileSync(quarantinePath, JSON.stringify({
+                quarantinedAt: new Date().toISOString(),
+                reason: 'Malformed schedule entries (not an object, no id, or duplicate id)',
+                entries: skipped,
+            }, null, 2), { encoding: 'utf-8', flag: 'wx' });
+            console.warn(`[PersistentScheduler] Moved ${skipped.length} malformed schedule entries to ${quarantinePath}`);
+        }
         const data = {
             version: FILE_VERSION,
             updatedAt: new Date().toISOString(),
@@ -329,17 +369,7 @@ export class PersistentScheduler {
     async handleCorruptFile(error) {
         const errorMsg = toErrorMessage(error);
         this.log(`Corrupt schedules file detected: ${errorMsg}`);
-        // Create backup of corrupt file
-        const backupPath = `${this.schedulesPath}.corrupt.${Date.now()}`;
-        try {
-            if (fs.existsSync(this.schedulesPath)) {
-                fs.copyFileSync(this.schedulesPath, backupPath);
-                this.log(`Backed up corrupt file to: ${backupPath}`);
-            }
-        }
-        catch (backupError) {
-            this.log(`Failed to backup corrupt file: ${backupError}`);
-        }
+        this.backupCorruptFile(error);
         // Remove corrupt file
         try {
             if (fs.existsSync(this.schedulesPath)) {
@@ -351,6 +381,20 @@ export class PersistentScheduler {
             this.log(`Failed to remove corrupt file: ${removeError}`);
         }
     }
+    /** Copy an unparseable schedules file to `.corrupt.<ts>` (left in place). */
+    backupCorruptFile(error) {
+        this.log(`Corrupt schedules file detected: ${toErrorMessage(error)}`);
+        const backupPath = `${this.schedulesPath}.corrupt.${Date.now()}`;
+        try {
+            if (fs.existsSync(this.schedulesPath)) {
+                fs.copyFileSync(this.schedulesPath, backupPath, fs.constants.COPYFILE_EXCL);
+                this.log(`Backed up corrupt file to: ${backupPath}`);
+            }
+        }
+        catch (backupError) {
+            this.log(`Failed to backup corrupt file: ${backupError}`);
+        }
+    }
     /**
      * Execute a function with file locking for safe concurrent access
      */
@@ -433,6 +477,28 @@ export class PersistentScheduler {
     }
 }
 // ============================================================================
+// Entry validation (#991)
+// ============================================================================
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Why a persisted entry cannot run, or undefined when it is valid. Such
+ * entries are kept (disabled) so `workflow list` shows them with the reason.
+ */
+function scheduleDisabledReason(entry) {
+    if (!Object.prototype.hasOwnProperty.call(entry, 'schedule')) {
+        return 'Missing cron expression (no schedule field)';
+    }
+    if (typeof entry.schedule !== 'string' || !isValidCronExpression(entry.schedule)) {
+        return `Invalid cron expression: ${String(entry.schedule)}`;
+    }
+    if (typeof entry.workflowId !== 'string' || entry.workflowId.length === 0) {
+        return 'Missing workflowId';
+    }
+    return undefined;
+}
+// ============================================================================
 // Factory Function
 // ============================================================================
 /**

package/dist/cli/utils/ci-output.d.ts

@@ -64,14 +64,22 @@ export interface TestRunSummary {
     tests?: TestResult[];
 }
 export interface CoverageResult {
+    /** `null` = the report never collected that metric (#995); not 0%. */
     summary: {
-        line: number;
-        branch: number;
-        function: number;
-        statement: number;
+        line: number | null;
+        branch: number | null;
+        function: number | null;
+        statement: number | null;
     };
-    meetsThreshold: boolean;
+    /** `null` = no verdict: nothing was measured (UNMEASURED or estimate only, #1012). */
+    meetsThreshold: boolean | null;
     threshold: number;
+    /** Provenance, the same vocabulary as MCP `coverage_analyze_sublinear` (#1012). */
+    measured?: boolean;
+    estimated?: boolean;
+    unmeasured?: boolean;
+    coverageMethod?: string;
+    warning?: string;
     files?: Array<{
         path: string;
         lineCoverage: number;
@@ -96,6 +104,15 @@ export interface QualityGateResult {
         threshold: number | string;
     }>;
     recommendations?: string[];
+    /** #996 (additive): 'insufficient-evidence' when the gate could not be evaluated. */
+    status?: 'insufficient-evidence';
+    evidenceStatus?: 'measured' | 'insufficient-evidence';
+    /** #996: canonical metrics with no measured evidence. */
+    unmeasured?: string[];
+    /** #996: false when missing evidence prevented the gate from running. */
+    gateEvaluated?: boolean;
+    /** #996: why the gate could not be evaluated. */
+    error?: string;
 }
 /**
  * Standard --format and --output options to add to any Command.

package/dist/cli/utils/ci-output.js

@@ -207,13 +207,28 @@ export function toJUnit(summary) {
 // ============================================================================
 export function coverageToMarkdown(result) {
     let md = `# Coverage Report\n\n`;
+    // #1012: an estimate is labelled and carries no verdict.
+    if (result.estimated) {
+        md += `> **STATIC ESTIMATE — not measured.** ${result.warning ?? ''}\n\n`;
+    }
+    const evaluated = result.meetsThreshold !== null && !result.estimated;
+    // #1027 N7: one decimal, never `~33.33333333333333%`.
+    const fmt = (v) => String(Math.round(v * 10) / 10);
     md += `| Metric | Value | Status |\n`;
     md += `|--------|-------|--------|\n`;
-    md += `| Lines | ${result.summary.line}% | ${result.summary.line >= result.threshold ? '\u2705' : '\u274C'} |\n`;
-    md += `| Branches | ${result.summary.branch}% | ${result.summary.branch >= result.threshold ? '\u2705' : '\u274C'} |\n`;
-    md += `| Functions | ${result.summary.function}% | ${result.summary.function >= result.threshold ? '\u2705' : '\u274C'} |\n`;
-    md += `| Statements | ${result.summary.statement}% | ${result.summary.statement >= result.threshold ? '\u2705' : '\u274C'} |\n`;
-    md += `\n**Threshold:** ${result.threshold}% \u2014 ${result.meetsThreshold ? '\u2705 Met' : '\u274C Not met'}\n`;
+    // #995: an uncollected metric is "n/a", with no pass/fail mark — it is not 0%.
+    const row = (label, v) => v === null
+        ? `| ${label} | n/a (not collected) | \u2014 |\n`
+        : evaluated
+            ? `| ${label} | ${fmt(v)}% | ${v >= result.threshold ? '\u2705' : '\u274C'} |\n`
+            : `| ${label} | ~${fmt(v)}% (estimate) | \u2014 |\n`;
+    md += row('Lines', result.summary.line);
+    md += row('Branches', result.summary.branch);
+    md += row('Functions', result.summary.function);
+    md += row('Statements', result.summary.statement);
+    md += evaluated
+        ? `\n**Threshold:** ${result.threshold}% \u2014 ${result.meetsThreshold ? '\u2705 Met' : '\u274C Not met'}\n`
+        : `\n**Threshold:** ${result.threshold}% \u2014 not evaluated (UNMEASURED)\n`;
     if (result.gaps && result.gaps.length > 0) {
         md += `\n## Coverage Gaps\n\n`;
         md += `| File | Uncovered Lines | Risk | Severity |\n`;
@@ -232,6 +247,19 @@ export function coverageToMarkdown(result) {
 }
 export function qualityGateToMarkdown(result) {
     let md = `# Quality Gate Report\n\n`;
+    if (result.evidenceStatus === 'insufficient-evidence') {
+        // #996: a gate that could not run is neither a pass nor a measured failure.
+        md += `**Result:** \u26A0\uFE0F INSUFFICIENT EVIDENCE \u2014 quality gate not evaluated\n`;
+        if (result.unmeasured && result.unmeasured.length > 0) {
+            md += `**Unmeasured:** ${result.unmeasured.join(', ')}\n`;
+        }
+        if (result.error)
+            md += `**Reason:** ${result.error}\n`;
+        if (result.recommendations && result.recommendations.length > 0) {
+            md += `\n## Recommendations\n\n${result.recommendations.map(rec => `- ${rec}`).join('\n')}\n`;
+        }
+        return md;
+    }
     md += `**Result:** ${result.passed ? '\u2705 PASSED' : '\u274C FAILED'}\n`;
     md += `**Score:** ${result.score}\n\n`;
     md += `## Checks\n\n`;

package/dist/cli/utils/coverage-data.d.ts

@@ -41,12 +41,22 @@ export interface CoverageData {
     };
     /** True if data came from real instrumented coverage (V8/istanbul) */
     instrumented: boolean;
+    /**
+     * Source files the instrumented report has no entry for (#995). These are
+     * UNMEASURED — excluded from the figures rather than counted as 0%.
+     */
+    unmeasuredFiles?: string[];
 }
 /**
  * Try to read real coverage data from a coverage-final.json file.
  * Returns null if no instrumented coverage is available.
+ *
+ * #1012: per-file figures come from the shared istanbul parser, so the CLI
+ * and MCP compute "line" coverage the same way (source lines, not statements).
  */
 export declare function readInstrumentedCoverage(projectRoot: string): Map<string, FileCoverage> | null;
+/** Aggregate per-file coverage into whole-number percentages. */
+export declare function summarizeCoverage(files: FileCoverage[]): CoverageData['summary'];
 /**
  * Build coverage data for the given source files.
  *

package/dist/cli/utils/coverage-data.js

@@ -11,6 +11,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { parseCoverageJson } from '../../coordination/handlers/handler-utils.js';
 // ============================================================================
 // V8/Istanbul Coverage Reader
 // ============================================================================
@@ -23,6 +24,9 @@ const COVERAGE_JSON_PATHS = [
 /**
  * Try to read real coverage data from a coverage-final.json file.
  * Returns null if no instrumented coverage is available.
+ *
+ * #1012: per-file figures come from the shared istanbul parser, so the CLI
+ * and MCP compute "line" coverage the same way (source lines, not statements).
  */
 export function readInstrumentedCoverage(projectRoot) {
     for (const relPath of COVERAGE_JSON_PATHS) {
@@ -30,50 +34,16 @@ export function readInstrumentedCoverage(projectRoot) {
         if (!fs.existsSync(fullPath))
             continue;
         try {
-            const raw = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const raw = JSON.parse(content);
             // coverage-summary.json has a different shape
             if (raw.total && raw.total.lines) {
                 return readCoverageSummary(raw, projectRoot);
             }
             // coverage-final.json: Record<filepath, IstanbulFileCoverage>
             const coverageMap = new Map();
-            for (const [filePath, entry] of Object.entries(raw)) {
-                const cov = entry;
-                const stmtKeys = Object.keys(cov.s);
-                const stmtCovered = stmtKeys.filter(k => cov.s[k] > 0).length;
-                const branchKeys = Object.keys(cov.b);
-                let branchTotal = 0;
-                let branchCovered = 0;
-                for (const k of branchKeys) {
-                    for (const count of cov.b[k]) {
-                        branchTotal++;
-                        if (count > 0)
-                            branchCovered++;
-                    }
-                }
-                const fnKeys = Object.keys(cov.f);
-                const fnCovered = fnKeys.filter(k => cov.f[k] > 0).length;
-                // Compute uncovered lines from statement map
-                const coveredLineSet = new Set();
-                const allLineSet = new Set();
-                for (const stmtKey of stmtKeys) {
-                    const stmt = cov.statementMap[stmtKey];
-                    for (let line = stmt.start.line; line <= stmt.end.line; line++) {
-                        allLineSet.add(line);
-                        if (cov.s[stmtKey] > 0)
-                            coveredLineSet.add(line);
-                    }
-                }
-                const uncoveredLines = [...allLineSet].filter(l => !coveredLineSet.has(l)).sort((a, b) => a - b);
-                coverageMap.set(filePath, {
-                    path: filePath,
-                    lines: { covered: coveredLineSet.size, total: allLineSet.size },
-                    branches: { covered: branchCovered, total: branchTotal },
-                    functions: { covered: fnCovered, total: fnKeys.length },
-                    statements: { covered: stmtCovered, total: stmtKeys.length },
-                    uncoveredLines,
-                    uncoveredBranches: uncoveredLines.slice(0, Math.floor(uncoveredLines.length / 2)),
-                });
+            for (const file of parseCoverageJson(content).files) {
+                coverageMap.set(file.path, file);
             }
             return coverageMap.size > 0 ? coverageMap : null;
         }
@@ -161,6 +131,25 @@ function estimateFileCoverage(filePath, content) {
 // ============================================================================
 // Public API
 // ============================================================================
+/** Aggregate per-file coverage into whole-number percentages. */
+export function summarizeCoverage(files) {
+    const sum = (pick) => files.reduce((acc, f) => acc + pick(f), 0);
+    const safeDiv = (a, b) => b > 0 ? Math.round((a / b) * 100) : 0;
+    const totalLines = sum(f => f.lines.total);
+    const coveredLines = sum(f => f.lines.covered);
+    // #1012: statements are statements. A report without statement detail
+    // (lcov) carries its line figures in `statements`, so this falls back alike.
+    const totalStatements = sum(f => f.statements.total);
+    return {
+        line: safeDiv(coveredLines, totalLines),
+        branch: safeDiv(sum(f => f.branches.covered), sum(f => f.branches.total)),
+        function: safeDiv(sum(f => f.functions.covered), sum(f => f.functions.total)),
+        statement: totalStatements > 0
+            ? safeDiv(sum(f => f.statements.covered), totalStatements)
+            : safeDiv(coveredLines, totalLines),
+        files: files.length,
+    };
+}
 /**
  * Build coverage data for the given source files.
  *
@@ -174,6 +163,7 @@ export function buildCoverageData(sourceFiles, projectRoot) {
     // Try instrumented coverage first
     const instrumentedData = readInstrumentedCoverage(root);
     const files = [];
+    const unmeasuredFiles = [];
     let isInstrumented = false;
     if (instrumentedData && instrumentedData.size > 0) {
         isInstrumented = true;
@@ -187,18 +177,10 @@ export function buildCoverageData(sourceFiles, projectRoot) {
                 files.push({ ...match, path: filePath });
             }
             else {
-                // File exists in source but has no coverage data — 0% coverage
-                const content = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
-                const totalLines = content.split('\n').length;
-                files.push({
-                    path: filePath,
-                    lines: { covered: 0, total: totalLines },
-                    branches: { covered: 0, total: 1 },
-                    functions: { covered: 0, total: 1 },
-                    statements: { covered: 0, total: totalLines },
-                    uncoveredLines: Array.from({ length: totalLines }, (_, i) => i + 1),
-                    uncoveredBranches: [],
-                });
+                // #995: the report has no entry for this file — the coverage run did
+                // not measure it. That is "unmeasured", not 0%: counting it as fully
+                // uncovered invented a figure nobody measured.
+                unmeasuredFiles.push(filePath);
             }
         }
     }
@@ -209,24 +191,11 @@ export function buildCoverageData(sourceFiles, projectRoot) {
             files.push(estimateFileCoverage(filePath, content));
         }
     }
-    // Compute summary
-    const totalLines = files.reduce((sum, f) => sum + f.lines.total, 0);
-    const coveredLines = files.reduce((sum, f) => sum + f.lines.covered, 0);
-    const totalBranches = files.reduce((sum, f) => sum + f.branches.total, 0);
-    const coveredBranches = files.reduce((sum, f) => sum + f.branches.covered, 0);
-    const totalFunctions = files.reduce((sum, f) => sum + f.functions.total, 0);
-    const coveredFunctions = files.reduce((sum, f) => sum + f.functions.covered, 0);
-    const safeDiv = (a, b) => b > 0 ? Math.round((a / b) * 100) : 0;
     return {
         files,
-        summary: {
-            line: safeDiv(coveredLines, totalLines),
-            branch: safeDiv(coveredBranches, totalBranches),
-            function: safeDiv(coveredFunctions, totalFunctions),
-            statement: safeDiv(coveredLines, totalLines),
-            files: files.length,
-        },
+        summary: summarizeCoverage(files),
         instrumented: isInstrumented,
+        ...(unmeasuredFiles.length > 0 ? { unmeasuredFiles } : {}),
     };
 }
 //# sourceMappingURL=coverage-data.js.map