tstyche 4.0.0-beta.0 → 4.0.0-beta.2

package/README.md

@@ -18,14 +18,18 @@ If you are used to test JavaScript, a simple type test file should look familiar
 ```ts
 import { expect, test } from "tstyche";
 
-function firstItem<T>(target: Array<T>): T | undefined {
-  return target[0];
+function pickLonger<T extends { length: number }>(a: T, b: T) {
+  return a.length >= b.length ? a : b;
 }
 
-test("firstItem", () => {
-  expect(firstItem(["a", "b", "c"])).type.toBe<string | undefined>();
+test("pickLonger()", () => {
+  expect(pickLonger([1, 2], [1, 2, 3])).type.toBe<Array<number>>();
+  expect(pickLonger("two", "three")).type.toBe<"two" | "three">();
 
-  expect(firstItem()).type.toRaiseError("Expected 1 argument");
+  expect(pickLonger).type.not.toBeCallableWith(1, 2);
+
+  expect(pickLonger).type.not.toBeCallableWith("zero", [123]);
+  expect(pickLonger<string | Array<number>>).type.toBeCallableWith("zero", [123]);
 });
 ```
 
@@ -57,9 +61,11 @@ test("handles numbers", () => {
 Here is the list of all matchers:
 
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()` compare types or types of expression,
-- `.toAcceptProps()` checks JSX component props type,
+- `.toAcceptProps()` checks the type of JSX component props,
+- `.toBeApplicable` ensures that the decorator function can be applied,
+- `.toBeCallableWith()` checks whether a function can be called with the given arguments,
 - `.toHaveProperty()` looks up keys on an object type,
-- `.toRaiseError()` captures the type error message or code.
+- `.toRaiseError()` captures the message or code of a type error.
 
 ## Runner
 

package/build/index.d.cts

@@ -97,6 +97,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */
@@ -123,6 +127,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type can be called with the target arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/index.d.ts

@@ -97,6 +97,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */
@@ -123,6 +127,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type can be called with the target arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/tstyche.d.ts

@@ -45,6 +45,7 @@ declare class DiagnosticOrigin {
     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 {
@@ -102,24 +103,16 @@ declare class TestTree {
     constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
 }
 
-interface MatcherNode extends ts.CallExpression {
-    expression: ts.PropertyAccessExpression;
-}
 declare class AssertionNode extends TestTreeNode {
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
     isNot: boolean;
-    matcherName: ts.MemberName;
-    matcherNode: MatcherNode;
+    matcherNode: ts.CallExpression | ts.Decorator;
+    matcherNameNode: ts.PropertyAccessExpression;
     modifierNode: ts.PropertyAccessExpression;
     notNode: ts.PropertyAccessExpression | undefined;
     source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
-}
-
-declare class CollectService {
-    #private;
-    constructor(compiler: typeof ts);
-    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode> | undefined;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: ts.CallExpression | ts.Decorator, matcherNameNode: ts.PropertyAccessExpression, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
 }
 
 declare enum OptionBrand {
@@ -207,7 +200,7 @@ interface CommandLineOptions {
      */
     failFast?: boolean;
     /**
-     * Fetch specified versions of the 'typescript' package and exit.
+     * Fetch the specified versions of the 'typescript' package and exit.
      */
     fetch?: boolean;
     /**
@@ -330,6 +323,21 @@ declare class Options {
 
 declare const defaultOptions: Required<ConfigFileOptions>;
 
+declare class ProjectService {
+    #private;
+    constructor(compiler: typeof ts, resolvedConfig: ResolvedConfig);
+    closeFile(filePath: string): void;
+    getDefaultProject(filePath: string): ts.server.Project | undefined;
+    getLanguageService(filePath: string): ts.LanguageService | undefined;
+    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
+}
+
+declare class CollectService {
+    #private;
+    constructor(compiler: typeof ts, projectService: ProjectService, resolvedConfig: ResolvedConfig);
+    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+}
+
 interface EnvironmentOptions {
     /**
      * Is `true` if the process is running in continuous integration environment.
@@ -592,8 +600,10 @@ declare class ExpectService {
     #private;
     private toAcceptProps;
     private toBe;
+    private toBeApplicable;
     private toBeAssignableTo;
     private toBeAssignableWith;
+    private toBeCallableWith;
     private toHaveProperty;
     private toRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig: ResolvedConfig);
@@ -767,15 +777,6 @@ declare class PluginService {
     static removeHandlers(): void;
 }
 
-declare class ProjectService {
-    #private;
-    constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
-    closeFile(filePath: string): void;
-    getDefaultProject(filePath: string): ts.server.Project | undefined;
-    getLanguageService(filePath: string): ts.LanguageService | undefined;
-    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
-}
-
 declare class Runner {
     #private;
     static version: string;

package/build/tstyche.js

@@ -93,12 +93,15 @@ class DiagnosticOrigin {
         this.assertion = assertion;
     }
     static fromAssertion(assertion) {
-        const node = assertion.matcherName;
+        const node = assertion.matcherNameNode.name;
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
     static fromNode(node, assertion) {
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
+    static fromNodes(nodes, assertion) {
+        return new DiagnosticOrigin(nodes.pos, nodes.end, nodes[0].getSourceFile(), assertion);
+    }
 }
 
 class Diagnostic {
@@ -903,7 +906,7 @@ class Options {
         },
         {
             brand: OptionBrand.BareTrue,
-            description: "Fetch specified versions of the 'typescript' package and exit.",
+            description: "Fetch the specified versions of the 'typescript' package and exit.",
             group: OptionGroup.CommandLine,
             name: "fetch",
         },
@@ -1948,17 +1951,17 @@ class TestTreeNode {
         };
         switch (this.brand) {
             case TestTreeNodeBrand.Describe:
-                for (const member of this.children) {
-                    if (member.brand === TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
+                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 member of this.children) {
-                    if (member.brand !== TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
+                for (const child of this.children) {
+                    if (child.brand !== TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(child.node)));
                     }
                 }
                 break;
@@ -1968,21 +1971,24 @@ class TestTreeNode {
 }
 
 class AssertionNode extends TestTreeNode {
+    abilityDiagnostics;
     isNot;
-    matcherName;
     matcherNode;
+    matcherNameNode;
     modifierNode;
     notNode;
     source;
     target;
-    constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
+    constructor(compiler, brand, node, parent, flags, matcherNode, matcherNameNode, modifierNode, notNode) {
         super(compiler, brand, node, parent, flags);
         this.isNot = notNode != null;
-        this.matcherName = matcherNode.expression.name;
         this.matcherNode = matcherNode;
+        this.matcherNameNode = matcherNameNode;
         this.modifierNode = modifierNode;
         this.source = this.node.typeArguments ?? this.node.arguments;
-        this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        if (compiler.isCallExpression(this.matcherNode)) {
+            this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        }
         for (const diagnostic of parent.diagnostics) {
             if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
                 this.diagnostics.add(diagnostic);
@@ -1992,6 +1998,97 @@ class AssertionNode extends TestTreeNode {
     }
 }
 
+class AbilityLayer {
+    #filePath = "";
+    #nodes = [];
+    #projectService;
+    #resolvedConfig;
+    #text = "";
+    constructor(projectService, resolvedConfig) {
+        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 = 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));
+            const nodes = this.#nodes.reverse();
+            for (const diagnostic of diagnostics) {
+                for (const node of nodes) {
+                    if (diagnostic.start != null &&
+                        diagnostic.start >= node.matcherNode.pos &&
+                        diagnostic.start <= node.matcherNode.end) {
+                        if (!node.abilityDiagnostics) {
+                            node.abilityDiagnostics = new Set();
+                        }
+                        node.abilityDiagnostics.add(diagnostic);
+                        diagnostics.delete(diagnostic);
+                    }
+                }
+            }
+        }
+        this.#filePath = "";
+        this.#nodes = [];
+        this.#text = "";
+    }
+    handleNode(assertionNode) {
+        switch (assertionNode.matcherNameNode.name.text) {
+            case "toBeApplicable": {
+                const expectStart = assertionNode.node.pos;
+                const expectExpressionEnd = assertionNode.node.expression.end;
+                const expectEnd = assertionNode.node.end;
+                const matcherNameEnd = assertionNode.matcherNameNode.end;
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd + 1, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd - 1 },
+                ]);
+                break;
+            }
+            case "toBeCallableWith": {
+                const expectStart = assertionNode.node.pos;
+                const expectExpressionEnd = assertionNode.node.expression.end;
+                const expectEnd = assertionNode.node.end;
+                const matcherNameEnd = assertionNode.matcherNameNode.end;
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd + 1, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd - 1 },
+                ]);
+                break;
+            }
+        }
+    }
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+    }
+}
+
 var TestTreeNodeFlags;
 (function (TestTreeNodeFlags) {
     TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
@@ -2103,9 +2200,15 @@ class TestTree {
 }
 
 class CollectService {
+    #abilityLayer;
     #compiler;
-    constructor(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)) {
@@ -2125,12 +2228,17 @@ class CollectService {
                     return;
                 }
                 const notNode = this.#getChainedNode(modifierNode, "not");
-                const matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
-                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
+                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, modifierNode, notNode);
+                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);
@@ -2149,7 +2257,9 @@ class CollectService {
     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;
     }
@@ -2162,8 +2272,17 @@ class CollectService {
         }
         return parent;
     }
-    #isMatcherNode(node) {
-        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
+    #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;
     }
 }
 
@@ -3179,9 +3298,9 @@ class ProjectService {
     #resolvedConfig;
     #seenPrograms = new WeakSet();
     #service;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
+    constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
+        this.#resolvedConfig = resolvedConfig;
         const noop = () => undefined;
         const noopLogger = {
             close: noop,
@@ -3329,12 +3448,30 @@ class ExpectDiagnosticText {
     static argumentMustBeProvided(argumentNameText) {
         return `An argument for '${argumentNameText}' must be provided.`;
     }
-    static componentAcceptsProps(isTypeNode) {
+    static canBeCalled(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} can be called ${targetText}.`;
+    }
+    static cannotBeCalled(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} cannot be called ${targetText}.`;
+    }
+    static acceptsProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
     }
-    static componentDoesNotAcceptProps(isTypeNode) {
+    static doesNotAcceptProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
     }
+    static canBeApplied(targetText) {
+        return `The decorator function can be applied${targetText}.`;
+    }
+    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 matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
@@ -3350,50 +3487,44 @@ class ExpectDiagnosticText {
     static typeArgumentMustBe(argumentNameText, expectedText) {
         return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
-    static typeDidNotRaiseError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
+    static raisedError(isTypeNode, 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"}.`;
     }
