tstyche 4.0.0-beta.6 → 4.0.0-beta.8

package/build/tstyche.js

@@ -1672,14 +1672,12 @@ class ResultCount {
 class Result {
     expectCount = new ResultCount();
     fileCount = new ResultCount();
-    resolvedConfig;
     results = [];
     targetCount = new ResultCount();
     tasks;
     testCount = new ResultCount();
     timing = new ResultTiming();
-    constructor(resolvedConfig, tasks) {
-        this.resolvedConfig = resolvedConfig;
+    constructor(tasks) {
         this.tasks = tasks;
     }
 }
@@ -1781,6 +1779,7 @@ class ResultHandler {
                 this.#taskResult.timing.start = Date.now();
                 break;
             case "task:error":
+            case "collect:error":
                 this.#targetResult.status = ResultStatus.Failed;
                 this.#taskResult.status = ResultStatus.Failed;
                 this.#taskResult.diagnostics.push(...payload.diagnostics);
@@ -1915,488 +1914,90 @@ class ResultHandler {
     }
 }
 
-var TestTreeNodeBrand;
-(function (TestTreeNodeBrand) {
-    TestTreeNodeBrand["Describe"] = "describe";
-    TestTreeNodeBrand["Test"] = "test";
-    TestTreeNodeBrand["Expect"] = "expect";
-})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+function jsx(type, props) {
+    return { props, type };
+}
 
-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])) {
-            for (const diagnostic of parent.diagnostics) {
-                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
-                    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;
+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] }));
 }
 
-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 (diagnosticBelongsToNode(diagnostic, this.source)) {
-                this.diagnostics.add(diagnostic);
-                parent.diagnostics.delete(diagnostic);
-            }
-        }
-    }
+function Line({ children, color, indent }) {
+    return (jsx(Text, { color: color, indent: indent, children: [children, jsx("newLine", {})] }));
 }
 
-class AbilityLayer {
-    #filePath = "";
-    #nodes = [];
-    #projectService;
-    #resolvedConfig;
-    #text = "";
-    constructor(projectService, resolvedConfig) {
-        this.#projectService = projectService;
-        this.#resolvedConfig = resolvedConfig;
+class Scribbler {
+    #indentStep = "  ";
+    #newLine;
+    #noColor;
+    #notEmptyLineRegex = /^(?!$)/gm;
+    constructor(options) {
+        this.#newLine = options?.newLine ?? "\n";
+        this.#noColor = options?.noColor ?? environmentOptions.noColor;
     }
-    #getErasedRangeText(range) {
-        if (this.#text.indexOf("\n", range.start) >= range.end) {
-            return " ".repeat(range.end - range.start);
-        }
-        const text = [];
-        for (let index = range.start; index < range.end; index++) {
-            const character = this.#text.charAt(index);
-            switch (character) {
-                case "\n":
-                case "\r":
-                    text.push(character);
-                    break;
-                default:
-                    text.push(" ");
-            }
-        }
-        return text.join("");
+    #escapeSequence(attributes) {
+        return ["\u001B[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
     }
-    #addRanges(node, ranges) {
-        this.#nodes.push(node);
-        for (const range of ranges) {
-            const rangeText = range.replacement != null
-                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
-                : this.#getErasedRangeText(range);
-            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
+    #indentEachLine(lines, level) {
+        if (level === 0) {
+            return lines;
         }
+        return lines.replace(this.#notEmptyLineRegex, this.#indentStep.repeat(level));
     }
-    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));
-            for (const node of this.#nodes.reverse()) {
-                for (const diagnostic of diagnostics) {
-                    if (diagnosticBelongsToNode(diagnostic, node.matcherNode)) {
-                        if (!node.abilityDiagnostics) {
-                            node.abilityDiagnostics = new Set();
-                        }
-                        node.abilityDiagnostics.add(diagnostic);
-                        diagnostics.delete(diagnostic);
-                    }
-                }
-            }
+    render(element) {
+        if (typeof element.type === "function") {
+            return this.render(element.type({ ...element.props }));
         }
-        this.#filePath = "";
-        this.#nodes = [];
-        this.#text = "";
-    }
-    handleNode(assertionNode) {
-        const expectStart = assertionNode.node.getStart();
-        const expectExpressionEnd = assertionNode.node.expression.getEnd();
-        const expectEnd = assertionNode.node.getEnd();
-        const matcherNameEnd = assertionNode.matcherNameNode.getEnd();
-        switch (assertionNode.matcherNameNode.name.text) {
-            case "toBeApplicable":
-                this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd, start: expectStart },
-                    { end: matcherNameEnd, start: expectEnd },
-                ]);
-                break;
-            case "toBeCallableWith":
-                this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd, start: expectStart, replacement: ";" },
-                    { end: matcherNameEnd, start: expectEnd },
-                ]);
-                break;
-            case "toBeConstructableWith":
-                this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd, start: expectStart, replacement: "; new" },
-                    { end: matcherNameEnd, start: expectEnd },
-                ]);
-                break;
+        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 "";
     }
-    open(sourceFile) {
-        this.#filePath = sourceFile.fileName;
-        this.#text = sourceFile.text;
+    #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("");
     }
 }
 
-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 {
-    #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 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 });
@@ -2627,39 +2228,12 @@ function CountText({ failed, passed, skipped, todo, total }) {
 function DurationText({ seconds }) {
     return jsx(Text, { children: `${Math.round(seconds * 10) / 10}s` });
 }
-function MatchText({ text }) {
-    if (typeof text === "string") {
-        return jsx(Text, { children: ["'", text, "'"] });
-    }
-    if (text.length === 1) {
-        return jsx(Text, { children: ["'", ...text, "'"] });
-    }
-    const lastItem = text.pop();
-    return (jsx(Text, { children: [text.map((match, index, list) => (jsx(Text, { children: ["'", match, "'", index === list.length - 1 ? jsx(Text, { children: " " }) : jsx(Text, { color: Color.Gray, children: ", " })] }))), jsx(Text, { color: Color.Gray, children: "or" }), " '", lastItem, "'"] }));
-}
-function RanFilesText({ onlyMatch, pathMatch, skipMatch }) {
-    const testNameMatchText = [];
-    if (onlyMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: "matching " }), jsx(MatchText, { text: onlyMatch })] }));
-    }
-    if (skipMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [onlyMatch && jsx(Text, { color: Color.Gray, children: " and " }), jsx(Text, { color: Color.Gray, children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
-    }
-    let pathMatchText;
-    if (pathMatch.length > 0) {
-        pathMatchText = (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: "test files matching " }), jsx(MatchText, { text: pathMatch }), jsx(Text, { color: Color.Gray, children: "." })] }));
-    }
-    else {
-        pathMatchText = jsx(Text, { color: Color.Gray, children: "all test files." });
-    }
-    return (jsx(Line, { children: [jsx(Text, { color: Color.Gray, children: "Ran " }), testNameMatchText.length > 0 ? jsx(Text, { color: Color.Gray, children: "tests " }) : undefined, testNameMatchText, testNameMatchText.length > 0 ? jsx(Text, { color: Color.Gray, children: " in " }) : undefined, pathMatchText] }));
-}
-function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }) {
+function summaryText({ duration, expectCount, fileCount, targetCount, testCount, }) {
     const targetCountText = (jsx(RowText, { label: "Targets", text: jsx(CountText, { failed: targetCount.failed, passed: targetCount.passed, skipped: targetCount.skipped, todo: targetCount.todo, total: targetCount.total }) }));
     const fileCountText = (jsx(RowText, { label: "Test files", text: jsx(CountText, { failed: fileCount.failed, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
     const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
     const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
-    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) }), jsx(Line, {}), jsx(RanFilesText, { onlyMatch: onlyMatch, pathMatch: pathMatch, skipMatch: skipMatch })] }));
+    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
 }
 
 function StatusText({ status }) {
@@ -2808,6 +2382,7 @@ class ListReporter extends BaseReporter {
                 this.#hasReportedError = false;
                 break;
             case "task:error":
+            case "collect:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
@@ -2903,9 +2478,6 @@ class SummaryReporter extends BaseReporter {
                 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,
             }));
@@ -2975,6 +2547,7 @@ var CancellationReason;
 (function (CancellationReason) {
     CancellationReason["ConfigChange"] = "configChange";
     CancellationReason["ConfigError"] = "configError";
+    CancellationReason["CollectError"] = "collectError";
     CancellationReason["FailFast"] = "failFast";
     CancellationReason["WatchClose"] = "watchClose";
 })(CancellationReason || (CancellationReason = {}));
@@ -3202,101 +2775,587 @@ class Debounce {
             this.#resolve?.(this.#onResolve());
         }, this.#delay);
     }
-    resolve(value) {
-        this.#resolve?.(value);
+    resolve(value) {
+        this.#resolve?.(value);
+    }
+    schedule() {
+        return new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+}
+
+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]));
+    }
+    #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();
+            }
+            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;
+                }
+            };
+            this.#inputService = new InputService(onInput);
+        }
+        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();
+        }
+        while (!cancellationToken.isCancellationRequested) {
+            const testFiles = await debounce.schedule();
+            if (testFiles.length > 0) {
+                yield testFiles;
+            }
+        }
+    }
+}
+
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+    TestTreeNodeBrand["When"] = "when";
+})(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])) {
+            for (const diagnostic of parent.diagnostics) {
+                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
+                    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 || child.brand === TestTreeNodeBrand.When) {
+                        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.Describe || child.brand === TestTreeNodeBrand.Test) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(child.node)));
+                    }
+                }
+                break;
+        }
+        return diagnostics;
+    }
+}
+
+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 (diagnosticBelongsToNode(diagnostic, this.source)) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
+    }
+}
+
+function nodeBelongsToArgumentList(compiler, node) {
+    if (compiler.isCallExpression(node.parent)) {
+        return node.parent.arguments.some((argument) => argument === node);
+    }
+    return false;
+}
+
+class AbilityLayer {
+    #compiler;
+    #filePath = "";
+    #nodes = [];
+    #projectService;
+    #resolvedConfig;
+    #text = "";
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
+    }
+    #getErasedRangeText(range) {
+        if (this.#text.indexOf("\n", range.start) >= range.end) {
+            return " ".repeat(range.end - range.start);
+        }
+        const text = [];
+        for (let index = range.start; index < range.end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
+                case "\n":
+                case "\r":
+                    text.push(character);
+                    break;
+                default:
+                    text.push(" ");
+            }
+        }
+        return text.join("");
+    }
+    #addRanges(node, ranges) {
+        this.#nodes.push(node);
+        for (const range of ranges) {
+            const rangeText = range.replacement != null
+                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
+                : this.#getErasedRangeText(range);
+            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
+        }
+    }
+    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));
+            for (const node of this.#nodes.reverse()) {
+                for (const diagnostic of diagnostics) {
+                    if (diagnosticBelongsToNode(diagnostic, "matcherNode" in node ? node.matcherNode : node.actionNode)) {
+                        if (!node.abilityDiagnostics) {
+                            node.abilityDiagnostics = new Set();
+                        }
+                        node.abilityDiagnostics.add(diagnostic);
+                        diagnostics.delete(diagnostic);
+                    }
+                }
+            }
+        }
+        this.#filePath = "";
+        this.#nodes = [];
+        this.#text = "";
+    }
+    handleWhen(whenNode) {
+        const whenStart = whenNode.node.getStart();
+        const whenExpressionEnd = whenNode.node.expression.getEnd();
+        const whenEnd = whenNode.node.getEnd();
+        const actionNameEnd = whenNode.actionNameNode.getEnd();
+        switch (whenNode.actionNameNode.name.text) {
+            case "isCalledWith":
+                this.#addRanges(whenNode, [
+                    {
+                        end: whenExpressionEnd,
+                        start: whenStart,
+                        replacement: nodeBelongsToArgumentList(this.#compiler, whenNode.actionNode) ? "" : ";",
+                    },
+                    { end: actionNameEnd, start: whenEnd },
+                ]);
+                break;
+        }
+    }
+    handleAssertion(assertionNode) {
+        const expectStart = assertionNode.node.getStart();
+        const expectExpressionEnd = assertionNode.node.expression.getEnd();
+        const expectEnd = assertionNode.node.getEnd();
+        const matcherNameEnd = assertionNode.matcherNameNode.getEnd();
+        switch (assertionNode.matcherNameNode.name.text) {
+            case "toBeApplicable":
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd },
+                ]);
+                break;
+            case "toBeCallableWith":
+                this.#addRanges(assertionNode, [
+                    {
+                        end: expectExpressionEnd,
+                        start: expectStart,
+                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "" : ";",
+                    },
+                    { end: matcherNameEnd, start: expectEnd },
+                ]);
+                break;
+            case "toBeConstructableWith":
+                this.#addRanges(assertionNode, [
+                    {
+                        end: expectExpressionEnd,
+                        start: expectStart,
+                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "new" : "; new",
+                    },
+                    { end: matcherNameEnd, start: expectEnd },
+                ]);
+                break;
+        }
+    }
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+    }
+}
+
+class CollectDiagnosticText {
+    static cannotBeNestedWithin(source, target) {
+        return `'${source}()' cannot be nested within '${target}()'.`;
+    }
+}
+
+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,
+                when: 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 identifier;
+        if (this.#compiler.isPropertyAccessExpression(expression) &&
+            expression.expression.getText() === this.#identifiers.namespace) {
+            identifier = expression.name.getText();
+        }
+        else {
+            identifier = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+        }
+        if (!identifier) {
+            return;
+        }
+        switch (identifier) {
+            case "describe":
+                return { brand: TestTreeNodeBrand.Describe, flags, identifier };
+            case "it":
+            case "test":
+                return { brand: TestTreeNodeBrand.Test, flags, identifier };
+            case "expect":
+                return { brand: TestTreeNodeBrand.Expect, flags, identifier };
+            case "when":
+                return { brand: TestTreeNodeBrand.When, flags, identifier };
+        }
+        return;
+    }
+}
+
+class TestTree {
+    children = [];
+    diagnostics;
+    hasOnly = false;
+    sourceFile;
+    constructor(diagnostics, sourceFile) {
+        this.diagnostics = diagnostics;
+        this.sourceFile = sourceFile;
     }
-    schedule() {
-        return new Promise((resolve) => {
-            this.#resolve = resolve;
-        });
+}
+
+class WhenNode extends TestTreeNode {
+    actionNode;
+    actionNameNode;
+    abilityDiagnostics;
+    target;
+    constructor(compiler, brand, node, parent, flags, actionNode, actionNameNode) {
+        super(compiler, brand, node, parent, flags);
+        this.actionNode = actionNode;
+        this.actionNameNode = actionNameNode;
+        this.target = this.node.typeArguments ?? this.node.arguments;
+        for (const diagnostic of parent.diagnostics) {
+            if (diagnosticBelongsToNode(diagnostic, node)) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
     }
 }
 
-class WatchService {
-    #changedTestFiles = new Map();
-    #inputService;
+class CollectService {
+    #abilityLayer;
+    #compiler;
+    #identifierLookup;
+    #projectService;
     #resolvedConfig;
-    #watchedTestFiles;
-    #watchers = [];
-    constructor(resolvedConfig, tasks) {
+    #testTree;
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#projectService = projectService;
         this.#resolvedConfig = resolvedConfig;
-        this.#watchedTestFiles = new Map(tasks.map((task) => [task.filePath, task]));
+        this.#abilityLayer = new AbilityLayer(compiler, this.#projectService, this.#resolvedConfig);
+        this.#identifierLookup = new IdentifierLookup(compiler);
     }
-    #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();
+    #collectTestTreeNodes(node, parent) {
+        if (this.#compiler.isCallExpression(node)) {
+            const meta = this.#identifierLookup.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);
+                this.#compiler.forEachChild(node, (node) => {
+                    this.#collectTestTreeNodes(node, testTreeNode);
+                });
+                this.#onNode(testTreeNode, parent);
+                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;
+            if (meta != null && meta.brand === TestTreeNodeBrand.Expect) {
+                const modifierNode = this.#getChainedNode(node, "type");
+                if (!modifierNode) {
+                    return;
                 }
-            };
-            this.#inputService = new InputService(onInput);
-        }
-        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 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);
+                this.#abilityLayer.handleAssertion(assertionNode);
+                this.#compiler.forEachChild(node, (node) => {
+                    this.#collectTestTreeNodes(node, assertionNode);
+                });
+                this.#onNode(assertionNode, parent);
+                return;
             }
