tstyche 3.5.0 → 4.0.0-beta.1

package/build/tstyche.js

@@ -93,7 +93,7 @@ class DiagnosticOrigin {
         this.assertion = assertion;
     }
     static fromAssertion(assertion) {
-        const node = assertion.matcherName;
+        const node = assertion.matcherNameNode.name;
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
     static fromNode(node, assertion) {
@@ -140,15 +140,15 @@ class Diagnostic {
             }
             const text = typeof diagnostic.messageText === "string"
                 ? diagnostic.messageText
-                : Diagnostic.#toMessageText(diagnostic.messageText);
+                : Diagnostic.toMessageText(diagnostic.messageText);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
         });
     }
-    static #toMessageText(chain) {
+    static toMessageText(chain) {
         const result = [chain.messageText];
         if (chain.next != null) {
             for (const nextChain of chain.next) {
-                result.push(...Diagnostic.#toMessageText(nextChain));
+                result.push(...Diagnostic.toMessageText(nextChain));
             }
         }
         return result;
@@ -363,9 +363,6 @@ class Version {
     static isSatisfiedWith(source, target) {
         return source === target || Version.#satisfies(source, target);
     }
-    static isVersionTag(target) {
-        return /^\d+/.test(target);
-    }
     static #satisfies(source, target) {
         const sourceElements = source.split(/\.|-/);
         const targetElements = target.split(/\.|-/);
@@ -394,8 +391,8 @@ class StoreDiagnosticText {
     static failedToFetchMetadata(registry) {
         return `Failed to fetch metadata of the 'typescript' package from '${registry}'.`;
     }
-    static failedToInstalTypeScript(version) {
-        return `Failed to install 'typescript@${version}'.`;
+    static failedToFetchPackage(version) {
+        return `Failed to fetch the 'typescript@${version}' package.`;
     }
     static failedToUpdateMetadata(registry) {
         return `Failed to update metadata of the 'typescript' package from '${registry}'.`;
@@ -499,9 +496,10 @@ class LockService {
 }
 
 class Manifest {
-    static #version = "2";
+    static #version = "3";
     $version;
     lastUpdated;
+    minorVersions;
     npmRegistry;
     packages;
     resolutions;
@@ -509,6 +507,7 @@ class Manifest {
     constructor(data) {
         this.$version = data.$version ?? Manifest.#version;
         this.lastUpdated = data.lastUpdated ?? Date.now();
+        this.minorVersions = data.minorVersions;
         this.npmRegistry = data.npmRegistry;
         this.packages = data.packages;
         this.resolutions = data.resolutions;
@@ -542,6 +541,7 @@ class Manifest {
         const manifestData = {
             $version: this.$version,
             lastUpdated: this.lastUpdated,
+            minorVersions: this.minorVersions,
             npmRegistry: this.npmRegistry,
             packages: this.packages,
             resolutions: this.resolutions,
@@ -556,7 +556,7 @@ class ManifestService {
     #manifestFilePath;
     #npmRegistry;
     #storePath;
-    #supportedVersionRegex = /^(4|5)\.\d\.\d$/;
+    #supportedVersionRegex = /^(5)\.\d\.\d$/;
     constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
         this.#npmRegistry = npmRegistry;
@@ -591,7 +591,7 @@ class ManifestService {
                 packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
         }
-        const minorVersions = new Set(versions.map((version) => version.slice(0, -2)));
+        const minorVersions = [...new Set(versions.map((version) => version.slice(0, -2)))];
         for (const tag of minorVersions) {
             const resolvedVersion = versions.findLast((version) => version.startsWith(tag));
             if (resolvedVersion != null) {
@@ -608,7 +608,7 @@ class ManifestService {
                 }
             }
         }
-        return new Manifest({ npmRegistry: this.#npmRegistry, packages, resolutions, versions });
+        return new Manifest({ minorVersions, npmRegistry: this.#npmRegistry, packages, resolutions, versions });
     }
     async open(options) {
         if (!existsSync(this.#manifestFilePath)) {
@@ -685,9 +685,6 @@ class PackageService {
         if (response?.body != null) {
             const targetPath = `${packagePath}-${Math.random().toString(32).slice(2)}`;
             for await (const file of TarReader.extract(response.body)) {
-                if (!file.name.startsWith("package/")) {
-                    continue;
-                }
                 const filePath = Path.join(targetPath, file.name.replace("package/", ""));
                 const directoryPath = Path.dirname(filePath);
                 if (!existsSync(directoryPath)) {
@@ -702,7 +699,7 @@ class PackageService {
     }
     async ensure(packageVersion, manifest) {
         let packagePath = Path.join(this.#storePath, `typescript@${packageVersion}`);
-        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToInstalTypeScript(packageVersion));
+        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToFetchPackage(packageVersion));
         if (await this.#lockService.isLocked(packagePath, diagnostic)) {
             return;
         }
@@ -742,11 +739,7 @@ class Store {
         Store.#packageService = new PackageService(Store.#storePath, Store.#fetcher, Store.#lockService);
         Store.#manifestService = new ManifestService(Store.#storePath, Store.#npmRegistry, Store.#fetcher);
     }
-    static async getSupportedTags() {
-        await Store.open();
-        return Store.#supportedTags;
-    }
-    static async install(tag) {
+    static async fetch(tag) {
         if (tag === "current") {
             return;
         }
@@ -799,14 +792,11 @@ class Store {
             modulePath = Path.resolve(modulePath, "../tsserverlibrary.js");
         }
         const sourceText = await fs.readFile(modulePath, { encoding: "utf8" });
-        const toExpose = [];
-        if (Version.isSatisfiedWith(packageVersion, "4.4")) {
-            toExpose.push("isApplicableIndexType");
-        }
-        if (!Version.isSatisfiedWith(packageVersion, "4.6")) {
-            toExpose.push("getTypeOfSymbol");
-        }
-        toExpose.push("isTypeRelatedTo", "relation: { assignable: assignableRelation, identity: identityRelation, subtype: strictSubtypeRelation }");
+        const toExpose = [
+            "isApplicableIndexType",
+            "isTypeRelatedTo",
+            "relation: { assignable: assignableRelation, identity: identityRelation }",
+        ];
         const modifiedSourceText = sourceText.replace("return checker;", `return { ...checker, ${toExpose.join(", ")} };`);
         const compiledWrapper = vm.compileFunction(modifiedSourceText, ["exports", "require", "module", "__filename", "__dirname"], { filename: modulePath });
         compiledWrapper(exports, createRequire(modulePath), module, modulePath, Path.dirname(modulePath));
@@ -857,7 +847,7 @@ class Target {
             }
             await Store.open();
             if (Store.manifest != null) {
-                let versions = Object.keys(Store.manifest.resolutions).slice(0, -4);
+                let versions = [...Store.manifest.minorVersions];
                 for (const comparator of query.split(" ")) {
                     versions = Target.#filter(comparator, versions);
                 }
@@ -913,15 +903,15 @@ class Options {
         },
         {
             brand: OptionBrand.BareTrue,
-            description: "Print the list of command line options with brief descriptions and exit.",
+            description: "Fetch the specified versions of the 'typescript' package and exit.",
             group: OptionGroup.CommandLine,
-            name: "help",
+            name: "fetch",
         },
         {
             brand: OptionBrand.BareTrue,
-            description: "Install specified versions of the 'typescript' package and exit.",
+            description: "Print the list of command line options with brief descriptions and exit.",
             group: OptionGroup.CommandLine,
-            name: "install",
+            name: "help",
         },
         {
             brand: OptionBrand.BareTrue,
@@ -1504,11 +1494,11 @@ class ConfigFileParser {
 }
 
 const defaultOptions = {
-    checkSourceFiles: false,
+    checkSourceFiles: true,
     failFast: false,
     plugins: [],
-    rejectAnyType: false,
-    rejectNeverType: false,
+    rejectAnyType: true,
+    rejectNeverType: true,
     reporters: ["list", "summary"],
     rootPath: Path.resolve("./"),
     target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
@@ -1909,152 +1899,544 @@ class ResultHandler {
     }
 }
 
-function jsx(type, props) {
-    return { props, type };
-}
-
-var Color;
-(function (Color) {
-    Color["Reset"] = "0";
-    Color["Red"] = "31";
-    Color["Green"] = "32";
-    Color["Yellow"] = "33";
-    Color["Blue"] = "34";
-    Color["Magenta"] = "35";
-    Color["Cyan"] = "36";
-    Color["Gray"] = "90";
-})(Color || (Color = {}));
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
 
-function Text({ children, color, indent }) {
-    const ansiEscapes = [];
-    if (color != null) {
-        ansiEscapes.push(color);
+class TestTreeNode {
+    brand;
+    children = [];
+    #compiler;
+    diagnostics = new Set();
+    flags;
+    name = "";
+    node;
+    parent;
+    constructor(compiler, brand, node, parent, flags) {
+        this.brand = brand;
+        this.#compiler = compiler;
+        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]) &&
+            compiler.isBlock(node.arguments[1].body)) {
+            const blockStart = node.arguments[1].body.getStart();
+            const blockEnd = node.arguments[1].body.getEnd();
+            for (const diagnostic of parent.diagnostics) {
+                if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
+                    this.diagnostics.add(diagnostic);
+                    parent.diagnostics.delete(diagnostic);
+                }
+            }
+        }
+    }
+    validate() {
+        const diagnostics = [];
+        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()'.`;
+        const getParentCallExpression = (node) => {
+            while (!this.#compiler.isCallExpression(node.parent)) {
+                node = node.parent;
+            }
+            return node.parent;
+        };
+        switch (this.brand) {
+            case TestTreeNodeBrand.Describe:
+                for (const child of this.children) {
+                    if (child.brand === TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(getParentCallExpression(child.node))));
+                    }
+                }
+                break;
+            case TestTreeNodeBrand.Test:
+            case TestTreeNodeBrand.Expect:
+                for (const child of this.children) {
+                    if (child.brand !== TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(child.node)));
+                    }
+                }
+                break;
+        }
+        return diagnostics;
     }
-    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] }));
 }
 
-function Line({ children, color, indent }) {
-    return (jsx(Text, { color: color, indent: indent, children: [children, jsx("newLine", {})] }));
+class AssertionNode extends TestTreeNode {
+    abilityDiagnostics;
+    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 (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
+    }
 }
 
-class Scribbler {
-    #indentStep = "  ";
-    #newLine;
-    #noColor;
-    #notEmptyLineRegex = /^(?!$)/gm;
-    constructor(options) {
-        this.#newLine = options?.newLine ?? "\n";
-        this.#noColor = options?.noColor ?? environmentOptions.noColor;
-    }
-    #escapeSequence(attributes) {
-        return ["\u001B[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
-    }
-    #indentEachLine(lines, level) {
-        if (level === 0) {
-            return lines;
-        }
-        return lines.replace(this.#notEmptyLineRegex, this.#indentStep.repeat(level));
+class AbilityLayer {
+    #filePath = "";
+    #nodes = [];
+    #projectService;
+    #resolvedConfig;
+    #text = "";
+    constructor(projectService, resolvedConfig) {
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
     }
-    render(element) {
-        if (typeof element.type === "function") {
-            return this.render(element.type({ ...element.props }));
-        }
-        if (element.type === "ansi" && !this.#noColor) {
-            return this.#escapeSequence(element.props.escapes);
+    #getErasedRangeText(range) {
+        if (this.#text.indexOf("\n", range.start) >= range.end) {
+            return " ".repeat(range.end - range.start);
         }
-        if (element.type === "newLine") {
-            return this.#newLine;
+        const text = [];
+        for (let i = range.start; i < range.end; i++) {
+            switch (this.#text.charAt(i)) {
+                case "\n":
+                case "\r":
+                    text.push(this.#text.charAt(i));
+                    break;
+                default:
+                    text.push(" ");
+            }
         }
-        if (element.type === "text") {
-            const text = this.#visitChildren(element.props.children);
-            return this.#indentEachLine(text, element.props.indent);
+        return text.join("");
+    }
+    #addRanges(node, ranges) {
+        this.#nodes.push(node);
+        for (const range of ranges) {
+            const rangeText = this.#getErasedRangeText(range);
+            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
         }
-        return "";
     }
-    #visitChildren(children) {
-        const text = [];
-        for (const child of children) {
-            if (typeof child === "string" || typeof child === "number") {
-                text.push(child);
-                continue;
-            }
-            if (Array.isArray(child)) {
-                text.push(this.#visitChildren(child));
-                continue;
+    close() {
+        if (this.#nodes.length > 0) {
+            this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
+            const languageService = this.#projectService.getLanguageService(this.#filePath);
+            const diagnostics = new Set(languageService?.getSemanticDiagnostics(this.#filePath)?.toReversed());
+            if (diagnostics.size > 0) {
+                for (const node of this.#nodes.toReversed()) {
+                    for (const diagnostic of diagnostics) {
+                        if (diagnostic.start != null &&
+                            diagnostic.start >= node.matcherNode.pos &&
+                            diagnostic.start <= node.matcherNode.end) {
+                            if (!node.abilityDiagnostics) {
+                                node.abilityDiagnostics = new Set();
+                            }
+                            node.abilityDiagnostics.add(diagnostic);
+                            diagnostics.delete(diagnostic);
+                        }
+                    }
+                }
             }
-            if (child != null && typeof child === "object") {
-                text.push(this.render(child));
+        }
+        this.#filePath = "";
+        this.#nodes = [];
+        this.#text = "";
+    }
+    handleNode(assertionNode) {
+        switch (assertionNode.matcherNameNode.name.text) {
+            case "toBeApplicable": {
+                const expectStart = assertionNode.node.pos;
+                const expectExpressionEnd = assertionNode.node.expression.end;
+                const expectEnd = assertionNode.node.end;
+                const matcherNameEnd = assertionNode.matcherNameNode.end;
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd + 1, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd - 1 },
+                ]);
+                break;
             }
         }
-        return text.join("");
+    }
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
     }
 }
 
-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] })] }));
-}
-
-function describeNameText(name, indent = 0) {
-    return jsx(Line, { indent: indent + 1, children: name });
-}
+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 = {}));
 
-function BreadcrumbsText({ ancestor }) {
-    const text = [];
-    while ("name" in ancestor) {
-        text.push(ancestor.name);
-        ancestor = ancestor.parent;
-    }
-    text.push("");
-    return jsx(Text, { color: Color.Gray, 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 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) })] }));
-}
-function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
-    const linesAbove = options?.linesAbove ?? 2;
-    const linesBelow = options?.linesBelow ?? 3;
-    const showBreadcrumbs = options?.showBreadcrumbs ?? true;
-    const lineMap = diagnosticOrigin.sourceFile.getLineStarts();
-    const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
-    const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
-    const firstLine = Math.max(firstMarkedLine - linesAbove, 0);
-    const lastLine = Math.min(lastMarkedLine + linesBelow, lineMap.length - 1);
-    const gutterWidth = (lastLine + 1).toString().length + 2;
-    let highlightColor;
-    switch (diagnosticCategory) {
-        case DiagnosticCategory.Error:
-            highlightColor = Color.Red;
-            break;
-        case DiagnosticCategory.Warning:
-            highlightColor = Color.Yellow;
-            break;
+class IdentifierLookup {
+    #compiler;
+    #identifiers;
+    #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
+    constructor(compiler, identifiers) {
+        this.#compiler = compiler;
+        this.#identifiers = identifiers ?? {
+            namedImports: {
+                describe: undefined,
+                expect: undefined,
+                it: undefined,
+                namespace: undefined,
+                test: undefined,
+            },
+            namespace: undefined,
+        };
     }
-    const codeFrame = [];
-    for (let index = firstLine; index <= lastLine; index++) {
-        const lineStart = lineMap[index];
-        const lineEnd = index === lineMap.length - 1 ? diagnosticOrigin.sourceFile.text.length : lineMap[index + 1];
-        const lineText = diagnosticOrigin.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
-        if (index >= firstMarkedLine && index <= lastMarkedLine) {
-            codeFrame.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineNumberColor: highlightColor, lineText: lineText }));
-            if (index === firstMarkedLine) {
-                const squiggleLength = index === lastMarkedLine
-                    ? lastMarkedLineCharacter - firstMarkedLineCharacter
-                    : lineText.length - firstMarkedLineCharacter;
-                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleColor: highlightColor, squiggleWidth: squiggleLength }));
-            }
-            else if (index === lastMarkedLine) {
-                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lastMarkedLineCharacter }));
+    handleImportDeclaration(node) {
+        if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
+            node.importClause?.isTypeOnly !== true &&
+            node.importClause?.namedBindings != null) {
+            if (this.#compiler.isNamedImports(node.importClause.namedBindings)) {
+                for (const element of node.importClause.namedBindings.elements) {
+                    if (element.isTypeOnly) {
+                        continue;
+                    }
+                    let identifierKey;
+                    if (element.propertyName) {
+                        identifierKey = element.propertyName.getText();
+                    }
+                    else {
+                        identifierKey = element.name.getText();
+                    }
+                    if (identifierKey in this.#identifiers.namedImports) {
+                        this.#identifiers.namedImports[identifierKey] = element.name.getText();
+                    }
+                }
             }
-            else {
-                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lineText.length }));
+            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
+                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
             }
         }
-        else {
-            codeFrame.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineText: lineText }));
-        }
+    }
+    resolveTestMemberMeta(node) {
+        let flags = TestTreeNodeFlags.None;
+        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;
+                    break;
+                case "skip":
+                    flags |= TestTreeNodeFlags.Skip;
+                    break;
+                case "todo":
+                    flags |= TestTreeNodeFlags.Todo;
+                    break;
+            }
+            expression = expression.expression;
+        }
+        let identifierName;
+        if (this.#compiler.isPropertyAccessExpression(expression) &&
+            expression.expression.getText() === this.#identifiers.namespace) {
+            identifierName = expression.name.getText();
+        }
+        else {
+            identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+        }
+        if (!identifierName) {
+            return;
+        }
+        switch (identifierName) {
+            case "describe":
+                return { brand: TestTreeNodeBrand.Describe, flags };
+            case "it":
+            case "test":
+                return { brand: TestTreeNodeBrand.Test, flags };
+            case "expect":
+                return { brand: TestTreeNodeBrand.Expect, flags };
+        }
+        return;
+    }
+}
+
+class TestTree {
+    children = [];
+    diagnostics;
+    hasOnly = false;
+    sourceFile;
+    constructor(diagnostics, sourceFile) {
+        this.diagnostics = diagnostics;
+        this.sourceFile = sourceFile;
+    }
+}
+
+class CollectService {
+    #abilityLayer;
+    #compiler;
+    #projectService;
+    #resolvedConfig;
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
+        this.#abilityLayer = new AbilityLayer(this.#projectService, this.#resolvedConfig);
+    }
+    #collectTestTreeNodes(node, identifiers, parent) {
+        if (this.#compiler.isCallExpression(node)) {
+            const meta = identifiers.resolveTestMemberMeta(node);
+            if (meta != null && (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test)) {
+                const testTreeNode = new TestTreeNode(this.#compiler, meta.brand, node, parent, meta.flags);
+                parent.children.push(testTreeNode);
+                EventEmitter.dispatch(["collect:node", { testNode: testTreeNode }]);
+                this.#compiler.forEachChild(node, (node) => {
+                    this.#collectTestTreeNodes(node, identifiers, testTreeNode);
+                });
+                return;
+            }
+            if (meta != null && meta.brand === TestTreeNodeBrand.Expect) {
+                const modifierNode = this.#getChainedNode(node, "type");
+                if (!modifierNode) {
+                    return;
+                }
+                const notNode = this.#getChainedNode(modifierNode, "not");
+                const matcherNameNode = this.#getChainedNode(notNode ?? modifierNode);
+                if (!matcherNameNode) {
+                    return;
+                }
+                const matcherNode = this.#getMatcherNode(matcherNameNode);
+                if (!matcherNode) {
+                    return;
+                }
+                const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
+                parent.children.push(assertionNode);
+                this.#abilityLayer.handleNode(assertionNode);
+                EventEmitter.dispatch(["collect:node", { testNode: assertionNode }]);
+                this.#compiler.forEachChild(node, (node) => {
+                    this.#collectTestTreeNodes(node, identifiers, assertionNode);
+                });
+                return;
+            }
+        }
+        if (this.#compiler.isImportDeclaration(node)) {
+            identifiers.handleImportDeclaration(node);
+            return;
+        }
+        this.#compiler.forEachChild(node, (node) => {
+            this.#collectTestTreeNodes(node, identifiers, parent);
+        });
+    }
+    createTestTree(sourceFile, semanticDiagnostics = []) {
+        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
+        EventEmitter.dispatch(["collect:start", { testTree }]);
+        this.#abilityLayer.open(sourceFile);
+        this.#collectTestTreeNodes(sourceFile, new IdentifierLookup(this.#compiler), testTree);
+        this.#abilityLayer.close();
+        EventEmitter.dispatch(["collect:end", { testTree }]);
+        return testTree;
+    }
+    #getChainedNode({ parent }, name) {
+        if (!this.#compiler.isPropertyAccessExpression(parent)) {
+            return;
+        }
+        if (name != null && name !== parent.name.getText()) {
+            return;
+        }
+        return parent;
+    }
+    #getMatcherNode(node) {
+        if (this.#compiler.isCallExpression(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isDecorator(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isParenthesizedExpression(node.parent)) {
+            return this.#getMatcherNode(node.parent);
+        }
+        return;
+    }
+}
+
+class TestTreeHandler {
+    testTree;
+    on([event, payload]) {
+        switch (event) {
+            case "collect:start":
+                this.testTree = payload.testTree;
+                break;
+            case "collect:end":
+                this.testTree = undefined;
+                break;
+            case "collect:node":
+                if (payload.testNode.flags & TestTreeNodeFlags.Only) {
+                    this.testTree.hasOnly = true;
+                }
+                break;
+        }
+    }
+}
+
+function jsx(type, props) {
+    return { props, type };
+}
+
+var Color;
+(function (Color) {
+    Color["Reset"] = "0";
+    Color["Red"] = "31";
+    Color["Green"] = "32";
+    Color["Yellow"] = "33";
+    Color["Blue"] = "34";
+    Color["Magenta"] = "35";
+    Color["Cyan"] = "36";
+    Color["Gray"] = "90";
+})(Color || (Color = {}));
+
+function Text({ children, color, indent }) {
+    const ansiEscapes = [];
+    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] }));
+}
+
+function Line({ children, color, indent }) {
+    return (jsx(Text, { color: color, indent: indent, children: [children, jsx("newLine", {})] }));
+}
+
+class Scribbler {
+    #indentStep = "  ";
+    #newLine;
+    #noColor;
+    #notEmptyLineRegex = /^(?!$)/gm;
+    constructor(options) {
+        this.#newLine = options?.newLine ?? "\n";
+        this.#noColor = options?.noColor ?? environmentOptions.noColor;
+    }
+    #escapeSequence(attributes) {
+        return ["\u001B[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
+    }
+    #indentEachLine(lines, level) {
+        if (level === 0) {
+            return lines;
+        }
+        return lines.replace(this.#notEmptyLineRegex, this.#indentStep.repeat(level));
+    }
+    render(element) {
+        if (typeof element.type === "function") {
+            return this.render(element.type({ ...element.props }));
+        }
+        if (element.type === "ansi" && !this.#noColor) {
+            return this.#escapeSequence(element.props.escapes);
+        }
+        if (element.type === "newLine") {
+            return this.#newLine;
+        }
+        if (element.type === "text") {
+            const text = this.#visitChildren(element.props.children);
+            return this.#indentEachLine(text, element.props.indent);
+        }
+        return "";
+    }
+    #visitChildren(children) {
+        const text = [];
+        for (const child of children) {
+            if (typeof child === "string" || typeof child === "number") {
+                text.push(child);
+                continue;
+            }
+            if (Array.isArray(child)) {
+                text.push(this.#visitChildren(child));
+                continue;
+            }
+            if (child != null && typeof child === "object") {
+                text.push(this.render(child));
+            }
+        }
+        return text.join("");
+    }
+}
+
+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] })] }));
+}
+
+function describeNameText(name, indent = 0) {
+    return jsx(Line, { indent: indent + 1, children: name });
+}
+
+function BreadcrumbsText({ ancestor }) {
+    const text = [];
+    while ("name" in ancestor) {
+        text.push(ancestor.name);
+        ancestor = ancestor.parent;
+    }
+    text.push("");
+    return jsx(Text, { color: Color.Gray, 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 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) })] }));
+}
+function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
+    const linesAbove = options?.linesAbove ?? 2;
+    const linesBelow = options?.linesBelow ?? 3;
+    const showBreadcrumbs = options?.showBreadcrumbs ?? true;
+    const lineMap = diagnosticOrigin.sourceFile.getLineStarts();
+    const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
+    const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
+    const firstLine = Math.max(firstMarkedLine - linesAbove, 0);
+    const lastLine = Math.min(lastMarkedLine + linesBelow, lineMap.length - 1);
+    const gutterWidth = (lastLine + 1).toString().length + 2;
+    let highlightColor;
+    switch (diagnosticCategory) {
+        case DiagnosticCategory.Error:
+            highlightColor = Color.Red;
+            break;
+        case DiagnosticCategory.Warning:
+            highlightColor = Color.Yellow;
+            break;
+    }
+    const codeFrame = [];
+    for (let index = firstLine; index <= lastLine; index++) {
+        const lineStart = lineMap[index];
+        const lineEnd = index === lineMap.length - 1 ? diagnosticOrigin.sourceFile.text.length : lineMap[index + 1];
+        const lineText = diagnosticOrigin.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
+        if (index >= firstMarkedLine && index <= lastMarkedLine) {
+            codeFrame.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineNumberColor: highlightColor, lineText: lineText }));
+            if (index === firstMarkedLine) {
+                const squiggleLength = index === lastMarkedLine
+                    ? lastMarkedLineCharacter - firstMarkedLineCharacter
+                    : lineText.length - firstMarkedLineCharacter;
+                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleColor: highlightColor, squiggleWidth: squiggleLength }));
+            }
+            else if (index === lastMarkedLine) {
+                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lastMarkedLineCharacter }));
+            }
+            else {
+                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lineText.length }));
+            }
+        }
+        else {
+            codeFrame.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineText: lineText }));
+        }
     }
     let breadcrumbs;
     if (showBreadcrumbs && diagnosticOrigin.assertion != null) {
@@ -2150,7 +2532,7 @@ function CommandLineUsageText() {
     const usage = [
         ["tstyche", "Run all tests."],
         ["tstyche path/to/first.test.ts", "Only run the test files with matching path."],
-        ["tstyche --target 4.9,5.3.2,current", "Test on all specified versions of TypeScript."],
+        ["tstyche --target 5.3,5.6.2,current", "Test on all specified 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 });
@@ -2363,21 +2745,11 @@ class ListReporter extends BaseReporter {
     #hasReportedError = false;
     #hasReportedUses = false;
     #isFileViewExpanded = false;
-    #seenDeprecations = new Set();
     get #isLastFile() {
         return this.#fileCount === 0;
     }
-    on([event, payload]) {
-        switch (event) {
-            case "deprecation:info": {
-                for (const diagnostic of payload.diagnostics) {
-                    if (!this.#seenDeprecations.has(diagnostic.text.toString())) {
-                        this.#fileView.addMessage(diagnosticText(diagnostic));
-                        this.#seenDeprecations.add(diagnostic.text.toString());
-                    }
-                }
-                break;
-            }
+    on([event, payload]) {
+        switch (event) {
             case "run:start":
                 this.#isFileViewExpanded = payload.result.tasks.length === 1 && this.resolvedConfig.watch !== true;
                 break;
@@ -2429,7 +2801,6 @@ class ListReporter extends BaseReporter {
                     this.#hasReportedError = true;
                 }
                 this.#fileView.clear();
-                this.#seenDeprecations.clear();
                 break;
             case "describe:start":
                 if (this.#isFileViewExpanded) {
@@ -2472,707 +2843,438 @@ class ListReporter extends BaseReporter {
             case "expect:error":
             case "expect:fail":
                 for (const diagnostic of payload.diagnostics) {
-                    this.#fileView.addMessage(diagnosticText(diagnostic));
-                }
-                break;
-        }
-    }
-}
-
-class SetupReporter {
-    on([event, payload]) {
-        if (event === "store:adds") {
-            OutputService.writeMessage(addsPackageText(payload.packageVersion, payload.packagePath));
-            return;
-        }
-        if ("diagnostics" in payload) {
-            for (const diagnostic of payload.diagnostics) {
-                switch (diagnostic.category) {
-                    case DiagnosticCategory.Error:
-                        OutputService.writeError(diagnosticText(diagnostic));
-                        break;
-                    case DiagnosticCategory.Warning:
-                        OutputService.writeWarning(diagnosticText(diagnostic));
-                        break;
-                }
-            }
-        }
-    }
-}
-
-class SummaryReporter extends BaseReporter {
-    on([event, payload]) {
-        if (this.resolvedConfig.watch) {
-            return;
-        }
-        if (event === "run:end") {
-            OutputService.writeMessage(summaryText({
-                duration: payload.result.timing.duration,
-                expectCount: payload.result.expectCount,
-                fileCount: payload.result.fileCount,
-                onlyMatch: payload.result.resolvedConfig.only,
-                pathMatch: payload.result.resolvedConfig.pathMatch,
-                skipMatch: payload.result.resolvedConfig.skip,
-                targetCount: payload.result.targetCount,
-                testCount: payload.result.testCount,
-            }));
-        }
-    }
-}
-
-class WatchReporter extends BaseReporter {
-    on([event, payload]) {
-        switch (event) {
-            case "run:start":
-                OutputService.clearTerminal();
-                break;
-            case "run:end":
-                OutputService.writeMessage(watchUsageText());
-                break;
-            case "watch:error":
-                OutputService.clearTerminal();
-                for (const diagnostic of payload.diagnostics) {
-                    OutputService.writeError(diagnosticText(diagnostic));
-                }
-                OutputService.writeMessage(waitingForFileChangesText());
-                break;
-        }
-    }
-}
-
-class Task {
-    filePath;
-    position;
-    constructor(filePath, position) {
-        this.filePath = Path.resolve(this.#toPath(filePath));
-        this.position = position;
-    }
-    #toPath(filePath) {
-        if (typeof filePath === "string" && !filePath.startsWith("file:")) {
-            return filePath;
-        }
-        return fileURLToPath(filePath);
-    }
-}
-
-class CancellationToken {
-    #isCancelled = false;
-    #reason;
-    get isCancellationRequested() {
-        return this.#isCancelled;
-    }
-    get reason() {
-        return this.#reason;
-    }
-    cancel(reason) {
-        if (!this.#isCancelled) {
-            this.#isCancelled = true;
-            this.#reason = reason;
-        }
-    }
-    reset() {
-        if (this.#isCancelled) {
-            this.#isCancelled = false;
-            this.#reason = undefined;
-        }
-    }
-}
-
-var CancellationReason;
-(function (CancellationReason) {
-    CancellationReason["ConfigChange"] = "configChange";
-    CancellationReason["ConfigError"] = "configError";
-    CancellationReason["FailFast"] = "failFast";
-    CancellationReason["WatchClose"] = "watchClose";
-})(CancellationReason || (CancellationReason = {}));
-
-class Watcher {
-    #onChanged;
-    #onRemoved;
-    #recursive;
-    #targetPath;
-    #watcher;
-    constructor(targetPath, onChanged, onRemoved, options) {
-        this.#targetPath = targetPath;
-        this.#onChanged = onChanged;
-        this.#onRemoved = onRemoved ?? onChanged;
-        this.#recursive = options?.recursive;
-    }
-    close() {
-        this.#watcher?.close();
-    }
-    watch() {
-        this.#watcher = watch(this.#targetPath, { recursive: this.#recursive }, (_eventType, fileName) => {
-            if (fileName != null) {
-                const filePath = Path.resolve(this.#targetPath, fileName);
-                if (existsSync(filePath)) {
-                    this.#onChanged(filePath);
-                }
-                else {
-                    this.#onRemoved(filePath);
-                }
-            }
-        });
-    }
-}
-
-class FileWatcher extends Watcher {
-    constructor(targetPath, onChanged) {
-        const onChangedFile = (filePath) => {
-            if (filePath === targetPath) {
-                onChanged();
-            }
-        };
-        super(Path.dirname(targetPath), onChangedFile);
-    }
-}
-
-class InputService {
-    #onInput;
-    #stdin = process.stdin;
-    constructor(onInput) {
-        this.#onInput = onInput;
-        this.#stdin.setRawMode?.(true);
-        this.#stdin.setEncoding("utf8");
-        this.#stdin.unref();
-        this.#stdin.addListener("data", this.#onInput);
-    }
-    close() {
-        this.#stdin.removeListener("data", this.#onInput);
-        this.#stdin.setRawMode?.(false);
-    }
-}
-
-class GlobPattern {
-    static #reservedCharacterRegex = /[^\w\s/]/g;
-    static #parse(pattern, usageTarget) {
-        const segments = pattern.split("/");
-        let resultPattern = "\\.";
-        let optionalSegmentCount = 0;
-        for (const segment of segments) {
-            if (segment === ".") {
-                continue;
-            }
-            if (segment === "**") {
-                resultPattern += "(\\/(?!(node_modules)(\\/|$))[^./][^/]*)*?";
-                continue;
-            }
-            if (usageTarget === "directories") {
-                resultPattern += "(";
-                optionalSegmentCount++;
-            }
-            resultPattern += "\\/";
-            const segmentPattern = segment.replace(GlobPattern.#reservedCharacterRegex, GlobPattern.#replaceReservedCharacter);
-            if (segmentPattern !== segment) {
-                resultPattern += "(?!(node_modules)(\\/|$))";
-            }
-            resultPattern += segmentPattern;
-        }
-        resultPattern += ")?".repeat(optionalSegmentCount);
-        return resultPattern;
-    }
-    static #replaceReservedCharacter(match, offset) {
-        switch (match) {
-            case "*":
-                return offset === 0 ? "([^./][^/]*)?" : "([^/]*)?";
-            case "?":
-                return offset === 0 ? "[^./]" : "[^/]";
-            default:
-                return `\\${match}`;
-        }
-    }
-    static toRegex(patterns, target) {
-        const patternText = patterns.map((pattern) => `(${GlobPattern.#parse(pattern, target)})`).join("|");
-        return new RegExp(`^(${patternText})$`);
-    }
-}
-
-class SelectDiagnosticText {
-    static #pathSelectOptions(resolvedConfig) {
-        const text = [
-            `Root path:       ${resolvedConfig.rootPath}`,
-            `Test file match: ${resolvedConfig.testFileMatch.join(", ")}`,
-        ];
-        if (resolvedConfig.pathMatch.length > 0) {
-            text.push(`Path match:      ${resolvedConfig.pathMatch.join(", ")}`);
-        }
-        return text;
-    }
-    static noTestFilesWereLeft(resolvedConfig) {
-        return [
-            "No test files were left to run using current configuration.",
-            ...SelectDiagnosticText.#pathSelectOptions(resolvedConfig),
-        ];
-    }
-    static noTestFilesWereSelected(resolvedConfig) {
-        return [
-            "No test files were selected using current configuration.",
-            ...SelectDiagnosticText.#pathSelectOptions(resolvedConfig),
-        ];
-    }
-}
-
-class Select {
-    static #patternsCache = new WeakMap();
-    static async #getAccessibleFileSystemEntries(targetPath) {
-        const directories = [];
-        const files = [];
-        try {
-            const entries = await fs.readdir(targetPath, { withFileTypes: true });
-            for (const entry of entries) {
-                let entryMeta = entry;
-                if (entry.isSymbolicLink()) {
-                    entryMeta = await fs.stat([targetPath, entry.name].join("/"));
-                }
-                if (entryMeta.isDirectory()) {
-                    directories.push(entry.name);
+                    this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
-                else if (entryMeta.isFile()) {
-                    files.push(entry.name);
+                break;
+        }
+    }
+}
+
+class SetupReporter {
+    on([event, payload]) {
+        if (event === "store:adds") {
+            OutputService.writeMessage(addsPackageText(payload.packageVersion, payload.packagePath));
+            return;
+        }
+        if ("diagnostics" in payload) {
+            for (const diagnostic of payload.diagnostics) {
+                switch (diagnostic.category) {
+                    case DiagnosticCategory.Error:
+                        OutputService.writeError(diagnosticText(diagnostic));
+                        break;
+                    case DiagnosticCategory.Warning:
+                        OutputService.writeWarning(diagnosticText(diagnostic));
+                        break;
                 }
             }
         }
-        catch {
-        }
-        return { directories, files };
     }
-    static #getMatchPatterns(globPatterns) {
-        let matchPatterns = Select.#patternsCache.get(globPatterns);
-        if (!matchPatterns) {
-            matchPatterns = {
-                includedDirectory: GlobPattern.toRegex(globPatterns, "directories"),
-                includedFile: GlobPattern.toRegex(globPatterns, "files"),
-            };
-            Select.#patternsCache.set(globPatterns, matchPatterns);
+}
+
+class SummaryReporter extends BaseReporter {
+    on([event, payload]) {
+        if (this.resolvedConfig.watch) {
+            return;
         }
-        return matchPatterns;
-    }
-    static #isDirectoryIncluded(directoryPath, matchPatterns) {
-        return matchPatterns.includedDirectory.test(directoryPath);
-    }
-    static #isFileIncluded(filePath, matchPatterns, resolvedConfig) {
-        if (resolvedConfig.pathMatch.length > 0 &&
-            !resolvedConfig.pathMatch.some((match) => filePath.toLowerCase().includes(match.toLowerCase()))) {
-            return false;
+        if (event === "run:end") {
+            OutputService.writeMessage(summaryText({
+                duration: payload.result.timing.duration,
+                expectCount: payload.result.expectCount,
+                fileCount: payload.result.fileCount,
+                onlyMatch: payload.result.resolvedConfig.only,
+                pathMatch: payload.result.resolvedConfig.pathMatch,
+                skipMatch: payload.result.resolvedConfig.skip,
+                targetCount: payload.result.targetCount,
+                testCount: payload.result.testCount,
+            }));
         }
-        return matchPatterns.includedFile.test(filePath);
-    }
-    static isTestFile(filePath, resolvedConfig) {
-        const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
-        return Select.#isFileIncluded(Path.relative(resolvedConfig.rootPath, filePath), matchPatterns, resolvedConfig);
-    }
-    static #onDiagnostics(diagnostic) {
-        EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
     }
-    static async selectFiles(resolvedConfig) {
-        const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
-        const testFilePaths = [];
-        await Select.#visitDirectory(".", testFilePaths, matchPatterns, resolvedConfig);
-        if (testFilePaths.length === 0) {
-            Select.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(resolvedConfig)));
+}
+
+class WatchReporter extends BaseReporter {
+    on([event, payload]) {
+        switch (event) {
+            case "run:start":
+                OutputService.clearTerminal();
+                break;
+            case "run:end":
+                OutputService.writeMessage(watchUsageText());
+                break;
+            case "watch:error":
+                OutputService.clearTerminal();
+                for (const diagnostic of payload.diagnostics) {
+                    OutputService.writeError(diagnosticText(diagnostic));
+                }
+                OutputService.writeMessage(waitingForFileChangesText());
+                break;
         }
-        return testFilePaths.sort();
     }
-    static async #visitDirectory(currentPath, testFilePaths, matchPatterns, resolvedConfig) {
-        const targetPath = Path.join(resolvedConfig.rootPath, currentPath);
-        const entries = await Select.#getAccessibleFileSystemEntries(targetPath);
-        for (const directoryName of entries.directories) {
-            const directoryPath = [currentPath, directoryName].join("/");
-            if (Select.#isDirectoryIncluded(directoryPath, matchPatterns)) {
-                await Select.#visitDirectory(directoryPath, testFilePaths, matchPatterns, resolvedConfig);
-            }
-        }
-        for (const fileName of entries.files) {
-            const filePath = [currentPath, fileName].join("/");
-            if (Select.#isFileIncluded(filePath, matchPatterns, resolvedConfig)) {
-                testFilePaths.push([targetPath, fileName].join("/"));
-            }
+}
+
+class Task {
+    filePath;
+    position;
+    constructor(filePath, position) {
+        this.filePath = Path.resolve(this.#toPath(filePath));
+        this.position = position;
+    }
+    #toPath(filePath) {
+        if (typeof filePath === "string" && !filePath.startsWith("file:")) {
+            return filePath;
         }
+        return fileURLToPath(filePath);
     }
 }
 
-class Debounce {
-    #delay;
-    #onResolve;
-    #resolve;
-    #timeout;
-    constructor(delay, onResolve) {
-        this.#delay = delay;
-        this.#onResolve = onResolve;
-    }
-    clearTimeout() {
-        clearTimeout(this.#timeout);
+class CancellationToken {
+    #isCancelled = false;
+    #reason;
+    get isCancellationRequested() {
+        return this.#isCancelled;
     }
-    refreshTimeout() {
-        this.clearTimeout();
-        this.#timeout = setTimeout(() => {
-            this.#resolve?.(this.#onResolve());
-        }, this.#delay);
+    get reason() {
+        return this.#reason;
     }
-    resolveWith(value) {
-        this.#resolve?.(value);
+    cancel(reason) {
+        if (!this.#isCancelled) {
+            this.#isCancelled = true;
+            this.#reason = reason;
+        }
     }
-    setup() {
-        return new Promise((resolve) => {
-            this.#resolve = resolve;
-        });
+    reset() {
+        if (this.#isCancelled) {
+            this.#isCancelled = false;
+            this.#reason = undefined;
+        }
     }
 }
 
-class WatchService {
-    #changedTestFiles = new Map();
-    #inputService;
-    #resolvedConfig;
-    #watchedTestFiles;
-    #watchers = [];
-    constructor(resolvedConfig, tasks) {
-        this.#resolvedConfig = resolvedConfig;
-        this.#watchedTestFiles = new Map(tasks.map((task) => [task.filePath, task]));
+var CancellationReason;
+(function (CancellationReason) {
+    CancellationReason["ConfigChange"] = "configChange";
+    CancellationReason["ConfigError"] = "configError";
+    CancellationReason["FailFast"] = "failFast";
+    CancellationReason["WatchClose"] = "watchClose";
+})(CancellationReason || (CancellationReason = {}));
+
+class Watcher {
+    #onChanged;
+    #onRemoved;
+    #recursive;
+    #targetPath;
+    #watcher;
+    constructor(targetPath, onChanged, onRemoved, options) {
+        this.#targetPath = targetPath;
+        this.#onChanged = onChanged;
+        this.#onRemoved = onRemoved ?? onChanged;
+        this.#recursive = options?.recursive;
     }
-    #onDiagnostics(diagnostic) {
-        EventEmitter.dispatch(["watch:error", { diagnostics: [diagnostic] }]);
+    close() {
+        this.#watcher?.close();
     }
-    async *watch(cancellationToken) {
-        const onResolve = () => {
-            const testFiles = [...this.#changedTestFiles.values()];
-            this.#changedTestFiles.clear();
-            return testFiles;
-        };
-        const debounce = new Debounce(100, onResolve);
-        const onClose = (reason) => {
-            debounce.clearTimeout();
-            this.#inputService?.close();
-            for (const watcher of this.#watchers) {
-                watcher.close();
-            }
-            cancellationToken.cancel(reason);
-            debounce.resolveWith([]);
-        };
-        if (!environmentOptions.noInteractive) {
-            const onInput = (chunk) => {
-                switch (chunk.toLowerCase()) {
-                    case "\u0003":
-                    case "\u0004":
-                    case "\u001B":
-                    case "q":
-                    case "x":
-                        onClose(CancellationReason.WatchClose);
-                        break;
-                    case "\u000D":
-                    case "\u0020":
-                    case "a":
-                        debounce.clearTimeout();
-                        if (this.#watchedTestFiles.size > 0) {
-                            debounce.resolveWith([...this.#watchedTestFiles.values()]);
-                        }
-                        break;
+    watch() {
+        this.#watcher = watch(this.#targetPath, { recursive: this.#recursive }, (_eventType, fileName) => {
+            if (fileName != null) {
+                const filePath = Path.resolve(this.#targetPath, fileName);
+                if (existsSync(filePath)) {
+                    this.#onChanged(filePath);
+                }
+                else {
+                    this.#onRemoved(filePath);
                 }
-            };
-            this.#inputService = new InputService(onInput);
-        }
-        const onChangedFile = (filePath) => {
-            debounce.refreshTimeout();
-            let task = this.#watchedTestFiles.get(filePath);
-            if (task != null) {
-                this.#changedTestFiles.set(filePath, task);
-            }
-            else if (Select.isTestFile(filePath, this.#resolvedConfig)) {
-                task = new Task(filePath);
-                this.#changedTestFiles.set(filePath, task);
-                this.#watchedTestFiles.set(filePath, task);
-            }
-        };
-        const onRemovedFile = (filePath) => {
-            this.#changedTestFiles.delete(filePath);
-            this.#watchedTestFiles.delete(filePath);
-            if (this.#watchedTestFiles.size === 0) {
-                debounce.clearTimeout();
-                this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
             }
-        };
-        this.#watchers.push(new Watcher(this.#resolvedConfig.rootPath, onChangedFile, onRemovedFile, { recursive: true }));
-        const onChangedConfigFile = () => {
-            onClose(CancellationReason.ConfigChange);
-        };
-        this.#watchers.push(new FileWatcher(this.#resolvedConfig.configFilePath, onChangedConfigFile));
-        for (const watcher of this.#watchers) {
-            watcher.watch();
-        }
-        while (!cancellationToken.isCancellationRequested) {
-            const testFiles = await debounce.setup();
-            if (testFiles.length > 0) {
-                yield testFiles;
+        });
+    }
+}
+
+class FileWatcher extends Watcher {
+    constructor(targetPath, onChanged) {
+        const onChangedFile = (filePath) => {
+            if (filePath === targetPath) {
+                onChanged();
             }
-        }
+        };
+        super(Path.dirname(targetPath), onChangedFile);
     }
 }
 
-var TestMemberBrand;
-(function (TestMemberBrand) {
-    TestMemberBrand["Describe"] = "describe";
-    TestMemberBrand["Test"] = "test";
-    TestMemberBrand["Expect"] = "expect";
-})(TestMemberBrand || (TestMemberBrand = {}));
+class InputService {
+    #onInput;
+    #stdin = process.stdin;
+    constructor(onInput) {
+        this.#onInput = onInput;
+        this.#stdin.setRawMode?.(true);
+        this.#stdin.setEncoding("utf8");
+        this.#stdin.unref();
+        this.#stdin.addListener("data", this.#onInput);
+    }
+    close() {
+        this.#stdin.removeListener("data", this.#onInput);
+        this.#stdin.setRawMode?.(false);
+    }
+}
 
-class TestMember {
-    brand;
-    #compiler;
-    diagnostics = new Set();
-    flags;
-    members = [];
-    name = "";
-    node;
-    parent;
-    constructor(compiler, brand, node, parent, flags) {
-        this.brand = brand;
-        this.#compiler = compiler;
-        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]) &&
-            compiler.isBlock(node.arguments[1].body)) {
-            const blockStart = node.arguments[1].body.getStart();
-            const blockEnd = node.arguments[1].body.getEnd();
-            for (const diagnostic of parent.diagnostics) {
-                if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
-                    this.diagnostics.add(diagnostic);
-                    parent.diagnostics.delete(diagnostic);
-                }
+class GlobPattern {
+    static #reservedCharacterRegex = /[^\w\s/]/g;
+    static #parse(pattern, usageTarget) {
+        const segments = pattern.split("/");
+        let resultPattern = "\\.";
+        let optionalSegmentCount = 0;
+        for (const segment of segments) {
+            if (segment === ".") {
+                continue;
+            }
+            if (segment === "**") {
+                resultPattern += "(\\/(?!(node_modules)(\\/|$))[^./][^/]*)*?";
+                continue;
+            }
+            if (usageTarget === "directories") {
+                resultPattern += "(";
+                optionalSegmentCount++;
+            }
+            resultPattern += "\\/";
+            const segmentPattern = segment.replace(GlobPattern.#reservedCharacterRegex, GlobPattern.#replaceReservedCharacter);
+            if (segmentPattern !== segment) {
+                resultPattern += "(?!(node_modules)(\\/|$))";
             }
+            resultPattern += segmentPattern;
         }
+        resultPattern += ")?".repeat(optionalSegmentCount);
+        return resultPattern;
     }
-    validate() {
-        const diagnostics = [];
-        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()'.`;
-        const getParentCallExpression = (node) => {
-            while (!this.#compiler.isCallExpression(node.parent)) {
-                node = node.parent;
-            }
-            return node.parent;
-        };
-        switch (this.brand) {
-            case TestMemberBrand.Describe:
-                for (const member of this.members) {
-                    if (member.brand === TestMemberBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
-                    }
-                }
-                break;
-            case TestMemberBrand.Test:
-            case TestMemberBrand.Expect:
-                for (const member of this.members) {
-                    if (member.brand !== TestMemberBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
-                    }
-                }
-                break;
+    static #replaceReservedCharacter(match, offset) {
+        switch (match) {
+            case "*":
+                return offset === 0 ? "([^./][^/]*)?" : "([^/]*)?";
+            case "?":
+                return offset === 0 ? "[^./]" : "[^/]";
+            default:
+                return `\\${match}`;
         }
-        return diagnostics;
+    }
+    static toRegex(patterns, target) {
+        const patternText = patterns.map((pattern) => `(${GlobPattern.#parse(pattern, target)})`).join("|");
+        return new RegExp(`^(${patternText})$`);
     }
 }
 
-class Assertion extends TestMember {
-    isNot;
-    matcherName;
-    matcherNode;
-    modifierNode;
-    notNode;
-    source;
-    target;
-    constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
-        super(compiler, brand, node, parent, flags);
-        this.isNot = notNode != null;
-        this.matcherName = matcherNode.expression.name;
-        this.matcherNode = matcherNode;
-        this.modifierNode = modifierNode;
-        this.source = this.node.typeArguments ?? this.node.arguments;
-        this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
-        for (const diagnostic of parent.diagnostics) {
-            if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
-                this.diagnostics.add(diagnostic);
-                parent.diagnostics.delete(diagnostic);
-            }
+class SelectDiagnosticText {
+    static #pathSelectOptions(resolvedConfig) {
+        const text = [
+            `Root path:       ${resolvedConfig.rootPath}`,
+            `Test file match: ${resolvedConfig.testFileMatch.join(", ")}`,
+        ];
+        if (resolvedConfig.pathMatch.length > 0) {
+            text.push(`Path match:      ${resolvedConfig.pathMatch.join(", ")}`);
         }
+        return text;
+    }
+    static noTestFilesWereLeft(resolvedConfig) {
+        return [
+            "No test files were left to run using current configuration.",
+            ...SelectDiagnosticText.#pathSelectOptions(resolvedConfig),
+        ];
+    }
+    static noTestFilesWereSelected(resolvedConfig) {
+        return [
+            "No test files were selected using current configuration.",
+            ...SelectDiagnosticText.#pathSelectOptions(resolvedConfig),
+        ];
     }
 }
 
-var TestMemberFlags;
-(function (TestMemberFlags) {
-    TestMemberFlags[TestMemberFlags["None"] = 0] = "None";
-    TestMemberFlags[TestMemberFlags["Fail"] = 1] = "Fail";
-    TestMemberFlags[TestMemberFlags["Only"] = 2] = "Only";
-    TestMemberFlags[TestMemberFlags["Skip"] = 4] = "Skip";
-    TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
-})(TestMemberFlags || (TestMemberFlags = {}));
-
-class IdentifierLookup {
-    #compiler;
-    #identifiers;
-    #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
-    constructor(compiler, identifiers) {
-        this.#compiler = compiler;
-        this.#identifiers = identifiers ?? {
-            namedImports: {
-                describe: undefined,
-                expect: undefined,
-                it: undefined,
-                namespace: undefined,
-                test: undefined,
-            },
-            namespace: undefined,
-        };
-    }
-    handleImportDeclaration(node) {
-        if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
-            node.importClause?.isTypeOnly !== true &&
-            node.importClause?.namedBindings != null) {
-            if (this.#compiler.isNamedImports(node.importClause.namedBindings)) {
-                for (const element of node.importClause.namedBindings.elements) {
-                    if (element.isTypeOnly) {
-                        continue;
-                    }
-                    let identifierKey;
-                    if (element.propertyName) {
-                        identifierKey = element.propertyName.getText();
-                    }
-                    else {
-                        identifierKey = element.name.getText();
-                    }
-                    if (identifierKey in this.#identifiers.namedImports) {
-                        this.#identifiers.namedImports[identifierKey] = element.name.getText();
-                    }
+class Select {
+    static #patternsCache = new WeakMap();
+    static async #getAccessibleFileSystemEntries(targetPath) {
+        const directories = [];
+        const files = [];
+        try {
+            const entries = await fs.readdir(targetPath, { withFileTypes: true });
+            for (const entry of entries) {
+                let entryMeta = entry;
+                if (entry.isSymbolicLink()) {
+                    entryMeta = await fs.stat([targetPath, entry.name].join("/"));
+                }
+                if (entryMeta.isDirectory()) {
+                    directories.push(entry.name);
+                }
+                else if (entryMeta.isFile()) {
+                    files.push(entry.name);
                 }
             }
-            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
-                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
-            }
         }
+        catch {
+        }
+        return { directories, files };
     }
-    resolveTestMemberMeta(node) {
-        let flags = TestMemberFlags.None;
-        let expression = node.expression;
-        while (this.#compiler.isPropertyAccessExpression(expression)) {
-            if (expression.expression.getText() === this.#identifiers.namespace) {
-                break;
-            }
-            switch (expression.name.getText()) {
-                case "fail":
-                    flags |= TestMemberFlags.Fail;
-                    break;
-                case "only":
-                    flags |= TestMemberFlags.Only;
-                    break;
-                case "skip":
-                    flags |= TestMemberFlags.Skip;
-                    break;
-                case "todo":
-                    flags |= TestMemberFlags.Todo;
-                    break;
-            }
-            expression = expression.expression;
+    static #getMatchPatterns(globPatterns) {
+        let matchPatterns = Select.#patternsCache.get(globPatterns);
+        if (!matchPatterns) {
+            matchPatterns = {
+                includedDirectory: GlobPattern.toRegex(globPatterns, "directories"),
+                includedFile: GlobPattern.toRegex(globPatterns, "files"),
+            };
+            Select.#patternsCache.set(globPatterns, matchPatterns);
         }
-        let identifierName;
-        if (this.#compiler.isPropertyAccessExpression(expression) &&
-            expression.expression.getText() === this.#identifiers.namespace) {
-            identifierName = expression.name.getText();
+        return matchPatterns;
+    }
+    static #isDirectoryIncluded(directoryPath, matchPatterns) {
+        return matchPatterns.includedDirectory.test(directoryPath);
+    }
+    static #isFileIncluded(filePath, matchPatterns, resolvedConfig) {
+        if (resolvedConfig.pathMatch.length > 0 &&
+            !resolvedConfig.pathMatch.some((match) => filePath.toLowerCase().includes(match.toLowerCase()))) {
+            return false;
         }
-        else {
-            identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+        return matchPatterns.includedFile.test(filePath);
+    }
+    static isTestFile(filePath, resolvedConfig) {
+        const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
+        return Select.#isFileIncluded(Path.relative(resolvedConfig.rootPath, filePath), matchPatterns, resolvedConfig);
+    }
+    static #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
+    }
+    static async selectFiles(resolvedConfig) {
+        const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
+        const testFilePaths = [];
+        await Select.#visitDirectory(".", testFilePaths, matchPatterns, resolvedConfig);
+        if (testFilePaths.length === 0) {
+            Select.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(resolvedConfig)));
         }
-        if (!identifierName) {
-            return;
+        return testFilePaths.sort();
+    }
+    static async #visitDirectory(currentPath, testFilePaths, matchPatterns, resolvedConfig) {
+        const targetPath = Path.join(resolvedConfig.rootPath, currentPath);
+        const entries = await Select.#getAccessibleFileSystemEntries(targetPath);
+        for (const directoryName of entries.directories) {
+            const directoryPath = [currentPath, directoryName].join("/");
+            if (Select.#isDirectoryIncluded(directoryPath, matchPatterns)) {
+                await Select.#visitDirectory(directoryPath, testFilePaths, matchPatterns, resolvedConfig);
+            }
         }
-        switch (identifierName) {
-            case "describe":
-                return { brand: TestMemberBrand.Describe, flags };
-            case "it":
-            case "test":
-                return { brand: TestMemberBrand.Test, flags };
-            case "expect":
-                return { brand: TestMemberBrand.Expect, flags };
+        for (const fileName of entries.files) {
+            const filePath = [currentPath, fileName].join("/");
+            if (Select.#isFileIncluded(filePath, matchPatterns, resolvedConfig)) {
+                testFilePaths.push([targetPath, fileName].join("/"));
+            }
         }
-        return;
     }
 }
 
-class TestTree {
-    diagnostics;
-    members = [];
-    sourceFile;
-    constructor(diagnostics, sourceFile) {
-        this.diagnostics = diagnostics;
-        this.sourceFile = sourceFile;
+class Debounce {
+    #delay;
+    #onResolve;
+    #resolve;
+    #timeout;
+    constructor(delay, onResolve) {
+        this.#delay = delay;
+        this.#onResolve = onResolve;
     }
-    get hasOnly() {
-        function hasOnly(root) {
-            return root.members.some((branch) => branch.flags & TestMemberFlags.Only || ("members" in branch && hasOnly(branch)));
-        }
-        return hasOnly(this);
+    cancel() {
+        clearTimeout(this.#timeout);
+    }
+    refresh() {
+        this.cancel();
+        this.#timeout = setTimeout(() => {
+            this.#resolve?.(this.#onResolve());
+        }, this.#delay);
+    }
+    resolve(value) {
+        this.#resolve?.(value);
+    }
+    schedule() {
+        return new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
     }
 }
 
-class CollectService {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
+class WatchService {
+    #changedTestFiles = new Map();
+    #inputService;
+    #resolvedConfig;
+    #watchedTestFiles;
+    #watchers = [];
+    constructor(resolvedConfig, tasks) {
+        this.#resolvedConfig = resolvedConfig;
+        this.#watchedTestFiles = new Map(tasks.map((task) => [task.filePath, task]));
     }
-    #collectTestMembers(node, identifiers, parent) {
-        if (this.#compiler.isCallExpression(node)) {
-            const meta = identifiers.resolveTestMemberMeta(node);
-            if (meta != null && (meta.brand === TestMemberBrand.Describe || meta.brand === TestMemberBrand.Test)) {
-                const testMember = new TestMember(this.#compiler, meta.brand, node, parent, meta.flags);
-                parent.members.push(testMember);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestMembers(node, identifiers, testMember);
-                });
-                return;
+    #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["watch:error", { diagnostics: [diagnostic] }]);
+    }
+    async *watch(cancellationToken) {
+        const onResolve = () => {
+            const testFiles = [...this.#changedTestFiles.values()];
+            this.#changedTestFiles.clear();
+            return testFiles;
+        };
+        const debounce = new Debounce(100, onResolve);
+        const onClose = (reason) => {
+            debounce.cancel();
+            this.#inputService?.close();
+            for (const watcher of this.#watchers) {
+                watcher.close();
             }
-            if (meta != null && meta.brand === TestMemberBrand.Expect) {
-                const modifierNode = this.#getChainedNode(node, "type");
-                if (!modifierNode) {
-                    return;
-                }
-                const notNode = this.#getChainedNode(modifierNode, "not");
-                const matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
-                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
-                    return;
+            cancellationToken.cancel(reason);
+            debounce.resolve([]);
+        };
+        if (!environmentOptions.noInteractive) {
+            const onInput = (chunk) => {
+                switch (chunk.toLowerCase()) {
+                    case "\u0003":
+                    case "\u0004":
+                    case "\u001B":
+                    case "q":
+                    case "x":
+                        onClose(CancellationReason.WatchClose);
+                        break;
+                    case "\u000D":
+                    case "\u0020":
+                    case "a":
+                        debounce.cancel();
+                        if (this.#watchedTestFiles.size > 0) {
+                            debounce.resolve([...this.#watchedTestFiles.values()]);
+                        }
+                        break;
                 }
-                const assertion = new Assertion(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
-                parent.members.push(assertion);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestMembers(node, identifiers, assertion);
-                });
-                return;
-            }
-        }
-        if (this.#compiler.isImportDeclaration(node)) {
-            identifiers.handleImportDeclaration(node);
-            return;
+            };
+            this.#inputService = new InputService(onInput);
         }
-        this.#compiler.forEachChild(node, (node) => {
-            this.#collectTestMembers(node, identifiers, parent);
-        });
-    }
-    createTestTree(sourceFile, semanticDiagnostics = []) {
-        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
-        this.#collectTestMembers(sourceFile, new IdentifierLookup(this.#compiler), testTree);
-        return testTree;
-    }
-    #getChainedNode({ parent }, name) {
-        if (!this.#compiler.isPropertyAccessExpression(parent)) {
-            return;
+        const onChangedFile = (filePath) => {
+            debounce.refresh();
+            let task = this.#watchedTestFiles.get(filePath);
+            if (task != null) {
+                this.#changedTestFiles.set(filePath, task);
+            }
+            else if (Select.isTestFile(filePath, this.#resolvedConfig)) {
+                task = new Task(filePath);
+                this.#changedTestFiles.set(filePath, task);
+                this.#watchedTestFiles.set(filePath, task);
+            }
+        };
+        const onRemovedFile = (filePath) => {
+            this.#changedTestFiles.delete(filePath);
+            this.#watchedTestFiles.delete(filePath);
+            if (this.#watchedTestFiles.size === 0) {
+                debounce.cancel();
+                this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
+            }
+        };
+        this.#watchers.push(new Watcher(this.#resolvedConfig.rootPath, onChangedFile, onRemovedFile, { recursive: true }));
+        const onChangedConfigFile = () => {
+            onClose(CancellationReason.ConfigChange);
+        };
+        this.#watchers.push(new FileWatcher(this.#resolvedConfig.configFilePath, onChangedConfigFile));
+        for (const watcher of this.#watchers) {
+            watcher.watch();
         }
-        if (name != null && name !== parent.name.getText()) {
-            return;
+        while (!cancellationToken.isCancellationRequested) {
+            const testFiles = await debounce.schedule();
+            if (testFiles.length > 0) {
+                yield testFiles;
+            }
         }
-        return parent;
-    }
-    #isMatcherNode(node) {
-        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
     }
 }
 
@@ -3234,24 +3336,19 @@ class ProjectService {
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
+            allowImportingTsExtensions: true,
             allowJs: true,
             checkJs: true,
-            esModuleInterop: true,
-            jsx: "preserve",
-            module: "esnext",
-            moduleResolution: "node",
+            exactOptionalPropertyTypes: true,
+            jsx: this.#compiler.JsxEmit.Preserve,
+            module: this.#compiler.ModuleKind.NodeNext,
+            moduleResolution: this.#compiler.ModuleResolutionKind.NodeNext,
+            noUncheckedIndexedAccess: true,
             resolveJsonModule: true,
-            strictFunctionTypes: true,
-            strictNullChecks: true,
-            target: "esnext",
+            strict: true,
+            target: this.#compiler.ScriptTarget.ESNext,
+            verbatimModuleSyntax: true,
         };
-        if (Version.isSatisfiedWith(this.#compiler.version, "5.4")) {
-            defaultCompilerOptions.module = "preserve";
-        }
-        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
-            defaultCompilerOptions.allowImportingTsExtensions = true;
-            defaultCompilerOptions.moduleResolution = "bundler";
-        }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
@@ -3343,11 +3440,11 @@ class ExpectDiagnosticText {
     static componentDoesNotAcceptProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
     }
-    static matcherIsDeprecated(matcherNameText) {
-        return [
-            `The '.${matcherNameText}()' matcher is deprecated and will be removed in TSTyche 4.`,
-            "To learn more, visit https://tstyche.org/releases/tstyche-3",
-        ];
+    static decoratorCanBeApplied(targetText) {
+        return `The decorator function can be applied${targetText}.`;
+    }
+    static decoratorCanNotBeApplied(targetText) {
+        return `The decorator function can not be applied${targetText}.`;
     }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
@@ -3373,18 +3470,9 @@ class ExpectDiagnosticText {
     static typeDoesNotHaveProperty(typeText, propertyNameText) {
         return `Type '${typeText}' does not have property '${propertyNameText}'.`;
     }
-    static typeDoesMatch(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' does match type '${targetTypeText}'.`;
-    }
-    static typeDoesNotMatch(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' does not match type '${targetTypeText}'.`;
-    }
     static typeHasProperty(typeText, propertyNameText) {
         return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
-    static typeIs(typeText) {
-        return `Type is '${typeText}'.`;
-    }
     static typeIsAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
     }
@@ -3445,18 +3533,9 @@ class MatchWorker {
     checkHasApplicableIndexType(sourceNode, targetNode) {
         const sourceType = this.getType(sourceNode);
         const targetType = this.getType(targetNode);
-        if (Version.isSatisfiedWith(this.#compiler.version, "4.4")) {
-            return this.#typeChecker
-                .getIndexInfosOfType(sourceType)
-                .some(({ keyType }) => this.#typeChecker.isApplicableIndexType(targetType, keyType));
-        }
-        if (targetType.flags & this.#compiler.TypeFlags.StringLiteral) {
-            return sourceType.getStringIndexType() != null;
-        }
-        if (targetType.flags & this.#compiler.TypeFlags.NumberLiteral) {
-            return (sourceType.getStringIndexType() ?? sourceType.getNumberIndexType()) != null;
-        }
-        return false;
+        return this.#typeChecker
+            .getIndexInfosOfType(sourceType)
+            .some(({ keyType }) => this.#typeChecker.isApplicableIndexType(targetType, keyType));
     }
     checkHasProperty(sourceNode, propertyNameText) {
         const sourceType = this.getType(sourceNode);
@@ -3478,10 +3557,6 @@ class MatchWorker {
             this.checkIsAssignableTo(sourceNode, targetNode) &&
             this.checkIsAssignableWith(sourceNode, targetNode));
     }
-    checkIsSubtype(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.subtype;
-        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
-    }
     #checkIsRelatedTo(sourceNode, targetNode, relation) {
         const sourceType = relation === this.#typeChecker.relation.identity
             ? this.#simplifyType(this.getType(sourceNode))
@@ -3568,26 +3643,6 @@ class MatchWorker {
     }
 }
 
-class PrimitiveTypeMatcher {
-    #targetTypeFlag;
-    constructor(targetTypeFlag) {
-        this.#targetTypeFlag = targetTypeFlag;
-    }
-    #explain(matchWorker, sourceNode) {
-        const sourceTypeText = matchWorker.getTypeText(sourceNode);
-        const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-        return [Diagnostic.error(ExpectDiagnosticText.typeIs(sourceTypeText), origin)];
-    }
-    match(matchWorker, sourceNode) {
-        const sourceType = matchWorker.getType(sourceNode);
-        const isMatch = !!(sourceType.flags & this.#targetTypeFlag);
-        return {
-            explain: () => this.#explain(matchWorker, sourceNode),
-            isMatch,
-        };
-    }
-}
-
 class ToAcceptProps {
     #compiler;
     #typeChecker;
@@ -3794,6 +3849,76 @@ class ToBe extends RelationMatcherBase {
     }
 }
 
+class ToBeApplicable {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(node) {
+        let text = "";
+        switch (node.kind) {
+            case this.#compiler.SyntaxKind.ClassDeclaration:
+                text = "class";
+                break;
+            case this.#compiler.SyntaxKind.MethodDeclaration:
+                text = "method";
+                break;
+            case this.#compiler.SyntaxKind.PropertyDeclaration:
+                text = node.modifiers?.some((modifier) => modifier.kind === this.#compiler.SyntaxKind.AccessorKeyword)
+                    ? "accessor"
+                    : "field";
+                break;
+            case this.#compiler.SyntaxKind.GetAccessor:
+                text = "getter";
+                break;
+            case this.#compiler.SyntaxKind.SetAccessor:
+                text = "setter";
+                break;
+        }
+        if (text.length > 0) {
+            text = ` to this ${text}`;
+        }
+        return text;
+    }
+    #explain(matchWorker, sourceNode) {
+        const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.decoratorCanNotBeApplied(targetText),
+                    typeof diagnostic.messageText === "string"
+                        ? diagnostic.messageText
+                        : Diagnostic.toMessageText(diagnostic.messageText),
+                ];
+                const origin = DiagnosticOrigin.fromNode(sourceNode);
+                diagnostics.push(Diagnostic.error(text.flat(), origin));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.decoratorCanBeApplied(targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, onDiagnostics) {
+        const type = matchWorker.getType(sourceNode);
+        if (type.getCallSignatures().length === 0) {
+            const expectedText = "of a function type";
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToBeAssignableTo extends RelationMatcherBase {
     explainText = ExpectDiagnosticText.typeIsAssignableTo;
     explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
@@ -3875,17 +4000,6 @@ class ToHaveProperty {
     }
 }
 
-class ToMatch extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeDoesMatch;
-    explainNotText = ExpectDiagnosticText.typeDoesNotMatch;
-    match(matchWorker, sourceNode, targetNode) {
-        return {
-            explain: () => this.explain(matchWorker, sourceNode, targetNode),
-            isMatch: matchWorker.checkIsSubtype(sourceNode, targetNode),
-        };
-    }
-}
-
 class ToRaiseError {
     #compiler;
     constructor(compiler) {
@@ -3955,14 +4069,17 @@ class ToRaiseError {
         };
     }
     #matchExpectedError(diagnostic, targetNode) {
+        if (this.#compiler.isNumericLiteral(targetNode)) {
+            return Number.parseInt(targetNode.text, 10) === diagnostic.code;
+        }
+        const messageText = typeof diagnostic.messageText === "string"
+            ? diagnostic.messageText
+            : Diagnostic.toMessageText(diagnostic.messageText).join("\n");
         if (this.#compiler.isRegularExpressionLiteral(targetNode)) {
             const targetRegex = new RegExp(...targetNode.text.slice(1).split("/"));
-            return targetRegex.test(this.#compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0));
-        }
-        if (this.#compiler.isStringLiteralLike(targetNode)) {
-            return this.#compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(targetNode.text);
+            return targetRegex.test(messageText);
         }
-        return Number.parseInt(targetNode.text, 10) === diagnostic.code;
+        return messageText.includes(targetNode.text);
     }
 }
 
@@ -3972,22 +4089,10 @@ class ExpectService {
     #typeChecker;
     toAcceptProps;
     toBe;
-    toBeAny;
+    toBeApplicable;
     toBeAssignableTo;
     toBeAssignableWith;
-    toBeBigInt;
-    toBeBoolean;
-    toBeNever;
-    toBeNull;
-    toBeNumber;
-    toBeString;
-    toBeSymbol;
-    toBeUndefined;
-    toBeUniqueSymbol;
-    toBeUnknown;
-    toBeVoid;
     toHaveProperty;
-    toMatch;
     toRaiseError;
     constructor(compiler, typeChecker, resolvedConfig) {
         this.#compiler = compiler;
@@ -4000,73 +4105,42 @@ class ExpectService {
         }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
-        this.toBeAny = new PrimitiveTypeMatcher(compiler.TypeFlags.Any);
+        this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
-        this.toBeBigInt = new PrimitiveTypeMatcher(compiler.TypeFlags.BigInt);
-        this.toBeBoolean = new PrimitiveTypeMatcher(compiler.TypeFlags.Boolean);
-        this.toBeNever = new PrimitiveTypeMatcher(compiler.TypeFlags.Never);
-        this.toBeNull = new PrimitiveTypeMatcher(compiler.TypeFlags.Null);
-        this.toBeNumber = new PrimitiveTypeMatcher(compiler.TypeFlags.Number);
-        this.toBeString = new PrimitiveTypeMatcher(compiler.TypeFlags.String);
-        this.toBeSymbol = new PrimitiveTypeMatcher(compiler.TypeFlags.ESSymbol);
-        this.toBeUndefined = new PrimitiveTypeMatcher(compiler.TypeFlags.Undefined);
-        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(compiler.TypeFlags.UniqueESSymbol);
-        this.toBeUnknown = new PrimitiveTypeMatcher(compiler.TypeFlags.Unknown);
-        this.toBeVoid = new PrimitiveTypeMatcher(compiler.TypeFlags.Void);
         this.toHaveProperty = new ToHaveProperty(compiler);
-        this.toMatch = new ToMatch();
         this.toRaiseError = new ToRaiseError(compiler);
     }
     match(assertion, onDiagnostics) {
-        const matcherNameText = assertion.matcherName.getText();
-        if (matcherNameText === "toMatch") {
-            const text = ExpectDiagnosticText.matcherIsDeprecated(matcherNameText);
-            const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-            EventEmitter.dispatch(["deprecation:info", { diagnostics: [Diagnostic.warning(text, origin)] }]);
-        }
+        const matcherNameText = assertion.matcherNameNode.name.text;
         if (!assertion.source[0]) {
             this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
+        if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
+            this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+            return;
+        }
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-            case "toMatch":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
-                if (this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            case "toBeAny":
-            case "toBeBigInt":
-            case "toBeBoolean":
-            case "toBeNever":
-            case "toBeNull":
-            case "toBeNumber":
-            case "toBeString":
-            case "toBeSymbol":
-            case "toBeUndefined":
-            case "toBeUniqueSymbol":
-            case "toBeUnknown":
-            case "toBeVoid":
-                return this[matcherNameText].match(matchWorker, assertion.source[0]);
+            case "toBeApplicable":
+                return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
             case "toHaveProperty":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             case "toRaiseError":
-                if (assertion.isNot && this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
                 return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
@@ -4075,7 +4149,7 @@ class ExpectService {
     }
     #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
@@ -4085,20 +4159,24 @@ class ExpectService {
     }
     #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #rejectsTypeArguments(matchWorker, onDiagnostics) {
         for (const rejectedType of this.#rejectTypes) {
+            const allowedKeyword = this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`];
+            if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
+                matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
+                continue;
+            }
             for (const argumentName of ["source", "target"]) {
-                const argumentNode = matchWorker.assertion[argumentName][0];
-                if (!argumentNode ||
-                    argumentNode.kind === this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`]) {
+                const argumentNode = matchWorker.assertion[argumentName]?.[0];
+                if (!argumentNode) {
                     continue;
                 }
                 if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[Format.capitalize(rejectedType)]) {
@@ -4119,7 +4197,6 @@ class ExpectService {
 }
 
 class TestTreeWalker {
-    #compiler;
     #cancellationToken;
     #expectService;
     #hasOnly;
@@ -4128,59 +4205,60 @@ class TestTreeWalker {
     #taskResult;
     constructor(resolvedConfig, compiler, typeChecker, options) {
         this.#resolvedConfig = resolvedConfig;
-        this.#compiler = compiler;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
         this.#taskResult = options.taskResult;
         this.#expectService = new ExpectService(compiler, typeChecker, this.#resolvedConfig);
     }
-    #resolveRunMode(mode, member) {
-        if (member.flags & TestMemberFlags.Fail) {
+    #resolveRunMode(mode, testNode) {
+        if (testNode.flags & TestTreeNodeFlags.Fail) {
             mode |= RunMode.Fail;
         }
-        if (member.flags & TestMemberFlags.Only ||
-            (this.#resolvedConfig.only != null && member.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
+        if (testNode.flags & TestTreeNodeFlags.Only ||
+            (this.#resolvedConfig.only != null &&
+                testNode.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
             mode |= RunMode.Only;
         }
-        if (member.flags & TestMemberFlags.Skip ||
-            (this.#resolvedConfig.skip != null && member.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
+        if (testNode.flags & TestTreeNodeFlags.Skip ||
+            (this.#resolvedConfig.skip != null &&
+                testNode.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
             mode |= RunMode.Skip;
         }
-        if (member.flags & TestMemberFlags.Todo) {
+        if (testNode.flags & TestTreeNodeFlags.Todo) {
             mode |= RunMode.Todo;
         }
-        if (this.#position != null && member.node.getStart() === this.#position) {
+        if (this.#position != null && testNode.node.getStart() === this.#position) {
             mode |= RunMode.Only;
             mode &= ~RunMode.Skip;
         }
         return mode;
     }
-    visit(members, runMode, parentResult) {
-        for (const member of members) {
+    visit(testNodes, runMode, parentResult) {
+        for (const testNode of testNodes) {
             if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
-            const validationError = member.validate();
+            const validationError = testNode.validate();
             if (validationError.length > 0) {
                 EventEmitter.dispatch(["task:error", { diagnostics: validationError, result: this.#taskResult }]);
                 break;
             }
-            switch (member.brand) {
-                case TestMemberBrand.Describe:
-                    this.#visitDescribe(member, runMode, parentResult);
+            switch (testNode.brand) {
+                case TestTreeNodeBrand.Describe:
+                    this.#visitDescribe(testNode, runMode, parentResult);
                     break;
-                case TestMemberBrand.Test:
-                    this.#visitTest(member, runMode, parentResult);
+                case TestTreeNodeBrand.Test:
+                    this.#visitTest(testNode, runMode, parentResult);
                     break;
-                case TestMemberBrand.Expect:
-                    this.#visitAssertion(member, runMode, parentResult);
+                case TestTreeNodeBrand.Expect:
+                    this.#visitAssertion(testNode, runMode, parentResult);
                     break;
             }
         }
     }
     #visitAssertion(assertion, runMode, parentResult) {
-        this.visit(assertion.members, runMode, parentResult);
+        this.visit(assertion.children, runMode, parentResult);
         const expectResult = new ExpectResult(assertion, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
         runMode = this.#resolveRunMode(runMode, assertion);
@@ -4194,7 +4272,7 @@ class TestTreeWalker {
                 { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
         };
-        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        if (assertion.diagnostics.size > 0 && assertion.matcherNameNode.name.text !== "toRaiseError") {
             onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics]));
             return;
         }
@@ -4234,7 +4312,7 @@ class TestTreeWalker {
             ]);
         }
         else {
-            this.visit(describe.members, runMode, describeResult);
+            this.visit(describe.children, runMode, describeResult);
         }
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
@@ -4256,7 +4334,7 @@ class TestTreeWalker {
             ]);
             return;
         }
-        this.visit(test.members, runMode, testResult);
+        this.visit(test.children, runMode, testResult);
         if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
             EventEmitter.dispatch(["test:skip", { result: testResult }]);
             return;
@@ -4278,8 +4356,8 @@ class TaskRunner {
     constructor(resolvedConfig, compiler) {
         this.#resolvedConfig = resolvedConfig;
         this.#compiler = compiler;
-        this.#collectService = new CollectService(compiler);
         this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
+        this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
     run(task, cancellationToken) {
         if (cancellationToken?.isCancellationRequested) {
@@ -4336,17 +4414,27 @@ class TaskRunner {
             hasOnly: testTree.hasOnly,
             position: task.position,
         });
-        testTreeWalker.visit(testTree.members, RunMode.Normal, undefined);
+        testTreeWalker.visit(testTree.children, RunMode.Normal, undefined);
     }
 }
 
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "3.5.0";
+    static version = "4.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
+    #addHandlers(cancellationToken) {
+        const resultHandler = new ResultHandler();
+        this.#eventEmitter.addHandler(resultHandler);
+        const testTreeHandler = new TestTreeHandler();
+        this.#eventEmitter.addHandler(testTreeHandler);
+        if (this.#resolvedConfig.failFast) {
+            const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.FailFast);
+            this.#eventEmitter.addHandler(cancellationHandler);
+        }
+    }
     async #addReporters() {
         if (this.#resolvedConfig.watch && !environmentOptions.noInteractive) {
             const watchReporter = new WatchReporter(this.#resolvedConfig);
@@ -4374,13 +4462,8 @@ class Runner {
     }
     async run(testFiles, cancellationToken = new CancellationToken()) {
         const tasks = testFiles.map((testFile) => (testFile instanceof Task ? testFile : new Task(testFile)));
-        const resultHandler = new ResultHandler();
-        this.#eventEmitter.addHandler(resultHandler);
+        this.#addHandlers(cancellationToken);
         await this.#addReporters();
-        if (this.#resolvedConfig.failFast) {
-            const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.FailFast);
-            this.#eventEmitter.addHandler(cancellationHandler);
-        }
         await this.#run(tasks, cancellationToken);
         if (this.#resolvedConfig.watch) {
             await this.#watch(tasks, cancellationToken);
@@ -4483,9 +4566,9 @@ class Cli {
                 OutputService.writeMessage(formattedText({ ...resolvedConfig, ...environmentOptions }));
                 continue;
             }
-            if (commandLine.includes("--install")) {
+            if (commandLine.includes("--fetch")) {
                 for (const tag of resolvedConfig.target) {
-                    await Store.install(tag);
+                    await Store.fetch(tag);
                 }
                 continue;
             }
@@ -4540,4 +4623,4 @@ class Cli {
     }
 }
 
-export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };