tstyche 4.3.0 → 5.0.0-beta.1

package/build/tstyche.js

@@ -6,34 +6,117 @@ import os from 'node:os';
 import process from 'node:process';
 import { createRequire } from 'node:module';
 import vm from 'node:vm';
-import streamConsumers from 'node:stream/consumers';
 
-var DiagnosticCategory;
-(function (DiagnosticCategory) {
-    DiagnosticCategory["Error"] = "error";
-    DiagnosticCategory["Warning"] = "warning";
-})(DiagnosticCategory || (DiagnosticCategory = {}));
+class EventEmitter {
+    static instanceCount = 0;
+    static #handlers = new Map();
+    static #reporters = new Map();
+    #scope;
+    constructor() {
+        this.#scope = EventEmitter.instanceCount++;
+        EventEmitter.#handlers.set(this.#scope, new Set());
+        EventEmitter.#reporters.set(this.#scope, new Set());
+    }
+    addHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.add(handler);
+    }
+    addReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
+    }
+    static dispatch(event) {
+        function forEachHandler(handlers, event) {
+            for (const handler of handlers) {
+                handler.on(event);
+            }
+        }
+        for (const handlers of EventEmitter.#handlers.values()) {
+            forEachHandler(handlers, event);
+        }
+        for (const handlers of EventEmitter.#reporters.values()) {
+            forEachHandler(handlers, event);
+        }
+    }
+    removeHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
+    }
+    removeReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
+    }
+    removeHandlers() {
+        EventEmitter.#handlers.get(this.#scope)?.clear();
+    }
+    removeReporters() {
+        EventEmitter.#reporters.get(this.#scope)?.clear();
+    }
+}
+
+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 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) {
+            return file;
+        }
+        return source;
+    }
+    static set(source) {
+        SourceService.#files.set(source.fileName, source);
+    }
+}
 
 class DiagnosticOrigin {
-    assertion;
+    assertionNode;
     end;
     sourceFile;
     start;
-    constructor(start, end, sourceFile, assertion) {
+    constructor(start, end, sourceFile, assertionNode) {
         this.start = start;
         this.end = end;
-        this.sourceFile = sourceFile;
-        this.assertion = assertion;
+        this.sourceFile = SourceService.get(sourceFile);
+        this.assertionNode = assertionNode;
     }
-    static fromAssertion(assertion) {
-        const node = assertion.matcherNameNode.name;
-        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
+    static fromAssertion(assertionNode) {
+        const node = assertionNode.matcherNameNode.name;
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
     }
-    static fromNode(node, assertion) {
-        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
+    static fromNode(node, assertionNode) {
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
     }
-    static fromNodes(nodes, assertion) {
-        return new DiagnosticOrigin(nodes.pos, nodes.end, nodes[0].getSourceFile(), assertion);
+    static fromNodes(nodes, assertionNode) {
+        return new DiagnosticOrigin(nodes.pos, nodes.end, nodes[0].getSourceFile(), assertionNode);
     }
 }
 
@@ -82,32 +165,141 @@ class Diagnostic {
         return this;
     }
     static error(text, origin) {
-        return new Diagnostic(text, DiagnosticCategory.Error, origin);
+        return new Diagnostic(text, "error", origin);
     }
     extendWith(text, origin) {
         return new Diagnostic([this.text, text].flat(), this.category, origin ?? this.origin);
     }
-    static fromDiagnostics(diagnostics, sourceFile) {
+    static fromDiagnostics(diagnostics) {
         return diagnostics.map((diagnostic) => {
             const code = `ts(${diagnostic.code})`;
             let origin;
             if (isDiagnosticWithLocation(diagnostic)) {
-                origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceFile ?? diagnostic.file);
+                origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), diagnostic.file);
             }
             let related;
             if (diagnostic.relatedInformation != null) {
                 related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
             }
             const text = getDiagnosticMessageText(diagnostic);
-            return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
+            return new Diagnostic(text, "error", origin).add({ code, related });
         });
     }
     static warning(text, origin) {
-        return new Diagnostic(text, DiagnosticCategory.Warning, origin);
+        return new Diagnostic(text, "warning", origin);
+    }
+}
+
+var DiagnosticCategory;
+(function (DiagnosticCategory) {
+    DiagnosticCategory["Error"] = "error";
+    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 SourceFile {
+class JsonSourceFile {
     fileName;
     #lineMap;
     text;
@@ -141,49 +333,6 @@ class SourceFile {
     }
 }
 
-class EventEmitter {
-    static instanceCount = 0;
-    static #handlers = new Map();
-    static #reporters = new Map();
-    #scope;
-    constructor() {
-        this.#scope = EventEmitter.instanceCount++;
-        EventEmitter.#handlers.set(this.#scope, new Set());
-        EventEmitter.#reporters.set(this.#scope, new Set());
-    }
-    addHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.add(handler);
-    }
-    addReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
-    }
-    static dispatch(event) {
-        function forEachHandler(handlers, event) {
-            for (const handler of handlers) {
-                handler.on(event);
-            }
-        }
-        for (const handlers of EventEmitter.#handlers.values()) {
-            forEachHandler(handlers, event);
-        }
-        for (const handlers of EventEmitter.#reporters.values()) {
-            forEachHandler(handlers, event);
-        }
-    }
-    removeHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
-    }
-    removeReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
-    }
-    removeHandlers() {
-        EventEmitter.#handlers.get(this.#scope)?.clear();
-    }
-    removeReporters() {
-        EventEmitter.#reporters.get(this.#scope)?.clear();
-    }
-}
-
 class Path {
     static normalizeSlashes;
     static {
@@ -237,19 +386,22 @@ class ConfigDiagnosticText {
     static moduleWasNotFound(specifier) {
         return `The specified module '${specifier}' was not found.`;
     }
+    static optionValueMustBe(optionName, optionBrand) {
+        return `Value for the '${optionName}' option must be a ${optionBrand}.`;
+    }
     static rangeIsNotValid(value) {
         return `The specified range '${value}' is not valid.`;
     }
+    static rangeDoesNotMatchSupported(value) {
+        return `The specified range '${value}' does not match any supported TypeScript versions.`;
+    }
     static rangeUsage() {
         return [
-            "A range must be specified using an operator and a minor version.",
-            "To set an upper bound, the intersection of two ranges can be used.",
-            "Examples: '>=5.5', '>=5.0 <5.3'.",
+            "A range must be specified using an operator and a minor version: '>=5.5'.",
+            "To set an upper bound, use the intersection of two ranges: '>=5.0 <5.3'.",
+            "Use the '||' operator to join ranges into a union: '>=5.2 <=5.3 || 5.4.2 || >5.5'.",
         ];
     }
-    static requiresValueType(optionName, optionBrand) {
-        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
-    }
     static seen(element) {
         return `The ${element} was seen here.`;
     }
@@ -259,46 +411,14 @@ class ConfigDiagnosticText {
     static unknownOption(optionName) {
         return `Unknown option '${optionName}'.`;
     }
-    static usage(optionName, optionBrand) {
-        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
-            case "target": {
-                const text = [];
-                if (optionName.startsWith("--")) {
-                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
-                }
-                return text;
-            }
-        }
-        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
-    }
     static versionIsNotSupported(value) {
-        if (value === "current") {
-            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
-        }
-        return `TypeScript version '${value}' is not supported.`;
+        return `The TypeScript version '${value}' is not supported.`;
     }
     static watchCannotBeEnabled() {
         return "Watch mode cannot be enabled in continuous integration environment.";
     }
 }
 
-var OptionBrand;
-(function (OptionBrand) {
-    OptionBrand["String"] = "string";
-    OptionBrand["Number"] = "number";
-    OptionBrand["Boolean"] = "boolean";
-    OptionBrand["BareTrue"] = "bareTrue";
-    OptionBrand["List"] = "list";
-})(OptionBrand || (OptionBrand = {}));
-
-var OptionGroup;
-(function (OptionGroup) {
-    OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
-    OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
-    OptionGroup[OptionGroup["InlineConditions"] = 8] = "InlineConditions";
-    OptionGroup[OptionGroup["ResolvedConfig"] = 6] = "ResolvedConfig";
-})(OptionGroup || (OptionGroup = {}));
-
 class Environment {
     static resolve() {
         return {
@@ -555,6 +675,9 @@ class Manifest {
         return;
     }
     resolve(tag) {
+        if (tag === "*") {
+            return this.resolutions["latest"];
+        }
         if (this.versions.includes(tag)) {
             return tag;
         }
@@ -663,32 +786,58 @@ class ManifestService {
 }
 
 class TarReader {
-    static #textDecoder = new TextDecoder();
-    static async *extract(stream) {
-        const decompressedStream = stream.pipeThrough(new DecompressionStream("gzip"));
-        const buffer = await streamConsumers.arrayBuffer(decompressedStream);
-        let offset = 0;
-        while (offset < buffer.byteLength - 512) {
-            const name = TarReader.#read(buffer, offset, 100);
-            if (name.length === 0) {
+    #leftover = new Uint8Array(0);
+    #reader;
+    #textDecoder = new TextDecoder();
+    constructor(stream) {
+        this.#reader = stream.getReader();
+    }
+    async *extract() {
+        while (true) {
+            const header = await this.#read(512);
+            if (this.#isEndOfArchive(header)) {
                 break;
             }
-            const size = Number.parseInt(TarReader.#read(buffer, offset + 124, 12), 8);
-            const contents = new Uint8Array(buffer, offset + 512, size);
-            yield { name, contents };
-            offset += 512 + 512 * Math.trunc(size / 512);
-            if (size % 512) {
-                offset += 512;
+            const name = this.#textDecoder.decode(header.subarray(0, 100)).replace(/\0.*$/, "");
+            const sizeOctal = this.#textDecoder.decode(header.subarray(124, 136)).replace(/\0.*$/, "").trim();
+            const size = Number.parseInt(sizeOctal, 8);
+            const content = await this.#read(size);
+            yield { name, content };
+            if (size % 512 !== 0) {
+                const toSkip = 512 - (size % 512);
+                await this.#read(toSkip);
             }
         }
     }
-    static #read(buffer, byteOffset, length) {
-        let view = new Uint8Array(buffer, byteOffset, length);
-        const zeroIndex = view.indexOf(0);
-        if (zeroIndex !== -1) {
-            view = view.subarray(0, zeroIndex);
+    #isEndOfArchive(entry) {
+        return entry.every((byte) => byte === 0);
+    }
+    async #read(n) {
+        const result = new Uint8Array(n);
+        let filled = 0;
+        if (this.#leftover.length > 0) {
+            const toCopy = Math.min(this.#leftover.length, n);
+            result.set(this.#leftover.subarray(0, toCopy), filled);
+            filled += toCopy;
+            this.#leftover = this.#leftover.subarray(toCopy);
+            if (filled === n) {
+                return result;
+            }
         }
-        return TarReader.#textDecoder.decode(view);
+        while (filled < n) {
+            const { value, done } = await this.#reader.read();
+            if (done) {
+                break;
+            }
+            const toCopy = Math.min(value.length, n - filled);
+            result.set(value.subarray(0, toCopy), filled);
+            filled += toCopy;
+            if (toCopy < value.length) {
+                this.#leftover = value.subarray(toCopy);
+                break;
+            }
+        }
+        return result.subarray(0, filled);
     }
 }
 
@@ -706,16 +855,18 @@ class PackageService {
         const response = await this.#fetcher.get(request, diagnostic);
         if (response?.body != null) {
             const targetPath = `${packagePath}-${Math.random().toString(32).slice(2)}`;
-            for await (const file of TarReader.extract(response.body)) {
+            const stream = response.body.pipeThrough(new DecompressionStream("gzip"));
+            const tarReader = new TarReader(stream);
+            for await (const file of tarReader.extract()) {
                 if (!file.name.startsWith("package/")) {
                     continue;
                 }
-                const filePath = Path.join(targetPath, file.name.replace("package/", ""));
+                const filePath = Path.join(targetPath, file.name.replace(/^package\//, ""));
                 const directoryPath = Path.dirname(filePath);
                 if (!existsSync(directoryPath)) {
                     await fs.mkdir(directoryPath, { recursive: true });
                 }
-                await fs.writeFile(filePath, file.contents);
+                await fs.writeFile(filePath, file.content);
             }
             await fs.rename(targetPath, packagePath);
             return packagePath;
@@ -765,7 +916,7 @@ class Store {
         Store.#manifestService = new ManifestService(Store.#storePath, Store.#npmRegistry, Store.#fetcher);
     }
     static async fetch(tag) {
-        if (tag === "current") {
+        if (tag === "*" && environmentOptions.typescriptModule != null) {
             return;
         }
         await Store.open();
@@ -782,7 +933,7 @@ class Store {
             return compilerInstance;
         }
         let modulePath;
-        if (tag === "current" && environmentOptions.typescriptModule != null) {
+        if (tag === "*" && environmentOptions.typescriptModule != null) {
             modulePath = fileURLToPath(environmentOptions.typescriptModule);
         }
         else {
@@ -830,7 +981,7 @@ class Store {
         Store.open = () => Promise.resolve();
         Store.manifest = await Store.#manifestService.open();
         if (Store.manifest != null) {
-            Store.#supportedTags = [...Object.keys(Store.manifest.resolutions), ...Store.manifest.versions, "current"].sort();
+            Store.#supportedTags = [...Object.keys(Store.manifest.resolutions), ...Store.manifest.versions];
         }
     }
     static async prune() {
@@ -840,8 +991,8 @@ class Store {
         await Store.#manifestService.open({ refresh: true });
     }
     static async validateTag(tag) {
-        if (tag === "current") {
-            return environmentOptions.typescriptModule != null;
+        if (tag === "*") {
+            return true;
         }
         await Store.open();
         if (Store.manifest?.isOutdated({ ageTolerance: 60 }) &&
@@ -859,23 +1010,25 @@ class Store {
 
 class Target {
     static #rangeRegex = /^[<>]=?\d\.\d( [<>]=?\d\.\d)?$/;
-    static async expand(queries) {
-        const include = [];
-        for (const query of queries) {
-            if (!Target.isRange(query)) {
-                include.push(query);
-                continue;
-            }
+    static async expand(range, onDiagnostics, origin) {
+        if (Target.isRange(range)) {
             await Store.open();
             if (Store.manifest != null) {
                 let versions = [...Store.manifest.minorVersions];
-                for (const comparator of query.split(" ")) {
-                    versions = Target.#filter(comparator, versions);
+                for (const comparator of range.split(" ")) {
+                    versions = Target.#filter(comparator.trim(), versions);
+                    if (versions.length === 0) {
+                        const text = [
+                            ConfigDiagnosticText.rangeDoesNotMatchSupported(range),
+                            ConfigDiagnosticText.inspectSupportedVersions(),
+                        ];
+                        onDiagnostics(Diagnostic.error(text, origin));
+                    }
                 }
-                include.push(...versions);
+                return versions;
             }
         }
-        return include;
+        return [range];
     }
     static #filter(comparator, versions) {
         const targetVersion = comparator.replace(/^[<>]=?/, "");
@@ -894,178 +1047,177 @@ class Target {
     static isRange(query) {
         return Target.#rangeRegex.test(query);
     }
+    static split(range) {
+        return range.split(/ *\|\| */);
+    }
 }
 
 class Options {
     static #definitions = [
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "The Url to the config file validation schema.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             name: "$schema",
         },
         {
-            brand: OptionBrand.Boolean,
-            description: "Enable type error reporting for source files.",
-            group: OptionGroup.ConfigFile,
-            name: "checkSourceFiles",
+            brand: "boolean",
+            description: "Check declaration files for type errors.",
+            group: 4,
+            name: "checkDeclarationFiles",
         },
         {
-            brand: OptionBrand.Boolean,
+            brand: "boolean",
             description: "Check errors silenced by '// @ts-expect-error' directives.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             name: "checkSuppressedErrors",
         },
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "The path to a TSTyche configuration file.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "config",
         },
         {
-            brand: OptionBrand.Boolean,
+            brand: "boolean",
             description: "Stop running tests after the first failed assertion.",
-            group: OptionGroup.ConfigFile | OptionGroup.CommandLine,
+            group: 4 | 2,
             name: "failFast",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Fetch the specified versions of the 'typescript' package and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "fetch",
         },
         {
-            brand: OptionBrand.List,
+            brand: "list",
             description: "The list of glob patterns matching the fixture files.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             items: {
-                brand: OptionBrand.String,
+                brand: "string",
                 name: "fixtureFileMatch",
             },
             name: "fixtureFileMatch",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Print the list of command line options with brief descriptions and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "help",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Print the list of supported versions of the 'typescript' package and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "list",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Print the list of the selected test files and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "listFiles",
         },
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "Only run tests with matching name.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "only",
         },
         {
-            brand: OptionBrand.List,
+            brand: "list",
             description: "The list of plugins to use.",
-            group: OptionGroup.CommandLine | OptionGroup.ConfigFile,
+            group: 2 | 4,
             items: {
-                brand: OptionBrand.String,
+                brand: "string",
                 name: "plugins",
             },
             name: "plugins",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Remove all installed versions of the 'typescript' package and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "prune",
         },
         {
-            brand: OptionBrand.Boolean,
+            brand: "boolean",
             description: "Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             name: "rejectAnyType",
         },
         {
-            brand: OptionBrand.Boolean,
+            brand: "boolean",
             description: "Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             name: "rejectNeverType",
         },
         {
-            brand: OptionBrand.List,
+            brand: "list",
             description: "The list of reporters to use.",
-            group: OptionGroup.CommandLine | OptionGroup.ConfigFile,
+            group: 2 | 4,
             items: {
-                brand: OptionBrand.String,
+                brand: "string",
                 name: "reporters",
             },
             name: "reporters",
         },
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "The path to a directory containing files of a test project.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             name: "rootPath",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Print the resolved configuration and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "showConfig",
         },
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "Skip tests with matching name.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "skip",
         },
         {
-            brand: OptionBrand.List,
-            description: "The list of TypeScript versions to be tested on.",
-            group: OptionGroup.CommandLine | OptionGroup.ConfigFile | OptionGroup.InlineConditions,
-            items: {
-                brand: OptionBrand.String,
-                name: "target",
-            },
+            brand: "range",
+            description: "The range of TypeScript versions to be tested against.",
+            group: 2 | 4 | 8,
             name: "target",
         },
         {
-            brand: OptionBrand.List,
+            brand: "list",
             description: "The list of glob patterns matching the test files.",
-            group: OptionGroup.ConfigFile,
+            group: 4,
             items: {
-                brand: OptionBrand.String,
+                brand: "string",
                 name: "testFileMatch",
             },
             name: "testFileMatch",
         },
         {
-            brand: OptionBrand.String,
+            brand: "string",
             description: "The look up strategy to be used to find the TSConfig file.",
-            group: OptionGroup.CommandLine | OptionGroup.ConfigFile,
+            group: 2 | 4,
             name: "tsconfig",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Fetch the 'typescript' package metadata from the registry and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "update",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Print the version number and exit.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "version",
         },
         {
-            brand: OptionBrand.BareTrue,
+            brand: "true",
             description: "Watch for changes and rerun related test files.",
-            group: OptionGroup.CommandLine,
+            group: 2,
             name: "watch",
         },
     ];
@@ -1117,7 +1269,7 @@ class Options {
         }
         return optionValue;
     }
-    static async validate(optionName, optionValue, optionBrand, onDiagnostics, origin) {
+    static async validate(optionName, optionValue, onDiagnostics, origin) {
         const canonicalOptionName = Options.#getCanonicalOptionName(optionName);
         switch (canonicalOptionName) {
             case "config":
@@ -1144,16 +1296,17 @@ class Options {
             case "target": {
                 if (/[<>=]/.test(optionValue)) {
                     if (!Target.isRange(optionValue)) {
-                        onDiagnostics(Diagnostic.error([ConfigDiagnosticText.rangeIsNotValid(optionValue), ...ConfigDiagnosticText.rangeUsage()], origin));
+                        const text = [ConfigDiagnosticText.rangeIsNotValid(optionValue), ...ConfigDiagnosticText.rangeUsage()];
+                        onDiagnostics(Diagnostic.error(text, origin));
                     }
                     break;
                 }
                 if ((await Store.validateTag(optionValue)) === false) {
-                    onDiagnostics(Diagnostic.error([
+                    const text = [
                         ConfigDiagnosticText.versionIsNotSupported(optionValue),
-                        ...ConfigDiagnosticText.usage(optionName, optionBrand),
                         ConfigDiagnosticText.inspectSupportedVersions(),
-                    ], origin));
+                    ];
+                    onDiagnostics(Diagnostic.error(text, origin));
                 }
                 break;
             }
@@ -1174,7 +1327,7 @@ class Options {
     }
 }
 
-class CommandLineParser {
+class CommandParser {
     #commandLineOptions;
     #onDiagnostics;
     #options;
@@ -1183,12 +1336,12 @@ class CommandLineParser {
         this.#commandLineOptions = commandLine;
         this.#pathMatch = pathMatch;
         this.#onDiagnostics = onDiagnostics;
-        this.#options = Options.for(OptionGroup.CommandLine);
+        this.#options = Options.for(2);
     }
     #onExpectsValue(optionName, optionBrand) {
         const text = [
             ConfigDiagnosticText.expectsValue(optionName),
-            ...ConfigDiagnosticText.usage(optionName, optionBrand),
+            ConfigDiagnosticText.optionValueMustBe(optionName, optionBrand),
         ];
         this.#onDiagnostics(Diagnostic.error(text));
     }
@@ -1218,18 +1371,18 @@ class CommandLineParser {
     async #parseOptionValue(commandLineArgs, index, optionName, optionDefinition) {
         let optionValue = this.#resolveOptionValue(commandLineArgs[index]);
         switch (optionDefinition.brand) {
-            case OptionBrand.BareTrue:
-                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
+            case "true":
+                await Options.validate(optionName, optionValue, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = true;
                 break;
-            case OptionBrand.Boolean:
-                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
+            case "boolean":
+                await Options.validate(optionName, optionValue, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
                     index++;
                 }
                 break;
-            case OptionBrand.List:
+            case "list":
                 if (optionValue !== "") {
                     const optionValues = optionValue
                         .split(",")
@@ -1237,7 +1390,7 @@ class CommandLineParser {
                         .filter((value) => value !== "")
                         .map((value) => Options.resolve(optionName, value));
                     for (const optionValue of optionValues) {
-                        await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
+                        await Options.validate(optionName, optionValue, this.#onDiagnostics);
                     }
                     this.#commandLineOptions[optionDefinition.name] = optionValues;
                     index++;
@@ -1245,16 +1398,30 @@ class CommandLineParser {
                 }
                 this.#onExpectsValue(optionName, optionDefinition.brand);
                 break;
-            case OptionBrand.String:
+            case "string":
                 if (optionValue !== "") {
                     optionValue = Options.resolve(optionName, optionValue);
-                    await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
+                    await Options.validate(optionName, optionValue, this.#onDiagnostics);
                     this.#commandLineOptions[optionDefinition.name] = optionValue;
                     index++;
                     break;
                 }
                 this.#onExpectsValue(optionName, optionDefinition.brand);
                 break;
+            case "range":
+                if (optionValue !== "") {
+                    const optionValues = [];
+                    for (const range of Target.split(optionValue)) {
+                        await Options.validate(optionName, range, this.#onDiagnostics);
+                        const versions = await Target.expand(range, this.#onDiagnostics);
+                        optionValues.push(...versions);
+                    }
+                    this.#commandLineOptions[optionDefinition.name] = optionValues;
+                    index++;
+                    break;
+                }
+                this.#onExpectsValue(optionName, "string");
+                break;
         }
         return index;
     }
@@ -1276,43 +1443,58 @@ class ConfigParser {
         this.#sourceFile = sourceFile;
         this.#options = Options.for(optionGroup);
     }
-    #onRequiresValue(optionDefinition, jsonNode, isListItem) {
+    #onRequiresValue(optionName, optionBrand, jsonNode, isListItem) {
         const text = isListItem
-            ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
-            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand);
+            ? ConfigDiagnosticText.expectsListItemType(optionName, optionBrand)
+            : ConfigDiagnosticText.optionValueMustBe(optionName, optionBrand);
         this.#onDiagnostics(Diagnostic.error(text, jsonNode.origin));
     }
     async #parseValue(optionDefinition, isListItem = false) {
         let jsonNode;
         let optionValue;
         switch (optionDefinition.brand) {
-            case OptionBrand.Boolean: {
+            case "boolean": {
                 jsonNode = this.#jsonScanner.read();
                 optionValue = jsonNode.getValue();
                 if (typeof optionValue !== "boolean") {
-                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    this.#onRequiresValue(optionDefinition.name, optionDefinition.brand, jsonNode, isListItem);
                     break;
                 }
                 break;
             }
-            case OptionBrand.String: {
+            case "string": {
                 jsonNode = this.#jsonScanner.read();
                 optionValue = jsonNode.getValue();
                 if (typeof optionValue !== "string") {
-                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    this.#onRequiresValue(optionDefinition.name, optionDefinition.brand, jsonNode, isListItem);
                     break;
                 }
                 const rootPath = Path.dirname(this.#sourceFile.fileName);
                 optionValue = Options.resolve(optionDefinition.name, optionValue, rootPath);
-                await Options.validate(optionDefinition.name, optionValue, optionDefinition.brand, this.#onDiagnostics, jsonNode.origin);
+                await Options.validate(optionDefinition.name, optionValue, this.#onDiagnostics, jsonNode.origin);
                 break;
             }
-            case OptionBrand.List: {
+            case "range": {
+                optionValue = [];
+                jsonNode = this.#jsonScanner.read();
+                const ranges = jsonNode.getValue();
+                if (typeof ranges !== "string") {
+                    this.#onRequiresValue(optionDefinition.name, "string", jsonNode, isListItem);
+                    break;
+                }
+                for (const range of Target.split(ranges)) {
+                    await Options.validate(optionDefinition.name, range, this.#onDiagnostics, jsonNode.origin);
+                    const versions = await Target.expand(range, this.#onDiagnostics, jsonNode.origin);
+                    optionValue.push(...versions);
+                }
+                break;
+            }
+            case "list": {
                 optionValue = [];
                 const leftBracketToken = this.#jsonScanner.readToken("[");
                 if (!leftBracketToken.text) {
                     jsonNode = this.#jsonScanner.read();
-                    this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
+                    this.#onRequiresValue(optionDefinition.name, optionDefinition.brand, jsonNode, isListItem);
                     break;
                 }
                 while (!this.#jsonScanner.isRead()) {
@@ -1410,152 +1592,19 @@ class ConfigParser {
 }
 
 const defaultOptions = {
-    checkSourceFiles: true,
-    checkSuppressedErrors: false,
+    checkDeclarationFiles: true,
+    checkSuppressedErrors: true,
     failFast: false,
-    fixtureFileMatch: ["**/__fixtures__/*.{ts,tsx}", "**/fixtures/*.{ts,tsx}"],
-    plugins: [],
-    rejectAnyType: true,
-    rejectNeverType: true,
-    reporters: ["list", "summary"],
-    rootPath: Path.resolve("./"),
-    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
-    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;
-    }
-}
+    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 Config {
     static #onDiagnostics(diagnostic) {
@@ -1564,11 +1613,8 @@ class Config {
     static async parseCommandLine(commandLine) {
         const commandLineOptions = {};
         const pathMatch = [];
-        const commandLineParser = new CommandLineParser(commandLineOptions, pathMatch, Config.#onDiagnostics);
+        const commandLineParser = new CommandParser(commandLineOptions, pathMatch, Config.#onDiagnostics);
         await commandLineParser.parse(commandLine);
-        if (commandLineOptions.target != null) {
-            commandLineOptions.target = await Target.expand(commandLineOptions.target);
-        }
         return { commandLineOptions, pathMatch };
     }
     static async parseConfigFile(filePath) {
@@ -1580,12 +1626,9 @@ class Config {
             const configFileText = await fs.readFile(configFilePath, {
                 encoding: "utf8",
             });
-            const sourceFile = new SourceFile(configFilePath, configFileText);
-            const configFileParser = new ConfigParser(configFileOptions, OptionGroup.ConfigFile, sourceFile, new JsonScanner(sourceFile), Config.#onDiagnostics);
+            const sourceFile = new JsonSourceFile(configFilePath, configFileText);
+            const configFileParser = new ConfigParser(configFileOptions, 4, sourceFile, new JsonScanner(sourceFile), Config.#onDiagnostics);
             await configFileParser.parse();
-            if (configFileOptions.target != null) {
-                configFileOptions.target = await Target.expand(configFileOptions.target);
-            }
         }
         return { configFileOptions, configFilePath };
     }
@@ -1621,12 +1664,30 @@ class DirectiveDiagnosticText {
 
 class Directive {
     static #directiveRegex = /^(\/\/ *@tstyche)( *|-)?(\S*)?( *)?(.*)?/i;
-    static getDirectiveRanges(compiler, sourceFile, position = 0) {
+    static #rangeCache = new WeakMap();
+    static getDirectiveRange(compiler, owner, directiveText) {
+        const directiveRanges = Directive.getDirectiveRanges(compiler, owner.node);
+        return directiveRanges?.find((range) => range.directive?.text === directiveText);
+    }
+    static getDirectiveRanges(compiler, node) {
+        let ranges = Directive.#rangeCache.get(node);
+        if (ranges != null) {
+            return ranges;
+        }
+        let sourceFile;
+        let position = 0;
+        if (compiler.isSourceFile(node)) {
+            sourceFile = node;
+        }
+        else {
+            sourceFile = node.getSourceFile();
+            position = node.getFullStart();
+        }
         const comments = compiler.getLeadingCommentRanges(sourceFile.text, position);
         if (!comments || comments.length === 0) {
             return;
         }
-        const ranges = Object.assign([], { sourceFile });
+        ranges = [];
         for (const comment of comments) {
             if (comment.kind !== compiler.SyntaxKind.SingleLineCommentTrivia) {
                 continue;
@@ -1636,15 +1697,17 @@ class Directive {
                 ranges.push(range);
             }
         }
+        Directive.#rangeCache.set(node, ranges);
         return ranges;
     }
     static async getInlineConfig(ranges) {
         if (!ranges) {
             return;
         }
+        ranges = Array.isArray(ranges) ? ranges : [ranges];
         const inlineConfig = {};
         for (const range of ranges) {
-            await Directive.#parse(inlineConfig, ranges.sourceFile, range);
+            await Directive.#parse(inlineConfig, range);
         }
         return inlineConfig;
     }
@@ -1656,6 +1719,7 @@ class Directive {
             return;
         }
         const range = {
+            sourceFile,
             namespace: { start: comment.pos, end: comment.pos + namespaceText.length, text: namespaceText },
         };
         const directiveSeparatorText = match?.[2];
@@ -1675,45 +1739,61 @@ class Directive {
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["directive:error", { diagnostics: [diagnostic] }]);
     }
-    static async #parse(inlineConfig, sourceFile, ranges) {
-        switch (ranges.directive?.text) {
+    static async #parse(inlineConfig, range) {
+        switch (range.directive?.text) {
             case "if":
                 {
-                    if (!ranges.argument?.text) {
+                    if (!range.argument?.text) {
                         const text = DirectiveDiagnosticText.requiresArgument();
-                        const origin = new DiagnosticOrigin(ranges.namespace.start, ranges.directive.end, sourceFile);
+                        const origin = new DiagnosticOrigin(range.namespace.start, range.directive.end, range.sourceFile);
                         Directive.#onDiagnostics(Diagnostic.error(text, origin));
                         return;
                     }
-                    const value = await Directive.#parseJson(sourceFile, ranges.argument.start, ranges.argument.end);
+                    const value = await Directive.#parseJson(range.sourceFile, range.argument.start, range.argument.end);
                     inlineConfig.if = value;
                 }
                 return;
+            case "fixme":
             case "template":
-                if (ranges.argument?.text != null) {
+                if (range.argument?.text != null) {
                     const text = DirectiveDiagnosticText.doesNotTakeArgument();
-                    const origin = new DiagnosticOrigin(ranges.argument.start, ranges.argument.end, sourceFile);
+                    const origin = new DiagnosticOrigin(range.argument.start, range.argument.end, range.sourceFile);
                     Directive.#onDiagnostics(Diagnostic.error(text, origin));
                 }
-                inlineConfig.template = true;
+                inlineConfig[range.directive?.text] = true;
                 return;
         }
-        const target = ranges?.directive ?? ranges.namespace;
+        const target = range?.directive ?? range.namespace;
         const text = DirectiveDiagnosticText.isNotSupported(target.text);
-        const origin = new DiagnosticOrigin(target.start, target.end, sourceFile);
+        const origin = new DiagnosticOrigin(target.start, target.end, range.sourceFile);
         Directive.#onDiagnostics(Diagnostic.error(text, origin));
     }
     static async #parseJson(sourceFile, start, end) {
         const inlineOptions = {};
-        const configParser = new ConfigParser(inlineOptions, OptionGroup.InlineConditions, sourceFile, new JsonScanner(sourceFile, { start, end }), Directive.#onDiagnostics);
+        const configParser = new ConfigParser(inlineOptions, 8, sourceFile, new JsonScanner(sourceFile, { start, end }), Directive.#onDiagnostics);
         await configParser.parse();
-        if ("target" in inlineOptions) {
-            inlineOptions["target"] = await Target.expand(inlineOptions["target"]);
-        }
         return inlineOptions;
     }
 }
 
+var OptionBrand;
+(function (OptionBrand) {
+    OptionBrand["String"] = "string";
+    OptionBrand["SemverRange"] = "range";
+    OptionBrand["Number"] = "number";
+    OptionBrand["Boolean"] = "boolean";
+    OptionBrand["True"] = "true";
+    OptionBrand["List"] = "list";
+})(OptionBrand || (OptionBrand = {}));
+
+var OptionGroup;
+(function (OptionGroup) {
+    OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
+    OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
+    OptionGroup[OptionGroup["InlineConditions"] = 8] = "InlineConditions";
+    OptionGroup[OptionGroup["ResolvedConfig"] = 6] = "ResolvedConfig";
+})(OptionGroup || (OptionGroup = {}));
+
 class CancellationHandler {
     #cancellationToken;
     #cancellationReason;
@@ -1723,7 +1803,7 @@ class CancellationHandler {
     }
     on([, payload]) {
         if ("diagnostics" in payload) {
-            if (payload.diagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
+            if (payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
                 this.#cancellationToken.cancel(this.#cancellationReason);
             }
         }
@@ -1737,7 +1817,7 @@ class ExitCodeHandler {
             return;
         }
         if ("diagnostics" in payload) {
-            if (payload.diagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
+            if (payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
                 this.#setCode(1);
             }
         }
@@ -1750,49 +1830,65 @@ 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;
     }
 }
 
-var ResultStatus;
-(function (ResultStatus) {
-    ResultStatus["Runs"] = "runs";
-    ResultStatus["Passed"] = "passed";
-    ResultStatus["Failed"] = "failed";
-    ResultStatus["Skipped"] = "skipped";
-    ResultStatus["Todo"] = "todo";
-})(ResultStatus || (ResultStatus = {}));
-
 class ExpectResult {
-    assertion;
-    diagnostics = [];
+    expect;
     parent;
-    status = ResultStatus.Runs;
-    timing = new ResultTiming();
-    constructor(assertion, parent) {
-        this.assertion = assertion;
+    status = "runs";
+    timing = createResultTiming();
+    constructor(expect, parent) {
+        this.expect = expect;
         this.parent = parent;
     }
 }
 
+class FileResult {
+    assertionCounts = createAssertionCounts();
+    file;
+    results = [];
+    suppressedCounts = createSuppressedCounts();
+    status = "runs";
+    testCounts = createTestCounts();
+    timing = createResultTiming();
+    constructor(file) {
+        this.file = file;
+    }
+}
+
 class ProjectResult {
     compilerVersion;
-    diagnostics = [];
     projectConfigFilePath;
     results = [];
     constructor(compilerVersion, projectConfigFilePath) {
@@ -1801,62 +1897,58 @@ class ProjectResult {
     }
 }
 
-class ResultCount {
-    failed = 0;
-    passed = 0;
-    skipped = 0;
-    todo = 0;
-    get total() {
-        return this.failed + this.passed + this.skipped + this.todo;
+class Result {
+    assertionCounts = createAssertionCounts();
+    fileCounts = createFileCounts();
+    files;
+    results = [];
+    suppressedCounts = createSuppressedCounts();
+    targetCounts = createTargetCounts();
+    testCounts = createTestCounts();
+    timing = createResultTiming();
+    constructor(files) {
+        this.files = files;
     }
 }
 
-class Result {
-    expectCount = new ResultCount();
-    fileCount = new ResultCount();
-    results = [];
-    targetCount = new ResultCount();
-    tasks;
-    testCount = new ResultCount();
-    timing = new ResultTiming();
-    constructor(tasks) {
-        this.tasks = tasks;
+var ResultStatus;
+(function (ResultStatus) {
+    ResultStatus["Runs"] = "runs";
+    ResultStatus["Passed"] = "passed";
+    ResultStatus["Matched"] = "matched";
+    ResultStatus["Failed"] = "failed";
+    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 = ResultStatus.Runs;
+    status = "runs";
     target;
-    tasks;
-    timing = new ResultTiming();
-    constructor(target, tasks) {
+    timing = createResultTiming();
+    constructor(target, files) {
         this.target = target;
-        this.tasks = tasks;
-    }
-}
-
-class TaskResult {
-    diagnostics = [];
-    expectCount = new ResultCount();
-    results = [];
-    status = ResultStatus.Runs;
-    task;
-    testCount = new ResultCount();
-    timing = new ResultTiming();
-    constructor(task) {
-        this.task = task;
+        this.files = files;
     }
 }
 
 class TestResult {
-    diagnostics = [];
-    expectCount = new ResultCount();
+    assertionCounts = createAssertionCounts();
     parent;
     results = [];
-    status = ResultStatus.Runs;
+    status = "runs";
     test;
-    timing = new ResultTiming();
+    timing = createResultTiming();
     constructor(test, parent) {
         this.test = test;
         this.parent = parent;
@@ -1866,10 +1958,10 @@ class TestResult {
 class ResultHandler {
     #describeResult;
     #expectResult;
+    #fileResult;
     #projectResult;
     #result;
     #targetResult;
-    #taskResult;
     #testResult;
     on([event, payload]) {
         switch (event) {
@@ -1887,19 +1979,19 @@ class ResultHandler {
                 this.#targetResult.timing.start = Date.now();
                 break;
             case "target:end":
-                if (this.#targetResult.status === ResultStatus.Failed) {
-                    this.#result.targetCount.failed++;
+                if (this.#targetResult.status === "failed") {
+                    this.#result.targetCounts.failed++;
                 }
                 else {
-                    this.#result.targetCount.passed++;
-                    this.#targetResult.status = ResultStatus.Passed;
+                    this.#result.targetCounts.passed++;
+                    this.#targetResult.status = "passed";
                 }
                 this.#targetResult.timing.end = Date.now();
                 this.#targetResult = undefined;
                 break;
             case "store:error":
-                if (payload.diagnostics.some(({ category }) => category === DiagnosticCategory.Error)) {
-                    this.#targetResult.status = ResultStatus.Failed;
+                if (payload.diagnostics.some(({ category }) => category === "error")) {
+                    this.#targetResult.status = "failed";
                 }
                 break;
             case "project:uses": {
@@ -1912,42 +2004,40 @@ class ResultHandler {
                 break;
             }
             case "project:error":
-                this.#targetResult.status = ResultStatus.Failed;
-                this.#projectResult.diagnostics.push(...payload.diagnostics);
+                this.#targetResult.status = "failed";
                 break;
-            case "task:start":
+            case "file:start":
                 this.#projectResult.results.push(payload.result);
-                this.#taskResult = payload.result;
-                this.#taskResult.timing.start = Date.now();
+                this.#fileResult = payload.result;
+                this.#fileResult.timing.start = Date.now();
                 break;
-            case "task:error":
+            case "file:error":
             case "directive:error":
             case "collect:error":
-                this.#targetResult.status = ResultStatus.Failed;
-                this.#taskResult.status = ResultStatus.Failed;
-                this.#taskResult.diagnostics.push(...payload.diagnostics);
+                this.#targetResult.status = "failed";
+                this.#fileResult.status = "failed";
                 break;
-            case "task:end":
-                if (this.#taskResult.status === ResultStatus.Failed ||
-                    this.#taskResult.expectCount.failed > 0 ||
-                    this.#taskResult.testCount.failed > 0) {
-                    this.#result.fileCount.failed++;
-                    this.#targetResult.status = ResultStatus.Failed;
-                    this.#taskResult.status = ResultStatus.Failed;
+            case "file:end":
+                if (this.#fileResult.status === "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.#taskResult.status = ResultStatus.Passed;
+                    this.#result.fileCounts.passed++;
+                    this.#fileResult.status = "passed";
                 }
-                this.#taskResult.timing.end = Date.now();
-                this.#taskResult = undefined;
+                this.#fileResult.timing.end = Date.now();
+                this.#fileResult = undefined;
                 break;
             case "describe:start":
                 if (this.#describeResult) {
                     this.#describeResult.results.push(payload.result);
                 }
                 else {
-                    this.#taskResult.results.push(payload.result);
+                    this.#fileResult.results.push(payload.result);
                 }
                 this.#describeResult = payload.result;
                 this.#describeResult.timing.start = Date.now();
@@ -1961,44 +2051,44 @@ class ResultHandler {
                     this.#describeResult.results.push(payload.result);
                 }
                 else {
-                    this.#taskResult.results.push(payload.result);
+                    this.#fileResult.results.push(payload.result);
                 }
                 this.#testResult = payload.result;
                 this.#testResult.timing.start = Date.now();
                 break;
             case "test:error":
-                this.#result.testCount.failed++;
-                this.#taskResult.testCount.failed++;
-                this.#testResult.status = ResultStatus.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.#taskResult.testCount.failed++;
-                this.#testResult.status = ResultStatus.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.#taskResult.testCount.passed++;
-                this.#testResult.status = ResultStatus.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.#taskResult.testCount.skipped++;
-                this.#testResult.status = ResultStatus.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.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.#taskResult.testCount.todo++;
-                this.#testResult.status = ResultStatus.Todo;
+                this.#result.testCounts.todo++;
+                this.#fileResult.testCounts.todo++;
+                this.#testResult.status = "todo";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
@@ -2007,52 +2097,66 @@ class ResultHandler {
                     this.#testResult.results.push(payload.result);
                 }
                 else {
-                    this.#taskResult.results.push(payload.result);
+                    this.#fileResult.results.push(payload.result);
                 }
                 this.#expectResult = payload.result;
                 this.#expectResult.timing.start = Date.now();
                 break;
             case "expect:error":
-                this.#result.expectCount.failed++;
-                this.#taskResult.expectCount.failed++;
+            case "expect:fail":
+                this.#result.assertionCounts.failed++;
+                this.#fileResult.assertionCounts.failed++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.failed++;
+                    this.#testResult.assertionCounts.failed++;
                 }
-                this.#expectResult.status = ResultStatus.Failed;
-                this.#expectResult.diagnostics.push(...payload.diagnostics);
+                this.#expectResult.status = "failed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            case "expect:fail":
-                this.#result.expectCount.failed++;
-                this.#taskResult.expectCount.failed++;
+            case "expect:pass":
+                this.#result.assertionCounts.passed++;
+                this.#fileResult.assertionCounts.passed++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.failed++;
+                    this.#testResult.assertionCounts.passed++;
                 }
-                this.#expectResult.status = ResultStatus.Failed;
+                this.#expectResult.status = "passed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            case "expect:pass":
-                this.#result.expectCount.passed++;
-                this.#taskResult.expectCount.passed++;
+            case "expect:skip":
+                this.#result.assertionCounts.skipped++;
+                this.#fileResult.assertionCounts.skipped++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.passed++;
+                    this.#testResult.assertionCounts.skipped++;
                 }
-                this.#expectResult.status = ResultStatus.Passed;
+                this.#expectResult.status = "skipped";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
-            case "expect:skip":
-                this.#result.expectCount.skipped++;
-                this.#taskResult.expectCount.skipped++;
+            case "expect:fixme":
+                this.#result.assertionCounts.fixme++;
+                this.#fileResult.assertionCounts.fixme++;
                 if (this.#testResult) {
-                    this.#testResult.expectCount.skipped++;
+                    this.#testResult.assertionCounts.fixme++;
                 }
-                this.#expectResult.status = ResultStatus.Skipped;
+                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;
         }
     }
 }
@@ -2078,7 +2182,7 @@ function Text({ children, color, indent }) {
     if (color != null) {
         ansiEscapes.push(color);
     }
-    return (jsx("text", { indent: indent ?? 0, children: [ansiEscapes.length > 0 ? jsx("ansi", { escapes: ansiEscapes }) : undefined, children, ansiEscapes.length > 0 ? jsx("ansi", { escapes: Color.Reset }) : undefined] }));
+    return (jsx("text", { indent: indent ?? 0, children: [ansiEscapes.length > 0 ? jsx("ansi", { escapes: ansiEscapes }) : undefined, children, ansiEscapes.length > 0 ? jsx("ansi", { escapes: "0" }) : undefined] }));
 }
 
 function Line({ children, color, indent }) {
@@ -2139,7 +2243,7 @@ class Scribbler {
 }
 
 function addsPackageText(packageVersion, packagePath) {
-    return (jsx(Line, { children: [jsx(Text, { color: Color.Gray, children: "adds" }), " TypeScript ", packageVersion, jsx(Text, { color: Color.Gray, children: [" to ", packagePath] })] }));
+    return (jsx(Line, { children: [jsx(Text, { color: "90", children: "adds" }), " TypeScript ", packageVersion, jsx(Text, { color: "90", children: [" to ", packagePath] })] }));
 }
 
 function describeNameText(name, indent = 0) {
@@ -2155,13 +2259,13 @@ function BreadcrumbsText({ ancestor }) {
         ancestor = ancestor.parent;
     }
     text.push("");
-    return jsx(Text, { color: Color.Gray, children: text.reverse().join(" ❭ ") });
+    return jsx(Text, { color: "90", children: text.reverse().join(" ❭ ") });
 }
-function CodeLineText({ gutterWidth, lineNumber, lineNumberColor = Color.Gray, lineText }) {
-    return (jsx(Line, { children: [jsx(Text, { color: lineNumberColor, children: lineNumber.toString().padStart(gutterWidth) }), jsx(Text, { color: Color.Gray, children: " | " }), lineText] }));
+function CodeLineText({ gutterWidth, lineNumber, lineNumberColor = "90", lineText }) {
+    return (jsx(Line, { children: [jsx(Text, { color: lineNumberColor, children: lineNumber.toString().padStart(gutterWidth) }), jsx(Text, { color: "90", children: " | " }), lineText] }));
 }
 function SquiggleLineText({ gutterWidth, indentWidth = 0, squiggleColor, squiggleWidth }) {
-    return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: Color.Gray, children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: squiggleColor, children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
+    return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: "90", children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: squiggleColor, children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
 }
 function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
     const linesAbove = options?.linesAbove ?? 2;
@@ -2175,11 +2279,11 @@ function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
     const gutterWidth = (lastLine + 1).toString().length + 2;
     let highlightColor;
     switch (diagnosticCategory) {
-        case DiagnosticCategory.Error:
-            highlightColor = Color.Red;
+        case "error":
+            highlightColor = "31";
             break;
-        case DiagnosticCategory.Warning:
-            highlightColor = Color.Yellow;
+        case "warning":
+            highlightColor = "33";
             break;
     }
     const codeFrame = [];
@@ -2207,15 +2311,15 @@ function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
         }
     }
     let breadcrumbs;
-    if (showBreadcrumbs && diagnosticOrigin.assertion != null) {
-        breadcrumbs = jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertion.parent });
+    if (showBreadcrumbs && diagnosticOrigin.assertionNode != null) {
+        breadcrumbs = jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertionNode.parent });
     }
-    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: Color.Gray, children: " at " }), jsx(Text, { color: Color.Cyan, children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: Color.Gray, children: `:${firstMarkedLine + 1}:${firstMarkedLineCharacter + 1}` }), breadcrumbs] }));
+    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: `:${firstMarkedLine + 1}:${firstMarkedLineCharacter + 1}` }), breadcrumbs] }));
     return (jsx(Text, { children: [codeFrame, jsx(Line, {}), location] }));
 }
 
 function DiagnosticText({ codeFrameOptions, diagnostic }) {
-    const code = diagnostic.code ? jsx(Text, { color: Color.Gray, children: [" ", diagnostic.code] }) : undefined;
+    const code = diagnostic.code ? jsx(Text, { color: "90", children: [" ", diagnostic.code] }) : undefined;
     const text = Array.isArray(diagnostic.text) ? diagnostic.text : [diagnostic.text];
     const message = text.map((text, index) => (jsx(Text, { children: [index === 1 ? jsx(Line, {}) : undefined, jsx(Line, { children: [text, index === 0 ? code : undefined] })] })));
     const related = diagnostic.related?.map((relatedDiagnostic) => jsx(DiagnosticText, { diagnostic: relatedDiagnostic }));
@@ -2225,16 +2329,63 @@ function DiagnosticText({ codeFrameOptions, diagnostic }) {
 function diagnosticText(diagnostic, codeFrameOptions = {}) {
     let prefix;
     switch (diagnostic.category) {
-        case DiagnosticCategory.Error:
-            prefix = jsx(Text, { color: Color.Red, children: "Error: " });
+        case "error":
+            prefix = jsx(Text, { color: "31", children: "Error: " });
             break;
-        case DiagnosticCategory.Warning:
-            prefix = jsx(Text, { color: Color.Yellow, children: "Warning: " });
+        case "warning":
+            prefix = jsx(Text, { color: "33", children: "Warning: " });
             break;
     }
     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("/");
+    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
+    const fileNameText = relativePath.slice(lastPathSeparator + 1);
+    return (jsx(Text, { children: [jsx(Text, { color: "90", children: directoryNameText }), fileNameText] }));
+}
+function fileStatusText(status, file) {
+    let statusText;
+    switch (status) {
+        case "runs":
+            statusText = "runs";
+            break;
+        case "passed":
+            statusText = "pass";
+            break;
+        case "failed":
+            statusText = "fail";
+            break;
+    }
+    return (jsx(Line, { children: [jsx(Text, { color: getStatusColor(status), children: statusText }), " ", jsx(FileNameText, { filePath: file.path })] }));
+}
+
 function fileViewText(lines, addEmptyFinalLine) {
     return (jsx(Text, { children: [[...lines], addEmptyFinalLine ? jsx(Line, {}) : undefined] }));
 }
@@ -2258,13 +2409,13 @@ function formattedText(input) {
 }
 
 function HintText({ children }) {
-    return (jsx(Text, { indent: 1, color: Color.Gray, children: children }));
+    return (jsx(Text, { indent: 1, color: "90", children: children }));
 }
 function HelpHeaderText({ tstycheVersion }) {
     return (jsx(Line, { children: ["The TSTyche Type Test Runner", jsx(HintText, { children: tstycheVersion })] }));
 }
 function CommandText({ hint, text }) {
-    return (jsx(Line, { indent: 1, children: [jsx(Text, { color: Color.Blue, children: text }), hint && jsx(HintText, { children: hint })] }));
+    return (jsx(Line, { indent: 1, children: [jsx(Text, { color: "34", children: text }), hint && jsx(HintText, { children: hint })] }));
 }
 function OptionDescriptionText({ text }) {
     return jsx(Line, { indent: 1, children: text });
@@ -2272,8 +2423,8 @@ function OptionDescriptionText({ text }) {
 function CommandLineUsageText() {
     const usage = [
         ["tstyche", "Run all tests."],
-        ["tstyche path/to/first.test.ts", "Only run the test files with matching path."],
-        ["tstyche --target 5.3,5.6.2,current", "Test on all specified versions of TypeScript."],
+        ["tstyche query-params", "Only run the matching test file."],
+        ["tstyche --target '5.3 || 5.5.2 || >=5.7'", "Test against specific versions of TypeScript."],
     ];
     const usageText = usage.map(([commandText, descriptionText]) => (jsx(Line, { children: [jsx(CommandText, { text: commandText }), jsx(OptionDescriptionText, { text: descriptionText })] })));
     return jsx(Text, { children: usageText });
@@ -2282,16 +2433,19 @@ function CommandLineOptionNameText({ text }) {
     return jsx(Text, { children: `--${text}` });
 }
 function CommandLineOptionHintText({ definition }) {
-    if (definition.brand === OptionBrand.List) {
+    if (definition.brand === "list") {
         return jsx(Text, { children: `${definition.brand} of ${definition.items.brand}s` });
     }
+    if (definition.brand === "range") {
+        return jsx(Text, { children: "string" });
+    }
     return jsx(Text, { children: definition.brand });
 }
 function CommandLineOptionsText({ optionDefinitions }) {
     const definitions = [...optionDefinitions.values()];
     const optionsText = definitions.map((definition) => {
         let hint;
-        if (definition.brand !== OptionBrand.BareTrue) {
+        if (definition.brand !== "true") {
             hint = jsx(CommandLineOptionHintText, { definition: definition });
         }
         return (jsx(Text, { children: [jsx(CommandText, { text: jsx(CommandLineOptionNameText, { text: definition.name }), hint: hint }), jsx(OptionDescriptionText, { text: definition.description }), jsx(Line, {})] }));
@@ -2340,69 +2494,60 @@ class OutputService {
 function RowText({ label, text }) {
     return (jsx(Line, { children: [`${label}:`.padEnd(12), text] }));
 }
-function CountText({ failed, passed, skipped, todo, total }) {
-    return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: Color.Red, children: [failed, " failed"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: Color.Yellow, children: [skipped, " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: Color.Magenta, children: [todo, " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: Color.Green, 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, 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, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
-    const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
-    const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, 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 FileNameText({ filePath }) {
-    const relativePath = Path.relative("", filePath);
-    const lastPathSeparator = relativePath.lastIndexOf("/");
-    const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
-    const fileNameText = relativePath.slice(lastPathSeparator + 1);
-    return (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: directoryNameText }), fileNameText] }));
-}
-function taskStatusText(status, task) {
-    let statusColor;
+function testNameText(status, name, indent = 0) {
     let statusText;
     switch (status) {
-        case ResultStatus.Runs:
-            statusColor = Color.Yellow;
-            statusText = "runs";
+        case "passed":
+            statusText = "+";
             break;
-        case ResultStatus.Passed:
-            statusColor = Color.Green;
-            statusText = "pass";
+        case "failed":
+            statusText = "×";
             break;
-        case ResultStatus.Failed:
-            statusColor = Color.Red;
-            statusText = "fail";
+        case "skipped":
+            statusText = "- skip";
+            break;
+        case "fixme":
+            statusText = "- fixme";
             break;
-    }
-    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: task.filePath })] }));
-}
-
-function StatusText({ status }) {
-    switch (status) {
-        case "fail":
-            return jsx(Text, { color: Color.Red, children: "\u00D7" });
-        case "pass":
-            return jsx(Text, { color: Color.Green, children: "+" });
-        case "skip":
-            return jsx(Text, { color: Color.Yellow, children: "- skip" });
         case "todo":
-            return jsx(Text, { color: Color.Magenta, 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: Color.Gray, 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) {
     let projectConfigPathText;
     if (projectConfigFilePath != null) {
-        projectConfigPathText = (jsx(Text, { color: Color.Gray, children: [" with ", Path.relative("", projectConfigFilePath)] }));
+        projectConfigPathText = (jsx(Text, { color: "90", children: [" with ", Path.relative("", projectConfigFilePath)] }));
     }
-    return (jsx(Text, { children: [options?.prependEmptyLine ? jsx(Line, {}) : undefined, jsx(Line, { children: [jsx(Text, { color: Color.Blue, children: "uses" }), " TypeScript ", compilerVersion, projectConfigPathText] }), jsx(Line, {})] }));
+    return (jsx(Text, { children: [options?.prependEmptyLine ? jsx(Line, {}) : undefined, jsx(Line, { children: [jsx(Text, { color: "34", children: "uses" }), " TypeScript ", compilerVersion, projectConfigPathText] }), jsx(Line, {})] }));
 }
 
 function waitingForFileChangesText() {
@@ -2415,7 +2560,7 @@ function watchUsageText() {
         ["x", "to exit."],
     ];
     const usageText = usage.map(([keyText, actionText]) => {
-        return (jsx(Line, { children: [jsx(Text, { color: Color.Gray, children: "Press" }), jsx(Text, { children: ` ${keyText} ` }), jsx(Text, { color: Color.Gray, children: actionText })] }));
+        return (jsx(Line, { children: [jsx(Text, { color: "90", children: "Press" }), jsx(Text, { children: ` ${keyText} ` }), jsx(Text, { color: "90", children: actionText })] }));
     });
     return jsx(Text, { children: usageText });
 }
@@ -2492,7 +2637,7 @@ class ListReporter extends BaseReporter {
     on([event, payload]) {
         switch (event) {
             case "run:start":
-                this.#isFileViewExpanded = payload.result.tasks.length === 1 && this.resolvedConfig.watch !== true;
+                this.#isFileViewExpanded = payload.result.files.length === 1 && this.resolvedConfig.watch !== true;
                 break;
             case "store:adds":
                 OutputService.writeMessage(addsPackageText(payload.packageVersion, payload.packagePath));
@@ -2504,7 +2649,7 @@ class ListReporter extends BaseReporter {
                 }
                 break;
             case "target:start":
-                this.#fileCount = payload.result.tasks.length;
+                this.#fileCount = payload.result.files.length;
                 this.#hasReportedUses = false;
                 break;
             case "project:uses":
@@ -2519,25 +2664,26 @@ class ListReporter extends BaseReporter {
                     OutputService.writeError(diagnosticText(diagnostic));
                 }
                 break;
-            case "task:start":
+            case "file:start":
                 if (!environmentOptions.noInteractive) {
-                    OutputService.writeMessage(taskStatusText(payload.result.status, payload.result.task));
+                    OutputService.writeMessage(fileStatusText(payload.result.status, payload.result.file));
                 }
                 this.#fileCount--;
                 this.#hasReportedError = false;
                 break;
-            case "task:error":
+            case "file:error":
             case "directive:error":
             case "collect:error":
+            case "suppressed:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
                 break;
-            case "task:end":
+            case "file:end":
                 if (!environmentOptions.noInteractive) {
                     OutputService.eraseLastLine();
                 }
-                OutputService.writeMessage(taskStatusText(payload.result.status, payload.result.task));
+                OutputService.writeMessage(fileStatusText(payload.result.status, payload.result.file));
                 OutputService.writeMessage(this.#fileView.getViewText({ appendEmptyLine: this.#isLastFile }));
                 if (this.#fileView.hasErrors) {
                     OutputService.writeError(this.#fileView.getMessages());
@@ -2557,7 +2703,12 @@ 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":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("fixme", payload.result.test.name);
                 }
                 break;
             case "test:todo":
@@ -2567,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));
@@ -2575,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":
@@ -2602,10 +2753,10 @@ class SetupReporter {
         if ("diagnostics" in payload) {
             for (const diagnostic of payload.diagnostics) {
                 switch (diagnostic.category) {
-                    case DiagnosticCategory.Error:
+                    case "error":
                         OutputService.writeError(diagnosticText(diagnostic));
                         break;
-                    case DiagnosticCategory.Warning:
+                    case "warning":
                         OutputService.writeWarning(diagnosticText(diagnostic));
                         break;
                 }
@@ -2621,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,
             }));
         }
     }
@@ -2651,18 +2803,18 @@ class WatchReporter extends BaseReporter {
     }
 }
 
-class Task {
-    filePath;
+class FileLocation {
+    path;
     position;
-    constructor(filePath, position) {
-        this.filePath = Path.resolve(this.#toPath(filePath));
+    constructor(file, position) {
+        this.path = Path.resolve(this.#toPath(file));
         this.position = position;
     }
-    #toPath(filePath) {
-        if (typeof filePath === "string" && !filePath.startsWith("file:")) {
-            return filePath;
+    #toPath(file) {
+        if (typeof file === "string" && !file.startsWith("file:")) {
+            return file;
         }
-        return fileURLToPath(filePath);
+        return fileURLToPath(file);
     }
 }
 
@@ -3000,9 +3152,9 @@ class WatchService {
     #resolvedConfig;
     #watchedTestFiles;
     #watchers = [];
-    constructor(resolvedConfig, tasks) {
+    constructor(resolvedConfig, files) {
         this.#resolvedConfig = resolvedConfig;
-        this.#watchedTestFiles = new Map(tasks.map((task) => [task.filePath, task]));
+        this.#watchedTestFiles = new Map(files.map((file) => [file.path, file]));
     }
     #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["watch:error", { diagnostics: [diagnostic] }]);
@@ -3031,7 +3183,7 @@ class WatchService {
                     case "\u001B":
                     case "q":
                     case "x":
-                        onClose(CancellationReason.WatchClose);
+                        onClose("watchClose");
                         break;
                     case "\u000D":
                     case "\u0020":
@@ -3047,14 +3199,14 @@ class WatchService {
         }
         const onChangedFile = (filePath) => {
             debounce.refresh();
-            let task = this.#watchedTestFiles.get(filePath);
-            if (task != null) {
-                this.#changedTestFiles.set(filePath, task);
+            let file = this.#watchedTestFiles.get(filePath);
+            if (file != null) {
+                this.#changedTestFiles.set(filePath, file);
             }
             else if (Select.isTestFile(filePath, this.#resolvedConfig)) {
-                task = new Task(filePath);
-                this.#changedTestFiles.set(filePath, task);
-                this.#watchedTestFiles.set(filePath, task);
+                file = new FileLocation(filePath);
+                this.#changedTestFiles.set(filePath, file);
+                this.#watchedTestFiles.set(filePath, file);
             }
         };
         const onRemovedFile = (filePath) => {
@@ -3067,7 +3219,7 @@ class WatchService {
         };
         this.#watchers.push(new Watcher(this.#resolvedConfig.rootPath, onChangedFile, onRemovedFile, { recursive: true }));
         const onChangedConfigFile = () => {
-            onClose(CancellationReason.ConfigChange);
+            onClose("configChange");
         };
         this.#watchers.push(new FileWatcher(this.#resolvedConfig.configFilePath, onChangedConfigFile));
         for (const watcher of this.#watchers) {
@@ -3082,67 +3234,28 @@ class WatchService {
     }
 }
 
-class TestTreeNode {
-    brand;
-    children = [];
-    diagnostics = new Set();
-    flags;
-    name = "";
-    node;
-    parent;
-    constructor(compiler, brand, node, parent, flags) {
-        this.brand = brand;
-        this.node = node;
-        this.parent = parent;
-        this.flags = flags;
-        if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
-            this.name = node.arguments[0].text;
-        }
-        if (node.arguments[1] != null && compiler.isFunctionLike(node.arguments[1])) {
-            for (const diagnostic of parent.diagnostics) {
-                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
-                    this.diagnostics.add(diagnostic);
-                    parent.diagnostics.delete(diagnostic);
-                }
-            }
-        }
-    }
-    getDirectiveRanges(compiler) {
-        return Directive.getDirectiveRanges(compiler, this.node.getSourceFile(), this.node.getFullStart());
+function compareDiagnostics(a, b) {
+    if (a.file?.fileName !== b.file?.fileName) {
+        return false;
     }
+    return deepCompareKeys(a, b, ["start", "length", "code", "messageText"]);
 }
-
-class AssertionNode extends TestTreeNode {
-    abilityDiagnostics = new Set();
-    isNot;
-    matcherNode;
-    matcherNameNode;
-    modifierNode;
-    notNode;
-    source;
-    target;
-    constructor(compiler, brand, node, parent, flags, matcherNode, matcherNameNode, modifierNode, notNode) {
-        super(compiler, brand, node, parent, flags);
-        this.isNot = notNode != null;
-        this.matcherNode = matcherNode;
-        this.matcherNameNode = matcherNameNode;
-        this.modifierNode = modifierNode;
-        this.source = this.node.typeArguments ?? this.node.arguments;
-        if (compiler.isCallExpression(this.matcherNode)) {
-            this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
-        }
-        for (const diagnostic of parent.diagnostics) {
-            if (diagnosticBelongsToNode(diagnostic, this.source) ||
-                (this.target != null && diagnosticBelongsToNode(diagnostic, this.target))) {
-                this.diagnostics.add(diagnostic);
-                parent.diagnostics.delete(diagnostic);
-            }
+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;
         }
     }
-}
-
-function nodeBelongsToArgumentList(compiler, node) {
-    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+    return true;
 }
 function nodeIsChildOfExpressionStatement(compiler, node) {
     return compiler.isExpressionStatement(node.parent);
@@ -3150,59 +3263,170 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
-    #expectErrorRegex = /^( *)(\/\/ *@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;
+        this.#editor = editor;
     }
-    #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)}`;
+    #belongsToNode(node, diagnostic) {
+        switch (node.brand) {
+            case "expect":
+                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 = [];
     }
-    #belongsToNode(diagnostic) {
+    #mapToNodes(diagnostic) {
         for (const node of this.#nodes) {
-            if (diagnosticBelongsToNode(diagnostic, "matcherNode" in node ? node.matcherNode : node.actionNode)) {
+            if (this.#belongsToNode(node, diagnostic)) {
                 node.abilityDiagnostics.add(diagnostic);
-                return true;
+                break;
             }
         }
-        return false;
     }
-    #belongsToDirective(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);
         }
     }
-    #collectSuppressedErrors() {
+}
+
+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(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];
@@ -3225,125 +3449,89 @@ class AbilityLayer {
         }
         return ranges;
     }
-    close() {
-        if (this.#nodes.length > 0 || this.#suppressedErrorsMap != null) {
-            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.#belongsToNode(diagnostic)) {
-                        continue;
-                    }
-                    this.#belongsToDirective(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("");
-    }
-    handleAssertion(assertionNode) {
-        const expectStart = assertionNode.node.getStart();
-        const expectExpressionEnd = assertionNode.node.expression.getEnd();
-        const expectEnd = assertionNode.node.getEnd();
-        const matcherNameEnd = assertionNode.matcherNameNode.getEnd();
-        switch (assertionNode.matcherNameNode.name.text) {
-            case "toBeApplicable":
-                this.#addRanges(assertionNode, [
-                    { start: expectStart, end: expectExpressionEnd },
-                    { start: expectEnd, end: matcherNameEnd },
-                ]);
-                break;
-            case "toBeCallableWith":
-                this.#eraseTrailingComma(assertionNode.source, assertionNode);
-                this.#addRanges(assertionNode, [
-                    {
-                        start: expectStart,
-                        end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.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(assertionNode.source, assertionNode);
-                this.#addRanges(assertionNode, [
-                    {
-                        start: expectStart,
-                        end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.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 = Object.assign(suppressedErrors, { sourceFile: testTree.sourceFile });
+            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 {
@@ -3352,22 +3540,61 @@ class CollectDiagnosticText {
     }
 }
 
-var TestTreeNodeBrand;
-(function (TestTreeNodeBrand) {
-    TestTreeNodeBrand["Describe"] = "describe";
-    TestTreeNodeBrand["Test"] = "test";
-    TestTreeNodeBrand["Expect"] = "expect";
-    TestTreeNodeBrand["When"] = "when";
-})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+class TestTreeNode {
+    brand;
+    children = [];
+    diagnostics = new Set();
+    flags;
+    name = "";
+    node;
+    parent;
+    constructor(compiler, brand, node, parent, flags) {
+        this.brand = brand;
+        this.node = node;
+        this.parent = parent;
+        this.flags = flags;
+        if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
+            this.name = node.arguments[0].text;
+        }
+        if (node.arguments[1] != null && compiler.isFunctionLike(node.arguments[1])) {
+            for (const diagnostic of parent.diagnostics) {
+                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
+                    this.diagnostics.add(diagnostic);
+                    parent.diagnostics.delete(diagnostic);
+                }
+            }
+        }
+    }
+}
 
-var TestTreeNodeFlags;
-(function (TestTreeNodeFlags) {
-    TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
-    TestTreeNodeFlags[TestTreeNodeFlags["Fail"] = 1] = "Fail";
-    TestTreeNodeFlags[TestTreeNodeFlags["Only"] = 2] = "Only";
-    TestTreeNodeFlags[TestTreeNodeFlags["Skip"] = 4] = "Skip";
-    TestTreeNodeFlags[TestTreeNodeFlags["Todo"] = 8] = "Todo";
-})(TestTreeNodeFlags || (TestTreeNodeFlags = {}));
+class ExpectNode extends TestTreeNode {
+    abilityDiagnostics = new Set();
+    isNot;
+    matcherNode;
+    matcherNameNode;
+    modifierNode;
+    notNode;
+    source;
+    target;
+    constructor(compiler, brand, node, parent, flags, matcherNode, matcherNameNode, modifierNode, notNode) {
+        super(compiler, brand, node, parent, flags);
+        this.isNot = notNode != null;
+        this.matcherNode = matcherNode;
+        this.matcherNameNode = matcherNameNode;
+        this.modifierNode = modifierNode;
+        this.source = this.node.typeArguments ?? this.node.arguments;
+        if (compiler.isCallExpression(this.matcherNode)) {
+            this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        }
+        for (const diagnostic of parent.diagnostics) {
+            if (diagnosticBelongsToNode(diagnostic, this.source) ||
+                (this.target != null && diagnosticBelongsToNode(diagnostic, this.target))) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
+    }
+}
 
 class IdentifierLookup {
     #compiler;
@@ -3416,24 +3643,21 @@ class IdentifierLookup {
         };
     }
     resolveTestTreeNodeMeta(node) {
-        let flags = TestTreeNodeFlags.None;
+        let flags = 0;
         let expression = node.expression;
         while (this.#compiler.isPropertyAccessExpression(expression)) {
             if (expression.expression.getText() === this.#identifiers.namespace) {
                 break;
             }
             switch (expression.name.getText()) {
-                case "fail":
-                    flags |= TestTreeNodeFlags.Fail;
-                    break;
                 case "only":
-                    flags |= TestTreeNodeFlags.Only;
+                    flags |= 1;
                     break;
                 case "skip":
-                    flags |= TestTreeNodeFlags.Skip;
+                    flags |= 2;
                     break;
                 case "todo":
-                    flags |= TestTreeNodeFlags.Todo;
+                    flags |= 4;
                     break;
             }
             expression = expression.expression;
@@ -3451,14 +3675,14 @@ class IdentifierLookup {
         }
         switch (identifier) {
             case "describe":
-                return { brand: TestTreeNodeBrand.Describe, flags, identifier };
+                return { brand: "describe", flags, identifier };
             case "it":
             case "test":
-                return { brand: TestTreeNodeBrand.Test, flags, identifier };
+                return { brand: "test", flags, identifier };
             case "expect":
-                return { brand: TestTreeNodeBrand.Expect, flags, identifier };
+                return { brand: "expect", flags, identifier };
             case "when":
-                return { brand: TestTreeNodeBrand.When, flags, identifier };
+                return { brand: "when", flags, identifier };
         }
         return;
     }
@@ -3474,9 +3698,6 @@ class TestTree {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
     }
-    getDirectiveRanges(compiler) {
-        return Directive.getDirectiveRanges(compiler, this.sourceFile);
-    }
 }
 
 class WhenNode extends TestTreeNode {
@@ -3499,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) {
@@ -3514,7 +3735,7 @@ class CollectService {
                 if (!this.#checkNode(node, meta, parent)) {
                     return;
                 }
-                if (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test) {
+                if (meta.brand === "describe" || meta.brand === "test") {
                     const testTreeNode = new TestTreeNode(this.#compiler, meta.brand, node, parent, meta.flags);
                     this.#compiler.forEachChild(node, (node) => {
                         this.#collectTestTreeNodes(node, testTreeNode, testTree);
@@ -3522,7 +3743,7 @@ class CollectService {
                     this.#onNode(testTreeNode, parent, testTree);
                     return;
                 }
-                if (meta.brand === TestTreeNodeBrand.Expect) {
+                if (meta.brand === "expect") {
                     const modifierNode = this.#getChainedNode(node, "type");
                     if (!modifierNode) {
                         return;
@@ -3536,15 +3757,15 @@ class CollectService {
                     if (!matcherNode) {
                         return;
                     }
-                    const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
-                    this.#abilityLayer.handleAssertion(assertionNode);
+                    const expectNode = new ExpectNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
+                    this.#layers.visit(expectNode);
                     this.#compiler.forEachChild(node, (node) => {
-                        this.#collectTestTreeNodes(node, assertionNode, testTree);
+                        this.#collectTestTreeNodes(node, expectNode, testTree);
                     });
-                    this.#onNode(assertionNode, parent, testTree);
+                    this.#onNode(expectNode, parent, testTree);
                     return;
                 }
-                if (meta.brand === TestTreeNodeBrand.When) {
+                if (meta.brand === "when") {
                     const actionNameNode = this.#getChainedNode(node);
                     if (!actionNameNode) {
                         return;
@@ -3556,7 +3777,7 @@ class CollectService {
                     this.#compiler.forEachChild(actionNode, (node) => {
                         if (this.#compiler.isCallExpression(node)) {
                             const meta = this.#identifierLookup.resolveTestTreeNodeMeta(node);
-                            if (meta?.brand === TestTreeNodeBrand.Describe || meta?.brand === TestTreeNodeBrand.Test) {
+                            if (meta?.brand === "describe" || meta?.brand === "test") {
                                 const text = CollectDiagnosticText.cannotBeNestedWithin(meta.identifier, "when");
                                 const origin = DiagnosticOrigin.fromNode(node);
                                 this.#onDiagnostics(Diagnostic.error(text, origin));
@@ -3564,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;
                 }
@@ -3581,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();
+        this.#layers.close();
         EventEmitter.dispatch(["collect:end", { tree: testTree }]);
         return testTree;
     }
@@ -3599,15 +3820,15 @@ class CollectService {
     }
     #isNodeAllowed(meta, parent) {
         switch (meta.brand) {
-            case TestTreeNodeBrand.Describe:
-            case TestTreeNodeBrand.Test:
-                if (parent.brand === TestTreeNodeBrand.Test || parent.brand === TestTreeNodeBrand.Expect) {
+            case "describe":
+            case "test":
+                if (parent.brand === "test" || parent.brand === "expect") {
                     return false;
                 }
                 break;
-            case TestTreeNodeBrand.Expect:
-            case TestTreeNodeBrand.When:
-                if (parent.brand === TestTreeNodeBrand.Describe) {
+            case "expect":
+            case "when":
+                if (parent.brand === "describe") {
                     return false;
                 }
                 break;
@@ -3646,13 +3867,33 @@ class CollectService {
     }
     #onNode(node, parent, testTree) {
         parent.children.push(node);
-        if (node.flags & TestTreeNodeFlags.Only) {
+        if (node.flags & 1) {
             testTree.hasOnly = true;
         }
         EventEmitter.dispatch(["collect:node", { node }]);
     }
 }
 
+function nodeBelongsToArgumentList(compiler, node) {
+    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+}
+
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+    TestTreeNodeBrand["When"] = "when";
+})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+
+var TestTreeNodeFlags;
+(function (TestTreeNodeFlags) {
+    TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
+    TestTreeNodeFlags[TestTreeNodeFlags["Only"] = 1] = "Only";
+    TestTreeNodeFlags[TestTreeNodeFlags["Skip"] = 2] = "Skip";
+    TestTreeNodeFlags[TestTreeNodeFlags["Todo"] = 4] = "Todo";
+})(TestTreeNodeFlags || (TestTreeNodeFlags = {}));
+
 class ProjectService {
     #compiler;
     #lastSeenProject = "";
@@ -3700,11 +3941,10 @@ class ProjectService {
     }
     closeFile(filePath) {
         this.#service.closeClientFile(filePath);
+        SourceService.delete(filePath);
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
-            allowJs: true,
-            checkJs: true,
             exactOptionalPropertyTypes: true,
             jsx: this.#compiler.JsxEmit.Preserve,
             module: this.#compiler.ModuleKind.NodeNext,
@@ -3726,11 +3966,20 @@ class ProjectService {
     getDefaultProject(filePath) {
         const project = this.#service.getDefaultProjectForFile(this.#compiler.server.toNormalizedPath(filePath), true);
         const compilerOptions = project?.getCompilerOptions();
-        if (this.#resolvedConfig.checkSourceFiles && compilerOptions?.skipLibCheck) {
+        if (this.#resolvedConfig.checkDeclarationFiles && compilerOptions?.skipLibCheck) {
             project?.setCompilerOptions({ ...compilerOptions, skipLibCheck: false });
         }
         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);
@@ -3740,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;
@@ -3752,19 +4001,19 @@ 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([
                 "project:uses",
                 { compilerVersion: this.#compiler.version, projectConfigFilePath: configFileName },
             ]);
-        }
-        if (configFileErrors && configFileErrors.length > 0) {
-            EventEmitter.dispatch([
-                "project:error",
-                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors) },
-            ]);
+            if (configFileErrors && configFileErrors.length > 0) {
+                EventEmitter.dispatch([
+                    "project:error",
+                    { diagnostics: Diagnostic.fromDiagnostics(configFileErrors) },
+                ]);
+            }
         }
         if (!this.#seenTestFiles.has(filePath)) {
             this.#seenTestFiles.add(filePath);
@@ -3778,13 +4027,16 @@ class ProjectService {
                 if (program.isSourceFileFromExternalLibrary(sourceFile) || program.isSourceFileDefaultLibrary(sourceFile)) {
                     return false;
                 }
+                if (this.#resolvedConfig.checkDeclarationFiles && sourceFile.isDeclarationFile) {
+                    return true;
+                }
                 if (Select.isFixtureFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
                     return true;
                 }
                 if (Select.isTestFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
                     return false;
                 }
-                return this.#resolvedConfig.checkSourceFiles;
+                return false;
             });
             const diagnostics = [];
             for (const sourceFile of sourceFilesToCheck) {
@@ -3817,50 +4069,65 @@ class SuppressedDiagnosticText {
 }
 
 class SuppressedService {
-    match(suppressedErrors, onDiagnostics) {
-        for (const suppressedError of suppressedErrors) {
-            if (suppressedError.diagnostics.length === 0 || suppressedError.ignore) {
+    match(testTree) {
+        if (!testTree.suppressedErrors) {
+            return;
+        }
+        for (const suppressedError of testTree.suppressedErrors) {
+            const suppressedResult = new SuppressedResult(suppressedError);
+            if (suppressedError.diagnostics.length === 0) {
                 continue;
             }
-            if (!suppressedError.argument?.text) {
-                const text = SuppressedDiagnosticText.directiveRequires();
-                const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, suppressedErrors.sourceFile);
-                onDiagnostics([Diagnostic.error(text, origin)]);
+            if (suppressedError.ignore) {
+                EventEmitter.dispatch(["suppressed:ignore", { result: suppressedResult }]);
                 continue;
             }
             const related = [
                 Diagnostic.error(SuppressedDiagnosticText.suppressedError(suppressedError.diagnostics.length)),
-                ...Diagnostic.fromDiagnostics(suppressedError.diagnostics, suppressedErrors.sourceFile),
+                ...Diagnostic.fromDiagnostics(suppressedError.diagnostics),
             ];
+            const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, testTree.sourceFile);
+            if (!suppressedError.argument?.text) {
+                const text = SuppressedDiagnosticText.directiveRequires();
+                this.#onDiagnostics(Diagnostic.error(text, origin).add({ related }), suppressedResult);
+                continue;
+            }
             if (suppressedError.diagnostics.length > 1) {
-                const text = [SuppressedDiagnosticText.onlySingleError()];
-                const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, suppressedErrors.sourceFile);
-                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]);
             if (Array.isArray(messageText)) {
                 messageText = messageText.join("\n");
             }
-            if (!messageText.includes(suppressedError.argument.text)) {
-                const text = [SuppressedDiagnosticText.messageDidNotMatch()];
-                const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, suppressedErrors.sourceFile);
-                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+            if (!this.#matchMessage(messageText, suppressedError.argument.text)) {
+                const text = SuppressedDiagnosticText.messageDidNotMatch();
+                const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, testTree.sourceFile);
+                this.#onDiagnostics(Diagnostic.error(text, origin).add({ related }), suppressedResult);
+                continue;
+            }
+            EventEmitter.dispatch(["suppressed:match", { result: suppressedResult }]);
+        }
+    }
+    #matchMessage(source, target) {
+        if (target.includes("...")) {
+            let position = 0;
+            for (const segment of target.split("...")) {
+                position = source.indexOf(segment, position);
+                if (position === -1) {
+                    break;
+                }
             }
+            return position > 0;
         }
+        return source.includes(target);
+    }
+    #onDiagnostics(diagnostic, result) {
+        EventEmitter.dispatch(["suppressed:error", { diagnostics: [diagnostic], result }]);
     }
 }
 
-var RunMode;
-(function (RunMode) {
-    RunMode[RunMode["Normal"] = 0] = "Normal";
-    RunMode[RunMode["Fail"] = 1] = "Fail";
-    RunMode[RunMode["Only"] = 2] = "Only";
-    RunMode[RunMode["Skip"] = 4] = "Skip";
-    RunMode[RunMode["Todo"] = 8] = "Todo";
-    RunMode[RunMode["Void"] = 16] = "Void";
-})(RunMode || (RunMode = {}));
-
 class EnsureDiagnosticText {
     static argumentMustBeProvided(argumentNameText) {
         return `An argument for '${argumentNameText}' must be provided.`;
@@ -3961,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}'.`;
@@ -3984,21 +4251,15 @@ class ExpectDiagnosticText {
     }
 }
 
-var Relation;
-(function (Relation) {
-    Relation["Assignable"] = "assignable";
-    Relation["Identical"] = "identical";
-})(Relation || (Relation = {}));
-
 class MatchWorker {
-    assertion;
+    assertionNode;
     #compiler;
     #signatureCache = new Map();
     typeChecker;
-    constructor(compiler, typeChecker, assertion) {
+    constructor(compiler, typeChecker, assertionNode) {
         this.#compiler = compiler;
         this.typeChecker = typeChecker;
-        this.assertion = assertion;
+        this.assertionNode = assertionNode;
     }
     checkHasApplicableIndexType(sourceNode, targetNode) {
         const sourceType = this.getType(sourceNode);
@@ -4014,13 +4275,13 @@ class MatchWorker {
             .some((property) => this.#compiler.unescapeLeadingUnderscores(property.escapedName) === propertyNameText);
     }
     checkIsAssignableTo(sourceNode, targetNode) {
-        return this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Assignable);
+        return this.#checkIsRelatedTo(sourceNode, targetNode, "assignable");
     }
     checkIsAssignableWith(sourceNode, targetNode) {
-        return this.#checkIsRelatedTo(targetNode, sourceNode, Relation.Assignable);
+        return this.#checkIsRelatedTo(targetNode, sourceNode, "assignable");
     }
     checkIsIdenticalTo(sourceNode, targetNode) {
-        return (this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Identical) &&
+        return (this.#checkIsRelatedTo(sourceNode, targetNode, "identical") &&
             this.checkIsAssignableTo(sourceNode, targetNode) &&
             this.checkIsAssignableWith(sourceNode, targetNode));
     }
@@ -4028,9 +4289,9 @@ class MatchWorker {
         const sourceType = relation === "identical" ? this.#simplifyType(this.getType(sourceNode)) : this.getType(sourceNode);
         const targetType = relation === "identical" ? this.#simplifyType(this.getType(targetNode)) : this.getType(targetNode);
         switch (relation) {
-            case Relation.Assignable:
+            case "assignable":
                 return this.typeChecker.isTypeAssignableTo(sourceType, targetType);
-            case Relation.Identical:
+            case "identical":
                 return this.typeChecker.isTypeIdenticalTo(sourceType, targetType);
         }
     }
@@ -4071,9 +4332,9 @@ class MatchWorker {
                 this.#compiler.isShorthandPropertyAssignment(symbol.valueDeclaration)) &&
             symbol.valueDeclaration.getStart() >= enclosingNode.getStart() &&
             symbol.valueDeclaration.getEnd() <= enclosingNode.getEnd()) {
-            return DiagnosticOrigin.fromNode(symbol.valueDeclaration.name, this.assertion);
+            return DiagnosticOrigin.fromNode(symbol.valueDeclaration.name, this.assertionNode);
         }
-        return DiagnosticOrigin.fromNode(enclosingNode, this.assertion);
+        return DiagnosticOrigin.fromNode(enclosingNode, this.assertionNode);
     }
     #simplifyType(type) {
         if (type.isUnionOrIntersection()) {
@@ -4108,10 +4369,10 @@ class ToAcceptProps {
         const signatures = matchWorker.getSignatures(sourceNode);
         return signatures.reduce((accumulator, signature, index) => {
             let diagnostic;
-            const introText = matchWorker.assertion.isNot
+            const introText = matchWorker.assertionNode.isNot
                 ? ExpectDiagnosticText.acceptsProps(isExpression)
                 : ExpectDiagnosticText.doesNotAcceptProps(isExpression);
-            const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+            const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
                 const overloadText = ExpectDiagnosticText.overloadGaveTheFollowingError(index + 1, signatures.length, signatureText);
@@ -4121,7 +4382,7 @@ class ToAcceptProps {
                 diagnostic = Diagnostic.error([introText], origin);
             }
             const { diagnostics, isMatch } = this.#explainProperties(matchWorker, signature, targetNode, diagnostic);
-            if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
+            if (matchWorker.assertionNode.isNot ? isMatch : !isMatch) {
                 accumulator.push(...diagnostics);
             }
             return accumulator;
@@ -4185,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);
@@ -4198,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));
@@ -4212,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));
@@ -4220,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 };
             }
@@ -4229,9 +4490,9 @@ class ToAcceptProps {
         if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
-                const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
+                const text = matchWorker.assertionNode.isNot
+                    ? ExpectDiagnosticText.isAssignableFrom(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
                 if (isMatch) {
                     accumulator = diagnostics;
@@ -4284,10 +4545,10 @@ class RelationMatcherBase {
     explain(matchWorker, sourceNode, targetNode) {
         const sourceTypeText = matchWorker.getTypeText(sourceNode);
         const targetTypeText = matchWorker.getTypeText(targetNode);
-        const text = matchWorker.assertion.isNot
+        const text = matchWorker.assertionNode.isNot
             ? this.explainText(sourceTypeText, targetTypeText)
             : this.explainNotText(sourceTypeText, targetTypeText);
-        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
         return [Diagnostic.error(text, origin)];
     }
 }
@@ -4334,18 +4595,22 @@ class ToBeApplicable {
         }
         return text;
     }
-    #explain(matchWorker, sourceNode) {
-        const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
+    #explain(matchWorker) {
+        const targetText = this.#resolveTargetText(matchWorker.assertionNode.matcherNode.parent);
         const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics.size > 0) {
-            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+        if (matchWorker.assertionNode.abilityDiagnostics.size > 0) {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
+            for (const diagnostic of matchWorker.assertionNode.abilityDiagnostics) {
                 const text = [ExpectDiagnosticText.cannotBeApplied(targetText), getDiagnosticMessageText(diagnostic)];
-                const origin = DiagnosticOrigin.fromNode(sourceNode);
-                diagnostics.push(Diagnostic.error(text.flat(), origin));
+                let related;
+                if (diagnostic.relatedInformation != null) {
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                }
+                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
             }
         }
         else {
-            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
             diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeApplied(targetText), origin));
         }
         return diagnostics;
@@ -4362,30 +4627,30 @@ class ToBeApplicable {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode),
-            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
+            explain: () => this.#explain(matchWorker),
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
 
-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),
         };
     }
 }
@@ -4408,32 +4673,25 @@ class AbilityMatcherBase {
         const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
         const targetText = this.#resolveTargetText(targetNodes);
         const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics.size > 0) {
-            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+        if (matchWorker.assertionNode.abilityDiagnostics.size > 0) {
+            for (const diagnostic of matchWorker.assertionNode.abilityDiagnostics) {
+                const text = [this.explainNotText(isExpression, targetText), getDiagnosticMessageText(diagnostic)];
                 let origin;
-                const text = [];
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, sourceNode)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
-                    text.push(getDiagnosticMessageText(diagnostic));
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertionNode);
                 }
                 else {
-                    if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                        origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
-                    }
-                    else {
-                        origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-                    }
-                    text.push(this.explainNotText(isExpression, targetText), getDiagnosticMessageText(diagnostic));
+                    origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
                 }
                 let related;
                 if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceNode.getSourceFile());
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
                 }
                 diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
             }
         }
         else {
-            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
             diagnostics.push(Diagnostic.error(this.explainText(isExpression, targetText), origin));
         }
         return diagnostics;
@@ -4473,7 +4731,7 @@ class ToBeCallableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4508,7 +4766,7 @@ class ToBeConstructableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4528,8 +4786,8 @@ class ToHaveProperty {
         else {
             propertyNameText = `[${this.#compiler.unescapeLeadingUnderscores(targetType.symbol.escapedName)}]`;
         }
-        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
-        return matchWorker.assertion.isNot
+        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
+        return matchWorker.assertionNode.isNot
             ? [Diagnostic.error(ExpectDiagnosticText.hasProperty(sourceTypeText, propertyNameText), origin)]
             : [Diagnostic.error(ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
     }
@@ -4579,28 +4837,28 @@ class ToRaiseError {
     }
     #explain(matchWorker, sourceNode, targetNodes) {
         const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
-        const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-        if (matchWorker.assertion.diagnostics.size === 0) {
+        const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
+        if (matchWorker.assertionNode.diagnostics.size === 0) {
             const text = ExpectDiagnosticText.didNotRaiseError(isExpression);
             return [Diagnostic.error(text, origin)];
         }
-        if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
-            const count = matchWorker.assertion.diagnostics.size;
+        if (matchWorker.assertionNode.diagnostics.size !== targetNodes.length) {
+            const count = matchWorker.assertionNode.diagnostics.size;
             const text = ExpectDiagnosticText.raisedError(isExpression, count, targetNodes.length);
             const related = [
                 Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
-                ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics]),
+                ...Diagnostic.fromDiagnostics([...matchWorker.assertionNode.diagnostics]),
             ];
             return [Diagnostic.error(text, origin).add({ related })];
         }
-        return [...matchWorker.assertion.diagnostics].reduce((accumulator, diagnostic, index) => {
+        return [...matchWorker.assertionNode.diagnostics].reduce((accumulator, diagnostic, index) => {
             const targetNode = targetNodes[index];
             const isMatch = this.#matchExpectedError(diagnostic, targetNode);
-            if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
-                const text = matchWorker.assertion.isNot
+            if (matchWorker.assertionNode.isNot ? isMatch : !isMatch) {
+                const text = matchWorker.assertionNode.isNot
                     ? ExpectDiagnosticText.raisedMatchingError(isExpression)
                     : ExpectDiagnosticText.didNotRaiseMatchingError(isExpression);
-                const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+                const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
                 const related = [
                     Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
                     ...Diagnostic.fromDiagnostics([diagnostic]),
@@ -4628,12 +4886,12 @@ class ToRaiseError {
         }
         let isMatch;
         if (targetNodes.length === 0) {
-            isMatch = matchWorker.assertion.diagnostics.size > 0;
+            isMatch = matchWorker.assertionNode.diagnostics.size > 0;
         }
         else {
             isMatch =
-                matchWorker.assertion.diagnostics.size === targetNodes.length &&
-                    [...matchWorker.assertion.diagnostics].every((diagnostic, index) => this.#matchExpectedError(diagnostic, targetNodes[index]));
+                matchWorker.assertionNode.diagnostics.size === targetNodes.length &&
+                    [...matchWorker.assertionNode.diagnostics].every((diagnostic, index) => this.#matchExpectedError(diagnostic, targetNodes[index]));
         }
         return {
             explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
@@ -4663,8 +4921,8 @@ class ExpectService {
     toAcceptProps;
     toBe;
     toBeApplicable;
+    toBeAssignableFrom;
     toBeAssignableTo;
-    toBeAssignableWith;
     toBeCallableWith;
     toBeConstructableWith;
     toHaveProperty;
@@ -4676,54 +4934,54 @@ 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);
         this.toRaiseError = new ToRaiseError(compiler);
     }
-    match(assertion, onDiagnostics) {
-        const matcherNameText = assertion.matcherNameNode.name.text;
-        if (!argumentOrTypeArgumentIsProvided("source", "Source", assertion.source[0], assertion.node.expression, onDiagnostics)) {
+    match(assertionNode, onDiagnostics) {
+        const matcherNameText = assertionNode.matcherNameNode.name.text;
+        if (!argumentOrTypeArgumentIsProvided("source", "Source", assertionNode.source[0], assertionNode.node.expression, onDiagnostics)) {
             return;
         }
-        const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
-        if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
+        const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertionNode);
+        if (!(matcherNameText === "toRaiseError" && assertionNode.isNot === false) &&
             this.#reject.argumentType([
-                ["source", assertion.source[0]],
-                ["target", assertion.target?.[0]],
+                ["source", assertionNode.source[0]],
+                ["target", assertionNode.target?.[0]],
             ], onDiagnostics)) {
             return;
         }
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
+            case "toBeAssignableFrom":
             case "toBeAssignableTo":
-            case "toBeAssignableWith":
-                if (!argumentOrTypeArgumentIsProvided("target", "Target", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
+                if (!argumentOrTypeArgumentIsProvided("target", "Target", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
-                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
+                return this[matcherNameText].match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
             case "toBeApplicable":
-                return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
+                return this.toBeApplicable.match(matchWorker, assertionNode.source[0], onDiagnostics);
             case "toBeCallableWith":
             case "toBeConstructableWith":
             case "toRaiseError":
-                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
+                return this[matcherNameText].match(matchWorker, assertionNode.source[0], assertionNode.target, onDiagnostics);
             case "toHaveProperty":
-                if (!argumentIsProvided("key", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
+                if (!argumentIsProvided("key", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
-                return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
+                return this.toHaveProperty.match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
             default:
-                this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
+                this.#onMatcherIsNotSupported(matcherNameText, assertionNode, onDiagnostics);
         }
         return;
     }
-    #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
+    #onMatcherIsNotSupported(matcherNameText, assertionNode, onDiagnostics) {
         const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
+        const origin = DiagnosticOrigin.fromNode(assertionNode.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
 }
@@ -4844,82 +5102,145 @@ class WhenService {
     }
 }
 
+class FixmeDiagnosticText {
+    static considerRemoving() {
+        return "Consider removing the '// @tstyche fixme' directive.";
+    }
+    static wasSupposedToFail(target) {
+        return `The '${target}()' was supposed to fail, but it passed.`;
+    }
+}
+
+class FixmeService {
+    static #expectRange;
+    static #range;
+    static async start(directive, owner) {
+        const inlineConfig = await Directive.getInlineConfig(directive);
+        if (inlineConfig?.fixme === true) {
+            if (owner.brand === "expect") {
+                FixmeService.#expectRange = { directive, owner, previous: FixmeService.#expectRange };
+            }
+            else {
+                FixmeService.#range = { directive, owner, previous: FixmeService.#range };
+            }
+        }
+    }
+    static isFixme(owner, isPass) {
+        if (owner.brand !== "expect") {
+            return owner === FixmeService.#range?.owner && FixmeService.#range.isFail === true;
+        }
+        if (owner === FixmeService.#expectRange?.owner) {
+            FixmeService.#expectRange.isFail = !isPass;
+            return !isPass;
+        }
+        if (FixmeService.#range != null) {
+            if (!isPass) {
+                FixmeService.#range.isFail = true;
+                return true;
+            }
+            FixmeService.#range.isFail ??= false;
+        }
+        return false;
+    }
+    static end(directive, owner, onFileDiagnostics) {
+        let isFail;
+        if (owner === FixmeService.#expectRange?.owner) {
+            isFail = FixmeService.#expectRange.isFail;
+            FixmeService.#expectRange = FixmeService.#expectRange?.previous;
+        }
+        if (owner === FixmeService.#range?.owner) {
+            isFail = FixmeService.#range?.isFail;
+            FixmeService.#range = FixmeService.#range?.previous;
+        }
+        if (isFail === false) {
+            const targetText = owner.node.expression.getText();
+            const text = [FixmeDiagnosticText.wasSupposedToFail(targetText), FixmeDiagnosticText.considerRemoving()];
+            const origin = new DiagnosticOrigin(directive.namespace.start, directive.directive.end, directive.sourceFile);
+            onFileDiagnostics([Diagnostic.error(text, origin)]);
+        }
+    }
+}
+
 class TestTreeWalker {
     #cancellationToken;
     #compiler;
     #expectService;
     #hasOnly;
-    #onTaskDiagnostics;
+    #onFileDiagnostics;
     #position;
     #resolvedConfig;
     #whenService;
-    constructor(compiler, typeChecker, resolvedConfig, onTaskDiagnostics, options) {
+    constructor(compiler, typeChecker, resolvedConfig, onFileDiagnostics, options) {
         this.#compiler = compiler;
         this.#resolvedConfig = resolvedConfig;
-        this.#onTaskDiagnostics = onTaskDiagnostics;
+        this.#onFileDiagnostics = onFileDiagnostics;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
         const reject = new Reject(compiler, typeChecker, resolvedConfig);
         this.#expectService = new ExpectService(compiler, typeChecker, reject);
-        this.#whenService = new WhenService(reject, onTaskDiagnostics);
+        this.#whenService = new WhenService(reject, onFileDiagnostics);
     }
-    async #resolveRunMode(mode, node) {
-        const directiveRanges = node.getDirectiveRanges(this.#compiler);
-        const inlineConfig = await Directive.getInlineConfig(directiveRanges);
+    async #resolveRunMode(flags, node) {
+        const ifDirective = Directive.getDirectiveRange(this.#compiler, node, "if");
+        const inlineConfig = await Directive.getInlineConfig(ifDirective);
         if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
-            mode |= RunMode.Void;
-        }
-        if (node.flags & TestTreeNodeFlags.Fail) {
-            mode |= RunMode.Fail;
+            flags |= 8;
         }
-        if (node.flags & TestTreeNodeFlags.Only ||
+        if (node.flags & 1 ||
             (this.#resolvedConfig.only != null && node.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
-            mode |= RunMode.Only;
+            flags |= 1;
         }
-        if (node.flags & TestTreeNodeFlags.Skip ||
+        if (node.flags & 2 ||
             (this.#resolvedConfig.skip != null && node.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
-            mode |= RunMode.Skip;
+            flags |= 2;
         }
-        if (node.flags & TestTreeNodeFlags.Todo) {
-            mode |= RunMode.Todo;
+        if (node.flags & 4) {
+            flags |= 4;
         }
         if (this.#position != null && node.node.getStart() === this.#position) {
-            mode |= RunMode.Only;
-            mode &= ~RunMode.Skip;
+            flags |= 1;
+            flags &= -3;
         }
-        return mode;
+        return flags;
     }
-    async visit(nodes, runMode, parentResult) {
+    async visit(nodes, runModeFlags, parentResult) {
         for (const node of nodes) {
             if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
+            const fixmeDirective = Directive.getDirectiveRange(this.#compiler, node, "fixme");
+            if (fixmeDirective) {
+                FixmeService.start(fixmeDirective, node);
+            }
             switch (node.brand) {
-                case TestTreeNodeBrand.Describe:
-                    await this.#visitDescribe(node, runMode, parentResult);
+                case "describe":
+                    await this.#visitDescribe(node, runModeFlags, parentResult);
                     break;
-                case TestTreeNodeBrand.Test:
-                    await this.#visitTest(node, runMode, parentResult);
+                case "test":
+                    await this.#visitTest(node, runModeFlags, parentResult);
                     break;
-                case TestTreeNodeBrand.Expect:
-                    await this.#visitAssertion(node, runMode, parentResult);
+                case "expect":
+                    await this.#visitExpect(node, runModeFlags, parentResult);
                     break;
-                case TestTreeNodeBrand.When:
+                case "when":
                     this.#visitWhen(node);
                     break;
             }
+            if (fixmeDirective) {
+                FixmeService.end(fixmeDirective, node, this.#onFileDiagnostics);
+            }
         }
     }
-    async #visitAssertion(assertion, runMode, parentResult) {
-        await this.visit(assertion.children, runMode, parentResult);
-        runMode = await this.#resolveRunMode(runMode, assertion);
-        if (runMode & RunMode.Void) {
+    async #visitExpect(expect, runModeFlags, parentResult) {
+        await this.visit(expect.children, runModeFlags, parentResult);
+        runModeFlags = await this.#resolveRunMode(runModeFlags, expect);
+        if (runModeFlags & 8) {
             return;
         }
-        const expectResult = new ExpectResult(assertion, parentResult);
+        const expectResult = new ExpectResult(expect, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
-        if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
+        if (runModeFlags & 2 || (this.#hasOnly && !(runModeFlags & 1))) {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
         }
@@ -4929,59 +5250,57 @@ class TestTreeWalker {
                 { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
         };
-        if (assertion.diagnostics.size > 0 && assertion.matcherNameNode.name.text !== "toRaiseError") {
-            onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics]));
+        if (expect.diagnostics.size > 0 && expect.matcherNameNode.name.text !== "toRaiseError") {
+            onExpectDiagnostics(Diagnostic.fromDiagnostics([...expect.diagnostics]));
             return;
         }
-        const matchResult = this.#expectService.match(assertion, onExpectDiagnostics);
+        const matchResult = this.#expectService.match(expect, onExpectDiagnostics);
         if (!matchResult) {
             return;
         }
-        if (assertion.isNot ? !matchResult.isMatch : matchResult.isMatch) {
-            if (runMode & RunMode.Fail) {
-                const text = ["The assertion was supposed to fail, but it passed.", "Consider removing the '.fail' flag."];
-                const origin = DiagnosticOrigin.fromNode(assertion.node.expression.name);
-                onExpectDiagnostics(Diagnostic.error(text, origin));
-            }
-            else {
-                EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
-            }
+        const isPass = expect.isNot ? !matchResult.isMatch : matchResult.isMatch;
+        if (FixmeService.isFixme(expect, isPass)) {
+            EventEmitter.dispatch(["expect:fixme", { result: expectResult }]);
+            return;
         }
-        else if (runMode & RunMode.Fail) {
+        if (isPass) {
             EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
         }
         else {
             EventEmitter.dispatch(["expect:fail", { diagnostics: matchResult.explain(), result: expectResult }]);
         }
     }
-    async #visitDescribe(describe, runMode, parentResult) {
-        runMode = await this.#resolveRunMode(runMode, describe);
-        if (runMode & RunMode.Void) {
+    async #visitDescribe(describe, runModeFlags, parentResult) {
+        runModeFlags = await this.#resolveRunMode(runModeFlags, describe);
+        if (runModeFlags & 8) {
             return;
         }
         const describeResult = new DescribeResult(describe, parentResult);
         EventEmitter.dispatch(["describe:start", { result: describeResult }]);
-        if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
+        if (!(runModeFlags & 2 ||
+            (this.#hasOnly && !(runModeFlags & 1)) ||
+            runModeFlags & 4) &&
             describe.diagnostics.size > 0) {
-            this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
+            this.#onFileDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
         }
         else {
-            await this.visit(describe.children, runMode, describeResult);
+            await this.visit(describe.children, runModeFlags, describeResult);
         }
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
-    async #visitTest(test, runMode, parentResult) {
-        runMode = await this.#resolveRunMode(runMode, test);
-        if (runMode & RunMode.Void) {
+    async #visitTest(test, runModeFlags, parentResult) {
+        runModeFlags = await this.#resolveRunMode(runModeFlags, test);
+        if (runModeFlags & 8) {
             return;
         }
         const testResult = new TestResult(test, parentResult);
         EventEmitter.dispatch(["test:start", { result: testResult }]);
-        if (runMode & RunMode.Todo) {
+        if (runModeFlags & 4) {
             EventEmitter.dispatch(["test:todo", { result: testResult }]);
             return;
         }
-        if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) && test.diagnostics.size > 0) {
+        if (!(runModeFlags & 2 || (this.#hasOnly && !(runModeFlags & 1))) &&
+            test.diagnostics.size > 0) {
             EventEmitter.dispatch([
                 "test:error",
                 {
@@ -4991,24 +5310,29 @@ class TestTreeWalker {
             ]);
             return;
         }
-        await this.visit(test.children, runMode, testResult);
-        if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
+        await this.visit(test.children, runModeFlags, testResult);
+        if (runModeFlags & 2 || (this.#hasOnly && !(runModeFlags & 1))) {
             EventEmitter.dispatch(["test:skip", { result: testResult }]);
             return;
         }
-        if (testResult.expectCount.failed > 0) {
-            EventEmitter.dispatch(["test:fail", { result: testResult }]);
+        const isPass = testResult.assertionCounts.failed === 0;
+        if (FixmeService.isFixme(test, isPass)) {
+            EventEmitter.dispatch(["test:fixme", { result: testResult }]);
+            return;
         }
-        else {
+        if (isPass) {
             EventEmitter.dispatch(["test:pass", { result: testResult }]);
         }
+        else {
+            EventEmitter.dispatch(["test:fail", { result: testResult }]);
+        }
     }
     #visitWhen(when) {
         this.#whenService.action(when);
     }
 }
 
-class TaskRunner {
+class FileRunner {
     #collectService;
     #compiler;
     #projectService;
@@ -5021,89 +5345,85 @@ class TaskRunner {
         this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
     #onDiagnostics(diagnostics, result) {
-        EventEmitter.dispatch(["task:error", { diagnostics, result }]);
+        EventEmitter.dispatch(["file:error", { diagnostics, result }]);
     }
-    async run(task, cancellationToken) {
+    async run(file, cancellationToken) {
         if (cancellationToken.isCancellationRequested) {
             return;
         }
-        this.#projectService.openFile(task.filePath, undefined, this.#resolvedConfig.rootPath);
-        const taskResult = new TaskResult(task);
-        EventEmitter.dispatch(["task:start", { result: taskResult }]);
-        await this.#run(task, taskResult, cancellationToken);
-        EventEmitter.dispatch(["task:end", { result: taskResult }]);
-        this.#projectService.closeFile(task.filePath);
+        this.#projectService.openFile(file.path);
+        const fileResult = new FileResult(file);
+        EventEmitter.dispatch(["file:start", { result: fileResult }]);
+        await this.#run(file, fileResult, cancellationToken);
+        EventEmitter.dispatch(["file:end", { result: fileResult }]);
+        this.#projectService.closeFile(file.path);
     }
-    async #resolveTaskFacts(task, taskResult, runMode = RunMode.Normal) {
-        const languageService = this.#projectService.getLanguageService(task.filePath);
-        const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
+    async #resolveFileFacts(file, fileResult, runModeFlags) {
+        const languageService = this.#projectService.getLanguageService(file.path);
+        const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(file.path);
         if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
-            this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
+            this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), fileResult);
             return;
         }
-        const semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+        const semanticDiagnostics = languageService?.getSemanticDiagnostics(file.path);
         const program = languageService?.getProgram();
         const typeChecker = program?.getTypeChecker();
-        const sourceFile = program?.getSourceFile(task.filePath);
+        const sourceFile = program?.getSourceFile(file.path);
         if (!sourceFile) {
             return;
         }
-        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
-        const directiveRanges = testTree.getDirectiveRanges(this.#compiler);
+        const directiveRanges = Directive.getDirectiveRanges(this.#compiler, sourceFile);
         const inlineConfig = await Directive.getInlineConfig(directiveRanges);
         if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
-            runMode |= RunMode.Skip;
-        }
-        if (testTree.suppressedErrors != null) {
-            this.#suppressedService.match(testTree.suppressedErrors, (diagnostics) => {
-                this.#onDiagnostics(diagnostics, taskResult);
-            });
+            runModeFlags |= 2;
         }
         if (inlineConfig?.template) {
             if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
-                this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), taskResult);
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), fileResult);
                 return;
             }
-            const moduleSpecifier = pathToFileURL(task.filePath).toString();
+            const moduleSpecifier = pathToFileURL(file.path).toString();
             const testText = (await import(moduleSpecifier))?.default;
             if (typeof testText !== "string") {
-                this.#onDiagnostics([Diagnostic.error("A template test file must export a string.")], taskResult);
+                this.#onDiagnostics([Diagnostic.error("A template test file must export a string.")], fileResult);
                 return;
             }
-            this.#projectService.openFile(task.filePath, testText, this.#resolvedConfig.rootPath);
-            return this.#resolveTaskFacts(task, taskResult, runMode);
+            this.#projectService.openFile(file.path, testText);
+            return this.#resolveFileFacts(file, fileResult, runModeFlags);
         }
-        return { runMode, testTree, typeChecker };
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
+        this.#suppressedService.match(testTree);
+        return { runModeFlags, testTree, typeChecker };
     }
-    async #run(task, taskResult, cancellationToken) {
-        if (!existsSync(task.filePath)) {
-            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
+    async #run(file, fileResult, cancellationToken) {
+        if (!existsSync(file.path)) {
+            this.#onDiagnostics([Diagnostic.error(`Test file '${file.path}' does not exist.`)], fileResult);
             return;
         }
-        const facts = await this.#resolveTaskFacts(task, taskResult);
+        const facts = await this.#resolveFileFacts(file, fileResult, 0);
         if (!facts) {
             return;
         }
         if (facts.testTree.diagnostics.size > 0) {
-            this.#onDiagnostics(Diagnostic.fromDiagnostics([...facts.testTree.diagnostics]), taskResult);
+            this.#onDiagnostics(Diagnostic.fromDiagnostics([...facts.testTree.diagnostics]), fileResult);
             return;
         }
-        const onTaskDiagnostics = (diagnostics) => {
-            this.#onDiagnostics(diagnostics, taskResult);
+        const onFileDiagnostics = (diagnostics) => {
+            this.#onDiagnostics(diagnostics, fileResult);
         };
-        const testTreeWalker = new TestTreeWalker(this.#compiler, facts.typeChecker, this.#resolvedConfig, onTaskDiagnostics, {
+        const testTreeWalker = new TestTreeWalker(this.#compiler, facts.typeChecker, this.#resolvedConfig, onFileDiagnostics, {
             cancellationToken,
             hasOnly: facts.testTree.hasOnly,
-            position: task.position,
+            position: file.position,
         });
-        await testTreeWalker.visit(facts.testTree.children, facts.runMode, undefined);
+        await testTreeWalker.visit(facts.testTree.children, facts.runModeFlags, undefined);
     }
 }
 
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.3.0";
+    static version = "5.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5111,7 +5431,7 @@ class Runner {
         const resultHandler = new ResultHandler();
         this.#eventEmitter.addHandler(resultHandler);
         if (this.#resolvedConfig.failFast) {
-            const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.FailFast);
+            const cancellationHandler = new CancellationHandler(cancellationToken, "failFast");
             this.#eventEmitter.addHandler(cancellationHandler);
         }
     }
@@ -5140,39 +5460,39 @@ class Runner {
             }
         }
     }
-    async run(testFiles, cancellationToken = new CancellationToken()) {
-        const tasks = testFiles.map((testFile) => (testFile instanceof Task ? testFile : new Task(testFile)));
+    async run(files, cancellationToken = new CancellationToken()) {
+        const fileLocations = files.map((file) => (file instanceof FileLocation ? file : new FileLocation(file)));
         this.#addHandlers(cancellationToken);
         await this.#addReporters();
-        await this.#run(tasks, cancellationToken);
+        await this.#run(fileLocations, cancellationToken);
         if (this.#resolvedConfig.watch) {
-            await this.#watch(tasks, cancellationToken);
+            await this.#watch(fileLocations, cancellationToken);
         }
         this.#eventEmitter.removeReporters();
         this.#eventEmitter.removeHandlers();
     }
-    async #run(tasks, cancellationToken) {
-        const result = new Result(tasks);
+    async #run(files, cancellationToken) {
+        const result = new Result(files);
         EventEmitter.dispatch(["run:start", { result }]);
         for (const target of this.#resolvedConfig.target) {
-            const targetResult = new TargetResult(target, tasks);
+            const targetResult = new TargetResult(target, files);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
             const compiler = await Store.load(target);
             if (compiler) {
-                const taskRunner = new TaskRunner(compiler, this.#resolvedConfig);
-                for (const task of tasks) {
-                    await taskRunner.run(task, cancellationToken);
+                const fileRunner = new FileRunner(compiler, this.#resolvedConfig);
+                for (const file of files) {
+                    await fileRunner.run(file, cancellationToken);
                 }
             }
             EventEmitter.dispatch(["target:end", { result: targetResult }]);
         }
         EventEmitter.dispatch(["run:end", { result }]);
-        if (cancellationToken.reason === CancellationReason.FailFast) {
+        if (cancellationToken.reason === "failFast") {
             cancellationToken.reset();
         }
     }
-    async #watch(testFiles, cancellationToken) {
-        const watchService = new WatchService(this.#resolvedConfig, testFiles);
+    async #watch(files, cancellationToken) {
+        const watchService = new WatchService(this.#resolvedConfig, files);
         for await (const testFiles of watchService.watch(cancellationToken)) {
             await this.#run(testFiles, cancellationToken);
         }
@@ -5182,14 +5502,14 @@ class Runner {
 class Cli {
     #eventEmitter = new EventEmitter();
     async run(commandLine, cancellationToken = new CancellationToken()) {
-        const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.ConfigError);
+        const cancellationHandler = new CancellationHandler(cancellationToken, "configError");
         this.#eventEmitter.addHandler(cancellationHandler);
         const exitCodeHandler = new ExitCodeHandler();
         this.#eventEmitter.addHandler(exitCodeHandler);
         const setupReporter = new SetupReporter();
         this.#eventEmitter.addReporter(setupReporter);
         if (commandLine.includes("--help")) {
-            const options = Options.for(OptionGroup.CommandLine);
+            const options = Options.for(2);
             OutputService.writeMessage(helpText(options, Runner.version));
             return;
         }
@@ -5217,7 +5537,7 @@ class Cli {
             return;
         }
         do {
-            if (cancellationToken.reason === CancellationReason.ConfigChange) {
+            if (cancellationToken.reason === "configChange") {
                 cancellationToken.reset();
                 exitCodeHandler.resetCode();
                 OutputService.clearTerminal();
@@ -5272,7 +5592,7 @@ class Cli {
             const runner = new Runner(resolvedConfig);
             await runner.run(testFiles, cancellationToken);
             PluginService.removeHandlers();
-        } while (cancellationToken.reason === CancellationReason.ConfigChange);
+        } while (cancellationToken.reason === "configChange");
         this.#eventEmitter.removeHandlers();
     }
     #waitForChangedFiles(resolvedConfig, cancellationToken) {
@@ -5281,7 +5601,7 @@ class Cli {
             cancellationToken.reset();
             OutputService.writeMessage(waitingForFileChangesText());
             const onChanged = () => {
-                cancellationToken.cancel(CancellationReason.ConfigChange);
+                cancellationToken.cancel("configChange");
                 for (const watcher of watchers) {
                     watcher.close();
                 }
@@ -5303,4 +5623,4 @@ class Cli {
     }
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, 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, Store, SummaryReporter, SuppressedService, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, 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 };