-        };
-        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)));
+            if (meta != null && meta.brand === TestTreeNodeBrand.When) {
+                const actionNameNode = this.#getChainedNode(node);
+                if (!actionNameNode) {
+                    return;
+                }
+                const actionNode = this.#getActionNode(actionNameNode);
+                if (!actionNode) {
+                    return;
+                }
+                this.#compiler.forEachChild(actionNode, (node) => {
+                    if (this.#compiler.isCallExpression(node)) {
+                        const meta = this.#identifierLookup.resolveTestMemberMeta(node);
+                        if (meta != null && (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test)) {
+                            const text = CollectDiagnosticText.cannotBeNestedWithin(meta.identifier, "when");
+                            const origin = DiagnosticOrigin.fromNode(node);
+                            this.#onDiagnostics(Diagnostic.error(text, origin));
+                        }
+                    }
+                });
+                const whenNode = new WhenNode(this.#compiler, meta.brand, node, parent, meta.flags, actionNode, actionNameNode);
+                this.#abilityLayer.handleWhen(whenNode);
+                this.#onNode(whenNode, parent);
+                return;
             }
-        };
-        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.schedule();
-            if (testFiles.length > 0) {
-                yield testFiles;
-            }
+        if (this.#compiler.isImportDeclaration(node)) {
+            this.#identifierLookup.handleImportDeclaration(node);
+            return;
+        }
+        this.#compiler.forEachChild(node, (node) => {
+            this.#collectTestTreeNodes(node, parent);
+        });
+    }
+    createTestTree(sourceFile, semanticDiagnostics = []) {
+        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
+        EventEmitter.dispatch(["collect:start", { tree: testTree }]);
+        this.#testTree = testTree;
+        this.#abilityLayer.open(sourceFile);
+        this.#collectTestTreeNodes(sourceFile, testTree);
+        this.#abilityLayer.close();
+        this.#testTree = undefined;
+        EventEmitter.dispatch(["collect:end", { tree: 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;
+    }
+    #getActionNode(node) {
+        if (this.#compiler.isCallExpression(node.parent)) {
+            return node.parent;
+        }
+        return;
+    }
+    #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["collect:error", { diagnostics: [diagnostic] }]);
+    }
+    #onNode(node, parent) {
+        parent.children.push(node);
+        if (node.flags & TestTreeNodeFlags.Only) {
+            this.#testTree.hasOnly = true;
         }
+        EventEmitter.dispatch(["collect:node", { node }]);
     }
 }
 
@@ -3305,6 +3364,7 @@ class ProjectService {
     #lastSeenProject = "";
     #resolvedConfig;
     #seenPrograms = new WeakSet();
+    #seenTestFiles = new Set();
     #service;
     constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
@@ -3342,15 +3402,6 @@ class ProjectService {
             useInferredProjectPerProjectRoot: true,
             useSingleInferredProject: false,
         });
-        switch (this.#resolvedConfig.tsconfig) {
-            case "findup":
-                break;
-            case "ignore":
-                this.#service.getConfigFileNameForFile = () => undefined;
-                break;
-            default:
-                this.#service.getConfigFileNameForFile = () => this.#resolvedConfig.tsconfig;
-        }
         this.#service.setCompilerOptionsForInferredProjects(this.#getDefaultCompilerOptions());
     }
     closeFile(filePath) {
@@ -3385,7 +3436,23 @@ class ProjectService {
         const project = this.getDefaultProject(filePath);
         return project?.getLanguageService(true);
     }
+    #isFileIncluded(filePath) {
+        const configSourceFile = this.#compiler.readJsonConfigFile(this.#resolvedConfig.tsconfig, this.#compiler.sys.readFile);
+        const { fileNames } = this.#compiler.parseJsonSourceFileConfigFileContent(configSourceFile, this.#compiler.sys, Path.dirname(this.#resolvedConfig.tsconfig), undefined, this.#resolvedConfig.tsconfig);
+        return fileNames.includes(filePath);
+    }
     openFile(filePath, sourceText, projectRootPath) {
+        switch (this.#resolvedConfig.tsconfig) {
+            case "findup":
+                break;
+            case "ignore":
+                this.#service.getConfigFileNameForFile = () => undefined;
+                break;
+            default:
+                this.#service.getConfigFileNameForFile = this.#isFileIncluded(filePath)
+                    ? () => this.#resolvedConfig.tsconfig
+                    : () => undefined;
+        }
         const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
         if (configFileName !== this.#lastSeenProject) {
             this.#lastSeenProject = configFileName;
@@ -3400,29 +3467,29 @@ class ProjectService {
                 { diagnostics: Diagnostic.fromDiagnostics(configFileErrors) },
             ]);
         }
-        if (this.#resolvedConfig.checkSourceFiles) {
+        if (this.#resolvedConfig.checkSourceFiles && !this.#seenTestFiles.has(filePath)) {
+            this.#seenTestFiles.add(filePath);
             const languageService = this.getLanguageService(filePath);
             const program = languageService?.getProgram();
             if (!program || this.#seenPrograms.has(program)) {
                 return;
             }
             this.#seenPrograms.add(program);
-            const filesToCheck = [];
-            for (const sourceFile of program.getSourceFiles()) {
+            const sourceFilesToCheck = program.getSourceFiles().filter((sourceFile) => {
                 if (program.isSourceFileFromExternalLibrary(sourceFile) || program.isSourceFileDefaultLibrary(sourceFile)) {
-                    continue;
+                    return false;
                 }
-                if (!Select.isTestFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
-                    filesToCheck.push(sourceFile);
+                if (Select.isTestFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
+                    return false;
                 }
-            }
+                return true;
+            });
             const diagnostics = [];
-            for (const sourceFile of filesToCheck) {
+            for (const sourceFile of sourceFilesToCheck) {
                 diagnostics.push(...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile));
             }
             if (diagnostics.length > 0) {
                 EventEmitter.dispatch(["project:error", { diagnostics: Diagnostic.fromDiagnostics(diagnostics) }]);
-                return;
             }
         }
     }
@@ -3437,10 +3504,8 @@ var RunMode;
     RunMode[RunMode["Todo"] = 8] = "Todo";
 })(RunMode || (RunMode = {}));
 
-class Format {
-    static capitalize(text) {
-        return text.replace(/^./, text.charAt(0).toUpperCase());
-    }
+function capitalize(text) {
+    return text.replace(/^./, text.charAt(0).toUpperCase());
 }
 
 class ExpectDiagnosticText {
@@ -3456,23 +3521,23 @@ class ExpectDiagnosticText {
     static argumentMustBeProvided(argumentNameText) {
         return `An argument for '${argumentNameText}' must be provided.`;
     }
-    static isCallable(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} is callable ${targetText}.`;
+    static isCallable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is callable ${targetText}.`;
     }
-    static isNotCallable(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} is not callable ${targetText}.`;
+    static isNotCallable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is not callable ${targetText}.`;
     }
-    static isConstructable(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} is constructable ${targetText}.`;
+    static isConstructable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is constructable ${targetText}.`;
     }
-    static isNotConstructable(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} is not constructable ${targetText}.`;
+    static isNotConstructable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is not constructable ${targetText}.`;
     }
-    static acceptsProps(isTypeNode) {
-        return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
+    static acceptsProps(isExpression) {
+        return `${isExpression ? "Component" : "Component type"} accepts props of the given type.`;
     }
-    static doesNotAcceptProps(isTypeNode) {
-        return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
+    static doesNotAcceptProps(isExpression) {
+        return `${isExpression ? "Component" : "Component type"} does not accept props of the given type.`;
     }
     static canBeApplied(targetText) {
         return `The decorator function can be applied${targetText}.`;
@@ -3504,21 +3569,21 @@ class ExpectDiagnosticText {
     static typeArgumentMustBe(argumentNameText, expectedText) {
         return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
-    static raisedError(isTypeNode, count, targetCount) {
+    static raisedError(isExpression, count, targetCount) {
         let countText = "a";
         if (count > 1 || targetCount > 1) {
             countText = count > targetCount ? `${count}` : `only ${count}`;
         }
-        return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
+        return `${isExpression ? "Expression" : "Type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
     }
-    static didNotRaiseError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
+    static didNotRaiseError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} did not raise a type error.`;
     }
-    static raisedMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
+    static raisedMatchingError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} raised a matching type error.`;
     }
-    static didNotRaiseMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
+    static didNotRaiseMatchingError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} did not raise a matching type error.`;
     }
     static isAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
@@ -3548,7 +3613,7 @@ class ExpectDiagnosticText {
         return `Types of property '${propertyNameText}' are not compatible.`;
     }
     static typeWasRejected(typeText) {
-        const optionNameText = `reject${Format.capitalize(typeText)}Type`;
+        const optionNameText = `reject${capitalize(typeText)}Type`;
         return [
             `The '${typeText}' type was rejected because the '${optionNameText}' option is enabled.`,
             `If this check is necessary, pass '${typeText}' as the type argument explicitly.`,
@@ -3670,12 +3735,13 @@ class ToAcceptProps {
         this.#typeChecker = typeChecker;
     }
     #explain(matchWorker, sourceNode, targetNode) {
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const signatures = matchWorker.getSignatures(sourceNode);
         return signatures.reduce((accumulator, signature, index) => {
             let diagnostic;
             const introText = matchWorker.assertion.isNot
-                ? ExpectDiagnosticText.acceptsProps(this.#compiler.isTypeNode(sourceNode))
-                : ExpectDiagnosticText.doesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
+                ? ExpectDiagnosticText.acceptsProps(isExpression)
+                : ExpectDiagnosticText.doesNotAcceptProps(isExpression);
             const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
@@ -3815,18 +3881,18 @@ class ToAcceptProps {
         const signatures = matchWorker.getSignatures(sourceNode);
         if (signatures.length === 0) {
             const expectedText = "of a function or class type";
-            const text = this.#compiler.isTypeNode(sourceNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
         const targetType = matchWorker.getType(targetNode);
         if (!(targetType.flags & this.#compiler.TypeFlags.Object)) {
             const expectedText = "of an object type";
-            const text = this.#compiler.isTypeNode(targetNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("target", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, targetNode)
+                ? ExpectDiagnosticText.argumentMustBe("target", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText);
             const origin = DiagnosticOrigin.fromNode(targetNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
@@ -3919,9 +3985,9 @@ class ToBeApplicable {
         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 text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             onDiagnostics([Diagnostic.error(text, origin)]);
             return;
@@ -3970,12 +4036,15 @@ class ToBeCallableWith {
         return `with the given argument${nodes.length === 1 ? "" : "s"}`;
     }
     #explain(matchWorker, sourceNode, targetNodes) {
-        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const targetText = this.#resolveTargetText(targetNodes);
         const diagnostics = [];
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [ExpectDiagnosticText.isNotCallable(isTypeNode, targetText), getDiagnosticMessageText(diagnostic)];
+                const text = [
+                    ExpectDiagnosticText.isNotCallable(isExpression, targetText),
+                    getDiagnosticMessageText(diagnostic),
+                ];
                 let origin;
                 if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
                     origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
@@ -3995,7 +4064,7 @@ class ToBeCallableWith {
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isCallable(isTypeNode, targetText), origin));
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isCallable(isExpression, targetText), origin));
         }
         return diagnostics;
     }
@@ -4014,11 +4083,11 @@ class ToBeCallableWith {
         }
         if (!type || type.getCallSignatures().length === 0) {
             const text = [];
-            if (this.#compiler.isTypeNode(sourceNode)) {
-                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a callable type"));
+            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
             }
             else {
-                text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a callable type"));
             }
             if (type != null && type.getConstructSignatures().length > 0) {
                 text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeConstructableWith()' matcher"));
@@ -4049,13 +4118,13 @@ class ToBeConstructableWith {
         return `with the given argument${nodes.length === 1 ? "" : "s"}`;
     }
     #explain(matchWorker, sourceNode, targetNodes) {
-        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const targetText = this.#resolveTargetText(targetNodes);
         const diagnostics = [];
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
                 const text = [
-                    ExpectDiagnosticText.isNotConstructable(isTypeNode, targetText),
+                    ExpectDiagnosticText.isNotConstructable(isExpression, targetText),
                     getDiagnosticMessageText(diagnostic),
                 ];
                 let origin;
@@ -4077,7 +4146,7 @@ class ToBeConstructableWith {
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isTypeNode, targetText), origin));
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isExpression, targetText), origin));
         }
         return diagnostics;
     }
@@ -4093,11 +4162,11 @@ class ToBeConstructableWith {
         }
         if (!type || type.getConstructSignatures().length === 0) {
             const text = [];
-            if (this.#compiler.isTypeNode(sourceNode)) {
-                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a constructable type"));
+            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
             }
             else {
-                text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a constructable type"));
             }
             if (type != null && type.getCallSignatures().length > 0) {
                 text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeCallableWith()' matcher"));
@@ -4139,9 +4208,9 @@ class ToHaveProperty {
         if (sourceType.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never) ||
             !matchWorker.extendsObjectType(sourceType)) {
             const expectedText = "of an object type";
-            const text = this.#compiler.isTypeNode(sourceNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
@@ -4178,15 +4247,15 @@ class ToRaiseError {
         this.#compiler = compiler;
     }
     #explain(matchWorker, sourceNode, targetNodes) {
-        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
         if (matchWorker.assertion.diagnostics.size === 0) {
-            const text = ExpectDiagnosticText.didNotRaiseError(isTypeNode);
+            const text = ExpectDiagnosticText.didNotRaiseError(isExpression);
             return [Diagnostic.error(text, origin)];
         }
         if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
             const count = matchWorker.assertion.diagnostics.size;
-            const text = ExpectDiagnosticText.raisedError(isTypeNode, count, targetNodes.length);
+            const text = ExpectDiagnosticText.raisedError(isExpression, count, targetNodes.length);
             const related = [
                 Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
                 ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics]),
@@ -4198,8 +4267,8 @@ class ToRaiseError {
             const isMatch = this.#matchExpectedError(diagnostic, targetNode);
             if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.raisedMatchingError(isTypeNode)
-                    : ExpectDiagnosticText.didNotRaiseMatchingError(isTypeNode);
+                    ? ExpectDiagnosticText.raisedMatchingError(isExpression)
+                    : ExpectDiagnosticText.didNotRaiseMatchingError(isExpression);
                 const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
                 const related = [
                     Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
@@ -4348,7 +4417,7 @@ class ExpectService {
     }
     #rejectsTypeArguments(matchWorker, onDiagnostics) {
         for (const rejectedType of this.#rejectTypes) {
-            const allowedKeyword = this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`];
+            const allowedKeyword = this.#compiler.SyntaxKind[`${capitalize(rejectedType)}Keyword`];
             if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
                 matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
                 continue;
@@ -4358,11 +4427,11 @@ class ExpectService {
                 if (!argumentNode) {
                     continue;
                 }
-                if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[Format.capitalize(rejectedType)]) {
+                if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
                     const text = [
-                        this.#compiler.isTypeNode(argumentNode)
-                            ? ExpectDiagnosticText.typeArgumentCannotBeOfType(Format.capitalize(argumentName), rejectedType)
-                            : ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType),
+                        nodeBelongsToArgumentList(this.#compiler, argumentNode)
+                            ? ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType)
+                            : ExpectDiagnosticText.typeArgumentCannotBeOfType(capitalize(argumentName), rejectedType),
                         ...ExpectDiagnosticText.typeWasRejected(rejectedType),
                     ];
                     const origin = DiagnosticOrigin.fromNode(argumentNode);
@@ -4433,6 +4502,9 @@ class TestTreeWalker {
                 case TestTreeNodeBrand.Expect:
                     this.#visitAssertion(testNode, runMode, parentResult);
                     break;
+                case TestTreeNodeBrand.When:
+                    this.#visitWhen(testNode, runMode, parentResult);
+                    break;
             }
         }
     }
@@ -4525,11 +4597,37 @@ class TestTreeWalker {
             EventEmitter.dispatch(["test:pass", { result: testResult }]);
         }
     }
+    #visitWhen(when, runMode, parentResult) {
+        if (when.abilityDiagnostics != null && when.abilityDiagnostics.size > 0) {
+            const diagnostics = [];
+            for (const diagnostic of when.abilityDiagnostics) {
+                if (isDiagnosticWithLocation(diagnostic)) {
+                    const text = getDiagnosticMessageText(diagnostic);
+                    let origin;
+                    if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, when.node)) {
+                        origin = DiagnosticOrigin.fromNodes(when.target);
+                    }
+                    else {
+                        origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), when.node.getSourceFile());
+                    }
+                    let related;
+                    if (diagnostic.relatedInformation != null) {
+                        related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                    }
+                    diagnostics.push(Diagnostic.error(text, origin).add({ related }));
+                }
+            }
+            EventEmitter.dispatch(["task:error", { diagnostics, result: this.#taskResult }]);
+            return;
+        }
+        this.visit(when.children, runMode, parentResult);
+    }
 }
 
 class TaskRunner {
     #collectService;
     #compiler;
+    #eventEmitter = new EventEmitter();
     #resolvedConfig;
     #projectService;
     constructor(compiler, resolvedConfig) {
@@ -4538,55 +4636,71 @@ class TaskRunner {
         this.#projectService = new ProjectService(compiler, this.#resolvedConfig);
         this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
-    run(task, cancellationToken) {
-        if (cancellationToken?.isCancellationRequested) {
+    #onDiagnostics(diagnostics, result) {
+        EventEmitter.dispatch(["task:error", { diagnostics, result }]);
+    }
+    async run(task, cancellationToken) {
+        if (cancellationToken.isCancellationRequested) {
             return;
         }
         this.#projectService.openFile(task.filePath, undefined, this.#resolvedConfig.rootPath);
         const taskResult = new TaskResult(task);
         EventEmitter.dispatch(["task:start", { result: taskResult }]);
-        this.#run(task, taskResult, cancellationToken);
+        await this.#run(task, taskResult, cancellationToken);
         EventEmitter.dispatch(["task:end", { result: taskResult }]);
         this.#projectService.closeFile(task.filePath);
     }
-    #run(task, taskResult, cancellationToken) {
+    async #run(task, taskResult, cancellationToken) {
         if (!existsSync(task.filePath)) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: [Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], result: taskResult },
-            ]);
-            return;
-        }
-        const languageService = this.#projectService.getLanguageService(task.filePath);
-        if (!languageService) {
+            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
             return;
         }
-        const syntacticDiagnostics = languageService.getSyntacticDiagnostics(task.filePath);
-        if (syntacticDiagnostics.length > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics), result: taskResult },
-            ]);
+        let languageService = this.#projectService.getLanguageService(task.filePath);
+        const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
+        if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
+            this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
             return;
         }
-        const semanticDiagnostics = languageService.getSemanticDiagnostics(task.filePath);
-        const program = languageService.getProgram();
-        if (!program) {
-            return;
+        let semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+        let program = languageService?.getProgram();
+        let sourceFile = program?.getSourceFile(task.filePath);
+        if (sourceFile?.text.startsWith("// @tstyche-template")) {
+            if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), taskResult);
+                return;
+            }
+            const moduleSpecifier = pathToFileURL(task.filePath).toString();
+            const testText = (await import(moduleSpecifier))?.default;
+            if (typeof testText !== "string") {
+                this.#onDiagnostics([Diagnostic.error("A template test file must export a string.")], taskResult);
+                return;
+            }
+            this.#projectService.openFile(task.filePath, testText, this.#resolvedConfig.rootPath);
+            languageService = this.#projectService.getLanguageService(task.filePath);
+            const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
+            if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
+                return;
+            }
+            semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+            program = languageService?.getProgram();
+            sourceFile = program?.getSourceFile(task.filePath);
         }
-        const sourceFile = program.getSourceFile(task.filePath);
         if (!sourceFile) {
             return;
         }
+        const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.CollectError);
+        this.#eventEmitter.addHandler(cancellationHandler);
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
+        this.#eventEmitter.removeHandler(cancellationHandler);
+        if (cancellationToken.isCancellationRequested) {
+            return;
+        }
         if (testTree.diagnostics.size > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: Diagnostic.fromDiagnostics([...testTree.diagnostics]), result: taskResult },
-            ]);
+            this.#onDiagnostics(Diagnostic.fromDiagnostics([...testTree.diagnostics]), taskResult);
             return;
         }
-        const typeChecker = program.getTypeChecker();
+        const typeChecker = program?.getTypeChecker();
         const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, {
             cancellationToken,
             taskResult,
@@ -4600,15 +4714,13 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.6";
+    static version = "4.0.0-beta.8";
     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);
@@ -4651,7 +4763,7 @@ class Runner {
         this.#eventEmitter.removeHandlers();
     }
     async #run(tasks, cancellationToken) {
-        const result = new Result(this.#resolvedConfig, tasks);
+        const result = new Result(tasks);
         EventEmitter.dispatch(["run:start", { result }]);
         for (const target of this.#resolvedConfig.target) {
             const targetResult = new TargetResult(target, tasks);
@@ -4660,7 +4772,7 @@ class Runner {
             if (compiler) {
                 const taskRunner = new TaskRunner(compiler, this.#resolvedConfig);
                 for (const task of tasks) {
-                    taskRunner.run(task, cancellationToken);
+                    await taskRunner.run(task, cancellationToken);
                 }
             }
             EventEmitter.dispatch(["target:end", { result: targetResult }]);
@@ -4802,4 +4914,4 @@ class Cli {
     }
 }
 
-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, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, 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, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };