tstyche 4.2.0 → 5.0.0-beta.0

package/build/tstyche.js

@@ -6,34 +6,146 @@ 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 Path {
+    static normalizeSlashes;
+    static {
+        if (path.sep === "/") {
+            Path.normalizeSlashes = (filePath) => filePath;
+        }
+        else {
+            Path.normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
+        }
+    }
+    static dirname(filePath) {
+        return Path.normalizeSlashes(path.dirname(filePath));
+    }
+    static join(...filePaths) {
+        return Path.normalizeSlashes(path.join(...filePaths));
+    }
+    static relative(from, to) {
+        const relativePath = Path.normalizeSlashes(path.relative(from, to));
+        if (/^\.\.?\//.test(relativePath)) {
+            return relativePath;
+        }
+        return `./${relativePath}`;
+    }
+    static resolve(...filePaths) {
+        return Path.normalizeSlashes(path.resolve(...filePaths));
+    }
+}
+
+class SourceFile {
+    fileName;
+    #lineMap;
+    text;
+    constructor(fileName, text) {
+        this.fileName = fileName;
+        this.text = text;
+        this.#lineMap = this.#createLineMap();
+    }
+    #createLineMap() {
+        const result = [0];
+        let position = 0;
+        while (position < this.text.length) {
+            if (this.text.charAt(position - 1) === "\r") {
+                position++;
+            }
+            if (this.text.charAt(position - 1) === "\n") {
+                result.push(position);
+            }
+            position++;
+        }
+        result.push(position);
+        return result;
+    }
+    getLineStarts() {
+        return this.#lineMap;
+    }
+    getLineAndCharacterOfPosition(position) {
+        const line = this.#lineMap.findLastIndex((line) => line <= position);
+        const character = position - this.#lineMap[line];
+        return { line, character };
+    }
+}
+
+class SourceService {
+    static #files = new Map();
+    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,135 +194,36 @@ 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);
-    }
-}
-
-class SourceFile {
-    fileName;
-    #lineMap;
-    text;
-    constructor(fileName, text) {
-        this.fileName = fileName;
-        this.text = text;
-        this.#lineMap = this.#createLineMap();
-    }
-    #createLineMap() {
-        const result = [0];
-        let position = 0;
-        while (position < this.text.length) {
-            if (this.text.charAt(position - 1) === "\r") {
-                position++;
-            }
-            if (this.text.charAt(position - 1) === "\n") {
-                result.push(position);
-            }
-            position++;
-        }
-        result.push(position);
-        return result;
-    }
-    getLineStarts() {
-        return this.#lineMap;
-    }
-    getLineAndCharacterOfPosition(position) {
-        const line = this.#lineMap.findLastIndex((line) => line <= position);
-        const character = position - this.#lineMap[line];
-        return { line, character };
+        return new Diagnostic(text, "warning", origin);
     }
 }
 
