tstyche 5.0.0-beta.0 → 5.0.0-beta.1

package/build/tstyche.js

@@ -50,70 +50,41 @@ class EventEmitter {
     }
 }
 
-class Path {
-    static normalizeSlashes;
-    static {
-        if (path.sep === "/") {
-            Path.normalizeSlashes = (filePath) => filePath;
-        }
-        else {
-            Path.normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
-        }
-    }
-    static dirname(filePath) {
-        return Path.normalizeSlashes(path.dirname(filePath));
-    }
-    static join(...filePaths) {
-        return Path.normalizeSlashes(path.join(...filePaths));
-    }
-    static relative(from, to) {
-        const relativePath = Path.normalizeSlashes(path.relative(from, to));
-        if (/^\.\.?\//.test(relativePath)) {
-            return relativePath;
-        }
-        return `./${relativePath}`;
-    }
-    static resolve(...filePaths) {
-        return Path.normalizeSlashes(path.resolve(...filePaths));
-    }
-}
-
-class SourceFile {
-    fileName;
-    #lineMap;
+class JsonNode {
+    origin;
     text;
-    constructor(fileName, text) {
-        this.fileName = fileName;
+    constructor(text, origin) {
+        this.origin = origin;
         this.text = text;
-        this.#lineMap = this.#createLineMap();
     }
-    #createLineMap() {
-        const result = [0];
-        let position = 0;
-        while (position < this.text.length) {
-            if (this.text.charAt(position - 1) === "\r") {
-                position++;
-            }
-            if (this.text.charAt(position - 1) === "\n") {
-                result.push(position);
-            }
-            position++;
+    getValue(options) {
+        if (this.text == null) {
+            return undefined;
         }
-        result.push(position);
-        return result;
-    }
-    getLineStarts() {
-        return this.#lineMap;
-    }
-    getLineAndCharacterOfPosition(position) {
-        const line = this.#lineMap.findLastIndex((line) => line <= position);
-        const character = position - this.#lineMap[line];
-        return { line, character };
+        if (/^['"]/.test(this.text)) {
+            return this.text.slice(1, -1);
+        }
+        if (options?.expectsIdentifier) {
+            return this.text;
+        }
+        if (this.text === "true") {
+            return true;
+        }
+        if (this.text === "false") {
+            return false;
+        }
+        if (/^\d/.test(this.text)) {
+            return Number.parseFloat(this.text);
+        }
+        return undefined;
     }
 }
 
 class SourceService {
     static #files = new Map();
+    static delete(filePath) {
+        SourceService.#files.delete(filePath);
+    }
     static get(source) {
         const file = SourceService.#files.get(source.fileName);
         if (file != null) {
@@ -225,6 +196,171 @@ var DiagnosticCategory;
     DiagnosticCategory["Warning"] = "warning";
 })(DiagnosticCategory || (DiagnosticCategory = {}));
 
+class JsonScanner {
+    #end;
+    #position;
+    #previousPosition;
+    #sourceFile;
+    constructor(sourceFile, options) {
+        this.#end = options?.end ?? sourceFile.text.length;
+        this.#position = options?.start ?? 0;
+        this.#previousPosition = options?.start ?? 0;
+        this.#sourceFile = sourceFile;
+    }
+    #getOrigin() {
+        return new DiagnosticOrigin(this.#previousPosition, this.#position, this.#sourceFile);
+    }
+    isRead() {
+        return !(this.#position < this.#end);
+    }
+    #peekCharacter() {
+        return this.#sourceFile.text.charAt(this.#position);
+    }
+    #peekNextCharacter() {
+        return this.#sourceFile.text.charAt(this.#position + 1);
+    }
+    peekToken(token) {
+        this.#skipTrivia();
+        return this.#peekCharacter() === token;
+    }
+    read() {
+        this.#skipTrivia();
+        this.#previousPosition = this.#position;
+        if (/[\s,:\]}]/.test(this.#peekCharacter())) {
+            return new JsonNode(undefined, this.#getOrigin());
+        }
+        let text = "";
+        let closingTokenText = "";
+        if (/[[{'"]/.test(this.#peekCharacter())) {
+            text += this.#readCharacter();
+            switch (text) {
+                case "[":
+                    closingTokenText = "]";
+                    break;
+                case "{":
+                    closingTokenText = "}";
+                    break;
+                default:
+                    closingTokenText = text;
+            }
+        }
+        while (!this.isRead()) {
+            text += this.#readCharacter();
+            if (text.slice(-1) === closingTokenText || (!closingTokenText && /[\s,:\]}]/.test(this.#peekCharacter()))) {
+                break;
+            }
+        }
+        return new JsonNode(text, this.#getOrigin());
+    }
+    #readCharacter() {
+        return this.#sourceFile.text.charAt(this.#position++);
+    }
+    readToken(token) {
+        this.#skipTrivia();
+        this.#previousPosition = this.#position;
+        const character = this.#peekCharacter();
+        if (typeof token === "string" ? token === character : token.test(character)) {
+            this.#position++;
+            return new JsonNode(character, this.#getOrigin());
+        }
+        return new JsonNode(undefined, this.#getOrigin());
+    }
+    #skipTrivia() {
+        while (!this.isRead()) {
+            if (/\s/.test(this.#peekCharacter())) {
+                this.#position++;
+                continue;
+            }
+            if (this.#peekCharacter() === "/") {
+                if (this.#peekNextCharacter() === "/") {
+                    this.#position += 2;
+                    while (!this.isRead()) {
+                        if (this.#readCharacter() === "\n") {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                if (this.#peekNextCharacter() === "*") {
+                    this.#position += 2;
+                    while (!this.isRead()) {
+                        if (this.#peekCharacter() === "*" && this.#peekNextCharacter() === "/") {
+                            this.#position += 2;
+                            break;
+                        }
+                        this.#position++;
+                    }
+                    continue;
+                }
+            }
+            break;
+        }
+        this.#previousPosition = this.#position;
+    }
+}
+
+class JsonSourceFile {
+    fileName;
+    #lineMap;
+    text;
+    constructor(fileName, text) {
+        this.fileName = fileName;
+        this.text = text;
+        this.#lineMap = this.#createLineMap();
+    }
+    #createLineMap() {
+        const result = [0];
+        let position = 0;
+        while (position < this.text.length) {
+            if (this.text.charAt(position - 1) === "\r") {
+                position++;
+            }
+            if (this.text.charAt(position - 1) === "\n") {
+                result.push(position);
+            }
+            position++;
+        }
+        result.push(position);
+        return result;
+    }
+    getLineStarts() {
+        return this.#lineMap;
+    }
+    getLineAndCharacterOfPosition(position) {
+        const line = this.#lineMap.findLastIndex((line) => line <= position);
+        const character = position - this.#lineMap[line];
+        return { line, character };
+    }
+}
+
+class Path {
+    static normalizeSlashes;
+    static {
+        if (path.sep === "/") {
+            Path.normalizeSlashes = (filePath) => filePath;
+        }
+        else {
+            Path.normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
+        }
+    }
+    static dirname(filePath) {
+        return Path.normalizeSlashes(path.dirname(filePath));
+    }
+    static join(...filePaths) {
+        return Path.normalizeSlashes(path.join(...filePaths));
+    }
+    static relative(from, to) {
+        const relativePath = Path.normalizeSlashes(path.relative(from, to));
+        if (/^\.\.?\//.test(relativePath)) {
+            return relativePath;
+        }
+        return `./${relativePath}`;
+    }
+    static resolve(...filePaths) {
+        return Path.normalizeSlashes(path.resolve(...filePaths));
+    }
+}
+
 class ConfigDiagnosticText {
     static expected(element) {
         return `Expected ${element}.`;
@@ -1460,148 +1596,15 @@ const defaultOptions = {
     checkSuppressedErrors: true,
     failFast: false,
     fixtureFileMatch: ["**/__fixtures__/*.{ts,tsx}", "**/fixtures/*.{ts,tsx}"],
-    plugins: [],
-    rejectAnyType: true,
-    rejectNeverType: true,
-    reporters: ["list", "summary"],
-    rootPath: Path.resolve("./"),
-    target: ["*"],
-    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
-    tsconfig: "findup",
-};
-
-class JsonNode {
-    origin;
-    text;
-    constructor(text, origin) {
-        this.origin = origin;
-        this.text = text;
-    }
-    getValue(options) {
-        if (this.text == null) {
-            return undefined;
-        }
-        if (/^['"]/.test(this.text)) {
-            return this.text.slice(1, -1);
-        }
-        if (options?.expectsIdentifier) {
-            return this.text;
-        }
-        if (this.text === "true") {
-            return true;
-        }
-        if (this.text === "false") {
-            return false;
-        }
-        if (/^\d/.test(this.text)) {
-            return Number.parseFloat(this.text);
-        }
-        return undefined;
-    }
-}
-
-class JsonScanner {
-    #end;
-    #position;
-    #previousPosition;
-    #sourceFile;
-    constructor(sourceFile, options) {
-        this.#end = options?.end ?? sourceFile.text.length;
-        this.#position = options?.start ?? 0;
-        this.#previousPosition = options?.start ?? 0;
-        this.#sourceFile = sourceFile;
-    }
-    #getOrigin() {
-        return new DiagnosticOrigin(this.#previousPosition, this.#position, this.#sourceFile);
-    }
-    isRead() {
-        return !(this.#position < this.#end);
-    }
-    #peekCharacter() {
-        return this.#sourceFile.text.charAt(this.#position);
-    }
-    #peekNextCharacter() {
-        return this.#sourceFile.text.charAt(this.#position + 1);
-    }
-    peekToken(token) {
-        this.#skipTrivia();
-        return this.#peekCharacter() === token;
-    }
-    read() {
-        this.#skipTrivia();
-        this.#previousPosition = this.#position;
-        if (/[\s,:\]}]/.test(this.#peekCharacter())) {
-            return new JsonNode(undefined, this.#getOrigin());
-        }
-        let text = "";
-        let closingTokenText = "";
-        if (/[[{'"]/.test(this.#peekCharacter())) {
-            text += this.#readCharacter();
-            switch (text) {
-                case "[":
-                    closingTokenText = "]";
-                    break;
-                case "{":
-                    closingTokenText = "}";
-                    break;
-                default:
-                    closingTokenText = text;
-            }
-        }
-        while (!this.isRead()) {
-            text += this.#readCharacter();
-            if (text.slice(-1) === closingTokenText || (!closingTokenText && /[\s,:\]}]/.test(this.#peekCharacter()))) {
-                break;
-            }
-        }
-        return new JsonNode(text, this.#getOrigin());
-    }
-    #readCharacter() {
-        return this.#sourceFile.text.charAt(this.#position++);
-    }
-    readToken(token) {
-        this.#skipTrivia();
-        this.#previousPosition = this.#position;
-        const character = this.#peekCharacter();
-        if (typeof token === "string" ? token === character : token.test(character)) {
-            this.#position++;
-            return new JsonNode(character, this.#getOrigin());
-        }
-        return new JsonNode(undefined, this.#getOrigin());
-    }
-    #skipTrivia() {
-        while (!this.isRead()) {
-            if (/\s/.test(this.#peekCharacter())) {
-                this.#position++;
-                continue;
-            }
-            if (this.#peekCharacter() === "/") {
-                if (this.#peekNextCharacter() === "/") {
-                    this.#position += 2;
-                    while (!this.isRead()) {
-                        if (this.#readCharacter() === "\n") {
-                            break;
-                        }
-                    }
-                    continue;
-                }
-                if (this.#peekNextCharacter() === "*") {
-                    this.#position += 2;
-                    while (!this.isRead()) {
-                        if (this.#peekCharacter() === "*" && this.#peekNextCharacter() === "/") {
-                            this.#position += 2;
-                            break;
-                        }
-                        this.#position++;
-                    }
-                    continue;
-                }
-            }
-            break;
-        }
-        this.#previousPosition = this.#position;
-    }
-}
+    plugins: [],
+    rejectAnyType: true,
+    rejectNeverType: true,
+    reporters: ["list", "summary"],
+    rootPath: Path.resolve("./"),
+    target: ["*"],
+    testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
+    tsconfig: "findup",
+};
 
 class Config {
     static #onDiagnostics(diagnostic) {
@@ -1623,7 +1626,7 @@ class Config {
             const configFileText = await fs.readFile(configFilePath, {
                 encoding: "utf8",
             });
-            const sourceFile = new SourceFile(configFilePath, configFileText);
+            const sourceFile = new JsonSourceFile(configFilePath, configFileText);
             const configFileParser = new ConfigParser(configFileOptions, 4, sourceFile, new JsonScanner(sourceFile), Config.#onDiagnostics);
             await configFileParser.parse();
         }
@@ -1827,19 +1830,33 @@ class ExitCodeHandler {
     }
 }
 
-class ResultTiming {
-    end = Number.NaN;
-    start = Number.NaN;
-    get duration() {
-        return this.end - this.start;
-    }
+function createObjectFromKeys(keys, defaultValue) {
+    return Object.fromEntries(keys.map((key) => [key, defaultValue]));
+}
+function createTargetCounts() {
+    return createObjectFromKeys(["failed", "passed"], 0);
+}
+function createFileCounts() {
+    return createObjectFromKeys(["failed", "passed"], 0);
+}
+function createTestCounts() {
+    return createObjectFromKeys(["failed", "passed", "fixme", "skipped", "todo"], 0);
+}
+function createAssertionCounts() {
+    return createObjectFromKeys(["failed", "passed", "fixme", "skipped", "todo"], 0);
+}
+function createSuppressedCounts() {
+    return createObjectFromKeys(["failed", "matched", "ignored"], 0);
+}
+function createResultTiming() {
+    return createObjectFromKeys(["start", "end"], Number.NaN);
 }
 
 class DescribeResult {
     describe;
     parent;
     results = [];
-    timing = new ResultTiming();
+    timing = createResultTiming();
     constructor(describe, parent) {
         this.describe = describe;
         this.parent = parent;
@@ -1848,35 +1865,23 @@ class DescribeResult {
 
 class ExpectResult {
     expect;
-    diagnostics = [];
     parent;
     status = "runs";
-    timing = new ResultTiming();
+    timing = createResultTiming();
     constructor(expect, parent) {
         this.expect = expect;
         this.parent = parent;
     }
 }
 
-class ResultCount {
-    failed = 0;
-    passed = 0;
-    skipped = 0;
-    fixme = 0;
-    todo = 0;
-    get total() {
-        return this.failed + this.passed + this.skipped + this.fixme + this.todo;
-    }
-}
-
 class FileResult {
-    diagnostics = [];
-    expectCount = new ResultCount();
+    assertionCounts = createAssertionCounts();
     file;
     results = [];
+    suppressedCounts = createSuppressedCounts();
     status = "runs";
-    testCount = new ResultCount();
-    timing = new ResultTiming();
+    testCounts = createTestCounts();
+    timing = createResultTiming();
     constructor(file) {
         this.file = file;
     }
@@ -1884,7 +1889,6 @@ class FileResult {
 
 class ProjectResult {
     compilerVersion;
-    diagnostics = [];
     projectConfigFilePath;
     results = [];
     constructor(compilerVersion, projectConfigFilePath) {
@@ -1894,13 +1898,14 @@ class ProjectResult {
 }
 
 class Result {
-    expectCount = new ResultCount();
-    fileCount = new ResultCount();
+    assertionCounts = createAssertionCounts();
+    fileCounts = createFileCounts();
     files;
     results = [];
-    targetCount = new ResultCount();
-    testCount = new ResultCount();
-    timing = new ResultTiming();
+    suppressedCounts = createSuppressedCounts();
+    targetCounts = createTargetCounts();
+    testCounts = createTestCounts();
+    timing = createResultTiming();
     constructor(files) {
         this.files = files;
     }
@@ -1910,18 +1915,27 @@ var ResultStatus;
 (function (ResultStatus) {
     ResultStatus["Runs"] = "runs";
     ResultStatus["Passed"] = "passed";
+    ResultStatus["Matched"] = "matched";
     ResultStatus["Failed"] = "failed";
-    ResultStatus["Skipped"] = "skipped";
     ResultStatus["Fixme"] = "fixme";
+    ResultStatus["Skipped"] = "skipped";
+    ResultStatus["Ignored"] = "ignored";
     ResultStatus["Todo"] = "todo";
 })(ResultStatus || (ResultStatus = {}));
 
+class SuppressedResult {
+    suppressed;
+    constructor(suppressed) {
+        this.suppressed = suppressed;
+    }
+}
+
 class TargetResult {
     files;
     results = new Map();
     status = "runs";
     target;
-    timing = new ResultTiming();
+    timing = createResultTiming();
     constructor(target, files) {
         this.target = target;
         this.files = files;
@@ -1929,13 +1943,12 @@ class TargetResult {
 }
 
 class TestResult {
-    diagnostics = [];
-    expectCount = new ResultCount();
+    assertionCounts = createAssertionCounts();
     parent;
     results = [];
     status = "runs";
     test;
-    timing = new ResultTiming();
+    timing = createResultTiming();
     constructor(test, parent) {
         this.test = test;
         this.parent = parent;
@@ -1967,10 +1980,10 @@ class ResultHandler {
                 break;
             case "target:end":
                 if (this.#targetResult.status === "failed") {
-                    this.#result.targetCount.failed++;
+                    this.#result.targetCounts.failed++;
                 }
                 else {
-                    this.#result.targetCount.passed++;
+                    this.#result.targetCounts.passed++;
                     this.#targetResult.status = "passed";
                 }
                 this.#targetResult.timing.end = Date.now();
@@ -1992,7 +2005,6 @@ class ResultHandler {
             }
             case "project:error":
                 this.#targetResult.status = "failed";
-                this.#projectResult.diagnostics.push(...payload.diagnostics);
                 break;
             case "file:start":
                 this.#projectResult.results.push(payload.result);
@@ -2004,18 +2016,17 @@ class ResultHandler {
             case "collect:error":
                 this.#targetResult.status = "failed";
                 this.#fileResult.status = "failed";
-                this.#fileResult.diagnostics.push(...payload.diagnostics);
                 break;
             case "file:end":
                 if (this.#fileResult.status === "failed" ||
-                    this.#fileResult.expectCount.failed > 0 ||
-                    this.#fileResult.testCount.failed > 0) {
-                    this.#result.fileCount.failed++;
+                    this.#fileResult.assertionCounts.failed > 0 ||
+                    this.#fileResult.testCounts.failed > 0) {
+                    this.#result.fileCounts.failed++;
                     this.#targetResult.status = "failed";
                     this.#fileResult.status = "failed";
                 }
                 else {
-                    this.#result.fileCount.passed++;
+                    this.#result.fileCounts.passed++;
                     this.#fileResult.status = "passed";
                 }
                 this.#fileResult.timing.end = Date.now();
@@ -2046,44 +2057,37 @@ class ResultHandler {
                 this.#testResult.timing.start = Date.now();
                 break;
             case "test:error":
-                this.#result.testCount.failed++;
-                this.#fileResult.testCount.failed++;
-                this.#testResult.status = "failed";
-                this.#testResult.diagnostics.push(...payload.diagnostics);
-                this.#testResult.timing.end = Date.now();
-                this.#testResult = undefined;
-                break;
             case "test:fail":
-                this.#result.testCount.failed++;
-                this.#fileResult.testCount.failed++;
+                this.#result.testCounts.failed++;
+                this.#fileResult.testCounts.failed++;
                 this.#testResult.status = "failed";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
             case "test:pass":
-                this.#result.testCount.passed++;
-                this.#fileResult.testCount.passed++;
+                this.#result.testCounts.passed++;
+                this.#fileResult.testCounts.passed++;
                 this.#testResult.status = "passed";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
             case "test:skip":
-                this.#result.testCount.skipped++;
-                this.#fileResult.testCount.skipped++;
+                this.#result.testCounts.skipped++;
+                this.#fileResult.testCounts.skipped++;
                 this.#testResult.status = "skipped";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
             case "test:fixme":
-                this.#result.testCount.fixme++;
-                this.#fileResult.testCount.fixme++;
+                this.#result.testCounts.fixme++;
+                this.#fileResult.testCounts.fixme++;
                 this.#testResult.status = "fixme";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
             case "test:todo":
-                this.#result.testCount.todo++;
-                this.#fileResult.testCount.todo++;
+                this.#result.testCounts.todo++;
+                this.#fileResult.testCounts.todo++;
                 this.#testResult.status = "todo";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
@@ -2099,56 +2103,60 @@ class ResultHandler {
                 this.#expectResult.timing.start = Date.now();
                 break;
             case "expect:error":
-                this.#result.expectCount.failed++;
-                this.#fileResult.expectCount.failed++;
-                if (this.#testResult) {
-                    this.#testResult.expectCount.failed++;
-                }
-                this.#expectResult.status = "failed";
-                this.#expectResult.diagnostics.push(...payload.diagnostics);
-                this.#expectResult.timing.end = Date.now();
-                this.#expectResult = undefined;
-                break;
             case "expect:fail":
-                this.#result.expectCount.failed++;
-                this.#fileResult.expectCount.failed++;
+                this.#result.assertionCounts.failed++;
+                this.#fileResult.assertionCounts.failed++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.failed++;
+                    this.#testResult.assertionCounts.failed++;
                 }
                 this.#expectResult.status = "failed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:pass":
-                this.#result.expectCount.passed++;
-                this.#fileResult.expectCount.passed++;
+                this.#result.assertionCounts.passed++;
+                this.#fileResult.assertionCounts.passed++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.passed++;
+                    this.#testResult.assertionCounts.passed++;
                 }
                 this.#expectResult.status = "passed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:skip":
-                this.#result.expectCount.skipped++;
-                this.#fileResult.expectCount.skipped++;
+                this.#result.assertionCounts.skipped++;
+                this.#fileResult.assertionCounts.skipped++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.skipped++;
+                    this.#testResult.assertionCounts.skipped++;
                 }
                 this.#expectResult.status = "skipped";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:fixme":
-                this.#result.expectCount.fixme++;
-                this.#fileResult.expectCount.fixme++;
+                this.#result.assertionCounts.fixme++;
+                this.#fileResult.assertionCounts.fixme++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.fixme++;
+                    this.#testResult.assertionCounts.fixme++;
                 }
                 this.#expectResult.status = "fixme";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
+            case "suppressed:error":
+                this.#result.suppressedCounts.failed++;
+                this.#fileResult.suppressedCounts.failed++;
+                this.#targetResult.status = "failed";
+                this.#fileResult.status = "failed";
+                break;
+            case "suppressed:match":
+                this.#result.suppressedCounts.matched++;
+                this.#fileResult.suppressedCounts.matched++;
+                break;
+            case "suppressed:ignore":
+                this.#result.suppressedCounts.ignored++;
+                this.#fileResult.suppressedCounts.ignored++;
+                break;
         }
     }
 }
@@ -2331,6 +2339,30 @@ function diagnosticText(diagnostic, codeFrameOptions = {}) {
     return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { codeFrameOptions: codeFrameOptions, diagnostic: diagnostic })] }));
 }
 
+function getStatusColor(status) {
+    switch (status) {
+        case "runs":
+            return "33";
+        case "passed":
+        case "matched":
+            return "32";
+        case "failed":
+            return "31";
+        case "fixme":
+        case "skipped":
+        case "ignored":
+            return "33";
+        case "todo":
+            return "35";
+    }
+}
+function duration(timing) {
+    return timing.end - timing.start;
+}
+function total(counts) {
+    return Object.values(counts).reduce((sum, value) => sum + value, 0);
+}
+
 function FileNameText({ filePath }) {
     const relativePath = Path.relative("", filePath);
     const lastPathSeparator = relativePath.lastIndexOf("/");
@@ -2339,23 +2371,19 @@ function FileNameText({ filePath }) {
     return (jsx(Text, { children: [jsx(Text, { color: "90", children: directoryNameText }), fileNameText] }));
 }
 function fileStatusText(status, file) {
-    let statusColor;
     let statusText;
     switch (status) {
         case "runs":
-            statusColor = "33";
             statusText = "runs";
             break;
         case "passed":
-            statusColor = "32";
             statusText = "pass";
             break;
         case "failed":
-            statusColor = "31";
             statusText = "fail";
             break;
     }
-    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: file.path })] }));
+    return (jsx(Line, { children: [jsx(Text, { color: getStatusColor(status), children: statusText }), " ", jsx(FileNameText, { filePath: file.path })] }));
 }
 
 function fileViewText(lines, addEmptyFinalLine) {
@@ -2466,36 +2494,52 @@ class OutputService {
 function RowText({ label, text }) {
     return (jsx(Line, { children: [`${label}:`.padEnd(12), text] }));
 }
-function CountText({ failed, fixme, passed, skipped, todo, total }) {
-    return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "31", children: [failed, " failed"] }), jsx(Text, { children: ", " })] })) : undefined, fixme > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [fixme, " fixme"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [skipped, " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: "35", children: [todo, " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "32", children: [passed, " passed"] }), jsx(Text, { children: ", " })] })) : undefined, jsx(Text, { children: [total, " total"] })] }));
+function CountsText({ counts, total }) {
+    const countsText = Object.entries(counts).map(([status, count]) => {
+        return (jsx(Text, { children: count > 0 ? (jsx(Text, { children: [jsx(Text, { color: getStatusColor(status), children: [count, " ", status] }), jsx(Text, { children: ", " })] })) : undefined }));
+    });
+    const totalText = (jsx(Text, { children: [total, " ", "total"] }));
+    return (jsx(Text, { children: [countsText, totalText] }));
 }
-function DurationText({ seconds }) {
+function DurationText({ timing }) {
+    const seconds = duration(timing) / 1000;
     return jsx(Text, { children: `${Math.round(seconds * 10) / 10}s` });
 }
-function summaryText({ duration, expectCount, fileCount, targetCount, testCount, }) {
-    const targetCountText = (jsx(RowText, { label: "Targets", text: jsx(CountText, { failed: targetCount.failed, fixme: targetCount.fixme, passed: targetCount.passed, skipped: targetCount.skipped, todo: targetCount.todo, total: targetCount.total }) }));
-    const fileCountText = (jsx(RowText, { label: "Test files", text: jsx(CountText, { failed: fileCount.failed, fixme: fileCount.fixme, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
-    const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, fixme: testCount.fixme, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
-    const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, fixme: expectCount.fixme, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
-    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
+function summaryText({ targetCounts, fileCounts, testCounts, assertionCounts, suppressedCounts, timing, }) {
+    const targetCountsTotal = total(targetCounts);
+    const targetCountsText = (jsx(RowText, { label: "Targets", text: jsx(CountsText, { counts: targetCounts, total: targetCountsTotal }) }));
+    const fileCountsTotal = total(fileCounts);
+    const fileCountsText = (jsx(RowText, { label: "Test files", text: jsx(CountsText, { counts: fileCounts, total: fileCountsTotal }) }));
+    const testCountsTotal = total(testCounts);
+    const testCountsText = testCountsTotal > 0 ? (jsx(RowText, { label: "Tests", text: jsx(CountsText, { counts: testCounts, total: testCountsTotal }) })) : undefined;
+    const assertionCountsTotal = total(assertionCounts);
+    const assertionCountsText = assertionCountsTotal > 0 ? (jsx(RowText, { label: "Assertions", text: jsx(CountsText, { counts: assertionCounts, total: assertionCountsTotal }) })) : undefined;
+    const suppressedCountsTotal = total(suppressedCounts);
+    const suppressedCountsText = suppressedCountsTotal > 0 ? (jsx(RowText, { label: "Suppressed", text: jsx(CountsText, { counts: suppressedCounts, total: suppressedCountsTotal }) })) : undefined;
+    const durationText = jsx(RowText, { label: "Duration", text: jsx(DurationText, { timing: timing }) });
+    return (jsx(Text, { children: [targetCountsText, fileCountsText, testCountsText, assertionCountsText, suppressedCountsText, durationText] }));
 }
 
-function StatusText({ status }) {
+function testNameText(status, name, indent = 0) {
+    let statusText;
     switch (status) {
-        case "fail":
-            return jsx(Text, { color: "31", children: "\u00D7" });
-        case "pass":
-            return jsx(Text, { color: "32", children: "+" });
-        case "skip":
-            return jsx(Text, { color: "33", children: "- skip" });
+        case "passed":
+            statusText = "+";
+            break;
+        case "failed":
+            statusText = "×";
+            break;
+        case "skipped":
+            statusText = "- skip";
+            break;
         case "fixme":
-            return jsx(Text, { color: "33", children: "- fixme" });
+            statusText = "- fixme";
+            break;
         case "todo":
-            return jsx(Text, { color: "35", children: "- todo" });
+            statusText = "- todo";
+            break;
     }
-}
-function testNameText(status, name, indent = 0) {
-    return (jsx(Line, { indent: indent + 1, children: [jsx(StatusText, { status: status }), " ", jsx(Text, { color: "90", children: name })] }));
+    return (jsx(Line, { indent: indent + 1, children: [jsx(Text, { color: getStatusColor(status), children: statusText }), " ", jsx(Text, { color: "90", children: name })] }));
 }
 
 function usesCompilerText(compilerVersion, projectConfigFilePath, options) {
@@ -2630,6 +2674,7 @@ class ListReporter extends BaseReporter {
             case "file:error":
             case "directive:error":
             case "collect:error":
+            case "suppressed:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
@@ -2658,7 +2703,7 @@ class ListReporter extends BaseReporter {
                 break;
             case "test:skip":
                 if (this.#isFileViewExpanded) {
-                    this.#fileView.addTest("skip", payload.result.test.name);
+                    this.#fileView.addTest("skipped", payload.result.test.name);
                 }
                 break;
             case "test:fixme":
@@ -2673,7 +2718,7 @@ class ListReporter extends BaseReporter {
                 break;
             case "test:error":
                 if (this.#isFileViewExpanded) {
-                    this.#fileView.addTest("fail", payload.result.test.name);
+                    this.#fileView.addTest("failed", payload.result.test.name);
                 }
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
@@ -2681,12 +2726,12 @@ class ListReporter extends BaseReporter {
                 break;
             case "test:fail":
                 if (this.#isFileViewExpanded) {
-                    this.#fileView.addTest("fail", payload.result.test.name);
+                    this.#fileView.addTest("failed", payload.result.test.name);
                 }
                 break;
             case "test:pass":
                 if (this.#isFileViewExpanded) {
-                    this.#fileView.addTest("pass", payload.result.test.name);
+                    this.#fileView.addTest("passed", payload.result.test.name);
                 }
                 break;
             case "expect:error":
@@ -2727,11 +2772,12 @@ class SummaryReporter extends BaseReporter {
         }
         if (event === "run:end") {
             OutputService.writeMessage(summaryText({
-                duration: payload.result.timing.duration,
-                expectCount: payload.result.expectCount,
-                fileCount: payload.result.fileCount,
-                targetCount: payload.result.targetCount,
-                testCount: payload.result.testCount,
+                targetCounts: payload.result.targetCounts,
+                fileCounts: payload.result.fileCounts,
+                testCounts: payload.result.testCounts,
+                assertionCounts: payload.result.assertionCounts,
+                suppressedCounts: payload.result.suppressedCounts,
+                timing: payload.result.timing,
             }));
         }
     }
@@ -3188,8 +3234,28 @@ class WatchService {
     }
 }
 
-function nodeBelongsToArgumentList(compiler, node) {
-    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+function compareDiagnostics(a, b) {
+    if (a.file?.fileName !== b.file?.fileName) {
+        return false;
+    }
+    return deepCompareKeys(a, b, ["start", "length", "code", "messageText"]);
+}
+function deepCompareKeys(a, b, keys) {
+    if (a == null || b == null) {
+        return a === b;
+    }
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (typeof a !== "object") {
+        return a === b;
+    }
+    for (const key of Object.keys(a).filter((key) => keys.includes(key))) {
+        if (!(key in b) || !deepCompareKeys(a[key], b[key], keys)) {
+            return false;
+        }
+    }
+    return true;
 }
 function nodeIsChildOfExpressionStatement(compiler, node) {
     return compiler.isExpressionStatement(node.parent);
@@ -3197,70 +3263,170 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
-    #expectErrorRegex = /^(\s*)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
-    #filePath = "";
+    #editor;
     #nodes = [];
-    #projectService;
-    #resolvedConfig;
-    #suppressedErrorsMap;
-    #text = "";
-    constructor(compiler, projectService, resolvedConfig) {
+    constructor(compiler, editor) {
         this.#compiler = compiler;
-        this.#projectService = projectService;
-        this.#resolvedConfig = resolvedConfig;
-    }
-    #addRanges(node, ranges) {
-        this.#nodes.push(node);
-        for (const range of ranges) {
-            const rangeText = range.replacement != null
-                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
-                : this.#getErasedRangeText(range);
-            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
-        }
+        this.#editor = editor;
     }
     #belongsToNode(node, diagnostic) {
         switch (node.brand) {
             case "expect":
-                return (diagnosticBelongsToNode(diagnostic, node.matcherNode) &&
-                    !diagnosticBelongsToNode(diagnostic, node.source));
+                return (diagnosticBelongsToNode(diagnostic, node.matcherNode) ||
+                    diagnosticBelongsToNode(diagnostic, node.source));
             case "when":
                 return (diagnosticBelongsToNode(diagnostic, node.actionNode) &&
                     !diagnosticBelongsToNode(diagnostic, node.target));
         }
         return false;
     }
+    close(diagnostics) {
+        if (diagnostics != null && this.#nodes.length > 0) {
+            this.#nodes.reverse();
+            for (const diagnostic of diagnostics) {
+                this.#mapToNodes(diagnostic);
+            }
+        }
+        this.#nodes = [];
+    }
     #mapToNodes(diagnostic) {
         for (const node of this.#nodes) {
             if (this.#belongsToNode(node, diagnostic)) {
                 node.abilityDiagnostics.add(diagnostic);
-                return true;
+                break;
             }
         }
-        return false;
     }
-    #mapToDirectives(diagnostic) {
-        if (!isDiagnosticWithLocation(diagnostic)) {
-            return;
-        }
-        const { file, start } = diagnostic;
-        const lineMap = file.getLineStarts();
-        let line = this.#compiler.getLineAndCharacterOfPosition(file, start).line - 1;
-        while (line >= 0) {
-            const suppressedError = this.#suppressedErrorsMap?.get(line);
-            if (suppressedError != null) {
-                suppressedError.diagnostics.push(diagnostic);
+    visitExpect(expect) {
+        const expectStart = expect.node.getStart();
+        const expectExpressionEnd = expect.node.expression.getEnd();
+        const expectEnd = expect.node.getEnd();
+        const matcherNameEnd = expect.matcherNameNode.getEnd();
+        switch (expect.matcherNameNode.name.text) {
+            case "toBeApplicable":
+                this.#nodes.push(expect);
+                this.#editor.replaceRanges([
+                    [expectStart, expectExpressionEnd],
+                    [expectEnd, matcherNameEnd],
+                ]);
                 break;
-            }
-            const lineText = file.text.slice(lineMap[line], lineMap[line + 1]).trim();
-            if (lineText !== "" && !lineText.startsWith("//")) {
+            case "toBeCallableWith":
+                this.#nodes.push(expect);
+                this.#editor.eraseTrailingComma(expect.source);
+                this.#editor.replaceRanges([
+                    [
+                        expectStart,
+                        expectExpressionEnd,
+                        nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
+                    ],
+                    [expectEnd, matcherNameEnd],
+                ]);
+                break;
+            case "toBeConstructableWith":
+                this.#nodes.push(expect);
+                this.#editor.eraseTrailingComma(expect.source);
+                this.#editor.replaceRanges([
+                    [
+                        expectStart,
+                        expectExpressionEnd,
+                        nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? "; new" : "new",
+                    ],
+                    [expectEnd, matcherNameEnd],
+                ]);
                 break;
+        }
+    }
+    visitWhen(when) {
+        const whenStart = when.node.getStart();
+        const whenExpressionEnd = when.node.expression.getEnd();
+        const whenEnd = when.node.getEnd();
+        const actionNameEnd = when.actionNameNode.getEnd();
+        switch (when.actionNameNode.name.text) {
+            case "isCalledWith":
+                this.#nodes.push(when);
+                this.#editor.eraseTrailingComma(when.target);
+                this.#editor.replaceRanges([
+                    [whenStart, whenExpressionEnd, nodeIsChildOfExpressionStatement(this.#compiler, when.actionNode) ? ";" : ""],
+                    [whenEnd, actionNameEnd],
+                ]);
+                break;
+        }
+    }
+}
+
+class SourceTextEditor {
+    #filePath = "";
+    #sourceFile;
+    #text = "";
+    open(sourceFile) {
+        this.#sourceFile = sourceFile;
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+    }
+    close() {
+        if (this.#sourceFile != null) {
+            SourceService.set(this.#sourceFile);
+            this.#sourceFile = undefined;
+        }
+        this.#filePath = "";
+        this.#text = "";
+    }
+    eraseTrailingComma(node) {
+        if (node.hasTrailingComma) {
+            this.replaceRange(node.end - 1, node.end);
+        }
+    }
+    #getErasedRange(start, end) {
+        if (this.#text.indexOf("\n", start) >= end) {
+            return " ".repeat(end - start);
+        }
+        const text = [];
+        for (let index = start; index < end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
+                case "\n":
+                case "\r":
+                    text.push(character);
+                    break;
+                default:
+                    text.push(" ");
             }
-            line--;
         }
+        return text.join("");
+    }
+    getFilePath() {
+        return this.#filePath;
+    }
+    getText() {
+        return this.#text;
+    }
+    replaceRange(start, end, replacement) {
+        const rangeText = replacement != null
+            ? `${replacement}${this.#getErasedRange(start, end).slice(replacement.length)}`
+            : this.#getErasedRange(start, end);
+        this.#text = `${this.#text.slice(0, start)}${rangeText}${this.#text.slice(end)}`;
+    }
+    replaceRanges(ranges) {
+        for (const [start, end, replacement] of ranges) {
+            this.replaceRange(start, end, replacement);
+        }
+    }
+}
+
+class SuppressedLayer {
+    #compiler;
+    #editor;
+    #expectErrorRegex = /^(\s*)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
+    #resolvedConfig;
+    #suppressedErrorsMap;
+    constructor(compiler, editor, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#editor = editor;
+        this.#resolvedConfig = resolvedConfig;
     }
-    #collectSuppressedErrors() {
+    #collectSuppressedErrors(text) {
         const ranges = [];
-        for (const match of this.#text.matchAll(this.#expectErrorRegex)) {
+        for (const match of text.matchAll(this.#expectErrorRegex)) {
             const offsetText = match?.[1];
             const directiveText = match?.[2];
             const ignoreText = match?.[3];
@@ -3283,126 +3449,89 @@ class AbilityLayer {
         }
         return ranges;
     }
-    close(testTree) {
-        if (this.#nodes.length > 0 || this.#suppressedErrorsMap != null) {
-            SourceService.set(testTree.sourceFile);
-            this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
-            const languageService = this.#projectService.getLanguageService(this.#filePath);
-            const diagnostics = languageService?.getSemanticDiagnostics(this.#filePath);
-            if (diagnostics != null) {
-                this.#nodes.reverse();
-                for (const diagnostic of diagnostics) {
-                    if (this.#mapToNodes(diagnostic)) {
-                        continue;
-                    }
-                    this.#mapToDirectives(diagnostic);
-                }
+    close(diagnostics) {
+        if (diagnostics != null && this.#suppressedErrorsMap != null) {
+            for (const diagnostic of diagnostics) {
+                this.#mapToDirectives(diagnostic);
             }
         }
-        this.#filePath = "";
-        this.#nodes = [];
         this.#suppressedErrorsMap = undefined;
-        this.#text = "";
-    }
-    #eraseTrailingComma(node, parent) {
-        if (node.hasTrailingComma) {
-            this.#addRanges(parent, [{ start: node.end - 1, end: node.end }]);
-        }
     }
-    #getErasedRangeText(range) {
-        if (this.#text.indexOf("\n", range.start) >= range.end) {
-            return " ".repeat(range.end - range.start);
-        }
-        const text = [];
-        for (let index = range.start; index < range.end; index++) {
-            const character = this.#text.charAt(index);
-            switch (character) {
-                case "\n":
-                case "\r":
-                    text.push(character);
-                    break;
-                default:
-                    text.push(" ");
-            }
+    #mapToDirectives(diagnostic) {
+        if (!isDiagnosticWithLocation(diagnostic)) {
+            return;
         }
-        return text.join("");
-    }
-    handleExpect(expect) {
-        const expectStart = expect.node.getStart();
-        const expectExpressionEnd = expect.node.expression.getEnd();
-        const expectEnd = expect.node.getEnd();
-        const matcherNameEnd = expect.matcherNameNode.getEnd();
-        switch (expect.matcherNameNode.name.text) {
-            case "toBeApplicable":
-                this.#addRanges(expect, [
-                    { start: expectStart, end: expectExpressionEnd },
-                    { start: expectEnd, end: matcherNameEnd },
-                ]);
-                break;
-            case "toBeCallableWith":
-                this.#eraseTrailingComma(expect.source, expect);
-                this.#addRanges(expect, [
-                    {
-                        start: expectStart,
-                        end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
-                    },
-                    { start: expectEnd, end: matcherNameEnd },
-                ]);
+        const { file, start } = diagnostic;
+        const lineMap = file.getLineStarts();
+        let line = this.#compiler.getLineAndCharacterOfPosition(file, start).line - 1;
+        while (line >= 0) {
+            const suppressedError = this.#suppressedErrorsMap?.get(line);
+            if (suppressedError != null) {
+                suppressedError.diagnostics.push(diagnostic);
                 break;
-            case "toBeConstructableWith":
-                this.#eraseTrailingComma(expect.source, expect);
-                this.#addRanges(expect, [
-                    {
-                        start: expectStart,
-                        end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? "; new" : "new",
-                    },
-                    { start: expectEnd, end: matcherNameEnd },
-                ]);
+            }
+            const lineText = file.text.slice(lineMap[line], lineMap[line + 1]).trim();
+            if (lineText !== "" && !lineText.startsWith("//")) {
                 break;
+            }
+            line--;
         }
     }
-    #handleSuppressedErrors(testTree) {
-        const suppressedErrors = this.#collectSuppressedErrors();
+    open(tree) {
+        const suppressedErrors = this.#collectSuppressedErrors(this.#editor.getText());
         if (this.#resolvedConfig.checkSuppressedErrors) {
-            testTree.suppressedErrors = suppressedErrors;
+            tree.suppressedErrors = suppressedErrors;
             this.#suppressedErrorsMap = new Map();
         }
         for (const suppressedError of suppressedErrors) {
             const { start, end } = suppressedError.directive;
-            const rangeText = this.#getErasedRangeText({ start: start + 2, end });
-            this.#text = `${this.#text.slice(0, start + 2)}${rangeText}${this.#text.slice(end)}`;
+            this.#editor.replaceRange(start + 2, end);
             if (this.#suppressedErrorsMap != null) {
-                const { line } = testTree.sourceFile.getLineAndCharacterOfPosition(start);
+                const { line } = tree.sourceFile.getLineAndCharacterOfPosition(start);
                 this.#suppressedErrorsMap.set(line, suppressedError);
             }
         }
     }
-    handleWhen(whenNode) {
-        const whenStart = whenNode.node.getStart();
-        const whenExpressionEnd = whenNode.node.expression.getEnd();
-        const whenEnd = whenNode.node.getEnd();
-        const actionNameEnd = whenNode.actionNameNode.getEnd();
-        switch (whenNode.actionNameNode.name.text) {
-            case "isCalledWith":
-                this.#eraseTrailingComma(whenNode.target, whenNode);
-                this.#addRanges(whenNode, [
-                    {
-                        start: whenStart,
-                        end: whenExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
-                    },
-                    { start: whenEnd, end: actionNameEnd },
-                ]);
+}
+
+class Layers {
+    #abilityLayer;
+    #editor = new SourceTextEditor();
+    #projectService;
+    #suppressedDiagnostics;
+    #suppressedLayer;
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#projectService = projectService;
+        this.#abilityLayer = new AbilityLayer(compiler, this.#editor);
+        this.#suppressedLayer = new SuppressedLayer(compiler, this.#editor, resolvedConfig);
+    }
+    close() {
+        let isSeenDiagnostic;
+        if (this.#suppressedDiagnostics != null) {
+            const seenDiagnostics = this.#suppressedDiagnostics;
+            this.#suppressedDiagnostics = undefined;
+            isSeenDiagnostic = (diagnostic) => !seenDiagnostics.some((seenDiagnostic) => compareDiagnostics(diagnostic, seenDiagnostic));
+        }
+        const abilityDiagnostics = this.#projectService.getDiagnostics(this.#editor.getFilePath(), this.#editor.getText(), isSeenDiagnostic);
+        this.#abilityLayer.close(abilityDiagnostics);
+        this.#editor.close();
+    }
+    open(tree) {
+        this.#editor.open(tree.sourceFile);
+        this.#suppressedLayer.open(tree);
+        this.#suppressedDiagnostics = this.#projectService.getDiagnostics(this.#editor.getFilePath(), this.#editor.getText());
+        this.#suppressedLayer.close(this.#suppressedDiagnostics);
+    }
+    visit(node) {
+        switch (node.brand) {
+            case "expect":
+                this.#abilityLayer.visitExpect(node);
+                break;
+            case "when":
+                this.#abilityLayer.visitWhen(node);
                 break;
         }
     }
-    open(testTree) {
-        this.#filePath = testTree.sourceFile.fileName;
-        this.#text = testTree.sourceFile.text;
-        this.#handleSuppressedErrors(testTree);
-    }
 }
 
 class CollectDiagnosticText {
@@ -3591,12 +3720,12 @@ class WhenNode extends TestTreeNode {
 }
 
 class CollectService {
-    #abilityLayer;
+    #layers;
     #compiler;
     #identifierLookup;
     constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
-        this.#abilityLayer = new AbilityLayer(compiler, projectService, resolvedConfig);
+        this.#layers = new Layers(compiler, projectService, resolvedConfig);
         this.#identifierLookup = new IdentifierLookup(compiler);
     }
     #collectTestTreeNodes(node, parent, testTree) {
@@ -3629,7 +3758,7 @@ class CollectService {
                         return;
                     }
                     const expectNode = new ExpectNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
-                    this.#abilityLayer.handleExpect(expectNode);
+                    this.#layers.visit(expectNode);
                     this.#compiler.forEachChild(node, (node) => {
                         this.#collectTestTreeNodes(node, expectNode, testTree);
                     });
@@ -3656,7 +3785,7 @@ class CollectService {
                         }
                     });
                     const whenNode = new WhenNode(this.#compiler, meta.brand, node, parent, meta.flags, actionNode, actionNameNode);
-                    this.#abilityLayer.handleWhen(whenNode);
+                    this.#layers.visit(whenNode);
                     this.#onNode(whenNode, parent, testTree);
                     return;
                 }
@@ -3673,10 +3802,10 @@ class CollectService {
     createTestTree(sourceFile, semanticDiagnostics = []) {
         const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
         EventEmitter.dispatch(["collect:start", { tree: testTree }]);
-        this.#abilityLayer.open(testTree);
+        this.#layers.open(testTree);
         this.#identifierLookup.open();
         this.#collectTestTreeNodes(sourceFile, testTree, testTree);
-        this.#abilityLayer.close(testTree);
+        this.#layers.close();
         EventEmitter.dispatch(["collect:end", { tree: testTree }]);
         return testTree;
     }
@@ -3745,6 +3874,10 @@ class CollectService {
     }
 }
 
+function nodeBelongsToArgumentList(compiler, node) {
+    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+}
+
 var TestTreeNodeBrand;
 (function (TestTreeNodeBrand) {
     TestTreeNodeBrand["Describe"] = "describe";
@@ -3808,6 +3941,7 @@ class ProjectService {
     }
     closeFile(filePath) {
         this.#service.closeClientFile(filePath);
+        SourceService.delete(filePath);
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
@@ -3837,6 +3971,15 @@ class ProjectService {
         }
         return project;
     }
+    getDiagnostics(filePath, sourceText, shouldInclude) {
+        this.openFile(filePath, sourceText);
+        const languageService = this.getLanguageService(filePath);
+        const diagnostics = languageService?.getSemanticDiagnostics(filePath);
+        if (diagnostics != null && shouldInclude != null) {
+            return diagnostics.filter(shouldInclude);
+        }
+        return diagnostics;
+    }
     getLanguageService(filePath) {
         const project = this.getDefaultProject(filePath);
         return project?.getLanguageService(true);
@@ -3846,7 +3989,7 @@ class ProjectService {
         const { fileNames } = this.#compiler.parseJsonSourceFileConfigFileContent(configSourceFile, this.#compiler.sys, Path.dirname(this.#resolvedConfig.tsconfig), undefined, this.#resolvedConfig.tsconfig);
         return fileNames.includes(filePath);
     }
-    openFile(filePath, sourceText, projectRootPath) {
+    openFile(filePath, sourceText) {
         switch (this.#resolvedConfig.tsconfig) {
             case "findup":
                 break;
@@ -3858,7 +4001,7 @@ class ProjectService {
                     ? () => this.#resolvedConfig.tsconfig
                     : () => undefined;
         }
-        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
+        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, this.#resolvedConfig.rootPath);
         if (configFileName !== this.#lastSeenProject) {
             this.#lastSeenProject = configFileName;
             EventEmitter.dispatch([
@@ -3926,12 +4069,17 @@ class SuppressedDiagnosticText {
 }
 
 class SuppressedService {
-    match(testTree, onDiagnostics) {
+    match(testTree) {
         if (!testTree.suppressedErrors) {
             return;
         }
         for (const suppressedError of testTree.suppressedErrors) {
-            if (suppressedError.diagnostics.length === 0 || suppressedError.ignore) {
+            const suppressedResult = new SuppressedResult(suppressedError);
+            if (suppressedError.diagnostics.length === 0) {
+                continue;
+            }
+            if (suppressedError.ignore) {
+                EventEmitter.dispatch(["suppressed:ignore", { result: suppressedResult }]);
                 continue;
             }
             const related = [
@@ -3941,12 +4089,12 @@ class SuppressedService {
             const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, testTree.sourceFile);
             if (!suppressedError.argument?.text) {
                 const text = SuppressedDiagnosticText.directiveRequires();
-                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+                this.#onDiagnostics(Diagnostic.error(text, origin).add({ related }), suppressedResult);
                 continue;
             }
             if (suppressedError.diagnostics.length > 1) {
-                const text = [SuppressedDiagnosticText.onlySingleError()];
-                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+                const text = SuppressedDiagnosticText.onlySingleError();
+                this.#onDiagnostics(Diagnostic.error(text, origin).add({ related }), suppressedResult);
                 continue;
             }
             let messageText = getDiagnosticMessageText(suppressedError.diagnostics[0]);
@@ -3954,10 +4102,12 @@ class SuppressedService {
                 messageText = messageText.join("\n");
             }
             if (!this.#matchMessage(messageText, suppressedError.argument.text)) {
-                const text = [SuppressedDiagnosticText.messageDidNotMatch()];
+                const text = SuppressedDiagnosticText.messageDidNotMatch();
                 const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, testTree.sourceFile);
-                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+                this.#onDiagnostics(Diagnostic.error(text, origin).add({ related }), suppressedResult);
+                continue;
             }
+            EventEmitter.dispatch(["suppressed:match", { result: suppressedResult }]);
         }
     }
     #matchMessage(source, target) {
@@ -3973,6 +4123,9 @@ class SuppressedService {
         }
         return source.includes(target);
     }
+    #onDiagnostics(diagnostic, result) {
+        EventEmitter.dispatch(["suppressed:error", { diagnostics: [diagnostic], result }]);
+    }
 }
 
 class EnsureDiagnosticText {
@@ -4075,11 +4228,11 @@ class ExpectDiagnosticText {
     static isNotAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable to type '${targetTypeText}'.`;
     }
-    static isAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
+    static isAssignableFrom(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable from type '${targetTypeText}'.`;
     }
-    static isNotAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
+    static isNotAssignableFrom(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not assignable from type '${targetTypeText}'.`;
     }
     static isTheSame(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is the same as type '${targetTypeText}'.`;
@@ -4293,7 +4446,7 @@ class ToAcceptProps {
                 }
                 if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
                     const text = [
-                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText),
                         ExpectDiagnosticText.requiresProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
@@ -4306,9 +4459,9 @@ class ToAcceptProps {
                     const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
                     const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
                     const text = [
-                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText),
                         ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
-                        ExpectDiagnosticText.isNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
+                        ExpectDiagnosticText.isNotAssignableFrom(sourcePropertyTypeText, targetPropertyTypeText),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -4320,7 +4473,7 @@ class ToAcceptProps {
                     const targetProperty = targetType.getProperty(sourcePropertyName);
                     if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
                         const text = [
-                            ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                            ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText),
                             ExpectDiagnosticText.requiresProperty(sourceTypeText, sourcePropertyName),
                         ];
                         diagnostics.push(diagnostic.extendWith(text));
@@ -4328,7 +4481,7 @@ class ToAcceptProps {
                 }
             }
             if (diagnostics.length === 0) {
-                const text = ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText);
+                const text = ExpectDiagnosticText.isAssignableFrom(sourceTypeText, targetTypeText);
                 diagnostics.push(diagnostic.extendWith(text));
                 return { diagnostics, isMatch: true };
             }
@@ -4338,8 +4491,8 @@ class ToAcceptProps {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertionNode.isNot
-                    ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
+                    ? ExpectDiagnosticText.isAssignableFrom(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
                 if (isMatch) {
                     accumulator = diagnostics;
@@ -4480,24 +4633,24 @@ class ToBeApplicable {
     }
 }
 
-class ToBeAssignableTo extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.isAssignableTo;
-    explainNotText = ExpectDiagnosticText.isNotAssignableTo;
+class ToBeAssignableFrom extends RelationMatcherBase {
+    explainText = ExpectDiagnosticText.isAssignableFrom;
+    explainNotText = ExpectDiagnosticText.isNotAssignableFrom;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
-            isMatch: matchWorker.checkIsAssignableTo(sourceNode, targetNode),
+            isMatch: matchWorker.checkIsAssignableWith(sourceNode, targetNode),
         };
     }
 }
 
-class ToBeAssignableWith extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.isAssignableWith;
-    explainNotText = ExpectDiagnosticText.isNotAssignableWith;
+class ToBeAssignableTo extends RelationMatcherBase {
+    explainText = ExpectDiagnosticText.isAssignableTo;
+    explainNotText = ExpectDiagnosticText.isNotAssignableTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
-            isMatch: matchWorker.checkIsAssignableWith(sourceNode, targetNode),
+            isMatch: matchWorker.checkIsAssignableTo(sourceNode, targetNode),
         };
     }
 }
@@ -4768,8 +4921,8 @@ class ExpectService {
     toAcceptProps;
     toBe;
     toBeApplicable;
+    toBeAssignableFrom;
     toBeAssignableTo;
-    toBeAssignableWith;
     toBeCallableWith;
     toBeConstructableWith;
     toHaveProperty;
@@ -4781,8 +4934,8 @@ class ExpectService {
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
         this.toBeApplicable = new ToBeApplicable(compiler);
+        this.toBeAssignableFrom = new ToBeAssignableFrom();
         this.toBeAssignableTo = new ToBeAssignableTo();
-        this.toBeAssignableWith = new ToBeAssignableWith();
         this.toBeCallableWith = new ToBeCallableWith(compiler);
         this.toBeConstructableWith = new ToBeConstructableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
@@ -4804,8 +4957,8 @@ class ExpectService {
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
+            case "toBeAssignableFrom":
             case "toBeAssignableTo":
-            case "toBeAssignableWith":
                 if (!argumentOrTypeArgumentIsProvided("target", "Target", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
@@ -5162,7 +5315,7 @@ class TestTreeWalker {
             EventEmitter.dispatch(["test:skip", { result: testResult }]);
             return;
         }
-        const isPass = testResult.expectCount.failed === 0;
+        const isPass = testResult.assertionCounts.failed === 0;
         if (FixmeService.isFixme(test, isPass)) {
             EventEmitter.dispatch(["test:fixme", { result: testResult }]);
             return;
@@ -5198,7 +5351,7 @@ class FileRunner {
         if (cancellationToken.isCancellationRequested) {
             return;
         }
-        this.#projectService.openFile(file.path, undefined, this.#resolvedConfig.rootPath);
+        this.#projectService.openFile(file.path);
         const fileResult = new FileResult(file);
         EventEmitter.dispatch(["file:start", { result: fileResult }]);
         await this.#run(file, fileResult, cancellationToken);
@@ -5235,13 +5388,11 @@ class FileRunner {
                 this.#onDiagnostics([Diagnostic.error("A template test file must export a string.")], fileResult);
                 return;
             }
-            this.#projectService.openFile(file.path, testText, this.#resolvedConfig.rootPath);
+            this.#projectService.openFile(file.path, testText);
             return this.#resolveFileFacts(file, fileResult, runModeFlags);
         }
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
-        this.#suppressedService.match(testTree, (diagnostics) => {
-            this.#onDiagnostics(diagnostics, fileResult);
-        });
+        this.#suppressedService.match(testTree);
         return { runModeFlags, testTree, typeChecker };
     }
     async #run(file, fileResult, cancellationToken) {
@@ -5272,7 +5423,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "5.0.0-beta.0";
+    static version = "5.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5472,4 +5623,4 @@ class Cli {
     }
 }
 
-export { BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectNode, ExpectResult, ExpectService, FileLocation, FileResult, FileWatcher, Glob, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, SourceService, Store, SummaryReporter, SuppressedService, TargetResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, Result, ResultStatus, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, Store, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };