npm - tstyche - Versions diffs - 2.0.0-beta.1 → 2.0.0-rc.0 - Mend

tstyche 2.0.0-beta.1 → 2.0.0-rc.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/build/tstyche.js CHANGED Viewed

@@ -3,10 +3,9 @@ import path from 'node:path';
 import process from 'node:process';
 import { createRequire } from 'node:module';
 import os from 'node:os';
-import { existsSync, watch, writeFileSync, rmSync } from 'node:fs';
+import { existsSync, writeFileSync, rmSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import vm from 'node:vm';
-import https from 'node:https';
 import { spawn } from 'node:child_process';
 class EventEmitter {
@@ -34,18 +33,21 @@ class EventEmitter {
 }
 class Path {
+    static normalizeSlashes;
+    static {
+        if (path.sep === "/") {
+            Path.normalizeSlashes = (filePath) => filePath;
+        }
+        else {
+            Path.normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
+        }
+    }
     static dirname(filePath) {
         return Path.normalizeSlashes(path.dirname(filePath));
     }
     static join(...filePaths) {
         return Path.normalizeSlashes(path.join(...filePaths));
     }
-    static normalizeSlashes(filePath) {
-        if (path.sep === "/") {
-            return filePath;
-        }
-        return filePath.replace(/\\/g, "/");
-    }
     static relative(from, to) {
         let relativePath = path.relative(from, to);
         if (!relativePath.startsWith("./")) {
@@ -61,16 +63,11 @@ class Path {
 class TestFile {
     path;
     position;
-    constructor(identifier) {
-        this.path = Path.normalizeSlashes(this.#resolvePath(identifier));
+    constructor(identifier, position) {
+        this.path = Path.normalizeSlashes(this.#toPath(identifier));
+        this.position = position;
     }
-    add(options) {
-        if (options.position != null) {
-            this.position = options.position;
-        }
-        return this;
-    }
-    #resolvePath(identifier) {
+    #toPath(identifier) {
         if (typeof identifier === "string" && !identifier.startsWith("file:")) {
             return identifier;
         }
@@ -304,21 +301,21 @@ class CodeSpanText {
         this.props = props;
     }
     render() {
-        const lastLineInFile = this.props.file.getLineAndCharacterOfPosition(this.props.file.text.length).line;
-        const { character: markedCharacter, line: markedLine } = this.props.file.getLineAndCharacterOfPosition(this.props.start);
+        const lastLineInFile = this.props.sourceFile.getLineAndCharacterOfPosition(this.props.sourceFile.text.length).line;
+        const { character: markedCharacter, line: markedLine } = this.props.sourceFile.getLineAndCharacterOfPosition(this.props.start);
         const firstLine = Math.max(markedLine - 2, 0);
         const lastLine = Math.min(firstLine + 5, lastLineInFile);
         const lineNumberMaxWidth = String(lastLine + 1).length;
         const codeSpan = [];
         for (let index = firstLine; index <= lastLine; index++) {
-            const lineStart = this.props.file.getPositionOfLineAndCharacter(index, 0);
+            const lineStart = this.props.sourceFile.getPositionOfLineAndCharacter(index, 0);
             const lineEnd = index === lastLineInFile
-                ? this.props.file.text.length
-                : this.props.file.getPositionOfLineAndCharacter(index + 1, 0);
+                ? this.props.sourceFile.text.length
+                : this.props.sourceFile.getPositionOfLineAndCharacter(index + 1, 0);
             const lineNumberText = String(index + 1);
-            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
+            const lineText = this.props.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
             if (index === markedLine) {
-                codeSpan.push(jsx(Line, { children: [jsx(Text, { color: "31", children: ">" }), " ", lineNumberText.padStart(lineNumberMaxWidth), " ", jsx(Text, { color: "90", children: "|" }), " ", lineText] }), jsx(Line, { children: [" ".repeat(lineNumberMaxWidth + 3), jsx(Text, { color: "90", children: "|" }), " ".repeat(markedCharacter + 1), jsx(Text, { color: "31", children: "^" })] }));
+                codeSpan.push(jsx(Line, { children: [jsx(Text, { color: "31", children: ">" }), jsx(Text, { children: " " }), lineNumberText.padStart(lineNumberMaxWidth), jsx(Text, { children: " " }), jsx(Text, { color: "90", children: "|" }), " ", lineText] }), jsx(Line, { children: [" ".repeat(lineNumberMaxWidth + 3), jsx(Text, { color: "90", children: "|" }), " ".repeat(markedCharacter + 1), jsx(Text, { color: "31", children: "^" })] }));
             }
             else {
                 codeSpan.push(jsx(Line, { children: [" ".repeat(2), jsx(Text, { color: "90", children: [lineNumberText.padStart(lineNumberMaxWidth), " | ", lineText || ""] })] }));
@@ -328,7 +325,7 @@ class CodeSpanText {
             jsx(Text, { color: "90", children: " ❭ " }),
             jsx(Text, { children: ancestor }),
         ]);
-        const location = (jsx(Line, { children: [" ".repeat(lineNumberMaxWidth + 5), jsx(Text, { color: "90", children: "at" }), " ", jsx(Text, { color: "36", children: Path.relative("", this.props.file.fileName) }), jsx(Text, { color: "90", children: [":", String(markedLine + 1), ":", String(markedCharacter + 1)] }), breadcrumbs] }));
+        const location = (jsx(Line, { children: [" ".repeat(lineNumberMaxWidth + 5), jsx(Text, { color: "90", children: "at" }), jsx(Text, { children: " " }), jsx(Text, { color: "36", children: Path.relative("", this.props.sourceFile.fileName) }), jsx(Text, { color: "90", children: [":", String(markedLine + 1), ":", String(markedCharacter + 1)] }), breadcrumbs] }));
         return (jsx(Text, { children: [codeSpan, jsx(Line, {}), location] }));
     }
 }
@@ -619,21 +616,21 @@ class RanFilesText {
         this.props = props;
     }
     render() {
-        const testNameMatch = [];
+        const testNameMatchText = [];
         if (this.props.onlyMatch != null) {
-            testNameMatch.push(jsx(Text, { children: [jsx(Text, { color: "90", children: "matching " }), jsx(MatchText, { text: this.props.onlyMatch })] }));
+            testNameMatchText.push(jsx(Text, { children: [jsx(Text, { color: "90", children: "matching " }), jsx(MatchText, { text: this.props.onlyMatch })] }));
         }
         if (this.props.skipMatch != null) {
-            testNameMatch.push(jsx(Text, { children: [this.props.onlyMatch == null ? undefined : jsx(Text, { color: "90", children: " and " }), jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: this.props.skipMatch })] }));
+            testNameMatchText.push(jsx(Text, { children: [this.props.onlyMatch == null ? undefined : jsx(Text, { color: "90", children: " and " }), jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: this.props.skipMatch })] }));
         }
-        let pathMatch;
+        let pathMatchText;
         if (this.props.pathMatch.length > 0) {
-            pathMatch = (jsx(Text, { children: [jsx(Text, { color: "90", children: "test files matching " }), jsx(MatchText, { text: this.props.pathMatch }), jsx(Text, { color: "90", children: "." })] }));
+            pathMatchText = (jsx(Text, { children: [jsx(Text, { color: "90", children: "test files matching " }), jsx(MatchText, { text: this.props.pathMatch }), jsx(Text, { color: "90", children: "." })] }));
         }
         else {
-            pathMatch = jsx(Text, { color: "90", children: "all test files." });
+            pathMatchText = jsx(Text, { color: "90", children: "all test files." });
         }
-        return (jsx(Line, { children: [jsx(Text, { color: "90", children: "Ran " }), testNameMatch.length > 0 ? jsx(Text, { color: "90", children: "tests " }) : undefined, testNameMatch, testNameMatch.length > 0 ? jsx(Text, { color: "90", children: " in " }) : undefined, pathMatch] }));
+        return (jsx(Line, { children: [jsx(Text, { color: "90", children: "Ran " }), testNameMatchText.length > 0 ? jsx(Text, { color: "90", children: "tests " }) : undefined, testNameMatchText, testNameMatchText.length > 0 ? jsx(Text, { color: "90", children: " in " }) : undefined, pathMatchText] }));
     }
 }
 function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }) {
@@ -728,7 +725,6 @@ class FileViewService {
 }
 class RuntimeReporter {
-    resolvedConfig;
     #currentCompilerVersion;
     #currentProjectConfigFilePath;
     #fileCount = 0;
@@ -736,10 +732,11 @@ class RuntimeReporter {
     #hasReportedAdds = false;
     #hasReportedError = false;
     #isFileViewExpanded = false;
+    #resolvedConfig;
     #outputService;
     #seenDeprecations = new Set();
     constructor(resolvedConfig, outputService) {
-        this.resolvedConfig = resolvedConfig;
+        this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
     }
     get #isLastFile() {
@@ -757,7 +754,7 @@ class RuntimeReporter {
                 break;
             }
             case "run:start": {
-                this.#isFileViewExpanded = payload.result.testFiles.length === 1 && this.resolvedConfig.watch !== true;
+                this.#isFileViewExpanded = payload.result.testFiles.length === 1 && this.#resolvedConfig.watch !== true;
                 break;
             }
             case "store:info": {
@@ -960,8 +957,8 @@ class WatchReporter {
 }
 class ResultTiming {
-    end = Date.now();
-    start = Date.now();
+    end = Number.NaN;
+    start = Number.NaN;
     get duration() {
         return this.end - this.start;
     }
@@ -989,8 +986,8 @@ var ResultStatus;
 class ExpectResult {
     assertion;
-    parent;
     diagnostics = [];
+    parent;
     status = "runs";
     timing = new ResultTiming();
     constructor(assertion, parent) {
@@ -1010,12 +1007,12 @@ class ResultCount {
 }
 class FileResult {
-    testFile;
     diagnostics = [];
     expectCount = new ResultCount();
     results = [];
     status = "runs";
     testCount = new ResultCount();
+    testFile;
     timing = new ResultTiming();
     constructor(testFile) {
         this.testFile = testFile;
@@ -1024,8 +1021,8 @@ class FileResult {
 class ProjectResult {
     compilerVersion;
-    projectConfigFilePath;
     diagnostics = [];
+    projectConfigFilePath;
     results = [];
     constructor(compilerVersion, projectConfigFilePath) {
         this.compilerVersion = compilerVersion;
@@ -1034,13 +1031,13 @@ class ProjectResult {
 }
 class Result {
-    resolvedConfig;
-    testFiles;
     expectCount = new ResultCount();
     fileCount = new ResultCount();
+    resolvedConfig;
     results = [];
     targetCount = new ResultCount();
     testCount = new ResultCount();
+    testFiles;
     timing = new ResultTiming();
     constructor(resolvedConfig, testFiles) {
         this.resolvedConfig = resolvedConfig;
@@ -1265,11 +1262,11 @@ class ResultHandler {
 }
 class TargetResult {
-    versionTag;
-    testFiles;
     results = new Map();
     status = "runs";
+    testFiles;
     timing = new ResultTiming();
+    versionTag;
     constructor(versionTag, testFiles) {
         this.versionTag = versionTag;
         this.testFiles = testFiles;
@@ -1277,12 +1274,12 @@ class TargetResult {
 }
 class TestResult {
-    test;
-    parent;
     diagnostics = [];
     expectCount = new ResultCount();
+    parent;
     results = [];
     status = "runs";
+    test;
     timing = new ResultTiming();
     constructor(test, parent) {
         this.test = test;
@@ -1328,27 +1325,27 @@ var CancellationReason;
 })(CancellationReason || (CancellationReason = {}));
 class Watcher {
-    targetPath;
     #abortController = new AbortController();
     #onChanged;
     #onRemoved;
     #recursive;
+    #targetPath;
     #watcher;
-    constructor(targetPath, onChanged, onRemoved, recursive) {
-        this.targetPath = targetPath;
+    constructor(targetPath, onChanged, onRemoved, options) {
+        this.#targetPath = targetPath;
         this.#onChanged = onChanged;
         this.#onRemoved = onRemoved ?? onChanged;
-        this.#recursive = recursive;
+        this.#recursive = options?.recursive;
     }
     close() {
         this.#abortController.abort();
     }
     async watch() {
-        this.#watcher = fs.watch(this.targetPath, { recursive: this.#recursive, signal: this.#abortController.signal });
+        this.#watcher = fs.watch(this.#targetPath, { recursive: this.#recursive, signal: this.#abortController.signal });
         try {
             for await (const event of this.#watcher) {
                 if (event.filename != null) {
-                    const filePath = Path.resolve(this.targetPath, event.filename);
+                    const filePath = Path.resolve(this.#targetPath, event.filename);
                     if (existsSync(filePath)) {
                         await this.#onChanged(filePath);
                     }
@@ -1375,12 +1372,31 @@ class FileWatcher extends Watcher {
     }
 }
+class DiagnosticOrigin {
+    breadcrumbs;
+    end;
+    sourceFile;
+    start;
+    constructor(start, end, sourceFile, breadcrumbs) {
+        this.start = start;
+        this.end = end;
+        this.sourceFile = sourceFile;
+        this.breadcrumbs = breadcrumbs;
+    }
+    static fromJsonNode(node, sourceFile, skipTrivia) {
+        return new DiagnosticOrigin(skipTrivia(node.pos, sourceFile), node.end, sourceFile);
+    }
+    static fromNode(node, breadcrumbs) {
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), breadcrumbs);
+    }
+}
 class Diagnostic {
-    text;
     category;
-    origin;
     code;
     related;
+    origin;
+    text;
     constructor(text, category, origin) {
         this.text = text;
         this.category = category;
@@ -1408,11 +1424,7 @@ class Diagnostic {
             let origin;
             const text = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
             if (Diagnostic.isTsDiagnosticWithLocation(diagnostic)) {
-                origin = {
-                    end: diagnostic.start + diagnostic.length,
-                    file: diagnostic.file,
-                    start: diagnostic.start,
-                };
+                origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file);
             }
             return new Diagnostic(text, category, origin).add({ code });
         });
@@ -1599,6 +1611,12 @@ class OptionDiagnosticText {
                 return optionName;
         }
     }
+    static testFileMatchCannotStartWith(segment) {
+        return [
+            `A test file match pattern cannot start with '${segment}'.`,
+            "The test files are only collected within the 'rootPath' directory.",
+        ];
+    }
     static requiresValueType(optionName, optionBrand, optionGroup) {
         optionName = OptionDiagnosticText.#optionName(optionName, optionGroup);
         return `Option '${optionName}' requires a value of type ${optionBrand}.`;
@@ -1681,30 +1699,22 @@ class OptionValidator {
                 }
                 break;
             }
+            case "testFileMatch": {
+                for (const segment of ["/", "../"]) {
+                    if (optionValue.startsWith(segment)) {
+                        this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.testFileMatchCannotStartWith(segment), origin));
+                    }
+                }
+                break;
+            }
             case "watch": {
                 if (Environment.isCi) {
                     this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.watchCannotBeEnabledInCiEnvironment(), origin));
-                    break;
-                }
-                if (!this.#isWatchSupported()) {
-                    this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.watchIsNotAvailable(), origin));
                 }
                 break;
             }
         }
     }
-    #isWatchSupported() {
-        let isRecursiveWatchAvailable;
-        try {
-            const watcher = watch(Path.resolve("./"), { persistent: false, recursive: true });
-            watcher.close();
-            isRecursiveWatchAvailable = true;
-        }
-        catch {
-            isRecursiveWatchAvailable = false;
-        }
-        return isRecursiveWatchAvailable;
-    }
 }
 class CommandLineOptionsWorker {
@@ -1810,7 +1820,7 @@ class CommandLineOptionsWorker {
 }
 class ConfigFileOptionsWorker {
-    compiler;
+    #compiler;
     #configFileOptionDefinitions;
     #configFileOptions;
     #configFilePath;
@@ -1819,7 +1829,7 @@ class ConfigFileOptionsWorker {
     #optionValidator;
     #storeService;
     constructor(compiler, configFileOptions, configFilePath, storeService, onDiagnostic) {
-        this.compiler = compiler;
+        this.#compiler = compiler;
         this.#configFileOptions = configFileOptions;
         this.#configFilePath = configFilePath;
         this.#storeService = storeService;
@@ -1828,31 +1838,27 @@ class ConfigFileOptionsWorker {
         this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostic);
     }
     #isDoubleQuotedString(node, sourceFile) {
-        return (node.kind === this.compiler.SyntaxKind.StringLiteral &&
+        return (node.kind === this.#compiler.SyntaxKind.StringLiteral &&
             sourceFile.text.slice(this.#skipTrivia(node.pos, sourceFile), node.end).startsWith('"'));
     }
     async parse(sourceText) {
-        const configSourceFile = this.compiler.parseJsonText(this.#configFilePath, sourceText);
-        if (configSourceFile.parseDiagnostics.length > 0) {
-            for (const diagnostic of Diagnostic.fromDiagnostics(configSourceFile.parseDiagnostics, this.compiler)) {
+        const sourceFile = this.#compiler.parseJsonText(this.#configFilePath, sourceText);
+        if (sourceFile.parseDiagnostics.length > 0) {
+            for (const diagnostic of Diagnostic.fromDiagnostics(sourceFile.parseDiagnostics, this.#compiler)) {
                 this.#onDiagnostic(diagnostic);
             }
             return;
         }
-        const rootExpression = configSourceFile.statements[0]?.expression;
-        if (rootExpression == null || !this.compiler.isObjectLiteralExpression(rootExpression)) {
-            const origin = { end: 0, file: configSourceFile, start: 0 };
+        const rootExpression = sourceFile.statements[0]?.expression;
+        if (rootExpression == null || !this.#compiler.isObjectLiteralExpression(rootExpression)) {
+            const origin = new DiagnosticOrigin(0, 0, sourceFile);
             this.#onDiagnostic(Diagnostic.error("The root value of a configuration file must be an object literal.", origin));
             return;
         }
         for (const property of rootExpression.properties) {
-            if (this.compiler.isPropertyAssignment(property)) {
-                if (!this.#isDoubleQuotedString(property.name, configSourceFile)) {
-                    const origin = {
-                        end: property.end,
-                        file: configSourceFile,
-                        start: this.#skipTrivia(property.pos, configSourceFile),
-                    };
+            if (this.#compiler.isPropertyAssignment(property)) {
+                if (!this.#isDoubleQuotedString(property.name, sourceFile)) {
+                    const origin = DiagnosticOrigin.fromJsonNode(property, sourceFile, this.#skipTrivia);
                     this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.doubleQuotesExpected(), origin));
                     continue;
                 }
@@ -1862,14 +1868,10 @@ class ConfigFileOptionsWorker {
                 }
                 const optionDefinition = this.#configFileOptionDefinitions.get(optionName);
                 if (optionDefinition) {
-                    this.#configFileOptions[optionDefinition.name] = await this.#parseOptionValue(configSourceFile, property.initializer, optionDefinition);
+                    this.#configFileOptions[optionDefinition.name] = await this.#parseOptionValue(sourceFile, property.initializer, optionDefinition);
                 }
                 else {
-                    const origin = {
-                        end: property.end,
-                        file: configSourceFile,
-                        start: this.#skipTrivia(property.pos, configSourceFile),
-                    };
+                    const origin = DiagnosticOrigin.fromJsonNode(property, sourceFile, this.#skipTrivia);
                     this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.unknownOption(optionName), origin));
                 }
             }
@@ -1878,25 +1880,21 @@ class ConfigFileOptionsWorker {
     }
     async #parseOptionValue(sourceFile, valueExpression, optionDefinition, isListItem = false) {
         switch (valueExpression.kind) {
-            case this.compiler.SyntaxKind.TrueKeyword: {
+            case this.#compiler.SyntaxKind.TrueKeyword: {
                 if (optionDefinition.brand === "boolean") {
                     return true;
                 }
                 break;
             }
-            case this.compiler.SyntaxKind.FalseKeyword: {
+            case this.#compiler.SyntaxKind.FalseKeyword: {
                 if (optionDefinition.brand === "boolean") {
                     return false;
                 }
                 break;
             }
-            case this.compiler.SyntaxKind.StringLiteral: {
+            case this.#compiler.SyntaxKind.StringLiteral: {
                 if (!this.#isDoubleQuotedString(valueExpression, sourceFile)) {
-                    const origin = {
-                        end: valueExpression.end,
-                        file: sourceFile,
-                        start: this.#skipTrivia(valueExpression.pos, sourceFile),
-                    };
+                    const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
                     this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.doubleQuotesExpected(), origin));
                     return;
                 }
@@ -1905,17 +1903,13 @@ class ConfigFileOptionsWorker {
                     if (optionDefinition.name === "rootPath") {
                         value = Path.resolve(Path.dirname(this.#configFilePath), value);
                     }
-                    const origin = {
-                        end: valueExpression.end,
-                        file: sourceFile,
-                        start: this.#skipTrivia(valueExpression.pos, sourceFile),
-                    };
+                    const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
                     await this.#optionValidator.check(optionDefinition.name, value, optionDefinition.brand, origin);
                     return value;
                 }
                 break;
             }
-            case this.compiler.SyntaxKind.ArrayLiteralExpression: {
+            case this.#compiler.SyntaxKind.ArrayLiteralExpression: {
                 if (optionDefinition.brand === "list") {
                     const value = [];
                     for (const element of valueExpression.elements) {
@@ -1926,14 +1920,10 @@ class ConfigFileOptionsWorker {
                 break;
             }
         }
-        const origin = {
-            end: valueExpression.end,
-            file: sourceFile,
-            start: this.#skipTrivia(valueExpression.pos, sourceFile),
-        };
         const text = isListItem
             ? OptionDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
             : OptionDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, this.#optionGroup);
+        const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
         this.#onDiagnostic(Diagnostic.error(text, origin));
         return;
     }
@@ -1988,14 +1978,14 @@ const defaultOptions = {
     testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
 };
 class ConfigService {
-    compiler;
     #commandLineOptions = {};
+    #compiler;
     #configFileOptions = {};
     #configFilePath = Path.resolve(defaultOptions.rootPath, "./tstyche.config.json");
     #pathMatch = [];
     #storeService;
     constructor(compiler, storeService) {
-        this.compiler = compiler;
+        this.#compiler = compiler;
         this.#storeService = storeService;
     }
     #onDiagnostic(diagnostic) {
@@ -2021,7 +2011,7 @@ class ConfigService {
         const configFileText = await fs.readFile(this.#configFilePath, {
             encoding: "utf8",
         });
-        const configFileWorker = new ConfigFileOptionsWorker(this.compiler, this.#configFileOptions, this.#configFilePath, this.#storeService, this.#onDiagnostic);
+        const configFileWorker = new ConfigFileOptionsWorker(this.#compiler, this.#configFileOptions, this.#configFilePath, this.#storeService, this.#onDiagnostic);
         await configFileWorker.parse(configFileText);
     }
     resolveConfig() {
@@ -2080,16 +2070,16 @@ class Timer {
 }
 class WatchService {
-    resolvedConfig;
     #changedTestFiles = new Map();
     #inputService;
+    #resolvedConfig;
     #runCallback;
     #selectService;
     #timer = new Timer();
     #watchers = [];
     #watchedTestFiles;
     constructor(resolvedConfig, runCallback, selectService, testFiles) {
-        this.resolvedConfig = resolvedConfig;
+        this.#resolvedConfig = resolvedConfig;
         this.#runCallback = runCallback;
         this.#selectService = selectService;
         this.#watchedTestFiles = new Map(testFiles.map((testFile) => [testFile.path, testFile]));
@@ -2157,39 +2147,37 @@ class WatchService {
             this.#changedTestFiles.delete(filePath);
             this.#watchedTestFiles.delete(filePath);
             if (this.#watchedTestFiles.size === 0) {
-                this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.noTestFilesWereLeft(this.resolvedConfig)));
+                this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
             }
         };
-        this.#watchers.push(new Watcher(this.resolvedConfig.rootPath, onChangedFile, onRemovedFile, true));
+        this.#watchers.push(new Watcher(this.#resolvedConfig.rootPath, onChangedFile, onRemovedFile, { recursive: true }));
         const onChangedConfigFile = () => {
             cancellationToken?.cancel("configChange");
         };
-        this.#watchers.push(new FileWatcher(this.resolvedConfig.configFilePath, onChangedConfigFile));
+        this.#watchers.push(new FileWatcher(this.#resolvedConfig.configFilePath, onChangedConfigFile));
         return Promise.all(this.#watchers.map((watcher) => watcher.watch()));
     }
 }
 class TestMember {
     brand;
-    node;
-    parent;
-    flags;
-    compiler;
     diagnostics = new Set();
+    flags;
     members = [];
     name = "";
-    constructor(brand, node, parent, flags) {
+    node;
+    parent;
+    constructor(compiler, brand, node, parent, flags) {
         this.brand = brand;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
-        this.compiler = parent.compiler;
-        if (node.arguments[0] != null && this.compiler.isStringLiteralLike(node.arguments[0])) {
+        if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
             this.name = node.arguments[0].text;
         }
         if (node.arguments[1] != null &&
-            parent.compiler.isFunctionLike(node.arguments[1]) &&
-            parent.compiler.isBlock(node.arguments[1].body)) {
+            compiler.isFunctionLike(node.arguments[1]) &&
+            compiler.isBlock(node.arguments[1].body)) {
             const blockStart = node.arguments[1].body.getStart();
             const blockEnd = node.arguments[1].body.getEnd();
             for (const diagnostic of parent.diagnostics) {
@@ -2216,11 +2204,7 @@ class TestMember {
             case "describe": {
                 for (const member of this.members) {
                     if (member.brand === "expect") {
-                        diagnostics.push(Diagnostic.error(getText(member.node), {
-                            end: member.node.getEnd(),
-                            file: member.node.getSourceFile(),
-                            start: member.node.getStart(),
-                        }));
+                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
                     }
                 }
                 break;
@@ -2229,11 +2213,7 @@ class TestMember {
             case "expect": {
                 for (const member of this.members) {
                     if (member.brand !== "expect") {
-                        diagnostics.push(Diagnostic.error(getText(member.node), {
-                            end: member.node.getEnd(),
-                            file: member.node.getSourceFile(),
-                            start: member.node.getStart(),
-                        }));
+                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
                     }
                 }
                 break;
@@ -2244,16 +2224,15 @@ class TestMember {
 }
 class Assertion extends TestMember {
+    isNot;
     matcherNode;
     modifierNode;
     notNode;
-    isNot;
-    constructor(brand, node, parent, flags, matcherNode, modifierNode, notNode) {
-        super(brand, node, parent, flags);
+    constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
+        super(compiler, brand, node, parent, flags);
+        this.isNot = notNode != null;
         this.matcherNode = matcherNode;
         this.modifierNode = modifierNode;
-        this.notNode = notNode;
-        this.isNot = notNode != null;
         const argStart = this.source[0]?.getStart();
         const argEnd = this.source[0]?.getEnd();
         for (const diagnostic of parent.diagnostics) {
@@ -2295,11 +2274,11 @@ class Assertion extends TestMember {
 }
 class IdentifierLookup {
-    compiler;
+    #compiler;
     #identifiers;
     #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
     constructor(compiler, identifiers) {
-        this.compiler = compiler;
+        this.#compiler = compiler;
         this.#identifiers = identifiers ?? {
             namedImports: {
                 describe: undefined,
@@ -2321,7 +2300,7 @@ class IdentifierLookup {
         if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
             node.importClause?.isTypeOnly !== true &&
             node.importClause?.namedBindings != null) {
-            if (this.compiler.isNamedImports(node.importClause.namedBindings)) {
+            if (this.#compiler.isNamedImports(node.importClause.namedBindings)) {
                 for (const element of node.importClause.namedBindings.elements) {
                     if (element.isTypeOnly) {
                         continue;
@@ -2338,7 +2317,7 @@ class IdentifierLookup {
                     }
                 }
             }
-            if (this.compiler.isNamespaceImport(node.importClause.namedBindings)) {
+            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
                 this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
             }
         }
@@ -2346,7 +2325,7 @@ class IdentifierLookup {
     resolveTestMemberMeta(node) {
         let flags = 0;
         let expression = node.expression;
-        while (this.compiler.isPropertyAccessExpression(expression)) {
+        while (this.#compiler.isPropertyAccessExpression(expression)) {
             if (expression.expression.getText() === this.#identifiers.namespace) {
                 break;
             }
@@ -2371,7 +2350,7 @@ class IdentifierLookup {
             expression = expression.expression;
         }
         let identifierName;
-        if (this.compiler.isPropertyAccessExpression(expression) &&
+        if (this.#compiler.isPropertyAccessExpression(expression) &&
             expression.expression.getText() === this.#identifiers.namespace) {
             identifierName = expression.name.getText();
         }
@@ -2395,12 +2374,10 @@ class IdentifierLookup {
 }
 class TestTree {
-    compiler;
     diagnostics;
-    sourceFile;
     members = [];
-    constructor(compiler, diagnostics, sourceFile) {
-        this.compiler = compiler;
+    sourceFile;
+    constructor(diagnostics, sourceFile) {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
     }
@@ -2413,8 +2390,8 @@ class TestTree {
 }
 class CollectService {
-    compiler;
-    matcherIdentifiers = [
+    #compiler;
+    #matcherIdentifiers = [
         "toBe",
         "toBeAny",
         "toBeAssignable",
@@ -2436,69 +2413,69 @@ class CollectService {
         "toMatch",
         "toRaiseError",
     ];
-    modifierIdentifiers = ["type"];
-    notIdentifier = "not";
+    #modifierIdentifiers = ["type"];
+    #notIdentifier = "not";
     constructor(compiler) {
-        this.compiler = compiler;
+        this.#compiler = compiler;
     }
     #collectTestMembers(node, identifiers, parent) {
-        if (this.compiler.isBlock(node)) {
-            this.compiler.forEachChild(node, (node) => {
-                this.#collectTestMembers(node, new IdentifierLookup(this.compiler, identifiers.clone()), parent);
+        if (this.#compiler.isBlock(node)) {
+            this.#compiler.forEachChild(node, (node) => {
+                this.#collectTestMembers(node, new IdentifierLookup(this.#compiler, identifiers.clone()), parent);
             });
             return;
         }
-        if (this.compiler.isCallExpression(node)) {
+        if (this.#compiler.isCallExpression(node)) {
             const meta = identifiers.resolveTestMemberMeta(node);
             if (meta != null && (meta.brand === "describe" || meta.brand === "test")) {
-                const testMember = new TestMember(meta.brand, node, parent, meta.flags);
+                const testMember = new TestMember(this.#compiler, meta.brand, node, parent, meta.flags);
                 parent.members.push(testMember);
-                this.compiler.forEachChild(node, (node) => {
+                this.#compiler.forEachChild(node, (node) => {
                     this.#collectTestMembers(node, identifiers, testMember);
                 });
                 return;
             }
             if (meta != null && meta.brand === "expect") {
-                const modifierNode = this.#getMatchingChainNode(node, this.modifierIdentifiers);
+                const modifierNode = this.#getMatchingChainNode(node, this.#modifierIdentifiers);
                 if (!modifierNode) {
                     return;
                 }
-                const notNode = this.#getMatchingChainNode(modifierNode, [this.notIdentifier]);
-                const matcherNode = this.#getMatchingChainNode(notNode ?? modifierNode, this.matcherIdentifiers)?.parent;
+                const notNode = this.#getMatchingChainNode(modifierNode, [this.#notIdentifier]);
+                const matcherNode = this.#getMatchingChainNode(notNode ?? modifierNode, this.#matcherIdentifiers)?.parent;
                 if (matcherNode == null || !this.#isMatcherNode(matcherNode)) {
                     return;
                 }
-                const assertion = new Assertion(meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
+                const assertion = new Assertion(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
                 parent.members.push(assertion);
-                this.compiler.forEachChild(node, (node) => {
+                this.#compiler.forEachChild(node, (node) => {
                     this.#collectTestMembers(node, identifiers, assertion);
                 });
                 return;
             }
         }
-        if (this.compiler.isImportDeclaration(node)) {
+        if (this.#compiler.isImportDeclaration(node)) {
             identifiers.handleImportDeclaration(node);
             return;
         }
-        if (this.compiler.isVariableDeclaration(node)) ;
-        if (this.compiler.isBinaryExpression(node)) ;
-        this.compiler.forEachChild(node, (node) => {
+        if (this.#compiler.isVariableDeclaration(node)) ;
+        if (this.#compiler.isBinaryExpression(node)) ;
+        this.#compiler.forEachChild(node, (node) => {
             this.#collectTestMembers(node, identifiers, parent);
         });
     }
     createTestTree(sourceFile, semanticDiagnostics = []) {
-        const testTree = new TestTree(this.compiler, new Set(semanticDiagnostics), sourceFile);
-        this.#collectTestMembers(sourceFile, new IdentifierLookup(this.compiler), testTree);
+        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
+        this.#collectTestMembers(sourceFile, new IdentifierLookup(this.#compiler), testTree);
         return testTree;
     }
     #getMatchingChainNode({ parent }, name) {
-        if (this.compiler.isPropertyAccessExpression(parent) && name.includes(parent.name.getText())) {
+        if (this.#compiler.isPropertyAccessExpression(parent) && name.includes(parent.name.getText())) {
             return parent;
         }
         return;
     }
     #isMatcherNode(node) {
-        return this.compiler.isCallExpression(node) && this.compiler.isPropertyAccessExpression(node.expression);
+        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
     }
 }
@@ -2518,8 +2495,8 @@ var TestMemberFlags;
 })(TestMemberFlags || (TestMemberFlags = {}));
 class PrimitiveTypeMatcher {
-    typeChecker;
     #targetTypeFlag;
+    typeChecker;
     constructor(typeChecker, targetTypeFlag) {
         this.typeChecker = typeChecker;
         this.#targetTypeFlag = targetTypeFlag;
@@ -2538,8 +2515,8 @@ class PrimitiveTypeMatcher {
 }
 class RelationMatcherBase {
-    typeChecker;
     relationExplanationVerb = "is";
+    typeChecker;
     constructor(typeChecker) {
         this.typeChecker = typeChecker;
     }
@@ -2729,8 +2706,8 @@ class ToRaiseError {
 }
 class Expect {
-    compiler;
-    typeChecker;
+    #compiler;
+    #typeChecker;
     toBe;
     toBeAny;
     toBeAssignable;
@@ -2752,36 +2729,36 @@ class Expect {
     toMatch;
     toRaiseError;
     constructor(compiler, typeChecker) {
-        this.compiler = compiler;
-        this.typeChecker = typeChecker;
-        this.toBe = new ToBe(this.typeChecker);
-        this.toBeAny = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Any);
-        this.toBeAssignable = new ToBeAssignableWith(this.typeChecker);
-        this.toBeAssignableTo = new ToBeAssignableTo(this.typeChecker);
-        this.toBeAssignableWith = new ToBeAssignableWith(this.typeChecker);
-        this.toBeBigInt = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.BigInt);
-        this.toBeBoolean = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Boolean);
-        this.toBeNever = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Never);
-        this.toBeNull = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Null);
-        this.toBeNumber = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Number);
-        this.toBeString = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.String);
-        this.toBeSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.ESSymbol);
-        this.toBeUndefined = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Undefined);
-        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.UniqueESSymbol);
-        this.toBeUnknown = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Unknown);
-        this.toBeVoid = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Void);
-        this.toEqual = new ToBe(this.typeChecker);
-        this.toHaveProperty = new ToHaveProperty(this.compiler, this.typeChecker);
-        this.toMatch = new ToMatch(this.typeChecker);
-        this.toRaiseError = new ToRaiseError(this.compiler, this.typeChecker);
+        this.#compiler = compiler;
+        this.#typeChecker = typeChecker;
+        this.toBe = new ToBe(typeChecker);
+        this.toBeAny = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Any);
+        this.toBeAssignable = new ToBeAssignableWith(typeChecker);
+        this.toBeAssignableTo = new ToBeAssignableTo(typeChecker);
+        this.toBeAssignableWith = new ToBeAssignableWith(typeChecker);
+        this.toBeBigInt = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.BigInt);
+        this.toBeBoolean = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Boolean);
+        this.toBeNever = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Never);
+        this.toBeNull = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Null);
+        this.toBeNumber = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Number);
+        this.toBeString = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.String);
+        this.toBeSymbol = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.ESSymbol);
+        this.toBeUndefined = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Undefined);
+        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.UniqueESSymbol);
+        this.toBeUnknown = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Unknown);
+        this.toBeVoid = new PrimitiveTypeMatcher(typeChecker, compiler.TypeFlags.Void);
+        this.toEqual = new ToBe(typeChecker);
+        this.toHaveProperty = new ToHaveProperty(compiler, typeChecker);
+        this.toMatch = new ToMatch(typeChecker);
+        this.toRaiseError = new ToRaiseError(compiler, typeChecker);
     }
     static assertTypeChecker(typeChecker) {
         return "isTypeRelatedTo" in typeChecker && "relation" in typeChecker;
     }
     #getType(node) {
-        return this.compiler.isExpression(node)
-            ? this.typeChecker.getTypeAtLocation(node)
-            : this.typeChecker.getTypeFromTypeNode(node);
+        return this.#compiler.isExpression(node)
+            ? this.#typeChecker.getTypeAtLocation(node)
+            : this.#typeChecker.getTypeFromTypeNode(node);
     }
     #getTypes(nodes) {
         return nodes.map((node) => this.#getType(node));
@@ -2790,10 +2767,10 @@ class Expect {
         return types.every((type) => this.#isStringOrNumberLiteralType(type));
     }
     #isStringOrNumberLiteralType(type) {
-        return Boolean(type.flags & this.compiler.TypeFlags.StringOrNumberLiteral);
+        return Boolean(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
     }
     #isUniqueSymbolType(type) {
-        return Boolean(type.flags & this.compiler.TypeFlags.UniqueESSymbol);
+        return Boolean(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
     }
     match(assertion, expectResult) {
         const matcherNameText = assertion.matcherName.getText();
@@ -2839,9 +2816,9 @@ class Expect {
                     return;
                 }
                 const sourceType = this.#getType(assertion.source[0]);
-                const nonPrimitiveType = { flags: this.compiler.TypeFlags.NonPrimitive };
-                if (sourceType.flags & (this.compiler.TypeFlags.Any | this.compiler.TypeFlags.Never) ||
-                    !this.typeChecker.isTypeRelatedTo(sourceType, nonPrimitiveType, this.typeChecker.relation.assignable)) {
+                const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
+                if (sourceType.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never) ||
+                    !this.#typeChecker.isTypeRelatedTo(sourceType, nonPrimitiveType, this.#typeChecker.relation.assignable)) {
                     this.#onSourceArgumentMustBeObjectType(assertion.source[0], expectResult);
                     return;
                 }
@@ -2880,29 +2857,17 @@ class Expect {
             `'.${matcherNameText}()' is deprecated and will be removed in TSTyche 3.`,
             "To learn more, visit https://tstyche.org/release-notes/tstyche-2",
         ];
-        const origin = {
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
         EventEmitter.dispatch(["deprecation:info", { diagnostics: [Diagnostic.warning(text, origin)] }]);
     }
     #onKeyArgumentMustBeOfType(node, expectResult) {
-        const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
+        const receivedTypeText = this.#typeChecker.typeToString(this.#getType(node));
         const text = `An argument for 'key' must be of type 'string | number | symbol', received: '${receivedTypeText}'.`;
-        const origin = {
-            end: node.getEnd(),
-            file: node.getSourceFile(),
-            start: node.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(node);
         EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
     }
     #onKeyArgumentMustBeProvided(assertion, expectResult) {
-        const origin = {
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
         EventEmitter.dispatch([
             "expect:error",
             {
@@ -2913,11 +2878,7 @@ class Expect {
     }
     #onNotSupportedMatcherName(assertion, expectResult) {
         const matcherNameText = assertion.matcherName.getText();
-        const origin = {
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
         EventEmitter.dispatch([
             "expect:error",
             {
@@ -2927,22 +2888,14 @@ class Expect {
         ]);
     }
     #onSourceArgumentMustBeObjectType(node, expectResult) {
-        const sourceText = this.compiler.isTypeNode(node) ? "A type argument for 'Source'" : "An argument for 'source'";
-        const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
+        const sourceText = this.#compiler.isTypeNode(node) ? "A type argument for 'Source'" : "An argument for 'source'";
+        const receivedTypeText = this.#typeChecker.typeToString(this.#getType(node));
         const text = `${sourceText} must be of an object type, received: '${receivedTypeText}'.`;
-        const origin = {
-            end: node.getEnd(),
-            file: node.getSourceFile(),
-            start: node.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(node);
         EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
     }
     #onSourceArgumentMustBeProvided(assertion, expectResult) {
-        const origin = {
-            end: assertion.node.getEnd(),
-            file: assertion.node.getSourceFile(),
-            start: assertion.node.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(assertion.node);
         EventEmitter.dispatch([
             "expect:error",
             {
@@ -2954,11 +2907,7 @@ class Expect {
         ]);
     }
     #onTargetArgumentMustBeProvided(assertion, expectResult) {
-        const origin = {
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
-        };
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
         EventEmitter.dispatch([
             "expect:error",
             {
@@ -2974,12 +2923,8 @@ class Expect {
         for (const node of nodes) {
             const receivedType = this.#getType(node);
             if (!this.#isStringOrNumberLiteralType(receivedType)) {
-                const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
-                const origin = {
-                    end: node.getEnd(),
-                    file: node.getSourceFile(),
-                    start: node.getStart(),
-                };
+                const receivedTypeText = this.#typeChecker.typeToString(this.#getType(node));
+                const origin = DiagnosticOrigin.fromNode(node);
                 diagnostics.push(Diagnostic.error(`An argument for 'target' must be of type 'string | number', received: '${receivedTypeText}'.`, origin));
             }
         }
@@ -3019,10 +2964,10 @@ class Version {
 }
 class ProjectService {
-    compiler;
+    #compiler;
     #service;
     constructor(compiler) {
-        this.compiler = compiler;
+        this.#compiler = compiler;
         function doNothing() {
         }
         function returnFalse() {
@@ -3044,7 +2989,7 @@ class ProjectService {
             startGroup: doNothing,
         };
         const host = {
-            ...this.compiler.sys,
+            ...this.#compiler.sys,
             clearImmediate,
             clearTimeout,
             setImmediate,
@@ -3052,9 +2997,9 @@ class ProjectService {
             watchDirectory: () => noopWatcher,
             watchFile: () => noopWatcher,
         };
-        this.#service = new this.compiler.server.ProjectService({
+        this.#service = new this.#compiler.server.ProjectService({
             allowLocalPluginLoads: true,
-            cancellationToken: this.compiler.server.nullCancellationToken,
+            cancellationToken: this.#compiler.server.nullCancellationToken,
             host,
             logger: noopLogger,
             session: undefined,
@@ -3079,17 +3024,17 @@ class ProjectService {
             strictNullChecks: true,
             target: "esnext",
         };
-        if (Version.isSatisfiedWith(this.compiler.version, "5.4")) {
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.4")) {
             defaultCompilerOptions.module = "preserve";
         }
-        if (Version.isSatisfiedWith(this.compiler.version, "5.0")) {
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
             defaultCompilerOptions["allowImportingTsExtensions"] = true;
             defaultCompilerOptions.moduleResolution = "bundler";
         }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
-        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
+        return this.#service.getDefaultProjectForFile(this.#compiler.server.toNormalizedPath(filePath), true);
     }
     getLanguageService(filePath) {
         const project = this.getDefaultProject(filePath);
@@ -3102,30 +3047,30 @@ class ProjectService {
         const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
         EventEmitter.dispatch([
             "project:info",
-            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
+            { compilerVersion: this.#compiler.version, projectConfigFilePath: configFileName },
         ]);
         if (configFileErrors && configFileErrors.length > 0) {
             EventEmitter.dispatch([
                 "project:error",
-                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
+                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.#compiler) },
             ]);
         }
     }
 }
 class TestTreeWorker {
-    resolvedConfig;
-    compiler;
+    #compiler;
     #cancellationToken;
     #expect;
     #fileResult;
     #hasOnly;
     #position;
+    #resolvedConfig;
     constructor(resolvedConfig, compiler, expect, options) {
-        this.resolvedConfig = resolvedConfig;
-        this.compiler = compiler;
-        this.#cancellationToken = options.cancellationToken;
+        this.#resolvedConfig = resolvedConfig;
+        this.#compiler = compiler;
         this.#expect = expect;
+        this.#cancellationToken = options.cancellationToken;
         this.#fileResult = options.fileResult;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
@@ -3135,11 +3080,11 @@ class TestTreeWorker {
             mode |= 1;
         }
         if (member.flags & 2 ||
-            (this.resolvedConfig.only != null && member.name.toLowerCase().includes(this.resolvedConfig.only.toLowerCase()))) {
+            (this.#resolvedConfig.only != null && member.name.toLowerCase().includes(this.#resolvedConfig.only.toLowerCase()))) {
             mode |= 2;
         }
         if (member.flags & 4 ||
-            (this.resolvedConfig.skip != null && member.name.toLowerCase().includes(this.resolvedConfig.skip.toLowerCase()))) {
+            (this.#resolvedConfig.skip != null && member.name.toLowerCase().includes(this.#resolvedConfig.skip.toLowerCase()))) {
             mode |= 4;
         }
         if (member.flags & 8) {
@@ -3196,7 +3141,7 @@ class TestTreeWorker {
             EventEmitter.dispatch([
                 "expect:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics([...assertion.diagnostics], this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...assertion.diagnostics], this.#compiler),
                     result: expectResult,
                 },
             ]);
@@ -3209,11 +3154,7 @@ class TestTreeWorker {
         if (assertion.isNot ? !matchResult.isMatch : matchResult.isMatch) {
             if (runMode & 1) {
                 const text = ["The assertion was supposed to fail, but it passed.", "Consider removing the '.fail' flag."];
-                const origin = {
-                    end: assertion.node.getEnd(),
-                    file: assertion.node.getSourceFile(),
-                    start: assertion.node.getStart(),
-                };
+                const origin = DiagnosticOrigin.fromNode(assertion.node);
                 EventEmitter.dispatch([
                     "expect:error",
                     { diagnostics: [Diagnostic.error(text, origin)], result: expectResult },
@@ -3227,19 +3168,13 @@ class TestTreeWorker {
             EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
         }
         else {
-            const origin = {
-                breadcrumbs: assertion.ancestorNames,
-                end: assertion.matcherName.getEnd(),
-                file: assertion.matcherName.getSourceFile(),
-                start: assertion.matcherName.getStart(),
-            };
-            const diagnostics = [];
-            for (const diagnostic of matchResult.explain()) {
+            const origin = DiagnosticOrigin.fromNode(assertion.matcherName, assertion.ancestorNames);
+            const diagnostics = matchResult.explain().map((diagnostic) => {
                 if (diagnostic.origin == null) {
-                    diagnostic.add({ origin });
+                    return diagnostic.add({ origin });
                 }
-                diagnostics.push(diagnostic);
-            }
+                return diagnostic;
+            });
             EventEmitter.dispatch(["expect:fail", { diagnostics, result: expectResult }]);
         }
     }
@@ -3252,7 +3187,7 @@ class TestTreeWorker {
             EventEmitter.dispatch([
                 "file:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics([...describe.diagnostics], this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...describe.diagnostics], this.#compiler),
                     result: this.#fileResult,
                 },
             ]);
@@ -3274,7 +3209,7 @@ class TestTreeWorker {
             EventEmitter.dispatch([
                 "test:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics([...test.diagnostics], this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...test.diagnostics], this.#compiler),
                     result: testResult,
                 },
             ]);
@@ -3295,13 +3230,13 @@ class TestTreeWorker {
 }
 class TestFileRunner {
-    resolvedConfig;
-    compiler;
+    #compiler;
     #collectService;
+    #resolvedConfig;
     #projectService;
     constructor(resolvedConfig, compiler) {
-        this.resolvedConfig = resolvedConfig;
-        this.compiler = compiler;
+        this.#resolvedConfig = resolvedConfig;
+        this.#compiler = compiler;
         this.#collectService = new CollectService(compiler);
         this.#projectService = new ProjectService(compiler);
     }
@@ -3309,7 +3244,7 @@ class TestFileRunner {
         if (cancellationToken?.isCancellationRequested === true) {
             return;
         }
-        this.#projectService.openFile(testFile.path, undefined, this.resolvedConfig.rootPath);
+        this.#projectService.openFile(testFile.path, undefined, this.#resolvedConfig.rootPath);
         const fileResult = new FileResult(testFile);
         EventEmitter.dispatch(["file:start", { result: fileResult }]);
         this.#runFile(testFile, fileResult, cancellationToken);
@@ -3326,7 +3261,7 @@ class TestFileRunner {
             EventEmitter.dispatch([
                 "file:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics, this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics, this.#compiler),
                     result: fileResult,
                 },
             ]);
@@ -3346,7 +3281,7 @@ class TestFileRunner {
             EventEmitter.dispatch([
                 "file:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics([...testTree.diagnostics], this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...testTree.diagnostics], this.#compiler),
                     result: fileResult,
                 },
             ]);
@@ -3358,8 +3293,8 @@ class TestFileRunner {
             EventEmitter.dispatch(["file:error", { diagnostics: [Diagnostic.error(text)], result: fileResult }]);
             return;
         }
-        const expect = new Expect(this.compiler, typeChecker);
-        const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, expect, {
+        const expect = new Expect(this.#compiler, typeChecker);
+        const testTreeWorker = new TestTreeWorker(this.#resolvedConfig, this.#compiler, expect, {
             cancellationToken,
             fileResult,
             hasOnly: testTree.hasOnly,
@@ -3370,12 +3305,12 @@ class TestFileRunner {
 }
 class TaskRunner {
-    resolvedConfig;
     #eventEmitter = new EventEmitter();
+    #resolvedConfig;
     #selectService;
     #storeService;
     constructor(resolvedConfig, selectService, storeService) {
-        this.resolvedConfig = resolvedConfig;
+        this.#resolvedConfig = resolvedConfig;
         this.#selectService = selectService;
         this.#storeService = storeService;
         this.#eventEmitter.addHandler(new ResultHandler());
@@ -3385,11 +3320,11 @@ class TaskRunner {
     }
     async run(testFiles, cancellationToken = new CancellationToken()) {
         let cancellationHandler;
-        if (this.resolvedConfig.failFast) {
+        if (this.#resolvedConfig.failFast) {
             cancellationHandler = new CancellationHandler(cancellationToken, "failFast");
             this.#eventEmitter.addHandler(cancellationHandler);
         }
-        if (this.resolvedConfig.watch === true) {
+        if (this.#resolvedConfig.watch === true) {
             await this.#watch(testFiles, cancellationToken);
         }
         else {
@@ -3400,14 +3335,14 @@ class TaskRunner {
         }
     }
     async #run(testFiles, cancellationToken) {
-        const result = new Result(this.resolvedConfig, testFiles);
+        const result = new Result(this.#resolvedConfig, testFiles);
         EventEmitter.dispatch(["run:start", { result }]);
-        for (const versionTag of this.resolvedConfig.target) {
+        for (const versionTag of this.#resolvedConfig.target) {
             const targetResult = new TargetResult(versionTag, testFiles);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
             const compiler = await this.#storeService.load(versionTag, cancellationToken);
             if (compiler) {
-                const testFileRunner = new TestFileRunner(this.resolvedConfig, compiler);
+                const testFileRunner = new TestFileRunner(this.#resolvedConfig, compiler);
                 for (const testFile of testFiles) {
                     testFileRunner.run(testFile, cancellationToken);
                 }
@@ -3424,7 +3359,7 @@ class TaskRunner {
         const runCallback = async (testFiles) => {
             await this.#run(testFiles, cancellationToken);
         };
-        const watchModeManager = new WatchService(this.resolvedConfig, runCallback, this.#selectService, testFiles);
+        const watchModeManager = new WatchService(this.#resolvedConfig, runCallback, this.#selectService, testFiles);
         cancellationToken?.onCancellationRequested((reason) => {
             if (reason !== "failFast") {
                 watchModeManager.close();
@@ -3435,26 +3370,26 @@ class TaskRunner {
 }
 class TSTyche {
-    resolvedConfig;
     #eventEmitter = new EventEmitter();
     #outputService;
+    #resolvedConfig;
     #selectService;
     #storeService;
     #taskRunner;
-    static version = "2.0.0-beta.1";
+    static version = "2.0.0-rc.0";
     constructor(resolvedConfig, outputService, selectService, storeService) {
-        this.resolvedConfig = resolvedConfig;
+        this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
         this.#selectService = selectService;
         this.#storeService = storeService;
-        this.#taskRunner = new TaskRunner(this.resolvedConfig, this.#selectService, this.#storeService);
+        this.#taskRunner = new TaskRunner(this.#resolvedConfig, this.#selectService, this.#storeService);
     }
     close() {
         this.#taskRunner.close();
     }
     async run(testFiles, cancellationToken = new CancellationToken()) {
-        this.#eventEmitter.addHandler(new RuntimeReporter(this.resolvedConfig, this.#outputService));
-        if (this.resolvedConfig.watch === true) {
+        this.#eventEmitter.addHandler(new RuntimeReporter(this.#resolvedConfig, this.#outputService));
+        if (this.#resolvedConfig.watch === true) {
             this.#eventEmitter.addHandler(new WatchReporter(this.#outputService));
         }
         else {
@@ -3472,6 +3407,9 @@ class GlobPattern {
         let resultPattern = "\\.";
         let optionalSegmentCount = 0;
         for (const segment of segments) {
+            if (segment === ".") {
+                continue;
+            }
             if (segment === "**") {
                 resultPattern += "(\\/(?!(node_modules)(\\/|$))[^./][^/]*)*?";
                 continue;
@@ -3507,11 +3445,11 @@ class GlobPattern {
 }
 class SelectService {
-    resolvedConfig;
     #includeDirectoryRegex;
     #includeFileRegex;
+    #resolvedConfig;
     constructor(resolvedConfig) {
-        this.resolvedConfig = resolvedConfig;
+        this.#resolvedConfig = resolvedConfig;
         this.#includeDirectoryRegex = GlobPattern.toRegex(resolvedConfig.testFileMatch, "directories");
         this.#includeFileRegex = GlobPattern.toRegex(resolvedConfig.testFileMatch, "files");
     }
@@ -3519,14 +3457,14 @@ class SelectService {
         return this.#includeDirectoryRegex.test(directoryPath);
     }
     #isFileIncluded(filePath) {
-        if (this.resolvedConfig.pathMatch.length > 0 &&
-            !this.resolvedConfig.pathMatch.some((match) => filePath.toLowerCase().includes(match.toLowerCase()))) {
+        if (this.#resolvedConfig.pathMatch.length > 0 &&
+            !this.#resolvedConfig.pathMatch.some((match) => filePath.toLowerCase().includes(match.toLowerCase()))) {
             return false;
         }
         return this.#includeFileRegex.test(filePath);
     }
     isTestFile(filePath) {
-        return this.#isFileIncluded(Path.relative(this.resolvedConfig.rootPath, filePath));
+        return this.#isFileIncluded(Path.relative(this.#resolvedConfig.rootPath, filePath));
     }
     #onDiagnostic(diagnostic) {
         EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
@@ -3536,12 +3474,12 @@ class SelectService {
         const testFilePaths = [];
         await this.#visitDirectory(currentPath, testFilePaths);
         if (testFilePaths.length === 0) {
-            this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.noTestFilesWereSelected(this.resolvedConfig)));
+            this.#onDiagnostic(Diagnostic.error(OptionDiagnosticText.noTestFilesWereSelected(this.#resolvedConfig)));
         }
         return testFilePaths.sort();
     }
     async #visitDirectory(currentPath, testFilePaths) {
-        const targetPath = Path.join(this.resolvedConfig.rootPath, currentPath);
+        const targetPath = Path.join(this.#resolvedConfig.rootPath, currentPath);
         let entries = [];
         try {
             entries = await fs.readdir(targetPath, { withFileTypes: true });
@@ -3573,6 +3511,21 @@ class SelectService {
     }
 }
+class StoreDiagnosticText {
+    static failedToFetchMetadata(registryUrl) {
+        return `Failed to fetch metadata of the 'typescript' package from '${registryUrl.toString()}'.`;
+    }
+    static failedWithStatusCode(code) {
+        return `Request failed with status code ${String(code)}.`;
+    }
+    static maybeNetworkConnectionIssue() {
+        return "Might be there is an issue with the registry or the network connection.";
+    }
+    static setupTimeoutExceeded(timeout) {
+        return `Setup timeout of ${String(timeout / 1000)}s was exceeded.`;
+    }
+}
 class ManifestWorker {
     #manifestFileName = "store-manifest.json";
     #manifestFilePath;
@@ -3593,35 +3546,6 @@ class ManifestWorker {
         }
         return manifest;
     }
-    async #fetch() {
-        return new Promise((resolve, reject) => {
-            const request = https.get(new URL("typescript", this.#registryUrl), {
-                headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
-                timeout: this.#timeout,
-            }, (response) => {
-                if (response.statusCode !== 200) {
-                    reject(new Error(`Request failed with status code ${String(response.statusCode)}.`));
-                    response.resume();
-                    return;
-                }
-                response.setEncoding("utf8");
-                let rawData = "";
-                response.on("data", (chunk) => {
-                    rawData += chunk;
-                });
-                response.on("end", () => {
-                    const packageMetadata = JSON.parse(rawData);
-                    resolve(packageMetadata);
-                });
-            });
-            request.on("error", (error) => {
-                reject(error);
-            });
-            request.on("timeout", () => {
-                request.destroy();
-            });
-        });
-    }
     isOutdated(manifest, ageTolerance = 0) {
         if (Date.now() - manifest.lastUpdated > 2 * 60 * 60 * 1000 + ageTolerance * 1000) {
             return true;
@@ -3637,20 +3561,35 @@ class ManifestWorker {
         };
         let packageMetadata;
         try {
-            packageMetadata = await this.#fetch();
+            const response = await fetch(new URL("typescript", this.#registryUrl), {
+                headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
+                signal: AbortSignal.timeout(this.#timeout),
+            });
+            if (!response.ok) {
+                this.#onDiagnostic(Diagnostic.error([
+                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
+                    StoreDiagnosticText.failedWithStatusCode(response.status),
+                ]));
+                return;
+            }
+            packageMetadata = (await response.json());
         }
         catch (error) {
             if (options?.quite === true) {
                 return;
             }
-            const text = [`Failed to fetch metadata of the 'typescript' package from '${this.#registryUrl.toString()}'.`];
-            if (error instanceof Error && "code" in error && error.code === "ECONNRESET") {
-                text.push(`Setup timeout of ${String(this.#timeout / 1000)}s was exceeded.`);
+            if (error instanceof Error && error.name === "TimeoutError") {
+                this.#onDiagnostic(Diagnostic.error([
+                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
+                    StoreDiagnosticText.setupTimeoutExceeded(this.#timeout),
+                ]));
             }
             else {
-                text.push("Might be there is an issue with the registry or the network connection.");
+                this.#onDiagnostic(Diagnostic.error([
+                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
+                    StoreDiagnosticText.maybeNetworkConnectionIssue(),
+                ]));
             }
-            this.#onDiagnostic(Diagnostic.fromError(text, error));
             return;
         }
         manifest.versions = Object.keys(packageMetadata.versions)
@@ -4068,10 +4007,10 @@ class Cli {
             };
             const onRemoved = () => {
             };
-            watchers.push(new Watcher(resolvedConfig.rootPath, onChangedTestFile, onRemoved, true));
+            watchers.push(new Watcher(resolvedConfig.rootPath, onChangedTestFile, onRemoved, { recursive: true }));
         }
         return Promise.all(watchers.map((watcher) => watcher.watch()));
     }
 }
-export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, ExitCodeHandler, Expect, ExpectResult, FileResult, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionDiagnosticText, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RuntimeReporter, Scribbler, SelectService, SetupReporter, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestFile, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageStepText, defaultOptions, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, waitingForFileChangesText, watchUsageText };
+export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Environment, EventEmitter, ExitCodeHandler, Expect, ExpectResult, FileResult, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionDiagnosticText, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RuntimeReporter, Scribbler, SelectService, SetupReporter, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestFile, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageStepText, defaultOptions, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, waitingForFileChangesText, watchUsageText };