tstyche 4.0.0-beta.9 → 4.0.0-rc.1

package/README.md

@@ -77,7 +77,7 @@ This simple! (And it has watch mode too.)
 
 ## Documentation
 
-Visit [https://tstyche.org](https://tstyche.org) to view the full documentation.
+Visit [tstyche.org](https://tstyche.org) to view the full documentation.
 
 ## Feedback
 

package/build/index.d.cts

@@ -85,15 +85,15 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is identical to the target type.
+     * Checks if the source type is the same as the target type.
      */
     toBe: {
         /**
-         * Checks if the source type is identical to the target type.
+         * Checks if the source type is the same as the target type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is identical to type of the target expression.
+         * Checks if the source type is the same as type of the target expression.
          */
         (target: unknown): void;
     };

package/build/index.d.ts

@@ -85,15 +85,15 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is identical to the target type.
+     * Checks if the source type is the same as the target type.
      */
     toBe: {
         /**
-         * Checks if the source type is identical to the target type.
+         * Checks if the source type is the same as the target type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is identical to type of the target expression.
+         * Checks if the source type is the same as type of the target expression.
          */
         (target: unknown): void;
     };

package/build/tstyche.d.ts

@@ -20,60 +20,6 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum TestTreeNodeBrand {
-    Describe = "describe",
-    Test = "test",
-    Expect = "expect",
-    When = "when"
-}
-
-declare enum TestTreeNodeFlags {
-    None = 0,
-    Fail = 1,
-    Only = 2,
-    Skip = 4,
-    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 {
-    brand: TestTreeNodeBrand;
-    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);
-}
-
-declare class TestTree {
-    children: Array<TestTreeNode | AssertionNode | WhenNode>;
-    diagnostics: Set<ts.Diagnostic>;
-    hasOnly: boolean;
-    sourceFile: ts.SourceFile;
-    constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
-}
-
-declare class AssertionNode extends TestTreeNode {
-    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
-    isNot: boolean;
-    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> | 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 {
     String = "string",
     Number = "number",
@@ -100,52 +46,6 @@ declare class ConfigDiagnosticText {
     static watchCannotBeEnabled(): string;
 }
 
-/**
- * Options loaded from the configuration file.
- */
-interface ConfigFileOptions {
-    /**
-     * Enable type error reporting for source files.
-     */
-    checkSourceFiles?: boolean;
-    /**
-     * Stop running tests after the first failed assertion.
-     */
-    failFast?: boolean;
-    /**
-     * The list of plugins to use.
-     */
-    plugins?: Array<string>;
-    /**
-     * Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.
-     */
-    rejectAnyType?: boolean;
-    /**
-     * Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.
-     */
-    rejectNeverType?: boolean;
-    /**
-     * The list of reporters to use.
-     */
-    reporters?: Array<string>;
-    /**
-     * The path to a directory containing files of a test project.
-     */
-    rootPath?: string;
-    /**
-     * The list of TypeScript versions to be tested on.
-     */
-    target?: Array<string>;
-    /**
-     * The list of glob patterns matching the test files.
-     */
-    testFileMatch?: Array<string>;
-    /**
-     * The look up strategy to be used to find the TSConfig file.
-     */
-    tsconfig?: string;
-}
-
 /**
  * Options passed through the command line.
  */
@@ -220,6 +120,58 @@ interface CommandLineOptions {
     watch?: boolean;
 }
 
+/**
+ * Options loaded from the configuration file.
+ */
+interface ConfigFileOptions {
+    /**
+     * Enable type error reporting for source files.
+     */
+    checkSourceFiles?: boolean;
+    /**
+     * Stop running tests after the first failed assertion.
+     */
+    failFast?: boolean;
+    /**
+     * The list of plugins to use.
+     */
+    plugins?: Array<string>;
+    /**
+     * Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.
+     */
+    rejectAnyType?: boolean;
+    /**
+     * Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.
+     */
+    rejectNeverType?: boolean;
+    /**
+     * The list of reporters to use.
+     */
+    reporters?: Array<string>;
+    /**
+     * The path to a directory containing files of a test project.
+     */
+    rootPath?: string;
+    /**
+     * The list of TypeScript versions to be tested on.
+     */
+    target?: Array<string>;
+    /**
+     * The list of glob patterns matching the test files.
+     */
+    testFileMatch?: Array<string>;
+    /**
+     * The look up strategy to be used to find the TSConfig file.
+     */
+    tsconfig?: string;
+}
+
+interface InlineConfig {
+    if?: {
+        target?: Array<string>;
+    };
+    template?: boolean;
+}
 interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof ConfigFileOptions>, Required<ConfigFileOptions> {
     /**
      * The path to a TSTyche configuration file.
@@ -230,6 +182,7 @@ interface ResolvedConfig extends Omit<CommandLineOptions, "config" | keyof Confi
      */
     pathMatch: Array<string>;
 }
+
 declare class Config {
     #private;
     static parseCommandLine(commandLine: Array<string>): Promise<{
@@ -249,6 +202,25 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
+interface TextRange {
+    start: number;
+    end: number;
+    text: string;
+}
+interface DirectiveRange {
+    namespace: TextRange;
+    directive?: TextRange;
+    argument?: TextRange;
+}
+type DirectiveRanges = Array<DirectiveRange> & {
+    sourceFile: ts.SourceFile;
+};
+declare class Directive {
+    #private;
+    static getDirectiveRanges(compiler: typeof ts, sourceFile: ts.SourceFile, position?: number): DirectiveRanges | undefined;
+    static getInlineConfig(ranges: DirectiveRanges | undefined): Promise<InlineConfig | undefined>;
+}
+
 declare enum DiagnosticCategory {
     Error = "error",
     Warning = "warning"
@@ -304,6 +276,7 @@ type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> =
 declare enum OptionGroup {
     CommandLine = 2,
     ConfigFile = 4,
+    InlineConditions = 8,
     ResolvedConfig = 6
 }
 
@@ -334,6 +307,62 @@ declare class Options {
 
 declare const defaultOptions: Required<ConfigFileOptions>;
 
+declare enum TestTreeNodeBrand {
+    Describe = "describe",
+    Test = "test",
+    Expect = "expect",
+    When = "when"
+}
+
+declare enum TestTreeNodeFlags {
+    None = 0,
+    Fail = 1,
+    Only = 2,
+    Skip = 4,
+    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 {
+    brand: TestTreeNodeBrand;
+    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);
+    getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
+}
+
+declare class TestTree {
+    children: Array<TestTreeNode | AssertionNode | WhenNode>;
+    diagnostics: Set<ts.Diagnostic>;
+    hasOnly: boolean;
+    sourceFile: ts.SourceFile;
+    constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
+    getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
+}
+
+declare class AssertionNode extends TestTreeNode {
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
+    isNot: boolean;
+    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> | 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 | undefined);
+}
+
 declare class ProjectService {
     #private;
     constructor(compiler: typeof ts, resolvedConfig: ResolvedConfig);
@@ -546,6 +575,8 @@ type Event = ["config:error", {
     result: TaskResult;
 }] | ["task:end", {
     result: TaskResult;
+}] | ["directive:error", {
+    diagnostics: Array<Diagnostic>;
 }] | ["collect:start", {
     tree: TestTree;
 }] | ["collect:error", {
@@ -610,14 +641,9 @@ interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
 }
-type Relation = Map<string, unknown>;
 interface TypeChecker extends ts.TypeChecker {
     isApplicableIndexType: (source: ts.Type, target: ts.Type) => boolean;
-    isTypeRelatedTo: (source: ts.Type, target: ts.Type, relation: Relation) => boolean;
-    relation: {
-        assignable: Relation;
-        identity: Relation;
-    };
+    isTypeIdenticalTo: (source: ts.Type, target: ts.Type) => boolean;
 }
 
 declare class ExpectService {
@@ -860,6 +886,7 @@ declare class Store {
 declare class Version {
     #private;
     static isGreaterThan(source: string, target: string): boolean;
+    static isIncluded(source: string, range: Array<string>): boolean;
     static isSatisfiedWith(source: string, target: string): boolean;
 }
 
@@ -891,5 +918,5 @@ declare class WhenService {
     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 };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, 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, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };

package/build/tstyche.js

@@ -292,6 +292,7 @@ var OptionGroup;
 (function (OptionGroup) {
     OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
     OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
+    OptionGroup[OptionGroup["InlineConditions"] = 8] = "InlineConditions";
     OptionGroup[OptionGroup["ResolvedConfig"] = 6] = "ResolvedConfig";
 })(OptionGroup || (OptionGroup = {}));
 
@@ -376,6 +377,9 @@ class Version {
     static isGreaterThan(source, target) {
         return !(source === target) && Version.#satisfies(source, target);
     }
+    static isIncluded(source, range) {
+        return range.some((target) => source.startsWith(target));
+    }
     static isSatisfiedWith(source, target) {
         return source === target || Version.#satisfies(source, target);
     }
@@ -810,11 +814,7 @@ class Store {
             modulePath = Path.resolve(modulePath, "../tsserverlibrary.js");
         }
         const sourceText = await fs.readFile(modulePath, { encoding: "utf8" });
-        const toExpose = [
-            "isApplicableIndexType",
-            "isTypeRelatedTo",
-            "relation: { assignable: assignableRelation, identity: identityRelation }",
-        ];
+        const toExpose = ["isApplicableIndexType", "isTypeIdenticalTo"];
         const modifiedSourceText = sourceText.replace("return checker;", `return { ...checker, ${toExpose.join(", ")} };`);
         const compiledWrapper = vm.compileFunction(modifiedSourceText, ["exports", "require", "module", "__filename", "__dirname"], { filename: modulePath });
         compiledWrapper(exports, createRequire(modulePath), module, modulePath, Path.dirname(modulePath));
@@ -1008,7 +1008,7 @@ class Options {
         {
             brand: OptionBrand.List,
             description: "The list of TypeScript versions to be tested on.",
-            group: OptionGroup.CommandLine | OptionGroup.ConfigFile,
+            group: OptionGroup.CommandLine | OptionGroup.ConfigFile | OptionGroup.InlineConditions,
             items: {
                 brand: OptionBrand.String,
                 name: "target",
@@ -1243,146 +1243,18 @@ class CommandLineParser {
     }
 }
 
-class JsonNode {
-    origin;
-    text;
-    constructor(text, origin) {
-        this.origin = origin;
-        this.text = text;
-    }
-    getValue(options) {
-        if (this.text == null) {
-            return undefined;
-        }
-        if (/^['"]/.test(this.text)) {
-            return this.text.slice(1, -1);
-        }
-        if (options?.expectsIdentifier) {
-            return this.text;
-        }
-        if (this.text === "true") {
-            return true;
-        }
-        if (this.text === "false") {
-            return false;
-        }
-        if (/^\d/.test(this.text)) {
-            return Number.parseFloat(this.text);
-        }
-        return undefined;
-    }
-}
-
-class JsonScanner {
-    #currentPosition = 0;
-    #previousPosition = 0;
-    #sourceFile;
-    constructor(sourceFile) {
-        this.#sourceFile = sourceFile;
-    }
-    #getOrigin() {
-        return new DiagnosticOrigin(this.#previousPosition, this.#currentPosition, this.#sourceFile);
-    }
-    isRead() {
-        return !(this.#currentPosition < this.#sourceFile.text.length);
-    }
-    #peekCharacter() {
-        return this.#sourceFile.text.charAt(this.#currentPosition);
-    }
-    #peekNextCharacter() {
-        return this.#sourceFile.text.charAt(this.#currentPosition + 1);
-    }
-    peekToken(token) {
-        this.#skipTrivia();
-        return this.#peekCharacter() === token;
-    }
-    read() {
-        this.#skipTrivia();
-        this.#previousPosition = this.#currentPosition;
-        if (/[\s,:\]}]/.test(this.#peekCharacter())) {
-            return new JsonNode(undefined, this.#getOrigin());
-        }
-        let text = "";
-        let closingTokenText = "";
-        if (/[[{'"]/.test(this.#peekCharacter())) {
-            text += this.#readCharacter();
-            switch (text) {
-                case "[":
-                    closingTokenText = "]";
-                    break;
-                case "{":
-                    closingTokenText = "}";
-                    break;
-                default:
-                    closingTokenText = text;
-            }
-        }
-        while (!this.isRead()) {
-            text += this.#readCharacter();
-            if (text.slice(-1) === closingTokenText || (!closingTokenText && /[\s,:\]}]/.test(this.#peekCharacter()))) {
-                break;
-            }
-        }
-        return new JsonNode(text, this.#getOrigin());
-    }
-    #readCharacter() {
-        return this.#sourceFile.text.charAt(this.#currentPosition++);
-    }
-    readToken(token) {
-        this.#skipTrivia();
-        this.#previousPosition = this.#currentPosition;
-        if (this.#peekCharacter() === token) {
-            this.#currentPosition++;
-            return new JsonNode(token, this.#getOrigin());
-        }
-        return new JsonNode(undefined, this.#getOrigin());
-    }
-    #skipTrivia() {
-        while (!this.isRead()) {
-            if (/\s/.test(this.#peekCharacter())) {
-                this.#currentPosition++;
-                continue;
-            }
-            if (this.#peekCharacter() === "/") {
-                if (this.#peekNextCharacter() === "/") {
-                    this.#currentPosition += 2;
-                    while (!this.isRead()) {
-                        if (this.#readCharacter() === "\n") {
-                            break;
-                        }
-                    }
-                    continue;
-                }
-                if (this.#peekNextCharacter() === "*") {
-                    this.#currentPosition += 2;
-                    while (!this.isRead()) {
-                        if (this.#peekCharacter() === "*" && this.#peekNextCharacter() === "/") {
-                            this.#currentPosition += 2;
-                            break;
-                        }
-                        this.#currentPosition++;
-                    }
-                    continue;
-                }
-            }
-            break;
-        }
-        this.#previousPosition = this.#currentPosition;
-    }
-}
-
-class ConfigFileParser {
+class ConfigParser {
     #configFileOptions;
     #jsonScanner;
     #onDiagnostics;
     #options;
     #sourceFile;
-    constructor(configFileOptions, sourceFile, onDiagnostics) {
-        this.#configFileOptions = configFileOptions;
-        this.#sourceFile = sourceFile;
+    constructor(configOptions, optionGroup, sourceFile, jsonScanner, onDiagnostics) {
+        this.#configFileOptions = configOptions;
+        this.#jsonScanner = jsonScanner;
         this.#onDiagnostics = onDiagnostics;
-        this.#options = Options.for(OptionGroup.ConfigFile);
-        this.#jsonScanner = new JsonScanner(this.#sourceFile);
+        this.#sourceFile = sourceFile;
+        this.#options = Options.for(optionGroup);
     }
     #onRequiresValue(optionDefinition, jsonNode, isListItem) {
         const text = isListItem
@@ -1475,9 +1347,8 @@ class ConfigFileParser {
             if (!optionDefinition) {
                 const text = ConfigDiagnosticText.unknownOption(optionName);
                 this.#onDiagnostics(Diagnostic.error(text, optionNameNode.origin));
-                if (this.#jsonScanner.readToken(":")) {
-                    this.#jsonScanner.read();
-                }
+                this.#jsonScanner.readToken(":");
+                this.#jsonScanner.read();
                 const commaToken = this.#jsonScanner.readToken(",");
                 if (!commaToken.text) {
                     break;
@@ -1511,6 +1382,138 @@ class ConfigFileParser {
     }
 }
 
+class JsonNode {
+    origin;
+    text;
+    constructor(text, origin) {
+        this.origin = origin;
+        this.text = text;
+    }
+    getValue(options) {
+        if (this.text == null) {
+            return undefined;
+        }
+        if (/^['"]/.test(this.text)) {
+            return this.text.slice(1, -1);
+        }
+        if (options?.expectsIdentifier) {
+            return this.text;
+        }
+        if (this.text === "true") {
+            return true;
+        }
+        if (this.text === "false") {
+            return false;
+        }
+        if (/^\d/.test(this.text)) {
+            return Number.parseFloat(this.text);
+        }
+        return undefined;
+    }
+}
+
+class JsonScanner {
+    #end;
+    #position;
+    #previousPosition;
+    #sourceFile;
+    constructor(sourceFile, options) {
+        this.#end = options?.end ?? sourceFile.text.length;
+        this.#position = options?.start ?? 0;
+        this.#previousPosition = options?.start ?? 0;
+        this.#sourceFile = sourceFile;
+    }
+    #getOrigin() {
+        return new DiagnosticOrigin(this.#previousPosition, this.#position, this.#sourceFile);
+    }
+    isRead() {
+        return !(this.#position < this.#end);
+    }
+    #peekCharacter() {
+        return this.#sourceFile.text.charAt(this.#position);
+    }
+    #peekNextCharacter() {
+        return this.#sourceFile.text.charAt(this.#position + 1);
+    }
+    peekToken(token) {
+        this.#skipTrivia();
+        return this.#peekCharacter() === token;
+    }
+    read() {
+        this.#skipTrivia();
+        this.#previousPosition = this.#position;
+        if (/[\s,:\]}]/.test(this.#peekCharacter())) {
+            return new JsonNode(undefined, this.#getOrigin());
+        }
+        let text = "";
+        let closingTokenText = "";
+        if (/[[{'"]/.test(this.#peekCharacter())) {
+            text += this.#readCharacter();
+            switch (text) {
+                case "[":
+                    closingTokenText = "]";
+                    break;
+                case "{":
+                    closingTokenText = "}";
+                    break;
+                default:
+                    closingTokenText = text;
+            }
+        }
+        while (!this.isRead()) {
+            text += this.#readCharacter();
+            if (text.slice(-1) === closingTokenText || (!closingTokenText && /[\s,:\]}]/.test(this.#peekCharacter()))) {
+                break;
+            }
+        }
+        return new JsonNode(text, this.#getOrigin());
+    }
+    #readCharacter() {
+        return this.#sourceFile.text.charAt(this.#position++);
+    }
+    readToken(token) {
+        this.#skipTrivia();
+        this.#previousPosition = this.#position;
+        if (this.#peekCharacter() === token) {
+            this.#position++;
+            return new JsonNode(token, this.#getOrigin());
+        }
+        return new JsonNode(undefined, this.#getOrigin());
+    }
+    #skipTrivia() {
+        while (!this.isRead()) {
+            if (/\s/.test(this.#peekCharacter())) {
+                this.#position++;
+                continue;
+            }
+            if (this.#peekCharacter() === "/") {
+                if (this.#peekNextCharacter() === "/") {
+                    this.#position += 2;
+                    while (!this.isRead()) {
+                        if (this.#readCharacter() === "\n") {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                if (this.#peekNextCharacter() === "*") {
+                    this.#position += 2;
+                    while (!this.isRead()) {
+                        if (this.#peekCharacter() === "*" && this.#peekNextCharacter() === "/") {
+                            this.#position += 2;
+                            break;
+                        }
+                        this.#position++;
+                    }
+                    continue;
+                }
+            }
+            break;
+        }
+        this.#previousPosition = this.#position;
+    }
+}
+
 const defaultOptions = {
     checkSourceFiles: true,
     failFast: false,
@@ -1548,7 +1551,7 @@ class Config {
                 encoding: "utf8",
             });
             const sourceFile = new SourceFile(configFilePath, configFileText);
-            const configFileParser = new ConfigFileParser(configFileOptions, sourceFile, Config.#onDiagnostics);
+            const configFileParser = new ConfigParser(configFileOptions, OptionGroup.ConfigFile, sourceFile, new JsonScanner(sourceFile), Config.#onDiagnostics);
             await configFileParser.parse();
             if (configFileOptions.target != null) {
                 configFileOptions.target = await Target.expand(configFileOptions.target);
@@ -1574,6 +1577,114 @@ class Config {
     }
 }
 
+class DirectiveDiagnosticText {
+    static doesNotTakeArgument(directiveName) {
+        return `Directive '${directiveName}' does not take an argument.`;
+    }
+    static isNotSupported(directive) {
+        return `The '${directive}' directive is not supported.`;
+    }
+    static requiresArgument(directiveName) {
+        return `Directive '${directiveName}' requires an argument.`;
+    }
+}
+
+class Directive {
+    static #commentSeparatorRegex = /--+/;
+    static #directiveRegex = /^(\/\/\s*@tstyche)(\s*|-)?(\S*)?(\s*)?(.*)?/i;
+    static getDirectiveRanges(compiler, sourceFile, position = 0) {
+        const comments = compiler.getLeadingCommentRanges(sourceFile.text, position);
+        if (!comments || comments.length === 0) {
+            return;
+        }
+        const ranges = Object.assign([], { sourceFile });
+        for (const comment of comments) {
+            if (comment.kind !== compiler.SyntaxKind.SingleLineCommentTrivia) {
+                continue;
+            }
+            const range = Directive.#getRange(sourceFile, comment);
+            if (range != null) {
+                ranges.push(range);
+            }
+        }
+        return ranges;
+    }
+    static async getInlineConfig(ranges) {
+        if (!ranges) {
+            return;
+        }
+        const inlineConfig = {};
+        for (const range of ranges) {
+            await Directive.#parse(inlineConfig, ranges.sourceFile, range);
+        }
+        return inlineConfig;
+    }
+    static #getRange(sourceFile, comment) {
+        const [text] = sourceFile.text.substring(comment.pos, comment.end).split(Directive.#commentSeparatorRegex);
+        const found = text?.match(Directive.#directiveRegex);
+        const namespaceText = found?.[1];
+        if (!namespaceText) {
+            return;
+        }
+        const ranges = {
+            namespace: { start: comment.pos, end: comment.pos + namespaceText.length, text: namespaceText },
+        };
+        const directiveSeparatorText = found?.[2];
+        const directiveText = found?.[3];
+        if (directiveText != null && directiveText.length > 0) {
+            const start = ranges.namespace.end + (directiveSeparatorText?.length ?? 0);
+            ranges.directive = { start, end: start + directiveText.length, text: directiveText };
+        }
+        const argumentSeparatorText = found?.[4];
+        const argumentText = found?.[5]?.trimEnd();
+        if (ranges.directive != null && argumentText != null && argumentText.length > 0) {
+            const start = ranges.directive.end + (argumentSeparatorText?.length ?? 0);
+            ranges.argument = { start, end: start + argumentText.length, text: argumentText };
+        }
+        return ranges;
+    }
+    static #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["directive:error", { diagnostics: [diagnostic] }]);
+    }
+    static async #parse(inlineConfig, sourceFile, ranges) {
+        switch (ranges.directive?.text) {
+            case "if":
+                {
+                    if (!ranges.argument?.text) {
+                        const text = DirectiveDiagnosticText.requiresArgument(ranges.directive.text);
+                        const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                        Directive.#onDiagnostics(Diagnostic.error(text, origin));
+                        return;
+                    }
+                    const value = await Directive.#parseJson(sourceFile, ranges.argument.start, ranges.argument.end);
+                    inlineConfig.if = value;
+                }
+                return;
+            case "template":
+                if (ranges.argument?.text != null) {
+                    const text = DirectiveDiagnosticText.doesNotTakeArgument(ranges.directive.text);
+                    const origin = new DiagnosticOrigin(ranges.directive.start, ranges.directive.end, sourceFile);
+                    Directive.#onDiagnostics(Diagnostic.error(text, origin));
+                }
+                inlineConfig.template = true;
+                return;
+        }
+        const target = ranges?.directive ?? ranges.namespace;
+        const text = DirectiveDiagnosticText.isNotSupported(target.text);
+        const origin = new DiagnosticOrigin(target.start, target.end, sourceFile);
+        Directive.#onDiagnostics(Diagnostic.error(text, origin));
+    }
+    static async #parseJson(sourceFile, start, end) {
+        const inlineOptions = {};
+        const configParser = new ConfigParser(inlineOptions, OptionGroup.InlineConditions, sourceFile, new JsonScanner(sourceFile, { start, end }), Directive.#onDiagnostics);
+        await configParser.parse();
+        if ("target" in inlineOptions) {
+            inlineOptions["target"] = await Target.expand(inlineOptions["target"]);
+        }
+        return inlineOptions;
+    }
+}
+
 class CancellationHandler {
     #cancellationToken;
     #cancellationReason;
@@ -1781,6 +1892,7 @@ class ResultHandler {
                 this.#taskResult.timing.start = Date.now();
                 break;
             case "task:error":
+            case "directive:error":
             case "collect:error":
                 this.#targetResult.status = ResultStatus.Failed;
                 this.#taskResult.status = ResultStatus.Failed;
@@ -2384,6 +2496,7 @@ class ListReporter extends BaseReporter {
                 this.#hasReportedError = false;
                 break;
             case "task:error":
+            case "directive:error":
             case "collect:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
@@ -2899,6 +3012,9 @@ class TestTreeNode {
             }
         }
     }
+    getDirectiveRanges(compiler) {
+        return Directive.getDirectiveRanges(compiler, this.node.getSourceFile(), this.node.getFullStart());
+    }
 }
 
 class AssertionNode extends TestTreeNode {
@@ -2930,10 +3046,10 @@ class AssertionNode extends TestTreeNode {
 }
 
 function nodeBelongsToArgumentList(compiler, node) {
-    if (compiler.isCallExpression(node.parent)) {
-        return node.parent.arguments.some((argument) => argument === node);
-    }
-    return false;
+    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+}
+function nodeIsChildOfExpressionStatement(compiler, node) {
+    return compiler.isExpressionStatement(node.parent);
 }
 
 class AbilityLayer {
@@ -3013,7 +3129,7 @@ class AbilityLayer {
                     {
                         start: whenStart,
                         end: whenExpressionEnd,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, whenNode.actionNode) ? "" : ";",
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
                     },
                     { start: whenEnd, end: actionNameEnd },
                 ]);
@@ -3038,7 +3154,7 @@ class AbilityLayer {
                     {
                         start: expectStart,
                         end: expectExpressionEnd,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "" : ";",
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? ";" : "",
                     },
                     { start: expectEnd, end: matcherNameEnd },
                 ]);
@@ -3049,7 +3165,7 @@ class AbilityLayer {
                     {
                         start: expectStart,
                         end: expectExpressionEnd,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "new" : "; new",
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? "; new" : "new",
                     },
                     { start: expectEnd, end: matcherNameEnd },
                 ]);
@@ -3189,6 +3305,9 @@ class TestTree {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
     }
+    getDirectiveRanges(compiler) {
+        return Directive.getDirectiveRanges(compiler, this.sourceFile);
+    }
 }
 
 class WhenNode extends TestTreeNode {
@@ -3618,11 +3737,11 @@ class ExpectDiagnosticText {
     static isNotAssignableWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
     }
-    static isIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
+    static isTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is the same as type '${targetTypeText}'.`;
     }
-    static isNotIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
+    static isNotTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not the same as type '${targetTypeText}'.`;
     }
     static isNotCompatibleWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
@@ -3635,6 +3754,12 @@ class ExpectDiagnosticText {
     }
 }
 
+var Relation;
+(function (Relation) {
+    Relation["Assignable"] = "assignable";
+    Relation["Identical"] = "identical";
+})(Relation || (Relation = {}));
+
 class MatchWorker {
     assertion;
     #compiler;
@@ -3659,27 +3784,25 @@ class MatchWorker {
             .some((property) => this.#compiler.unescapeLeadingUnderscores(property.escapedName) === propertyNameText);
     }
     checkIsAssignableTo(sourceNode, targetNode) {
-        const relation = this.typeChecker.relation.assignable;
-        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
+        return this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Assignable);
     }
     checkIsAssignableWith(sourceNode, targetNode) {
-        const relation = this.typeChecker.relation.assignable;
-        return this.#checkIsRelatedTo(targetNode, sourceNode, relation);
+        return this.#checkIsRelatedTo(targetNode, sourceNode, Relation.Assignable);
     }
     checkIsIdenticalTo(sourceNode, targetNode) {
-        const relation = this.typeChecker.relation.identity;
-        return (this.#checkIsRelatedTo(sourceNode, targetNode, relation) &&
+        return (this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Identical) &&
             this.checkIsAssignableTo(sourceNode, targetNode) &&
             this.checkIsAssignableWith(sourceNode, targetNode));
     }
     #checkIsRelatedTo(sourceNode, targetNode, relation) {
-        const sourceType = relation === this.typeChecker.relation.identity
-            ? this.#simplifyType(this.getType(sourceNode))
-            : this.getType(sourceNode);
-        const targetType = relation === this.typeChecker.relation.identity
-            ? this.#simplifyType(this.getType(targetNode))
-            : this.getType(targetNode);
-        return this.typeChecker.isTypeRelatedTo(sourceType, targetType, relation);
+        const sourceType = relation === "identical" ? this.#simplifyType(this.getType(sourceNode)) : this.getType(sourceNode);
+        const targetType = relation === "identical" ? this.#simplifyType(this.getType(targetNode)) : this.getType(targetNode);
+        switch (relation) {
+            case Relation.Assignable:
+                return this.typeChecker.isTypeAssignableTo(sourceType, targetType);
+            case Relation.Identical:
+                return this.typeChecker.isTypeIdenticalTo(sourceType, targetType);
+        }
     }
     extendsObjectType(type) {
         const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
@@ -3723,7 +3846,7 @@ class MatchWorker {
     #simplifyType(type) {
         if (type.isUnionOrIntersection()) {
             const candidateType = this.#simplifyType(type.types[0]);
-            if (type.types.every((type) => this.typeChecker.isTypeRelatedTo(this.#simplifyType(type), candidateType, this.typeChecker.relation.identity))) {
+            if (type.types.every((type) => this.typeChecker.isTypeIdenticalTo(this.#simplifyType(type), candidateType))) {
                 return candidateType;
             }
         }
@@ -3938,8 +4061,8 @@ class RelationMatcherBase {
 }
 
 class ToBe extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.isIdenticalTo;
-    explainNotText = ExpectDiagnosticText.isNotIdenticalTo;
+    explainText = ExpectDiagnosticText.isTheSame;
+    explainNotText = ExpectDiagnosticText.isNotTheSame;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -4529,6 +4652,7 @@ class WhenService {
 
 class TestTreeWalker {
     #cancellationToken;
+    #compiler;
     #expectService;
     #hasOnly;
     #onTaskDiagnostics;
@@ -4536,6 +4660,7 @@ class TestTreeWalker {
     #resolvedConfig;
     #whenService;
     constructor(compiler, typeChecker, resolvedConfig, onTaskDiagnostics, options) {
+        this.#compiler = compiler;
         this.#resolvedConfig = resolvedConfig;
         this.#onTaskDiagnostics = onTaskDiagnostics;
         this.#cancellationToken = options.cancellationToken;
@@ -4545,43 +4670,46 @@ class TestTreeWalker {
         this.#expectService = new ExpectService(compiler, typeChecker, reject);
         this.#whenService = new WhenService(reject, onTaskDiagnostics);
     }
-    #resolveRunMode(mode, testNode) {
-        if (testNode.flags & TestTreeNodeFlags.Fail) {
+    async #resolveRunMode(mode, node) {
+        const directiveRanges = node.getDirectiveRanges(this.#compiler);
+        const inlineConfig = await Directive.getInlineConfig(directiveRanges);
+        if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
+            mode |= RunMode.Skip;
+        }
+        if (node.flags & TestTreeNodeFlags.Fail) {
             mode |= RunMode.Fail;
         }
-        if (testNode.flags & TestTreeNodeFlags.Only ||
-            (this.#resolvedConfig.only != null &&
-                testNode.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
+        if (node.flags & TestTreeNodeFlags.Only ||
+            (this.#resolvedConfig.only != null && node.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
             mode |= RunMode.Only;
         }
-        if (testNode.flags & TestTreeNodeFlags.Skip ||
-            (this.#resolvedConfig.skip != null &&
-                testNode.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
+        if (node.flags & TestTreeNodeFlags.Skip ||
+            (this.#resolvedConfig.skip != null && node.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
             mode |= RunMode.Skip;
         }
-        if (testNode.flags & TestTreeNodeFlags.Todo) {
+        if (node.flags & TestTreeNodeFlags.Todo) {
             mode |= RunMode.Todo;
         }
-        if (this.#position != null && testNode.node.getStart() === this.#position) {
+        if (this.#position != null && node.node.getStart() === this.#position) {
             mode |= RunMode.Only;
             mode &= ~RunMode.Skip;
         }
         return mode;
     }
-    visit(nodes, runMode, parentResult) {
+    async visit(nodes, runMode, parentResult) {
         for (const node of nodes) {
             if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
             switch (node.brand) {
                 case TestTreeNodeBrand.Describe:
-                    this.#visitDescribe(node, runMode, parentResult);
+                    await this.#visitDescribe(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Test:
-                    this.#visitTest(node, runMode, parentResult);
+                    await this.#visitTest(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Expect:
-                    this.#visitAssertion(node, runMode, parentResult);
+                    await this.#visitAssertion(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.When:
                     this.#visitWhen(node);
@@ -4589,11 +4717,11 @@ class TestTreeWalker {
             }
         }
     }
-    #visitAssertion(assertion, runMode, parentResult) {
-        this.visit(assertion.children, runMode, parentResult);
+    async #visitAssertion(assertion, runMode, parentResult) {
+        await this.visit(assertion.children, runMode, parentResult);
         const expectResult = new ExpectResult(assertion, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
-        runMode = this.#resolveRunMode(runMode, assertion);
+        runMode = await this.#resolveRunMode(runMode, assertion);
         if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
@@ -4629,23 +4757,23 @@ class TestTreeWalker {
             EventEmitter.dispatch(["expect:fail", { diagnostics: matchResult.explain(), result: expectResult }]);
         }
     }
-    #visitDescribe(describe, runMode, parentResult) {
+    async #visitDescribe(describe, runMode, parentResult) {
         const describeResult = new DescribeResult(describe, parentResult);
         EventEmitter.dispatch(["describe:start", { result: describeResult }]);
-        runMode = this.#resolveRunMode(runMode, describe);
+        runMode = await this.#resolveRunMode(runMode, describe);
         if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
             describe.diagnostics.size > 0) {
             this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
         }
         else {
-            this.visit(describe.children, runMode, describeResult);
+            await this.visit(describe.children, runMode, describeResult);
         }
         EventEmitter.dispatch(["describe:end", { result: describeResult }]);
     }
-    #visitTest(test, runMode, parentResult) {
+    async #visitTest(test, runMode, parentResult) {
         const testResult = new TestResult(test, parentResult);
         EventEmitter.dispatch(["test:start", { result: testResult }]);
-        runMode = this.#resolveRunMode(runMode, test);
+        runMode = await this.#resolveRunMode(runMode, test);
         if (runMode & RunMode.Todo) {
             EventEmitter.dispatch(["test:todo", { result: testResult }]);
             return;
@@ -4660,7 +4788,7 @@ class TestTreeWalker {
             ]);
             return;
         }
-        this.visit(test.children, runMode, testResult);
+        await this.visit(test.children, runMode, testResult);
         if (runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only))) {
             EventEmitter.dispatch(["test:skip", { result: testResult }]);
             return;
@@ -4702,21 +4830,27 @@ class TaskRunner {
         EventEmitter.dispatch(["task:end", { result: taskResult }]);
         this.#projectService.closeFile(task.filePath);
     }
-    async #run(task, taskResult, cancellationToken) {
-        if (!existsSync(task.filePath)) {
-            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
-            return;
-        }
-        let languageService = this.#projectService.getLanguageService(task.filePath);
+    async #resolveTaskFacts(task, taskResult, runMode = RunMode.Normal) {
+        const languageService = this.#projectService.getLanguageService(task.filePath);
         const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
         if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
             this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
             return;
         }
-        let semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
-        let program = languageService?.getProgram();
-        let sourceFile = program?.getSourceFile(task.filePath);
-        if (sourceFile?.text.startsWith("// @tstyche-template")) {
+        const semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+        const program = languageService?.getProgram();
+        const typeChecker = program?.getTypeChecker();
+        const sourceFile = program?.getSourceFile(task.filePath);
+        if (!sourceFile) {
+            return;
+        }
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
+        const directiveRanges = testTree.getDirectiveRanges(this.#compiler);
+        const inlineConfig = await Directive.getInlineConfig(directiveRanges);
+        if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
+            runMode |= RunMode.Skip;
+        }
+        if (inlineConfig?.template) {
             if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
                 this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), taskResult);
                 return;
@@ -4728,41 +4862,39 @@ class TaskRunner {
                 return;
             }
             this.#projectService.openFile(task.filePath, testText, this.#resolvedConfig.rootPath);
-            languageService = this.#projectService.getLanguageService(task.filePath);
-            const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
-            if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
-                this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
-                return;
-            }
-            semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
-            program = languageService?.getProgram();
-            sourceFile = program?.getSourceFile(task.filePath);
+            return this.#resolveTaskFacts(task, taskResult, runMode);
         }
-        if (!sourceFile) {
+        return { runMode, testTree, typeChecker };
+    }
+    async #run(task, taskResult, cancellationToken) {
+        if (!existsSync(task.filePath)) {
+            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
             return;
         }
-        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
-        if (testTree.diagnostics.size > 0) {
-            this.#onDiagnostics(Diagnostic.fromDiagnostics([...testTree.diagnostics]), taskResult);
+        const facts = await this.#resolveTaskFacts(task, taskResult);
+        if (!facts) {
+            return;
+        }
+        if (facts.testTree.diagnostics.size > 0) {
+            this.#onDiagnostics(Diagnostic.fromDiagnostics([...facts.testTree.diagnostics]), taskResult);
             return;
         }
-        const typeChecker = program?.getTypeChecker();
         const onTaskDiagnostics = (diagnostics) => {
             this.#onDiagnostics(diagnostics, taskResult);
         };
-        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, onTaskDiagnostics, {
+        const testTreeWalker = new TestTreeWalker(this.#compiler, facts.typeChecker, this.#resolvedConfig, onTaskDiagnostics, {
             cancellationToken,
-            hasOnly: testTree.hasOnly,
+            hasOnly: facts.testTree.hasOnly,
             position: task.position,
         });
-        testTreeWalker.visit(testTree.children, RunMode.Normal, undefined);
+        await testTreeWalker.visit(facts.testTree.children, facts.runMode, undefined);
     }
 }
 
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.9";
+    static version = "4.0.0-rc.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4962,4 +5094,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, 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 };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, 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.9",
+  "version": "4.0.0-rc.1",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -31,50 +31,6 @@
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "bin": "./build/bin.js",
-  "files": [
-    "build/*"
-  ],
-  "scripts": {
-    "bench": "./benchmarks/tstyche.bench.sh",
-    "build": "rollup --config rollup.config.js",
-    "build:watch": "yarn build --sourcemap --watch",
-    "check": "yarn check:spelling && yarn check:types",
-    "check:spelling": "cspell --config cspell.config.json --quiet",
-    "check:types": "tsc --noEmit --project tsconfig.json",
-    "format": "biome format --write",
-    "generate": "yarn generate:schema && yarn generate:types",
-    "generate:schema": "node ./scripts/generate-schema.js",
-    "generate:types": "node ./scripts/generate-types.js",
-    "lint": "biome lint --write",
-    "prepublish": "yarn build",
-    "test": "yarn test:unit && yarn test:e2e",
-    "test:coverage": "yarn test:coverage:collect && yarn test:coverage:report",
-    "test:coverage:collect": "yarn build --sourcemap && NODE_V8_COVERAGE='./coverage/v8-coverage' yarn test:e2e",
-    "test:coverage:report": "node ./scripts/report-coverage.js",
-    "test:e2e": "yarn test:e2e:parallel && yarn test:e2e:serial",
-    "test:e2e:parallel": "yarn test:run tests/*.test.js --exclude feature --parallel",
-    "test:e2e:serial": "yarn test:run tests/*.test.js --include feature",
-    "test:examples": "NODE_OPTIONS='--import ts-blank-space/register' tstyche examples",
-    "test:run": "rm -rf ./tests/__fixtures__/.generated && yarn node ./tests/__utilities__/runner.js",
-    "test:types": "tstyche typetests",
-    "test:unit": "yarn test:run **/__tests__/*.test.js --parallel"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@rollup/plugin-typescript": "12.1.2",
-    "@types/node": "22.15.15",
-    "@types/react": "19.1.3",
-    "ajv": "8.17.1",
-    "cspell": "9.0.0",
-    "magic-string": "0.30.17",
-    "monocart-coverage-reports": "2.12.4",
-    "pretty-ansi": "3.0.0",
-    "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": ">=4.7"
   },
@@ -83,7 +39,6 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.9.1",
   "engines": {
     "node": ">=20.9"
   }