-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 {
-        if (path.sep === "/") {
-            Path.normalizeSlashes = (filePath) => filePath;
-        }
-        else {
-            Path.normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
-        }
-    }
-    static dirname(filePath) {
-        return Path.normalizeSlashes(path.dirname(filePath));
-    }
-    static join(...filePaths) {
-        return Path.normalizeSlashes(path.join(...filePaths));
-    }
-    static relative(from, to) {
-        const relativePath = Path.normalizeSlashes(path.relative(from, to));
-        if (/^\.\.?\//.test(relativePath)) {
-            return relativePath;
-        }
-        return `./${relativePath}`;
-    }
-    static resolve(...filePaths) {
-        return Path.normalizeSlashes(path.resolve(...filePaths));
-    }
-}
+var DiagnosticCategory;
+(function (DiagnosticCategory) {
+    DiagnosticCategory["Error"] = "error";
+    DiagnosticCategory["Warning"] = "warning";
+})(DiagnosticCategory || (DiagnosticCategory = {}));
 
 class ConfigDiagnosticText {
     static expected(element) {
@@ -225,80 +238,51 @@ class ConfigDiagnosticText {
     static fileDoesNotExist(filePath) {
         return `The specified path '${filePath}' does not exist.`;
     }
+    static fileMatchPatternCannotStartWith(optionName, segment) {
+        return [
+            `A '${optionName}' pattern cannot start with '${segment}'.`,
+            "The files are only collected within the 'rootPath' directory.",
+        ];
+    }
     static inspectSupportedVersions() {
         return "Use the '--list' command line option to inspect the list of supported versions.";
     }
     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.`;
     }
-    static testFileMatchCannotStartWith(segment) {
-        return [
-            `A test file match pattern cannot start with '${segment}'.`,
-            "The test files are only collected within the 'rootPath' directory.",
-        ];
-    }
     static unexpected(element) {
         return `Unexpected ${element}.`;
     }
     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 +539,9 @@ class Manifest {
         return;
     }
     resolve(tag) {
+        if (tag === "*") {
+            return this.resolutions["latest"];
+        }
         if (this.versions.includes(tag)) {
             return tag;
         }
@@ -663,32 +650,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 +719,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 +780,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 +797,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 +845,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 +855,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 +874,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,168 +911,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.BareTrue,
+            brand: "list",
+            description: "The list of glob patterns matching the fixture files.",
+            group: 4,
+            items: {
+                brand: "string",
+                name: "fixtureFileMatch",
+            },
+            name: "fixtureFileMatch",
+        },
+        {
+            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",
         },
     ];
@@ -1107,7 +1133,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":
@@ -1134,23 +1160,25 @@ 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;
             }
+            case "fixtureFileMatch":
             case "testFileMatch":
                 for (const segment of ["/", "../"]) {
                     if (optionValue.startsWith(segment)) {
-                        onDiagnostics(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
+                        onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileMatchPatternCannotStartWith(canonicalOptionName, segment), origin));
                     }
                 }
                 break;
@@ -1163,7 +1191,7 @@ class Options {
     }
 }
 
-class CommandLineParser {
+class CommandParser {
     #commandLineOptions;
     #onDiagnostics;
     #options;
@@ -1172,12 +1200,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));
     }
@@ -1207,18 +1235,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(",")
@@ -1226,7 +1254,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++;
@@ -1234,16 +1262,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;
     }
@@ -1265,43 +1307,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 "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 OptionBrand.List: {
+            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()) {
@@ -1399,15 +1456,16 @@ 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"],
+    target: ["*"],
     testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
     tsconfig: "findup",
 };
@@ -1552,11 +1610,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) {
@@ -1569,11 +1624,8 @@ class Config {
                 encoding: "utf8",
             });
             const sourceFile = new SourceFile(configFilePath, configFileText);
-            const configFileParser = new ConfigParser(configFileOptions, OptionGroup.ConfigFile, sourceFile, new JsonScanner(sourceFile), Config.#onDiagnostics);
+            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 };
     }
@@ -1609,12 +1661,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;
@@ -1624,15 +1694,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;
     }
@@ -1644,6 +1716,7 @@ class Directive {
             return;
         }
         const range = {
+            sourceFile,
             namespace: { start: comment.pos, end: comment.pos + namespaceText.length, text: namespaceText },
         };
         const directiveSeparatorText = match?.[2];
@@ -1663,45 +1736,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;
@@ -1711,7 +1800,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);
             }
         }
@@ -1725,7 +1814,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);
             }
         }
@@ -1757,27 +1846,42 @@ class DescribeResult {
     }
 }
 
-var ResultStatus;
-(function (ResultStatus) {
-    ResultStatus["Runs"] = "runs";
-    ResultStatus["Passed"] = "passed";
-    ResultStatus["Failed"] = "failed";
-    ResultStatus["Skipped"] = "skipped";
-    ResultStatus["Todo"] = "todo";
-})(ResultStatus || (ResultStatus = {}));
-
 class ExpectResult {
-    assertion;
+    expect;
     diagnostics = [];
     parent;
-    status = ResultStatus.Runs;
+    status = "runs";
     timing = new ResultTiming();
-    constructor(assertion, parent) {
-        this.assertion = assertion;
+    constructor(expect, parent) {
+        this.expect = expect;
         this.parent = parent;
     }
 }
 
+class ResultCount {
+    failed = 0;
+    passed = 0;
+    skipped = 0;
+    fixme = 0;
+    todo = 0;
+    get total() {
+        return this.failed + this.passed + this.skipped + this.fixme + this.todo;
+    }
+}
+
+class FileResult {
+    diagnostics = [];
+    expectCount = new ResultCount();
+    file;
+    results = [];
+    status = "runs";
+    testCount = new ResultCount();
+    timing = new ResultTiming();
+    constructor(file) {
+        this.file = file;
+    }
+}
+
 class ProjectResult {
     compilerVersion;
     diagnostics = [];
@@ -1789,51 +1893,38 @@ 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 {
     expectCount = new ResultCount();
     fileCount = new ResultCount();
+    files;
     results = [];
     targetCount = new ResultCount();
-    tasks;
     testCount = new ResultCount();
     timing = new ResultTiming();
-    constructor(tasks) {
-        this.tasks = tasks;
+    constructor(files) {
+        this.files = files;
     }
 }
 
+var ResultStatus;
+(function (ResultStatus) {
+    ResultStatus["Runs"] = "runs";
+    ResultStatus["Passed"] = "passed";
+    ResultStatus["Failed"] = "failed";
+    ResultStatus["Skipped"] = "skipped";
+    ResultStatus["Fixme"] = "fixme";
+    ResultStatus["Todo"] = "todo";
+})(ResultStatus || (ResultStatus = {}));
+
 class TargetResult {
+    files;
     results = new Map();
-    status = ResultStatus.Runs;
+    status = "runs";
     target;
-    tasks;
     timing = new ResultTiming();
-    constructor(target, tasks) {
+    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;
     }
 }
 
@@ -1842,7 +1933,7 @@ class TestResult {
     expectCount = new ResultCount();
     parent;
     results = [];
-    status = ResultStatus.Runs;
+    status = "runs";
     test;
     timing = new ResultTiming();
     constructor(test, parent) {
@@ -1854,10 +1945,10 @@ class TestResult {
 class ResultHandler {
     #describeResult;
     #expectResult;
+    #fileResult;
     #projectResult;
     #result;
     #targetResult;
-    #taskResult;
     #testResult;
     on([event, payload]) {
         switch (event) {
@@ -1875,19 +1966,19 @@ class ResultHandler {
                 this.#targetResult.timing.start = Date.now();
                 break;
             case "target:end":
-                if (this.#targetResult.status === ResultStatus.Failed) {
+                if (this.#targetResult.status === "failed") {
                     this.#result.targetCount.failed++;
                 }
                 else {
                     this.#result.targetCount.passed++;
-                    this.#targetResult.status = ResultStatus.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": {
@@ -1900,42 +1991,42 @@ class ResultHandler {
                 break;
             }
             case "project:error":
-                this.#targetResult.status = ResultStatus.Failed;
+                this.#targetResult.status = "failed";
                 this.#projectResult.diagnostics.push(...payload.diagnostics);
                 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";
+                this.#fileResult.diagnostics.push(...payload.diagnostics);
                 break;
-            case "task:end":
-                if (this.#taskResult.status === ResultStatus.Failed ||
-                    this.#taskResult.expectCount.failed > 0 ||
-                    this.#taskResult.testCount.failed > 0) {
+            case "file:end":
+                if (this.#fileResult.status === "failed" ||
+                    this.#fileResult.expectCount.failed > 0 ||
+                    this.#fileResult.testCount.failed > 0) {
                     this.#result.fileCount.failed++;
-                    this.#targetResult.status = ResultStatus.Failed;
-                    this.#taskResult.status = ResultStatus.Failed;
+                    this.#targetResult.status = "failed";
+                    this.#fileResult.status = "failed";
                 }
                 else {
                     this.#result.fileCount.passed++;
-                    this.#taskResult.status = ResultStatus.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();
@@ -1949,44 +2040,51 @@ 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.#fileResult.testCount.failed++;
+                this.#testResult.status = "failed";
                 this.#testResult.diagnostics.push(...payload.diagnostics);
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
             case "test:fail":
                 this.#result.testCount.failed++;
-                this.#taskResult.testCount.failed++;
-                this.#testResult.status = ResultStatus.Failed;
+                this.#fileResult.testCount.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.#fileResult.testCount.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.#fileResult.testCount.skipped++;
+                this.#testResult.status = "skipped";
+                this.#testResult.timing.end = Date.now();
+                this.#testResult = undefined;
+                break;
+            case "test:fixme":
+                this.#result.testCount.fixme++;
+                this.#fileResult.testCount.fixme++;
+                this.#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.#fileResult.testCount.todo++;
+                this.#testResult.status = "todo";
                 this.#testResult.timing.end = Date.now();
                 this.#testResult = undefined;
                 break;
@@ -1995,49 +2093,59 @@ 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++;
+                this.#fileResult.expectCount.failed++;
                 if (this.#testResult) {
                     this.#testResult.expectCount.failed++;
                 }
-                this.#expectResult.status = ResultStatus.Failed;
+                this.#expectResult.status = "failed";
                 this.#expectResult.diagnostics.push(...payload.diagnostics);
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:fail":
                 this.#result.expectCount.failed++;
-                this.#taskResult.expectCount.failed++;
+                this.#fileResult.expectCount.failed++;
                 if (this.#testResult) {
                     this.#testResult.expectCount.failed++;
                 }
-                this.#expectResult.status = ResultStatus.Failed;
+                this.#expectResult.status = "failed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:pass":
                 this.#result.expectCount.passed++;
-                this.#taskResult.expectCount.passed++;
+                this.#fileResult.expectCount.passed++;
                 if (this.#testResult) {
                     this.#testResult.expectCount.passed++;
                 }
-                this.#expectResult.status = ResultStatus.Passed;
+                this.#expectResult.status = "passed";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
             case "expect:skip":
                 this.#result.expectCount.skipped++;
-                this.#taskResult.expectCount.skipped++;
+                this.#fileResult.expectCount.skipped++;
                 if (this.#testResult) {
                     this.#testResult.expectCount.skipped++;
                 }
-                this.#expectResult.status = ResultStatus.Skipped;
+                this.#expectResult.status = "skipped";
+                this.#expectResult.timing.end = Date.now();
+                this.#expectResult = undefined;
+                break;
+            case "expect:fixme":
+                this.#result.expectCount.fixme++;
+                this.#fileResult.expectCount.fixme++;
+                if (this.#testResult) {
+                    this.#testResult.expectCount.fixme++;
+                }
+                this.#expectResult.status = "fixme";
                 this.#expectResult.timing.end = Date.now();
                 this.#expectResult = undefined;
                 break;
@@ -2066,7 +2174,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 }) {
@@ -2127,7 +2235,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) {
@@ -2143,13 +2251,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;
@@ -2163,11 +2271,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 = [];
@@ -2195,32 +2303,59 @@ 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 }));
     const codeFrame = diagnostic.origin ? (jsx(Text, { children: [jsx(Line, {}), jsx(CodeFrameText, { diagnosticCategory: diagnostic.category, diagnosticOrigin: diagnostic.origin, options: codeFrameOptions })] })) : undefined;
     return (jsx(Text, { children: [message, codeFrame, jsx(Line, {}), jsx(Text, { indent: 2, children: related })] }));
 }
-function diagnosticText(diagnostic, codeFrameOptions = {}) {
-    let prefix;
-    switch (diagnostic.category) {
-        case DiagnosticCategory.Error:
-            prefix = jsx(Text, { color: Color.Red, children: "Error: " });
+function diagnosticText(diagnostic, codeFrameOptions = {}) {
+    let prefix;
+    switch (diagnostic.category) {
+        case "error":
+            prefix = jsx(Text, { color: "31", children: "Error: " });
+            break;
+        case "warning":
+            prefix = jsx(Text, { color: "33", children: "Warning: " });
+            break;
+    }
+    return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { codeFrameOptions: codeFrameOptions, diagnostic: diagnostic })] }));
+}
+
+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 statusColor;
+    let statusText;
+    switch (status) {
+        case "runs":
+            statusColor = "33";
+            statusText = "runs";
+            break;
+        case "passed":
+            statusColor = "32";
+            statusText = "pass";
             break;
-        case DiagnosticCategory.Warning:
-            prefix = jsx(Text, { color: Color.Yellow, children: "Warning: " });
+        case "failed":
+            statusColor = "31";
+            statusText = "fail";
             break;
     }
-    return (jsx(Text, { children: [prefix, jsx(DiagnosticText, { codeFrameOptions: codeFrameOptions, diagnostic: diagnostic })] }));
+    return (jsx(Line, { children: [jsx(Text, { color: statusColor, children: statusText }), " ", jsx(FileNameText, { filePath: file.path })] }));
 }
 
 function fileViewText(lines, addEmptyFinalLine) {
@@ -2246,13 +2381,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 });
@@ -2260,8 +2395,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 });
@@ -2270,16 +2405,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, {})] }));
@@ -2328,69 +2466,44 @@ 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 CountText({ failed, fixme, passed, skipped, todo, total }) {
+    return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "31", children: [failed, " failed"] }), jsx(Text, { children: ", " })] })) : undefined, fixme > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [fixme, " fixme"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [skipped, " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: "35", children: [todo, " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "32", children: [passed, " passed"] }), jsx(Text, { children: ", " })] })) : undefined, jsx(Text, { children: [total, " total"] })] }));
 }
 function DurationText({ seconds }) {
     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 }) }));
+    const targetCountText = (jsx(RowText, { label: "Targets", text: jsx(CountText, { failed: targetCount.failed, fixme: targetCount.fixme, passed: targetCount.passed, skipped: targetCount.skipped, todo: targetCount.todo, total: targetCount.total }) }));
+    const fileCountText = (jsx(RowText, { label: "Test files", text: jsx(CountText, { failed: fileCount.failed, fixme: fileCount.fixme, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
+    const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, fixme: testCount.fixme, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
+    const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, fixme: expectCount.fixme, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
     return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
 }
 
-function 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;
-    let statusText;
-    switch (status) {
-        case ResultStatus.Runs:
-            statusColor = Color.Yellow;
-            statusText = "runs";
-            break;
-        case ResultStatus.Passed:
-            statusColor = Color.Green;
-            statusText = "pass";
-            break;
-        case ResultStatus.Failed:
-            statusColor = Color.Red;
-            statusText = "fail";
-            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" });
+            return jsx(Text, { color: "31", children: "\u00D7" });
         case "pass":
-            return jsx(Text, { color: Color.Green, children: "+" });
+            return jsx(Text, { color: "32", children: "+" });
         case "skip":
-            return jsx(Text, { color: Color.Yellow, children: "- skip" });
+            return jsx(Text, { color: "33", children: "- skip" });
+        case "fixme":
+            return jsx(Text, { color: "33", children: "- fixme" });
         case "todo":
-            return jsx(Text, { color: Color.Magenta, children: "- todo" });
+            return jsx(Text, { color: "35", children: "- todo" });
     }
 }
 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(StatusText, { status: status }), " ", 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() {
@@ -2403,7 +2516,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 });
 }
@@ -2480,7 +2593,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));
@@ -2492,7 +2605,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":
@@ -2507,25 +2620,25 @@ 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":
                 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());
@@ -2548,6 +2661,11 @@ class ListReporter extends BaseReporter {
                     this.#fileView.addTest("skip", payload.result.test.name);
                 }
                 break;
+            case "test:fixme":
+                if (this.#isFileViewExpanded) {
+                    this.#fileView.addTest("fixme", payload.result.test.name);
+                }
+                break;
             case "test:todo":
                 if (this.#isFileViewExpanded) {
                     this.#fileView.addTest("todo", payload.result.test.name);
@@ -2590,10 +2708,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;
                 }
@@ -2639,18 +2757,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);
     }
 }
 
@@ -2916,6 +3034,10 @@ class Select {
         }
         return matchPatterns.includedFile.test(filePath);
     }
+    static isFixtureFile(filePath, resolvedConfig) {
+        const matchPatterns = Select.#getMatchPatterns(resolvedConfig.fixtureFileMatch);
+        return Select.#isFileIncluded(Path.relative(resolvedConfig.rootPath, filePath), matchPatterns, resolvedConfig);
+    }
     static isTestFile(filePath, resolvedConfig) {
         const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
         return Select.#isFileIncluded(Path.relative(resolvedConfig.rootPath, filePath), matchPatterns, resolvedConfig);
@@ -2984,9 +3106,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] }]);
@@ -3015,7 +3137,7 @@ class WatchService {
                     case "\u001B":
                     case "q":
                     case "x":
-                        onClose(CancellationReason.WatchClose);
+                        onClose("watchClose");
                         break;
                     case "\u000D":
                     case "\u0020":
@@ -3031,14 +3153,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) => {
@@ -3051,7 +3173,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) {
@@ -3066,65 +3188,6 @@ 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());
-    }
-}
-
-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 nodeBelongsToArgumentList(compiler, node) {
     return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
 }
@@ -3134,7 +3197,7 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
-    #expectErrorRegex = /^( *)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
+    #expectErrorRegex = /^(\s*)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
     #filePath = "";
     #nodes = [];
     #projectService;
@@ -3155,16 +3218,27 @@ class AbilityLayer {
             this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
         }
     }
-    #belongsToNode(diagnostic) {
+    #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;
+    }
+    #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;
             }
         }
         return false;
     }
-    #belongsToDirective(diagnostic) {
+    #mapToDirectives(diagnostic) {
         if (!isDiagnosticWithLocation(diagnostic)) {
             return;
         }
@@ -3209,18 +3283,19 @@ class AbilityLayer {
         }
         return ranges;
     }
-    close() {
+    close(testTree) {
         if (this.#nodes.length > 0 || this.#suppressedErrorsMap != null) {
+            SourceService.set(testTree.sourceFile);
             this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
             const languageService = this.#projectService.getLanguageService(this.#filePath);
             const diagnostics = languageService?.getSemanticDiagnostics(this.#filePath);
             if (diagnostics != null) {
                 this.#nodes.reverse();
                 for (const diagnostic of diagnostics) {
-                    if (this.#belongsToNode(diagnostic)) {
+                    if (this.#mapToNodes(diagnostic)) {
                         continue;
                     }
-                    this.#belongsToDirective(diagnostic);
+                    this.#mapToDirectives(diagnostic);
                 }
             }
         }
@@ -3252,36 +3327,36 @@ class AbilityLayer {
         }
         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) {
+    handleExpect(expect) {
+        const expectStart = expect.node.getStart();
+        const expectExpressionEnd = expect.node.expression.getEnd();
+        const expectEnd = expect.node.getEnd();
+        const matcherNameEnd = expect.matcherNameNode.getEnd();
+        switch (expect.matcherNameNode.name.text) {
             case "toBeApplicable":
-                this.#addRanges(assertionNode, [
+                this.#addRanges(expect, [
                     { start: expectStart, end: expectExpressionEnd },
                     { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeCallableWith":
-                this.#eraseTrailingComma(assertionNode.source, assertionNode);
-                this.#addRanges(assertionNode, [
+                this.#eraseTrailingComma(expect.source, expect);
+                this.#addRanges(expect, [
                     {
                         start: expectStart,
                         end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? ";" : "",
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
                     },
                     { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeConstructableWith":
-                this.#eraseTrailingComma(assertionNode.source, assertionNode);
-                this.#addRanges(assertionNode, [
+                this.#eraseTrailingComma(expect.source, expect);
+                this.#addRanges(expect, [
                     {
                         start: expectStart,
                         end: expectExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? "; new" : "new",
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? "; new" : "new",
                     },
                     { start: expectEnd, end: matcherNameEnd },
                 ]);
@@ -3291,7 +3366,7 @@ class AbilityLayer {
     #handleSuppressedErrors(testTree) {
         const suppressedErrors = this.#collectSuppressedErrors();
         if (this.#resolvedConfig.checkSuppressedErrors) {
-            testTree.suppressedErrors = Object.assign(suppressedErrors, { sourceFile: testTree.sourceFile });
+            testTree.suppressedErrors = suppressedErrors;
             this.#suppressedErrorsMap = new Map();
         }
         for (const suppressedError of suppressedErrors) {
@@ -3336,22 +3411,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;
@@ -3400,24 +3514,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;
@@ -3435,14 +3546,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;
     }
@@ -3458,9 +3569,6 @@ class TestTree {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
     }
-    getDirectiveRanges(compiler) {
-        return Directive.getDirectiveRanges(compiler, this.sourceFile);
-    }
 }
 
 class WhenNode extends TestTreeNode {
@@ -3498,7 +3606,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);
@@ -3506,7 +3614,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;
@@ -3520,15 +3628,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.#abilityLayer.handleExpect(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;
@@ -3540,7 +3648,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));
@@ -3568,7 +3676,7 @@ class CollectService {
         this.#abilityLayer.open(testTree);
         this.#identifierLookup.open();
         this.#collectTestTreeNodes(sourceFile, testTree, testTree);
-        this.#abilityLayer.close();
+        this.#abilityLayer.close(testTree);
         EventEmitter.dispatch(["collect:end", { tree: testTree }]);
         return testTree;
     }
@@ -3583,15 +3691,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;
@@ -3630,13 +3738,29 @@ 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 }]);
     }
 }
 
+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 = "";
@@ -3687,8 +3811,6 @@ class ProjectService {
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
-            allowJs: true,
-            checkJs: true,
             exactOptionalPropertyTypes: true,
             jsx: this.#compiler.JsxEmit.Preserve,
             module: this.#compiler.ModuleKind.NodeNext,
@@ -3710,7 +3832,7 @@ 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;
@@ -3743,14 +3865,14 @@ class ProjectService {
                 "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.#resolvedConfig.checkSourceFiles && !this.#seenTestFiles.has(filePath)) {
+        if (!this.#seenTestFiles.has(filePath)) {
             this.#seenTestFiles.add(filePath);
             const languageService = this.getLanguageService(filePath);
             const program = languageService?.getProgram();
@@ -3762,10 +3884,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 true;
+                return false;
             });
             const diagnostics = [];
             for (const sourceFile of sourceFilesToCheck) {
@@ -3798,24 +3926,26 @@ class SuppressedDiagnosticText {
 }
 
 class SuppressedService {
-    match(suppressedErrors, onDiagnostics) {
-        for (const suppressedError of suppressedErrors) {
+    match(testTree, onDiagnostics) {
+        if (!testTree.suppressedErrors) {
+            return;
+        }
+        for (const suppressedError of testTree.suppressedErrors) {
             if (suppressedError.diagnostics.length === 0 || suppressedError.ignore) {
                 continue;
             }
+            const related = [
+                Diagnostic.error(SuppressedDiagnosticText.suppressedError(suppressedError.diagnostics.length)),
+                ...Diagnostic.fromDiagnostics(suppressedError.diagnostics),
+            ];
+            const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, testTree.sourceFile);
             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)]);
+                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
                 continue;
             }
-            const related = [
-                Diagnostic.error(SuppressedDiagnosticText.suppressedError(suppressedError.diagnostics.length)),
-                ...Diagnostic.fromDiagnostics(suppressedError.diagnostics, suppressedErrors.sourceFile),
-            ];
             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 })]);
                 continue;
             }
@@ -3823,25 +3953,28 @@ class SuppressedService {
             if (Array.isArray(messageText)) {
                 messageText = messageText.join("\n");
             }
-            if (!messageText.includes(suppressedError.argument.text)) {
+            if (!this.#matchMessage(messageText, suppressedError.argument.text)) {
                 const text = [SuppressedDiagnosticText.messageDidNotMatch()];
-                const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, suppressedErrors.sourceFile);
+                const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, testTree.sourceFile);
                 onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
             }
         }
     }
+    #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);
+    }
 }
 
-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.`;
@@ -3965,21 +4098,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);
@@ -3995,13 +4122,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));
     }
