tstyche 4.0.0-beta.7 → 4.0.0-beta.9

package/build/tstyche.d.ts

@@ -3,7 +3,6 @@ import type ts from 'typescript';
 declare enum CancellationReason {
     ConfigChange = "configChange",
     ConfigError = "configError",
-    CollectError = "collectError",
     FailFast = "failFast",
     WatchClose = "watchClose"
 }
@@ -21,58 +20,6 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum DiagnosticCategory {
-    Error = "error",
-    Warning = "warning"
-}
-
-declare class SourceFile {
-    #private;
-    fileName: string;
-    text: string;
-    constructor(fileName: string, text: string);
-    getLineStarts(): Array<number>;
-    getLineAndCharacterOfPosition(position: number): {
-        line: number;
-        character: number;
-    };
-}
-
-declare class DiagnosticOrigin {
-    assertion: AssertionNode | undefined;
-    end: number;
-    sourceFile: SourceFile | ts.SourceFile;
-    start: number;
-    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
-    static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
-    static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
-    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertion?: AssertionNode): DiagnosticOrigin;
-}
-
-declare class Diagnostic {
-    category: DiagnosticCategory;
-    code: string | undefined;
-    origin: DiagnosticOrigin | undefined;
-    related: Array<Diagnostic> | undefined;
-    text: string | Array<string>;
-    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
-    add(options: {
-        code?: string | undefined;
-        related?: Array<Diagnostic> | undefined;
-    }): this;
-    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
-    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-}
-
-declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
-declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
-declare function getTextSpanEnd(span: ts.TextSpan): number;
-declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
-
-type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
-
 declare enum TestTreeNodeBrand {
     Describe = "describe",
     Test = "test",
@@ -88,21 +35,27 @@ declare enum TestTreeNodeFlags {
     Todo = 8
 }
 
+declare class WhenNode extends TestTreeNode {
+    actionNode: ts.CallExpression;
+    actionNameNode: ts.PropertyAccessExpression;
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
+}
+
 declare class TestTreeNode {
-    #private;
     brand: TestTreeNodeBrand;
-    children: Array<TestTreeNode | AssertionNode>;
+    children: Array<TestTreeNode | AssertionNode | WhenNode>;
     diagnostics: Set<ts.Diagnostic>;
     flags: TestTreeNodeFlags;
     name: string;
     node: ts.CallExpression;
     parent: TestTree | TestTreeNode;
     constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags);
-    validate(): Array<Diagnostic>;
 }
 
 declare class TestTree {
-    children: Array<TestTreeNode | AssertionNode>;
+    children: Array<TestTreeNode | AssertionNode | WhenNode>;
     diagnostics: Set<ts.Diagnostic>;
     hasOnly: boolean;
     sourceFile: ts.SourceFile;
@@ -296,6 +249,58 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
+declare enum DiagnosticCategory {
+    Error = "error",
+    Warning = "warning"
+}
+
+declare class SourceFile {
+    #private;
+    fileName: string;
+    text: string;
+    constructor(fileName: string, text: string);
+    getLineStarts(): Array<number>;
+    getLineAndCharacterOfPosition(position: number): {
+        line: number;
+        character: number;
+    };
+}
+
+declare class DiagnosticOrigin {
+    assertion: AssertionNode | undefined;
+    end: number;
+    sourceFile: SourceFile | ts.SourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
+    static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
+    static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
+    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertion?: AssertionNode): DiagnosticOrigin;
+}
+
+declare class Diagnostic {
+    category: DiagnosticCategory;
+    code: string | undefined;
+    origin: DiagnosticOrigin | undefined;
+    related: Array<Diagnostic> | undefined;
+    text: string | Array<string>;
+    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
+    add(options: {
+        code?: string | undefined;
+        related?: Array<Diagnostic> | undefined;
+    }): this;
+    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
+    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+}
+
+declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
+declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
+declare function getTextSpanEnd(span: ts.TextSpan): number;
+declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
+
+type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
+
 declare enum OptionGroup {
     CommandLine = 2,
     ConfigFile = 4,
@@ -346,13 +351,9 @@ declare class CollectService {
 
 declare function nodeBelongsToArgumentList(compiler: typeof ts, node: ts.Node): boolean;
 
-declare class WhenNode extends TestTreeNode {
-    actionNode: ts.CallExpression;
-    actionNameNode: ts.PropertyAccessExpression;
-    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
-}
+declare function argumentIsProvided<T>(argumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
+
+declare function argumentOrTypeArgumentIsProvided<T>(argumentNameText: string, typeArgumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
 
 interface EnvironmentOptions {
     /**
@@ -599,6 +600,12 @@ declare class EventEmitter {
     removeReporters(): void;
 }
 
+declare class Reject {
+    #private;
+    constructor(compiler: typeof ts, typeChecker: ts.TypeChecker, resolvedConfig: ResolvedConfig);
+    argumentType(target: Array<[name: string, node: ts.Expression | ts.TypeNode | undefined]>, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): boolean;
+}
+
 interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
@@ -624,7 +631,7 @@ declare class ExpectService {
     private toBeConstructableWith;
     private toHaveProperty;
     private toRaiseError;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig: ResolvedConfig);
+    constructor(compiler: typeof ts, typeChecker: TypeChecker, reject: Reject);
     match(assertion: AssertionNode, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
 }
 
@@ -878,5 +885,11 @@ declare class WatchService {
     watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
 }
 
-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, ScribblerJsx, 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 };
+declare class WhenService {
+    #private;
+    constructor(reject: Reject, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>);
+    action(when: WhenNode): void;
+}
+
+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, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
 export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };

package/build/tstyche.js

@@ -572,7 +572,6 @@ class ManifestService {
     #manifestFilePath;
     #npmRegistry;
     #storePath;
-    #supportedVersionRegex = /^(5)\.\d\.\d$/;
     constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
         this.#npmRegistry = npmRegistry;
@@ -602,7 +601,7 @@ class ManifestService {
         const versions = [];
         const packageMetadata = (await response.json());
         for (const [tag, meta] of Object.entries(packageMetadata.versions)) {
-            if (this.#supportedVersionRegex.test(tag)) {
+            if (!tag.includes("-") && Version.isSatisfiedWith(tag, "4.7.2")) {
                 versions.push(tag);
                 packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
@@ -701,6 +700,9 @@ 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)) {
@@ -2547,7 +2549,6 @@ var CancellationReason;
 (function (CancellationReason) {
     CancellationReason["ConfigChange"] = "configChange";
     CancellationReason["ConfigError"] = "configError";
-    CancellationReason["CollectError"] = "collectError";
     CancellationReason["FailFast"] = "failFast";
     CancellationReason["WatchClose"] = "watchClose";
 })(CancellationReason || (CancellationReason = {}));
@@ -2873,18 +2874,9 @@ class WatchService {
     }
 }
 
-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 = "";
@@ -2892,7 +2884,6 @@ class TestTreeNode {
     parent;
     constructor(compiler, brand, node, parent, flags) {
         this.brand = brand;
-        this.#compiler = compiler;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
@@ -2908,34 +2899,6 @@ class TestTreeNode {
             }
         }
     }
-    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 {
@@ -3033,6 +2996,11 @@ class AbilityLayer {
         this.#nodes = [];
         this.#text = "";
     }
+    #eraseTrailingComma(node, parent) {
+        if (node.hasTrailingComma) {
+            this.#addRanges(parent, [{ start: node.end - 1, end: node.end }]);
+        }
+    }
     handleWhen(whenNode) {
         const whenStart = whenNode.node.getStart();
         const whenExpressionEnd = whenNode.node.expression.getEnd();
@@ -3040,13 +3008,14 @@ class AbilityLayer {
         const actionNameEnd = whenNode.actionNameNode.getEnd();
         switch (whenNode.actionNameNode.name.text) {
             case "isCalledWith":
+                this.#eraseTrailingComma(whenNode.target, whenNode);
                 this.#addRanges(whenNode, [
                     {
-                        end: whenExpressionEnd,
                         start: whenStart,
+                        end: whenExpressionEnd,
                         replacement: nodeBelongsToArgumentList(this.#compiler, whenNode.actionNode) ? "" : ";",
                     },
-                    { end: actionNameEnd, start: whenEnd },
+                    { start: whenEnd, end: actionNameEnd },
                 ]);
                 break;
         }
@@ -3059,28 +3028,30 @@ class AbilityLayer {
         switch (assertionNode.matcherNameNode.name.text) {
             case "toBeApplicable":
                 this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd, start: expectStart },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectStart, end: expectExpressionEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeCallableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
                 this.#addRanges(assertionNode, [
                     {
-                        end: expectExpressionEnd,
                         start: expectStart,
+                        end: expectExpressionEnd,
                         replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "" : ";",
                     },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeConstructableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
                 this.#addRanges(assertionNode, [
                     {
-                        end: expectExpressionEnd,
                         start: expectStart,
+                        end: expectExpressionEnd,
                         replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "new" : "; new",
                     },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
         }
@@ -3097,6 +3068,14 @@ class CollectDiagnosticText {
     }
 }
 
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+    TestTreeNodeBrand["When"] = "when";
+})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+
 var TestTreeNodeFlags;
 (function (TestTreeNodeFlags) {
     TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
@@ -3110,19 +3089,8 @@ class IdentifierLookup {
     #compiler;
     #identifiers;
     #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
-    constructor(compiler, identifiers) {
+    constructor(compiler) {
         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()) &&
@@ -3150,7 +3118,20 @@ class IdentifierLookup {
             }
         }
     }
-    resolveTestMemberMeta(node) {
+    open() {
+        this.#identifiers = {
+            namedImports: {
+                describe: undefined,
+                expect: undefined,
+                it: undefined,
+                namespace: undefined,
+                test: undefined,
+                when: undefined,
+            },
+            namespace: undefined,
+        };
+    }
+    resolveTestTreeNodeMeta(node) {
         let flags = TestTreeNodeFlags.None;
         let expression = node.expression;
         while (this.#compiler.isPropertyAccessExpression(expression)) {
@@ -3173,27 +3154,27 @@ class IdentifierLookup {
             }
             expression = expression.expression;
         }
-        let identifierName;
+        let identifier;
         if (this.#compiler.isPropertyAccessExpression(expression) &&
             expression.expression.getText() === this.#identifiers.namespace) {
-            identifierName = expression.name.getText();
+            identifier = expression.name.getText();
         }
         else {
-            identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+            identifier = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
         }
-        if (!identifierName) {
+        if (!identifier) {
             return;
         }
-        switch (identifierName) {
+        switch (identifier) {
             case "describe":
-                return { brand: TestTreeNodeBrand.Describe, flags };
+                return { brand: TestTreeNodeBrand.Describe, flags, identifier };
             case "it":
             case "test":
-                return { brand: TestTreeNodeBrand.Test, flags };
+                return { brand: TestTreeNodeBrand.Test, flags, identifier };
             case "expect":
-                return { brand: TestTreeNodeBrand.Expect, flags };
+                return { brand: TestTreeNodeBrand.Expect, flags, identifier };
             case "when":
-                return { brand: TestTreeNodeBrand.When, flags };
+                return { brand: TestTreeNodeBrand.When, flags, identifier };
         }
         return;
     }
@@ -3232,92 +3213,119 @@ class WhenNode extends TestTreeNode {
 class CollectService {
     #abilityLayer;
     #compiler;
-    #projectService;
-    #resolvedConfig;
-    #testTree;
+    #identifierLookup;
     constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
-        this.#projectService = projectService;
-        this.#resolvedConfig = resolvedConfig;
-        this.#abilityLayer = new AbilityLayer(compiler, this.#projectService, this.#resolvedConfig);
+        this.#abilityLayer = new AbilityLayer(compiler, projectService, resolvedConfig);
+        this.#identifierLookup = new IdentifierLookup(compiler);
     }
-    #collectTestTreeNodes(node, identifiers, parent) {
+    #collectTestTreeNodes(node, parent, testTree) {
         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);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestTreeNodes(node, identifiers, testTreeNode);
-                });
-                this.#onNode(testTreeNode, parent);
-                return;
-            }
-            if (meta != null && meta.brand === TestTreeNodeBrand.Expect) {
-                const modifierNode = this.#getChainedNode(node, "type");
-                if (!modifierNode) {
+            const meta = this.#identifierLookup.resolveTestTreeNodeMeta(node);
+            if (meta != null) {
+                if (!this.#checkNode(node, meta, parent)) {
                     return;
                 }
-                const notNode = this.#getChainedNode(modifierNode, "not");
-                const matcherNameNode = this.#getChainedNode(notNode ?? modifierNode);
-                if (!matcherNameNode) {
-                    return;
-                }
-                const matcherNode = this.#getMatcherNode(matcherNameNode);
-                if (!matcherNode) {
+                if (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, testTree);
+                    });
+                    this.#onNode(testTreeNode, parent, testTree);
                     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, identifiers, assertionNode);
-                });
-                this.#onNode(assertionNode, parent);
-                return;
-            }
-            if (meta != null && meta.brand === TestTreeNodeBrand.When) {
-                const actionNameNode = this.#getChainedNode(node);
-                if (!actionNameNode) {
+                if (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);
+                    this.#abilityLayer.handleAssertion(assertionNode);
+                    this.#compiler.forEachChild(node, (node) => {
+                        this.#collectTestTreeNodes(node, assertionNode, testTree);
+                    });
+                    this.#onNode(assertionNode, parent, testTree);
                     return;
                 }
-                const actionNode = this.#getActionNode(actionNameNode);
-                if (!actionNode) {
+                if (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.resolveTestTreeNodeMeta(node);
+                            if (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, testTree);
                     return;
                 }
-                this.#compiler.forEachChild(actionNode, (node) => {
-                    if (this.#compiler.isCallExpression(node)) {
-                        const meta = identifiers.resolveTestMemberMeta(node);
-                        if (meta != null && (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test)) {
-                            const text = CollectDiagnosticText.cannotBeNestedWithin(node.expression.getText(), "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;
             }
         }
         if (this.#compiler.isImportDeclaration(node)) {
-            identifiers.handleImportDeclaration(node);
+            this.#identifierLookup.handleImportDeclaration(node);
             return;
         }
         this.#compiler.forEachChild(node, (node) => {
-            this.#collectTestTreeNodes(node, identifiers, parent);
+            this.#collectTestTreeNodes(node, parent, testTree);
         });
     }
     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, new IdentifierLookup(this.#compiler), testTree);
+        this.#identifierLookup.open();
+        this.#collectTestTreeNodes(sourceFile, testTree, testTree);
         this.#abilityLayer.close();
-        this.#testTree = undefined;
         EventEmitter.dispatch(["collect:end", { tree: testTree }]);
         return testTree;
     }
+    #checkNode(node, meta, parent) {
+        if ("brand" in parent && !this.#isNodeAllowed(meta, parent)) {
+            const text = CollectDiagnosticText.cannotBeNestedWithin(meta.identifier, parent.node.expression.getText());
+            const origin = DiagnosticOrigin.fromNode(node);
+            this.#onDiagnostics(Diagnostic.error(text, origin));
+            return false;
+        }
+        return true;
+    }
+    #isNodeAllowed(meta, parent) {
+        switch (meta.brand) {
+            case TestTreeNodeBrand.Describe:
+            case TestTreeNodeBrand.Test:
+                if (parent.brand === TestTreeNodeBrand.Test || parent.brand === TestTreeNodeBrand.Expect) {
+                    return false;
+                }
+                break;
+            case TestTreeNodeBrand.Expect:
+            case TestTreeNodeBrand.When:
+                if (parent.brand === TestTreeNodeBrand.Describe) {
+                    return false;
+                }
+                break;
+        }
+        return true;
+    }
     #getChainedNode({ parent }, name) {
         if (!this.#compiler.isPropertyAccessExpression(parent)) {
             return;
@@ -3348,10 +3356,10 @@ class CollectService {
     #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["collect:error", { diagnostics: [diagnostic] }]);
     }
-    #onNode(node, parent) {
+    #onNode(node, parent, testTree) {
         parent.children.push(node);
         if (node.flags & TestTreeNodeFlags.Only) {
-            this.#testTree.hasOnly = true;
+            testTree.hasOnly = true;
         }
         EventEmitter.dispatch(["collect:node", { node }]);
     }
@@ -3362,6 +3370,7 @@ class ProjectService {
     #lastSeenProject = "";
     #resolvedConfig;
     #seenPrograms = new WeakSet();
+    #seenTestFiles = new Set();
     #service;
     constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
@@ -3399,15 +3408,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) {
@@ -3415,7 +3415,6 @@ class ProjectService {
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
-            allowImportingTsExtensions: true,
             allowJs: true,
             checkJs: true,
             exactOptionalPropertyTypes: true,
@@ -3426,8 +3425,11 @@ class ProjectService {
             resolveJsonModule: true,
             strict: true,
             target: this.#compiler.ScriptTarget.ESNext,
-            verbatimModuleSyntax: true,
         };
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
+            defaultCompilerOptions.allowImportingTsExtensions = true;
+            defaultCompilerOptions.verbatimModuleSyntax = true;
+        }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
@@ -3442,7 +3444,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;
@@ -3457,29 +3475,29 @@ class ProjectService {
                 { diagnostics: Diagnostic.fromDiagnostics(configFileErrors) },
             ]);
         }
-        if (this.#resolvedConfig.checkSourceFiles && !sourceText) {
+        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;
             }
         }
     }
@@ -3494,22 +3512,41 @@ var RunMode;
     RunMode[RunMode["Todo"] = 8] = "Todo";
 })(RunMode || (RunMode = {}));
 
-function capitalize(text) {
-    return text.replace(/^./, text.charAt(0).toUpperCase());
-}
-
-class ExpectDiagnosticText {
-    static argumentCannotBeOfType(argumentNameText, typeText) {
-        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
+class EnsureDiagnosticText {
+    static argumentMustBeProvided(argumentNameText) {
+        return `An argument for '${argumentNameText}' must be provided.`;
     }
     static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
         return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
     }
+}
+
+function argumentIsProvided(argumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node) {
+        const text = EnsureDiagnosticText.argumentMustBeProvided(argumentNameText);
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+        return false;
+    }
+    return true;
+}
+
+function argumentOrTypeArgumentIsProvided(argumentNameText, typeArgumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node) {
+        const text = EnsureDiagnosticText.argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText);
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+        return false;
+    }
+    return true;
+}
+
+class ExpectDiagnosticText {
     static argumentMustBe(argumentNameText, expectedText) {
         return `An argument for '${argumentNameText}' must be ${expectedText}.`;
     }
-    static argumentMustBeProvided(argumentNameText) {
-        return `An argument for '${argumentNameText}' must be provided.`;
+    static typeArgumentMustBe(argumentNameText, expectedText) {
+        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
     static isCallable(isExpression, targetText) {
         return `${isExpression ? "Expression" : "Type"} is callable ${targetText}.`;
@@ -3535,12 +3572,12 @@ class ExpectDiagnosticText {
     static cannotBeApplied(targetText) {
         return `The decorator function cannot be applied${targetText}.`;
     }
-    static doesNotHaveProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
-    }
     static hasProperty(typeText, propertyNameText) {
         return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
+    static doesNotHaveProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    }
     static didYouMeanToUse(suggestionText) {
         return `Did you mean to use ${suggestionText}?`;
     }
@@ -3553,12 +3590,6 @@ class ExpectDiagnosticText {
     static raisedTypeError(count = 1) {
         return `The raised type error${count === 1 ? "" : "s"}:`;
     }
-    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
-        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
-    }
-    static typeArgumentMustBe(argumentNameText, expectedText) {
-        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
-    }
     static raisedError(isExpression, count, targetCount) {
         let countText = "a";
         if (count > 1 || targetCount > 1) {
@@ -3602,13 +3633,6 @@ class ExpectDiagnosticText {
     static typesOfPropertyAreNotCompatible(propertyNameText) {
         return `Types of property '${propertyNameText}' are not compatible.`;
     }
-    static typeWasRejected(typeText) {
-        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.`,
-        ];
-    }
 }
 
 class MatchWorker {
@@ -4317,7 +4341,7 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
-    #rejectTypes = new Set();
+    #reject;
     #typeChecker;
     toAcceptProps;
     toBe;
@@ -4328,15 +4352,10 @@ class ExpectService {
     toBeConstructableWith;
     toHaveProperty;
     toRaiseError;
-    constructor(compiler, typeChecker, resolvedConfig) {
+    constructor(compiler, typeChecker, reject) {
         this.#compiler = compiler;
+        this.#reject = reject;
         this.#typeChecker = typeChecker;
-        if (resolvedConfig?.rejectAnyType) {
-            this.#rejectTypes.add("any");
-        }
-        if (resolvedConfig?.rejectNeverType) {
-            this.#rejectTypes.add("never");
-        }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
         this.toBeApplicable = new ToBeApplicable(compiler);
@@ -4349,13 +4368,15 @@ class ExpectService {
     }
     match(assertion, onDiagnostics) {
         const matcherNameText = assertion.matcherNameNode.name.text;
-        if (!assertion.source[0]) {
-            this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
+        if (!argumentOrTypeArgumentIsProvided("source", "Source", assertion.source[0], assertion.node.expression, onDiagnostics)) {
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
         if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
-            this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+            this.#reject.argumentType([
+                ["source", assertion.source[0]],
+                ["target", assertion.target?.[0]],
+            ], onDiagnostics)) {
             return;
         }
         switch (matcherNameText) {
@@ -4363,8 +4384,7 @@ class ExpectService {
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-                if (!assertion.target?.[0]) {
-                    this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
+                if (!argumentOrTypeArgumentIsProvided("target", "Target", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
@@ -4375,8 +4395,7 @@ class ExpectService {
             case "toRaiseError":
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
             case "toHaveProperty":
-                if (!assertion.target?.[0]) {
-                    this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
+                if (!argumentIsProvided("key", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
@@ -4390,42 +4409,61 @@ class ExpectService {
         const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
-    #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("source", "Source");
-        const origin = DiagnosticOrigin.fromNode(assertion.node.expression);
-        onDiagnostics(Diagnostic.error(text, origin));
+}
+
+function capitalize(text) {
+    return text.replace(/^./, text.charAt(0).toUpperCase());
+}
+
+class RejectDiagnosticText {
+    static argumentCannotBeOfType(argumentNameText, typeText) {
+        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
     }
-    #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
-        onDiagnostics(Diagnostic.error(text, origin));
+    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
+        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
     }
-    #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
-        onDiagnostics(Diagnostic.error(text, origin));
+    static typeWasRejected(typeText) {
+        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.`,
+        ];
+    }
+}
+
+class Reject {
+    #compiler;
+    #rejectedArgumentTypes = new Set();
+    #typeChecker;
+    constructor(compiler, typeChecker, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#typeChecker = typeChecker;
+        if (resolvedConfig?.rejectAnyType) {
+            this.#rejectedArgumentTypes.add("any");
+        }
+        if (resolvedConfig?.rejectNeverType) {
+            this.#rejectedArgumentTypes.add("never");
+        }
     }
-    #rejectsTypeArguments(matchWorker, onDiagnostics) {
-        for (const rejectedType of this.#rejectTypes) {
+    argumentType(target, onDiagnostics) {
+        for (const rejectedType of this.#rejectedArgumentTypes) {
             const allowedKeyword = this.#compiler.SyntaxKind[`${capitalize(rejectedType)}Keyword`];
-            if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
-                matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
+            if (target.some(([, node]) => node?.kind === allowedKeyword)) {
                 continue;
             }
-            for (const argumentName of ["source", "target"]) {
-                const argumentNode = matchWorker.assertion[argumentName]?.[0];
-                if (!argumentNode) {
+            for (const [name, node] of target) {
+                if (!node) {
                     continue;
                 }
-                if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
+                if (this.#typeChecker.getTypeAtLocation(node).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
                     const text = [
-                        nodeBelongsToArgumentList(this.#compiler, argumentNode)
-                            ? ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType)
-                            : ExpectDiagnosticText.typeArgumentCannotBeOfType(capitalize(argumentName), rejectedType),
-                        ...ExpectDiagnosticText.typeWasRejected(rejectedType),
+                        nodeBelongsToArgumentList(this.#compiler, node)
+                            ? RejectDiagnosticText.argumentCannotBeOfType(name, rejectedType)
+                            : RejectDiagnosticText.typeArgumentCannotBeOfType(capitalize(name), rejectedType),
+                        ...RejectDiagnosticText.typeWasRejected(rejectedType),
                     ];
-                    const origin = DiagnosticOrigin.fromNode(argumentNode);
-                    onDiagnostics(Diagnostic.error(text, origin));
+                    const origin = DiagnosticOrigin.fromNode(node);
+                    onDiagnostics([Diagnostic.error(text, origin)]);
                     return true;
                 }
             }
@@ -4434,20 +4472,78 @@ class ExpectService {
     }
 }
 
+class WhenDiagnosticText {
+    static actionIsNotSupported(actionNameText) {
+        return `The '.${actionNameText}()' action is not supported.`;
+    }
+}
+
+class WhenService {
+    #onDiagnostics;
+    #reject;
+    constructor(reject, onDiagnostics) {
+        this.#reject = reject;
+        this.#onDiagnostics = onDiagnostics;
+    }
+    action(when) {
+        if (!argumentIsProvided("target", when.target[0], when.node.expression, this.#onDiagnostics) ||
+            this.#reject.argumentType([["target", when.target[0]]], this.#onDiagnostics)) {
+            return;
+        }
+        const actionNameText = when.actionNameNode.name.getText();
+        switch (actionNameText) {
+            case "isCalledWith":
+                break;
+            default:
+                this.#onActionIsNotSupported(actionNameText, when, this.#onDiagnostics);
+                return;
+        }
+        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 }));
+                }
+            }
+            this.#onDiagnostics(diagnostics);
+        }
+    }
+    #onActionIsNotSupported(actionNameText, when, onDiagnostics) {
+        const text = WhenDiagnosticText.actionIsNotSupported(actionNameText);
+        const origin = DiagnosticOrigin.fromNode(when.actionNameNode.name);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+    }
+}
+
 class TestTreeWalker {
     #cancellationToken;
     #expectService;
     #hasOnly;
+    #onTaskDiagnostics;
     #position;
     #resolvedConfig;
-    #taskResult;
-    constructor(compiler, typeChecker, resolvedConfig, options) {
+    #whenService;
+    constructor(compiler, typeChecker, resolvedConfig, onTaskDiagnostics, options) {
         this.#resolvedConfig = resolvedConfig;
+        this.#onTaskDiagnostics = onTaskDiagnostics;
         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);
+        const reject = new Reject(compiler, typeChecker, resolvedConfig);
+        this.#expectService = new ExpectService(compiler, typeChecker, reject);
+        this.#whenService = new WhenService(reject, onTaskDiagnostics);
     }
     #resolveRunMode(mode, testNode) {
         if (testNode.flags & TestTreeNodeFlags.Fail) {
@@ -4472,28 +4568,23 @@ class TestTreeWalker {
         }
         return mode;
     }
-    visit(testNodes, runMode, parentResult) {
-        for (const testNode of testNodes) {
+    visit(nodes, runMode, parentResult) {
+        for (const node of nodes) {
             if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
-            const validationError = testNode.validate();
-            if (validationError.length > 0) {
-                EventEmitter.dispatch(["task:error", { diagnostics: validationError, result: this.#taskResult }]);
-                break;
-            }
-            switch (testNode.brand) {
+            switch (node.brand) {
                 case TestTreeNodeBrand.Describe:
-                    this.#visitDescribe(testNode, runMode, parentResult);
+                    this.#visitDescribe(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Test:
-                    this.#visitTest(testNode, runMode, parentResult);
+                    this.#visitTest(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Expect:
-                    this.#visitAssertion(testNode, runMode, parentResult);
+                    this.#visitAssertion(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.When:
-                    this.#visitWhen(testNode, runMode, parentResult);
+                    this.#visitWhen(node);
                     break;
             }
         }
@@ -4544,13 +4635,7 @@ class TestTreeWalker {
         runMode = this.#resolveRunMode(runMode, describe);
         if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
             describe.diagnostics.size > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                {
-                    diagnostics: Diagnostic.fromDiagnostics([...describe.diagnostics]),
-                    result: this.#taskResult,
-                },
-            ]);
+            this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
         }
         else {
             this.visit(describe.children, runMode, describeResult);
@@ -4587,36 +4672,14 @@ 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;
-        }
+    #visitWhen(when) {
+        this.#whenService.action(when);
     }
 }
 
 class TaskRunner {
     #collectService;
     #compiler;
-    #eventEmitter = new EventEmitter();
     #resolvedConfig;
     #projectService;
     constructor(compiler, resolvedConfig) {
@@ -4625,6 +4688,9 @@ class TaskRunner {
         this.#projectService = new ProjectService(compiler, this.#resolvedConfig);
         this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
+    #onDiagnostics(diagnostics, result) {
+        EventEmitter.dispatch(["task:error", { diagnostics, result }]);
+    }
     async run(task, cancellationToken) {
         if (cancellationToken.isCancellationRequested) {
             return;
@@ -4638,19 +4704,13 @@ class TaskRunner {
     }
     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 },
-            ]);
+            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
             return;
         }
         let languageService = this.#projectService.getLanguageService(task.filePath);
         const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
         if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics), result: taskResult },
-            ]);
+            this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
             return;
         }
         let semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
@@ -4658,21 +4718,20 @@ class TaskRunner {
         let sourceFile = program?.getSourceFile(task.filePath);
         if (sourceFile?.text.startsWith("// @tstyche-template")) {
             if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
-                EventEmitter.dispatch([
-                    "task:error",
-                    { diagnostics: Diagnostic.fromDiagnostics(semanticDiagnostics), result: taskResult },
-                ]);
+                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;
             }
-            const text = (await import(task.filePath)).default;
-            this.#projectService.openFile(task.filePath, text, this.#resolvedConfig.rootPath);
+            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) {
-                EventEmitter.dispatch([
-                    "task:error",
-                    { diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics), result: taskResult },
-                ]);
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
                 return;
             }
             semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
@@ -4682,24 +4741,17 @@ class TaskRunner {
         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 testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, {
+        const onTaskDiagnostics = (diagnostics) => {
+            this.#onDiagnostics(diagnostics, taskResult);
+        };
+        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, onTaskDiagnostics, {
             cancellationToken,
-            taskResult,
             hasOnly: testTree.hasOnly,
             position: task.position,
         });
@@ -4710,7 +4762,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.7";
+    static version = "4.0.0-beta.9";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4910,4 +4962,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, 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 };
+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, Reject, 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, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-beta.7",
+  "version": "4.0.0-beta.9",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -62,21 +62,21 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.2",
-    "@types/node": "22.15.3",
-    "@types/react": "19.1.2",
+    "@types/node": "22.15.15",
+    "@types/react": "19.1.3",
     "ajv": "8.17.1",
-    "cspell": "8.19.4",
+    "cspell": "9.0.0",
     "magic-string": "0.30.17",
     "monocart-coverage-reports": "2.12.4",
     "pretty-ansi": "3.0.0",
-    "rollup": "4.40.1",
+    "rollup": "4.40.2",
     "rollup-plugin-dts": "6.2.1",
     "ts-blank-space": "0.6.1",
     "tslib": "2.8.1",
     "typescript": "5.8.3"
   },
   "peerDependencies": {
-    "typescript": "5.x"
+    "typescript": ">=4.7"
   },
   "peerDependenciesMeta": {
     "typescript": {