tstyche 3.5.0 → 4.0.0-beta.0

package/build/tstyche.js

@@ -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 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,6 +1899,293 @@ class ResultHandler {
     }
 }
 
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+
+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 member of this.children) {
+                    if (member.brand === TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
+                    }
+                }
+                break;
+            case TestTreeNodeBrand.Test:
+            case TestTreeNodeBrand.Expect:
+                for (const member of this.children) {
+                    if (member.brand !== TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
+                    }
+                }
+                break;
+        }
+        return diagnostics;
+    }
+}
+
+class AssertionNode extends TestTreeNode {
+    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);
+            }
+        }
+    }
+}
+
+var TestTreeNodeFlags;
+(function (TestTreeNodeFlags) {
+    TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
+    TestTreeNodeFlags[TestTreeNodeFlags["Fail"] = 1] = "Fail";
+    TestTreeNodeFlags[TestTreeNodeFlags["Only"] = 2] = "Only";
+    TestTreeNodeFlags[TestTreeNodeFlags["Skip"] = 4] = "Skip";
+    TestTreeNodeFlags[TestTreeNodeFlags["Todo"] = 8] = "Todo";
+})(TestTreeNodeFlags || (TestTreeNodeFlags = {}));
+
+class 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();
+                    }
+                }
+            }
+            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
+                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
+            }
+        }
+    }
+    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 {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #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 matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
+                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
+                    return;
+                }
+                const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
+                parent.children.push(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.#collectTestTreeNodes(sourceFile, new IdentifierLookup(this.#compiler), testTree);
+        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;
+    }
+    #isMatcherNode(node) {
+        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
+    }
+}
+
+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 };
 }
@@ -2150,7 +2427,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 +2640,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;
-            }
             case "run:start":
                 this.#isFileViewExpanded = payload.result.tasks.length === 1 && this.resolvedConfig.watch !== true;
                 break;
@@ -2429,7 +2696,6 @@ class ListReporter extends BaseReporter {
                     this.#hasReportedError = true;
                 }
                 this.#fileView.clear();
-                this.#seenDeprecations.clear();
                 break;
             case "describe:start":
                 if (this.#isFileViewExpanded) {
@@ -2800,19 +3066,19 @@ class Debounce {
         this.#delay = delay;
         this.#onResolve = onResolve;
     }
-    clearTimeout() {
+    cancel() {
         clearTimeout(this.#timeout);
     }
-    refreshTimeout() {
-        this.clearTimeout();
+    refresh() {
+        this.cancel();
         this.#timeout = setTimeout(() => {
             this.#resolve?.(this.#onResolve());
         }, this.#delay);
     }
-    resolveWith(value) {
+    resolve(value) {
         this.#resolve?.(value);
     }
-    setup() {
+    schedule() {
         return new Promise((resolve) => {
             this.#resolve = resolve;
         });
@@ -2840,13 +3106,13 @@ class WatchService {
         };
         const debounce = new Debounce(100, onResolve);
         const onClose = (reason) => {
-            debounce.clearTimeout();
+            debounce.cancel();
             this.#inputService?.close();
             for (const watcher of this.#watchers) {
                 watcher.close();
             }
             cancellationToken.cancel(reason);
-            debounce.resolveWith([]);
+            debounce.resolve([]);
         };
         if (!environmentOptions.noInteractive) {
             const onInput = (chunk) => {
@@ -2861,9 +3127,9 @@ class WatchService {
                     case "\u000D":
                     case "\u0020":
                     case "a":
-                        debounce.clearTimeout();
+                        debounce.cancel();
                         if (this.#watchedTestFiles.size > 0) {
-                            debounce.resolveWith([...this.#watchedTestFiles.values()]);
+                            debounce.resolve([...this.#watchedTestFiles.values()]);
                         }
                         break;
                 }
@@ -2871,7 +3137,7 @@ class WatchService {
             this.#inputService = new InputService(onInput);
         }
         const onChangedFile = (filePath) => {
-            debounce.refreshTimeout();
+            debounce.refresh();
             let task = this.#watchedTestFiles.get(filePath);
             if (task != null) {
                 this.#changedTestFiles.set(filePath, task);
@@ -2886,7 +3152,7 @@ class WatchService {
             this.#changedTestFiles.delete(filePath);
             this.#watchedTestFiles.delete(filePath);
             if (this.#watchedTestFiles.size === 0) {
-                debounce.clearTimeout();
+                debounce.cancel();
                 this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
             }
         };
@@ -2899,7 +3165,7 @@ class WatchService {
             watcher.watch();
         }
         while (!cancellationToken.isCancellationRequested) {
-            const testFiles = await debounce.setup();
+            const testFiles = await debounce.schedule();
             if (testFiles.length > 0) {
                 yield testFiles;
             }
@@ -2907,276 +3173,7 @@ class WatchService {
     }
 }
 
-var TestMemberBrand;
-(function (TestMemberBrand) {
-    TestMemberBrand["Describe"] = "describe";
-    TestMemberBrand["Test"] = "test";
-    TestMemberBrand["Expect"] = "expect";
-})(TestMemberBrand || (TestMemberBrand = {}));
-
-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);
-                }
-            }
-        }
-    }
-    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;
-        }
-        return diagnostics;
-    }
-}
-
-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);
-            }
-        }
-    }
-}
-
-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();
-                    }
-                }
-            }
-            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
-                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
-            }
-        }
-    }
-    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;
-        }
-        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: TestMemberBrand.Describe, flags };
-            case "it":
-            case "test":
-                return { brand: TestMemberBrand.Test, flags };
-            case "expect":
-                return { brand: TestMemberBrand.Expect, flags };
-        }
-        return;
-    }
-}
-
-class TestTree {
-    diagnostics;
-    members = [];
-    sourceFile;
-    constructor(diagnostics, sourceFile) {
-        this.diagnostics = diagnostics;
-        this.sourceFile = sourceFile;
-    }
-    get hasOnly() {
-        function hasOnly(root) {
-            return root.members.some((branch) => branch.flags & TestMemberFlags.Only || ("members" in branch && hasOnly(branch)));
-        }
-        return hasOnly(this);
-    }
-}
-
-class CollectService {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
-    }
-    #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;
-            }
-            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;
-                }
-                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.#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;
-        }
-        if (name != null && name !== parent.name.getText()) {
-            return;
-        }
-        return parent;
-    }
-    #isMatcherNode(node) {
-        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
-    }
-}
-
-class ProjectService {
+class ProjectService {
     #compiler;
     #lastSeenProject = "";
     #resolvedConfig;
@@ -3234,24 +3231,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,12 +3335,6 @@ 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 matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
@@ -3373,18 +3359,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 +3422,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 +3446,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 +3532,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;
@@ -3875,17 +3819,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 +3888,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 +3908,9 @@ class ExpectService {
     #typeChecker;
     toAcceptProps;
     toBe;
-    toBeAny;
     toBeAssignableTo;
     toBeAssignableWith;
-    toBeBigInt;
-    toBeBoolean;
-    toBeNever;
-    toBeNull;
-    toBeNumber;
-    toBeString;
-    toBeSymbol;
-    toBeUndefined;
-    toBeUniqueSymbol;
-    toBeUnknown;
-    toBeVoid;
     toHaveProperty;
-    toMatch;
     toRaiseError;
     constructor(compiler, typeChecker, resolvedConfig) {
         this.#compiler = compiler;
@@ -4000,31 +3923,13 @@ class ExpectService {
         }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
-        this.toBeAny = new PrimitiveTypeMatcher(compiler.TypeFlags.Any);
         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)] }]);
-        }
         if (!assertion.source[0]) {
             this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
             return;
@@ -4035,7 +3940,6 @@ class ExpectService {
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-            case "toMatch":
                 if (!assertion.target[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
@@ -4044,19 +3948,6 @@ class ExpectService {
                     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 "toHaveProperty":
                 if (!assertion.target[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
@@ -4095,10 +3986,14 @@ class ExpectService {
     }
     #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`]) {
+                if (!argumentNode) {
                     continue;
                 }
                 if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[Format.capitalize(rejectedType)]) {
@@ -4119,7 +4014,6 @@ class ExpectService {
 }
 
 class TestTreeWalker {
-    #compiler;
     #cancellationToken;
     #expectService;
     #hasOnly;
@@ -4128,59 +4022,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);
@@ -4234,7 +4129,7 @@ class TestTreeWalker {
             ]);
         }
         else {
-            this.visit(describe.members, runMode, describeResult);
+            this.visit(describe.children, runMode, describeResult);
         }
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
@@ -4256,7 +4151,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;
@@ -4336,17 +4231,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.0";
     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 +4279,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 +4383,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 +4440,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 };