@@ -4009,9 +4136,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);
         }
     }
@@ -4052,9 +4179,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()) {
@@ -4089,10 +4216,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);
@@ -4102,7 +4229,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;
@@ -4210,7 +4337,7 @@ class ToAcceptProps {
         if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
-                const text = matchWorker.assertion.isNot
+                const text = matchWorker.assertionNode.isNot
                     ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
                     : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
@@ -4265,10 +4392,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)];
     }
 }
@@ -4315,18 +4442,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;
@@ -4343,8 +4474,8 @@ 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,
         };
     }
 }
@@ -4389,32 +4520,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;
@@ -4454,7 +4578,7 @@ class ToBeCallableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4489,7 +4613,7 @@ class ToBeConstructableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4509,8 +4633,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)];
     }
@@ -4560,28 +4684,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]),
@@ -4609,12 +4733,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),
@@ -4664,16 +4788,16 @@ class ExpectService {
         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;
         }
@@ -4682,29 +4806,29 @@ class ExpectService {
             case "toBe":
             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));
     }
 }
@@ -4825,82 +4949,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;
+            flags |= 8;
         }
-        if (node.flags & TestTreeNodeFlags.Fail) {
-            mode |= RunMode.Fail;
-        }
-        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;
         }
@@ -4910,59 +5097,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",
                 {
@@ -4972,24 +5157,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.expectCount.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;
@@ -5002,89 +5192,87 @@ 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, undefined, this.#resolvedConfig.rootPath);
+        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, this.#resolvedConfig.rootPath);
+            return this.#resolveFileFacts(file, fileResult, runModeFlags);
         }