-    static typeDidNotRaiseMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
+    static didNotRaiseError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
     }
-    static typeDoesNotHaveProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    static raisedMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
     }
-    static typeHasProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' has property '${propertyNameText}'.`;
+    static didNotRaiseMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
     }
-    static typeIsAssignableTo(sourceTypeText, targetTypeText) {
+    static isAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
     }
-    static typeIsAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
-    }
-    static typeIsIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
-    }
-    static typeIsNotAssignableTo(sourceTypeText, targetTypeText) {
+    static isNotAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable to type '${targetTypeText}'.`;
     }
-    static typeIsNotAssignableWith(sourceTypeText, targetTypeText) {
+    static isAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
+    }
+    static isNotAssignableWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
     }
-    static typeIsNotCompatibleWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
+    static isIdenticalTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
     }
-    static typeIsNotIdenticalTo(sourceTypeText, targetTypeText) {
+    static isNotIdenticalTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
     }
-    static typeRaisedError(isTypeNode, 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"}.`;
-    }
-    static typeRaisedMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
+    static isNotCompatibleWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
     }
-    static typeRequiresProperty(typeText, propertyNameText) {
+    static requiresProperty(typeText, propertyNameText) {
         return `Type '${typeText}' requires property '${propertyNameText}'.`;
     }
     static typesOfPropertyAreNotCompatible(propertyNameText) {
@@ -3412,7 +3543,6 @@ class MatchWorker {
     assertion;
     #compiler;
     #signatureCache = new Map();
-    #typeCache = new Map();
     #typeChecker;
     constructor(compiler, typeChecker, assertion) {
         this.#compiler = compiler;
@@ -3464,7 +3594,7 @@ class MatchWorker {
         if (!parameter) {
             return;
         }
-        return this.#getTypeOfNode(parameter);
+        return this.getType(parameter);
     }
     getSignatures(node) {
         let signatures = this.#signatureCache.get(node);
@@ -3482,21 +3612,7 @@ class MatchWorker {
         return this.#typeChecker.typeToString(type);
     }
     getType(node) {
-        return this.#compiler.isTypeNode(node) ? this.#getTypeOfTypeNode(node) : this.#getTypeOfNode(node);
-    }
-    #getTypeOfNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeAtLocation(node);
-        }
-        return type;
-    }
-    #getTypeOfTypeNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeFromTypeNode(node);
-        }
-        return type;
+        return this.#typeChecker.getTypeAtLocation(node);
     }
     isStringOrNumberLiteralType(type) {
         return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
@@ -3544,8 +3660,8 @@ class ToAcceptProps {
         return signatures.reduce((accumulator, signature, index) => {
             let diagnostic;
             const introText = matchWorker.assertion.isNot
-                ? ExpectDiagnosticText.componentAcceptsProps(this.#compiler.isTypeNode(sourceNode))
-                : ExpectDiagnosticText.componentDoesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
+                ? ExpectDiagnosticText.acceptsProps(this.#compiler.isTypeNode(sourceNode))
+                : ExpectDiagnosticText.doesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
             const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
@@ -3611,8 +3727,8 @@ class ToAcceptProps {
                 const sourceProperty = sourceType?.getProperty(targetPropertyName);
                 if (!sourceProperty) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotCompatibleWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotCompatibleWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3620,8 +3736,8 @@ class ToAcceptProps {
                 }
                 if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.requiresProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3633,9 +3749,9 @@ class ToAcceptProps {
                     const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
                     const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
                         ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3647,15 +3763,15 @@ class ToAcceptProps {
                     const targetProperty = targetType.getProperty(sourcePropertyName);
                     if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
                         const text = [
-                            ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                            ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, sourcePropertyName),
+                            ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                            ExpectDiagnosticText.requiresProperty(sourceTypeText, sourcePropertyName),
                         ];
                         diagnostics.push(diagnostic.extendWith(text));
                     }
                 }
             }
             if (diagnostics.length === 0) {
-                const text = ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText);
+                const text = ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText);
                 diagnostics.push(diagnostic.extendWith(text));
                 return { diagnostics, isMatch: true };
             }
@@ -3665,8 +3781,8 @@ class ToAcceptProps {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText);
+                    ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
                 if (isMatch) {
                     accumulator = diagnostics;
@@ -3728,8 +3844,8 @@ class RelationMatcherBase {
 }
 
 class ToBe extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsIdenticalTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotIdenticalTo;
+    explainText = ExpectDiagnosticText.isIdenticalTo;
+    explainNotText = ExpectDiagnosticText.isNotIdenticalTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3738,9 +3854,79 @@ class ToBe extends RelationMatcherBase {
     }
 }
 
+class ToBeApplicable {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(node) {
+        let text = "";
+        switch (node.kind) {
+            case this.#compiler.SyntaxKind.ClassDeclaration:
+                text = "class";
+                break;
+            case this.#compiler.SyntaxKind.MethodDeclaration:
+                text = "method";
+                break;
+            case this.#compiler.SyntaxKind.PropertyDeclaration:
+                text = node.modifiers?.some((modifier) => modifier.kind === this.#compiler.SyntaxKind.AccessorKeyword)
+                    ? "accessor"
+                    : "field";
+                break;
+            case this.#compiler.SyntaxKind.GetAccessor:
+                text = "getter";
+                break;
+            case this.#compiler.SyntaxKind.SetAccessor:
+                text = "setter";
+                break;
+        }
+        if (text.length > 0) {
+            text = ` to this ${text}`;
+        }
+        return text;
+    }
+    #explain(matchWorker, sourceNode) {
+        const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.cannotBeApplied(targetText),
+                    typeof diagnostic.messageText === "string"
+                        ? diagnostic.messageText
+                        : Diagnostic.toMessageText(diagnostic.messageText),
+                ];
+                const origin = DiagnosticOrigin.fromNode(sourceNode);
+                diagnostics.push(Diagnostic.error(text.flat(), origin));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeApplied(targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, onDiagnostics) {
+        const type = matchWorker.getType(sourceNode);
+        if (type.getCallSignatures().length === 0) {
+            const expectedText = "of a function type";
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToBeAssignableTo extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
+    explainText = ExpectDiagnosticText.isAssignableTo;
+    explainNotText = ExpectDiagnosticText.isNotAssignableTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3750,8 +3936,8 @@ class ToBeAssignableTo extends RelationMatcherBase {
 }
 
 class ToBeAssignableWith extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableWith;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableWith;
+    explainText = ExpectDiagnosticText.isAssignableWith;
+    explainNotText = ExpectDiagnosticText.isNotAssignableWith;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3760,6 +3946,84 @@ class ToBeAssignableWith extends RelationMatcherBase {
     }
 }
 
+class ToBeCallableWith {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    isDiagnosticWithLocation(diagnostic) {
+        return diagnostic.start != null;
+    }
+    #resolveTargetText(nodes) {
+        if (nodes.length === 0) {
+            return "without arguments";
+        }
+        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
+            return "with the given arguments";
+        }
+        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
+    }
+    #explain(matchWorker, sourceNode, targetNodes) {
+        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const targetText = this.#resolveTargetText(targetNodes);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.cannotBeCalled(isTypeNode, targetText),
+                    typeof diagnostic.messageText === "string"
+                        ? diagnostic.messageText
+                        : Diagnostic.toMessageText(diagnostic.messageText),
+                ];
+                let origin;
+                if (this.isDiagnosticWithLocation(diagnostic) &&
+                    diagnostic.start >= targetNodes.pos &&
+                    diagnostic.start <= targetNodes.end) {
+                    origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, sourceNode.getSourceFile());
+                }
+                else {
+                    origin =
+                        targetNodes.length > 0
+                            ? DiagnosticOrigin.fromNodes(targetNodes)
+                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                }
+                let related;
+                if (diagnostic.relatedInformation != null) {
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                }
+                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeCalled(isTypeNode, targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
+        let mustBeText;
+        if (!(sourceNode.kind === this.#compiler.SyntaxKind.Identifier ||
+            sourceNode.kind === this.#compiler.SyntaxKind.ExpressionWithTypeArguments)) {
+            mustBeText = "an identifier or instantiation expression";
+        }
+        if (matchWorker.getType(sourceNode).getCallSignatures().length === 0) {
+            mustBeText = "of a function type";
+        }
+        if (mustBeText != null) {
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", mustBeText)
+                : ExpectDiagnosticText.argumentMustBe("source", mustBeText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToHaveProperty {
     #compiler;
     constructor(compiler) {
@@ -3777,8 +4041,8 @@ class ToHaveProperty {
         }
         const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
         return matchWorker.assertion.isNot
-            ? [Diagnostic.error(ExpectDiagnosticText.typeHasProperty(sourceTypeText, propertyNameText), origin)]
-            : [Diagnostic.error(ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
+            ? [Diagnostic.error(ExpectDiagnosticText.hasProperty(sourceTypeText, propertyNameText), origin)]
+            : [Diagnostic.error(ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
     }
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
@@ -3828,12 +4092,12 @@ class ToRaiseError {
         const isTypeNode = this.#compiler.isTypeNode(sourceNode);
         const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
         if (matchWorker.assertion.diagnostics.size === 0) {
-            const text = ExpectDiagnosticText.typeDidNotRaiseError(isTypeNode);
+            const text = ExpectDiagnosticText.didNotRaiseError(isTypeNode);
             return [Diagnostic.error(text, origin)];
         }
         if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
             const count = matchWorker.assertion.diagnostics.size;
-            const text = ExpectDiagnosticText.typeRaisedError(isTypeNode, count, targetNodes.length);
+            const text = ExpectDiagnosticText.raisedError(isTypeNode, count, targetNodes.length);
             const related = [
                 Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
                 ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics]),
@@ -3845,8 +4109,8 @@ class ToRaiseError {
             const isMatch = this.#matchExpectedError(diagnostic, targetNode);
             if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeRaisedMatchingError(isTypeNode)
-                    : ExpectDiagnosticText.typeDidNotRaiseMatchingError(isTypeNode);
+                    ? ExpectDiagnosticText.raisedMatchingError(isTypeNode)
+                    : ExpectDiagnosticText.didNotRaiseMatchingError(isTypeNode);
                 const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
                 const related = [
                     Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
@@ -3908,8 +4172,10 @@ class ExpectService {
     #typeChecker;
     toAcceptProps;
     toBe;
+    toBeApplicable;
     toBeAssignableTo;
     toBeAssignableWith;
+    toBeCallableWith;
     toHaveProperty;
     toRaiseError;
     constructor(compiler, typeChecker, resolvedConfig) {
@@ -3923,42 +4189,45 @@ class ExpectService {
         }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
+        this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
+        this.toBeCallableWith = new ToBeCallableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
     match(assertion, onDiagnostics) {
-        const matcherNameText = assertion.matcherName.getText();
+        const matcherNameText = assertion.matcherNameNode.name.text;
         if (!assertion.source[0]) {
             this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
+        if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
+            this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+            return;
+        }
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
-                if (this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
+            case "toBeApplicable":
+                return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
+            case "toBeCallableWith":
+            case "toRaiseError":
+                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
             case "toHaveProperty":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            case "toRaiseError":
-                if (assertion.isNot && this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
-                return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
         }
@@ -3966,7 +4235,7 @@ class ExpectService {
     }
     #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
@@ -3976,23 +4245,23 @@ class ExpectService {
     }
     #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #rejectsTypeArguments(matchWorker, onDiagnostics) {
         for (const rejectedType of this.#rejectTypes) {
             const allowedKeyword = this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`];
             if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
-                matchWorker.assertion.target[0]?.kind === allowedKeyword) {
+                matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
                 continue;
             }
             for (const argumentName of ["source", "target"]) {
-                const argumentNode = matchWorker.assertion[argumentName][0];
+                const argumentNode = matchWorker.assertion[argumentName]?.[0];
                 if (!argumentNode) {
                     continue;
                 }
@@ -4020,7 +4289,7 @@ class TestTreeWalker {
     #position;
     #resolvedConfig;
     #taskResult;
-    constructor(resolvedConfig, compiler, typeChecker, options) {
+    constructor(compiler, typeChecker, resolvedConfig, options) {
         this.#resolvedConfig = resolvedConfig;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
@@ -4089,7 +4358,7 @@ class TestTreeWalker {
                 { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
         };
-        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        if (assertion.diagnostics.size > 0 && assertion.matcherNameNode.name.text !== "toRaiseError") {
             onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics]));
             return;
         }
@@ -4166,15 +4435,15 @@ class TestTreeWalker {
 }
 
 class TaskRunner {
-    #compiler;
     #collectService;
+    #compiler;
     #resolvedConfig;
     #projectService;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
+    constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
-        this.#collectService = new CollectService(compiler);
-        this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
+        this.#resolvedConfig = resolvedConfig;
+        this.#projectService = new ProjectService(compiler, this.#resolvedConfig);
+        this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
     run(task, cancellationToken) {
         if (cancellationToken?.isCancellationRequested) {
@@ -4225,7 +4494,7 @@ class TaskRunner {
             return;
         }
         const typeChecker = program.getTypeChecker();
-        const testTreeWalker = new TestTreeWalker(this.#resolvedConfig, this.#compiler, typeChecker, {
+        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, {
             cancellationToken,
             taskResult,
             hasOnly: testTree.hasOnly,
@@ -4238,7 +4507,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.0";
+    static version = "4.0.0-beta.2";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4296,7 +4565,7 @@ class Runner {
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
             const compiler = await Store.load(target);
             if (compiler) {
-                const taskRunner = new TaskRunner(this.#resolvedConfig, compiler);
+                const taskRunner = new TaskRunner(compiler, this.#resolvedConfig);
                 for (const task of tasks) {
                     taskRunner.run(task, cancellationToken);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.2",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -28,6 +28,8 @@
     "./package.json": "./package.json",
     "./tstyche": "./build/tstyche.js"
   },
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
   "bin": "./build/bin.js",
   "files": [
     "build/*"
@@ -60,17 +62,17 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.2",
-    "@types/node": "22.13.14",
-    "@types/react": "19.0.12",
+    "@types/node": "22.14.0",
+    "@types/react": "19.1.0",
     "ajv": "8.17.1",
     "cspell": "8.18.1",
     "magic-string": "0.30.17",
     "monocart-coverage-reports": "2.12.3",
     "pretty-ansi": "3.0.0",
-    "rollup": "4.38.0",
+    "rollup": "4.39.0",
     "rollup-plugin-dts": "6.2.1",
     "tslib": "2.8.1",
-    "typescript": "5.8.2"
+    "typescript": "5.8.3"
   },
   "peerDependencies": {
     "typescript": "5.x"
@@ -80,7 +82,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.8.0",
+  "packageManager": "yarn@4.9.0",
   "engines": {
     "node": ">=20.9"
   }