-        return { runMode, testTree, typeChecker };
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
+        this.#suppressedService.match(testTree, (diagnostics) => {
+            this.#onDiagnostics(diagnostics, fileResult);
+        });
+        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.2.0";
+    static version = "5.0.0-beta.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5092,7 +5280,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);
         }
     }
@@ -5121,39 +5309,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);
         }
@@ -5163,14 +5351,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;
         }
@@ -5198,7 +5386,7 @@ class Cli {
             return;
         }
         do {
-            if (cancellationToken.reason === CancellationReason.ConfigChange) {
+            if (cancellationToken.reason === "configChange") {
                 cancellationToken.reset();
                 exitCodeHandler.resetCode();
                 OutputService.clearTerminal();
@@ -5253,7 +5441,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) {
@@ -5262,7 +5450,7 @@ class Cli {
             cancellationToken.reset();
             OutputService.writeMessage(waitingForFileChangesText());
             const onChanged = () => {
-                cancellationToken.cancel(CancellationReason.ConfigChange);
+                cancellationToken.cancel("configChange");
                 for (const watcher of watchers) {
                     watcher.close();
                 }
@@ -5284,4 +5472,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, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectNode, ExpectResult, ExpectService, FileLocation, FileResult, FileWatcher, Glob, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, SourceService, Store, SummaryReporter, SuppressedService, TargetResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };