tstyche 1.0.0 → 2.0.0-beta.0

package/build/tstyche.js

@@ -1,8 +1,8 @@
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
 import { createRequire } from 'node:module';
 import os from 'node:os';
-import path from 'node:path';
 import { existsSync, writeFileSync, rmSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import vm from 'node:vm';
@@ -24,103 +24,6 @@ class EventEmitter {
     }
 }
 
-class Path {
-    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.replaceAll("\\", "/");
-    }
-    static relative(from, to) {
-        let relativePath = path.relative(from, to);
-        if (!relativePath.startsWith(".")) {
-            relativePath = `./${relativePath}`;
-        }
-        return Path.normalizeSlashes(relativePath);
-    }
-    static resolve(...filePaths) {
-        return Path.normalizeSlashes(path.resolve(...filePaths));
-    }
-}
-
-class Environment {
-    static #noColor = Environment.#resolveNoColor();
-    static #noInteractive = Environment.#resolveNoInteractive();
-    static #storePath = Environment.#resolveStorePath();
-    static #timeout = Environment.#resolveTimeout();
-    static #typescriptPath = Environment.#resolveTypeScriptPath();
-    static get noColor() {
-        return Environment.#noColor;
-    }
-    static get noInteractive() {
-        return Environment.#noInteractive;
-    }
-    static get storePath() {
-        return Environment.#storePath;
-    }
-    static get timeout() {
-        return Environment.#timeout;
-    }
-    static get typescriptPath() {
-        return Environment.#typescriptPath;
-    }
-    static #resolveNoColor() {
-        if (process.env["TSTYCHE_NO_COLOR"] != null) {
-            return process.env["TSTYCHE_NO_COLOR"] !== "";
-        }
-        if (process.env["NO_COLOR"] != null) {
-            return process.env["NO_COLOR"] !== "";
-        }
-        return false;
-    }
-    static #resolveNoInteractive() {
-        if (process.env["TSTYCHE_NO_INTERACTIVE"] != null) {
-            return process.env["TSTYCHE_NO_INTERACTIVE"] !== "";
-        }
-        return !process.stdout.isTTY;
-    }
-    static #resolveStorePath() {
-        if (process.env["TSTYCHE_STORE_PATH"] != null) {
-            return Path.resolve(process.env["TSTYCHE_STORE_PATH"]);
-        }
-        if (process.platform === "darwin") {
-            return Path.resolve(os.homedir(), "Library", "TSTyche");
-        }
-        if (process.env["LocalAppData"] != null) {
-            return Path.resolve(process.env["LocalAppData"], "TSTyche");
-        }
-        if (process.env["XDG_DATA_HOME"] != null) {
-            return Path.resolve(process.env["XDG_DATA_HOME"], "TSTyche");
-        }
-        return Path.resolve(os.homedir(), ".local", "share", "TSTyche");
-    }
-    static #resolveTimeout() {
-        if (process.env["TSTYCHE_TIMEOUT"] != null) {
-            return Number(process.env["TSTYCHE_TIMEOUT"]);
-        }
-        return 30;
-    }
-    static #resolveTypeScriptPath() {
-        let moduleId = "typescript";
-        if (process.env["TSTYCHE_TYPESCRIPT_PATH"] != null) {
-            moduleId = process.env["TSTYCHE_TYPESCRIPT_PATH"];
-        }
-        let resolvedPath;
-        try {
-            resolvedPath = createRequire(import.meta.url).resolve(moduleId);
-        }
-        catch {
-        }
-        return resolvedPath;
-    }
-}
-
 var Color;
 (function (Color) {
     Color["Reset"] = "0";
@@ -134,8 +37,10 @@ var Color;
 })(Color || (Color = {}));
 
 class Scribbler {
+    #indentStep = "  ";
     #newLine;
     #noColor;
+    #notEmptyLineRegex = /^(?!$)/gm;
     constructor(options) {
         this.#newLine = options?.newLine ?? "\n";
         this.#noColor = options?.noColor ?? false;
@@ -152,9 +57,7 @@ class Scribbler {
         return ["\u001B[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
     }
     #indentEachLine(lines, level) {
-        const indentStep = "  ";
-        const notEmptyLineRegExp = /^(?!$)/gm;
-        return lines.replaceAll(notEmptyLineRegExp, indentStep.repeat(level));
+        return lines.replace(this.#notEmptyLineRegex, this.#indentStep.repeat(level));
     }
     render(element) {
         if (element != null) {
@@ -245,49 +148,6 @@ class Line {
     }
 }
 
-class Logger {
-    #noColor;
-    #scribbler;
-    #stderr;
-    #stdout;
-    constructor(options) {
-        this.#noColor = options?.noColor ?? Environment.noColor;
-        this.#stderr = options?.stderr ?? process.stderr;
-        this.#stdout = options?.stdout ?? process.stdout;
-        this.#scribbler = new Scribbler({ noColor: this.#noColor });
-    }
-    eraseLastLine() {
-        this.#stdout.write("\u001B[1A\u001B[0K");
-    }
-    #write(stream, body) {
-        const elements = Array.isArray(body) ? body : [body];
-        for (const element of elements) {
-            if (element.$$typeof !== Symbol.for("tstyche:scribbler")) {
-                return;
-            }
-            stream.write(this.#scribbler.render(element));
-        }
-    }
-    writeError(body) {
-        this.#write(this.#stderr, body);
-    }
-    writeMessage(body) {
-        this.#write(this.#stdout, body);
-    }
-    writeWarning(body) {
-        this.#write(this.#stderr, body);
-    }
-}
-
-class Reporter {
-    resolvedConfig;
-    logger;
-    constructor(resolvedConfig) {
-        this.resolvedConfig = resolvedConfig;
-        this.logger = new Logger();
-    }
-}
-
 function addsPackageStepText(compilerVersion, installationPath) {
     return (Scribbler.createElement(Line, null,
         Scribbler.createElement(Text, { color: "90" }, "adds"),
@@ -302,6 +162,31 @@ function describeNameText(name, indent = 0) {
     return Scribbler.createElement(Line, { indent: indent + 1 }, name);
 }
 
+class Path {
+    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("./")) {
+            relativePath = `./${relativePath}`;
+        }
+        return Path.normalizeSlashes(relativePath);
+    }
+    static resolve(...filePaths) {
+        return Path.normalizeSlashes(path.resolve(...filePaths));
+    }
+}
+
 class CodeSpanText {
     props;
     constructor(props) {
@@ -312,7 +197,7 @@ class CodeSpanText {
         const { character: markedCharacter, line: markedLine } = this.props.file.getLineAndCharacterOfPosition(this.props.start);
         const firstLine = Math.max(markedLine - 2, 0);
         const lastLine = Math.min(firstLine + 5, lastLineInFile);
-        const lineNumberMaxWidth = `${lastLine + 1}`.length;
+        const lineNumberMaxWidth = String(lastLine + 1).length;
         const codeSpan = [];
         for (let index = firstLine; index <= lastLine; index++) {
             const lineStart = this.props.file.getPositionOfLineAndCharacter(index, 0);
@@ -320,7 +205,7 @@ class CodeSpanText {
                 ? this.props.file.text.length
                 : this.props.file.getPositionOfLineAndCharacter(index + 1, 0);
             const lineNumberText = String(index + 1);
-            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replaceAll("\t", " ");
+            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
             if (index === markedLine) {
                 codeSpan.push(Scribbler.createElement(Line, null,
                     Scribbler.createElement(Text, { color: "31" }, ">"),
@@ -609,6 +494,125 @@ function helpText(optionDefinitions, tstycheVersion) {
         Scribbler.createElement(Line, null)));
 }
 
+class Environment {
+    static #isCi = Environment.#resolveIsCi();
+    static #noColor = Environment.#resolveNoColor();
+    static #noInteractive = Environment.#resolveNoInteractive();
+    static #storePath = Environment.#resolveStorePath();
+    static #timeout = Environment.#resolveTimeout();
+    static #typescriptPath = Environment.#resolveTypeScriptPath();
+    static get isCi() {
+        return Environment.#isCi;
+    }
+    static get noColor() {
+        return Environment.#noColor;
+    }
+    static get noInteractive() {
+        return Environment.#noInteractive;
+    }
+    static get storePath() {
+        return Environment.#storePath;
+    }
+    static get timeout() {
+        return Environment.#timeout;
+    }
+    static get typescriptPath() {
+        return Environment.#typescriptPath;
+    }
+    static #resolveIsCi() {
+        if (process.env["CI"] != null) {
+            return process.env["CI"] !== "";
+        }
+        return false;
+    }
+    static #resolveNoColor() {
+        if (process.env["TSTYCHE_NO_COLOR"] != null) {
+            return process.env["TSTYCHE_NO_COLOR"] !== "";
+        }
+        if (process.env["NO_COLOR"] != null) {
+            return process.env["NO_COLOR"] !== "";
+        }
+        return false;
+    }
+    static #resolveNoInteractive() {
+        if (process.env["TSTYCHE_NO_INTERACTIVE"] != null) {
+            return process.env["TSTYCHE_NO_INTERACTIVE"] !== "";
+        }
+        return !process.stdout.isTTY;
+    }
+    static #resolveStorePath() {
+        if (process.env["TSTYCHE_STORE_PATH"] != null) {
+            return Path.resolve(process.env["TSTYCHE_STORE_PATH"]);
+        }
+        if (process.platform === "darwin") {
+            return Path.resolve(os.homedir(), "Library", "TSTyche");
+        }
+        if (process.env["LocalAppData"] != null) {
+            return Path.resolve(process.env["LocalAppData"], "TSTyche");
+        }
+        if (process.env["XDG_DATA_HOME"] != null) {
+            return Path.resolve(process.env["XDG_DATA_HOME"], "TSTyche");
+        }
+        return Path.resolve(os.homedir(), ".local", "share", "TSTyche");
+    }
+    static #resolveTimeout() {
+        if (process.env["TSTYCHE_TIMEOUT"] != null) {
+            return Number(process.env["TSTYCHE_TIMEOUT"]);
+        }
+        return 30;
+    }
+    static #resolveTypeScriptPath() {
+        let moduleId = "typescript";
+        if (process.env["TSTYCHE_TYPESCRIPT_PATH"] != null) {
+            moduleId = process.env["TSTYCHE_TYPESCRIPT_PATH"];
+        }
+        let resolvedPath;
+        try {
+            resolvedPath = Path.normalizeSlashes(createRequire(import.meta.url).resolve(moduleId));
+        }
+        catch {
+        }
+        return resolvedPath;
+    }
+}
+
+class OutputService {
+    #noColor;
+    #scribbler;
+    #stderr;
+    #stdout;
+    constructor(options) {
+        this.#noColor = options?.noColor ?? Environment.noColor;
+        this.#stderr = options?.stderr ?? process.stderr;
+        this.#stdout = options?.stdout ?? process.stdout;
+        this.#scribbler = new Scribbler({ noColor: this.#noColor });
+    }
+    clearTerminal() {
+        this.#stdout.write("\u001B[2J\u001B[3J\u001B[H");
+    }
+    eraseLastLine() {
+        this.#stdout.write("\u001B[1A\u001B[0K");
+    }
+    #write(stream, body) {
+        const elements = Array.isArray(body) ? body : [body];
+        for (const element of elements) {
+            if (element.$$typeof !== Symbol.for("tstyche:scribbler")) {
+                return;
+            }
+            stream.write(this.#scribbler.render(element));
+        }
+    }
+    writeError(body) {
+        this.#write(this.#stderr, body);
+    }
+    writeMessage(body) {
+        this.#write(this.#stdout, body);
+    }
+    writeWarning(body) {
+        this.#write(this.#stderr, body);
+    }
+}
+
 class RowText {
     props;
     constructor(props) {
@@ -670,8 +674,8 @@ class DurationText {
         const minutes = Math.floor(duration / 60);
         const seconds = duration % 60;
         return (Scribbler.createElement(Text, null,
-            minutes > 0 ? `${minutes}m ` : undefined,
-            `${Math.round(seconds * 10) / 10}s`));
+            minutes > 0 ? `${String(minutes)}m ` : undefined,
+            `${String(Math.round(seconds * 10) / 10)}s`));
     }
 }
 class MatchText {
@@ -807,11 +811,30 @@ function usesCompilerStepText(compilerVersion, tsconfigFilePath, options) {
         Scribbler.createElement(Line, null)));
 }
 
+function watchModeUsageText() {
+    const usageText = Object.entries({ a: "run all tests", x: "exit" }).map(([key, action]) => {
+        return (Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, { color: "90" }, "Press"),
+            Scribbler.createElement(Text, null, ` ${key} `),
+            Scribbler.createElement(Text, { color: "90" }, `to ${action}.`)));
+    });
+    return (Scribbler.createElement(Text, null, usageText));
+}
+
+class Reporter {
+    resolvedConfig;
+    outputService;
+    constructor(resolvedConfig) {
+        this.resolvedConfig = resolvedConfig;
+        this.outputService = new OutputService();
+    }
+}
+
 class SummaryReporter extends Reporter {
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "end":
-                this.logger.writeMessage(summaryText({
+            case "run:end":
+                this.outputService.writeMessage(summaryText({
                     duration: payload.result.timing.duration,
                     expectCount: payload.result.expectCount,
                     fileCount: payload.result.fileCount,
@@ -867,21 +890,30 @@ class ThoroughReporter extends Reporter {
     #hasReportedAdds = false;
     #hasReportedError = false;
     #isFileViewExpanded = false;
+    #seenDeprecations = new Set();
     get #isLastFile() {
         return this.#fileCount === 0;
     }
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "start":
-                this.#isFileViewExpanded = payload.result.testFiles.length === 1;
+            case "deprecation:info":
+                for (const diagnostic of payload.diagnostics) {
+                    if (!this.#seenDeprecations.has(diagnostic.text.toString())) {
+                        this.#fileView.addMessage(diagnosticText(diagnostic));
+                        this.#seenDeprecations.add(diagnostic.text.toString());
+                    }
+                }
+                break;
+            case "run:start":
+                this.#isFileViewExpanded = payload.result.testFiles.length === 1 && this.resolvedConfig.watch !== true;
                 break;
             case "store:info":
-                this.logger.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+                this.outputService.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
                 this.#hasReportedAdds = true;
                 break;
             case "store:error":
                 for (const diagnostic of payload.diagnostics) {
-                    this.logger.writeError(diagnosticText(diagnostic));
+                    this.outputService.writeError(diagnosticText(diagnostic));
                 }
                 break;
             case "target:start":
@@ -894,7 +926,7 @@ class ThoroughReporter extends Reporter {
             case "project:info":
                 if (this.#currentCompilerVersion !== payload.compilerVersion
                     || this.#currentProjectConfigFilePath !== payload.projectConfigFilePath) {
-                    this.logger.writeMessage(usesCompilerStepText(payload.compilerVersion, payload.projectConfigFilePath, {
+                    this.outputService.writeMessage(usesCompilerStepText(payload.compilerVersion, payload.projectConfigFilePath, {
                         prependEmptyLine: this.#currentCompilerVersion != null && !this.#hasReportedAdds
                             && !this.#hasReportedError,
                     }));
@@ -905,12 +937,12 @@ class ThoroughReporter extends Reporter {
                 break;
             case "project:error":
                 for (const diagnostic of payload.diagnostics) {
-                    this.logger.writeError(diagnosticText(diagnostic));
+                    this.outputService.writeError(diagnosticText(diagnostic));
                 }
                 break;
             case "file:start":
                 if (!Environment.noInteractive) {
-                    this.logger.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
+                    this.outputService.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
                 }
                 this.#fileCount--;
                 this.#hasReportedError = false;
@@ -922,12 +954,12 @@ class ThoroughReporter extends Reporter {
                 break;
             case "file:end":
                 if (!Environment.noInteractive) {
-                    this.logger.eraseLastLine();
+                    this.outputService.eraseLastLine();
                 }
-                this.logger.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
-                this.logger.writeMessage(this.#fileView.getViewText({ appendEmptyLine: this.#isLastFile }));
+                this.outputService.writeMessage(fileStatusText(payload.result.status, payload.result.testFile));
+                this.outputService.writeMessage(this.#fileView.getViewText({ appendEmptyLine: this.#isLastFile }));
                 if (this.#fileView.hasErrors) {
-                    this.logger.writeError(this.#fileView.getMessages());
+                    this.outputService.writeError(this.#fileView.getMessages());
                     this.#hasReportedError = true;
                 }
                 this.#fileView.reset();
@@ -980,6 +1012,19 @@ class ThoroughReporter extends Reporter {
     }
 }
 
+class WatchModeReporter extends Reporter {
+    handleEvent([eventName]) {
+        switch (eventName) {
+            case "run:start":
+                this.outputService.clearTerminal();
+                break;
+            case "run:end":
+                this.outputService.writeMessage(watchModeUsageText());
+                break;
+        }
+    }
+}
+
 class ResultTiming {
     end = Date.now();
     start = Date.now();
@@ -1079,11 +1124,11 @@ class ResultManager {
     #testResult;
     handleEvent([eventName, payload]) {
         switch (eventName) {
-            case "start":
+            case "run:start":
                 this.#result = payload.result;
                 this.#result.timing.start = Date.now();
                 break;
-            case "end":
+            case "run:end":
                 this.#result.timing.end = Date.now();
                 this.#result = undefined;
                 break;
@@ -1318,7 +1363,7 @@ class Diagnostic {
     static fromDiagnostics(diagnostics, compiler) {
         return diagnostics.map((diagnostic) => {
             const category = "error";
-            const code = `ts(${diagnostic.code})`;
+            const code = `ts(${String(diagnostic.code)})`;
             let origin;
             const text = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
             if (Diagnostic.isTsDiagnosticWithLocation(diagnostic)) {
@@ -1333,30 +1378,20 @@ class Diagnostic {
     }
     static fromError(text, error) {
         const messageText = Array.isArray(text) ? text : [text];
-        if (error instanceof Error) {
-            if (error.cause != null) {
-                messageText.push(this.#normalizeMessage(String(error.cause)));
-            }
-            messageText.push(this.#normalizeMessage(String(error.message)));
-            if (error.stack != null) {
-                const stackLines = error.stack
-                    .split("\n")
-                    .slice(1)
-                    .map((line) => line.trimStart());
-                messageText.push(...stackLines);
+        if (error instanceof Error && error.stack != null) {
+            if (messageText.length > 1) {
+                messageText.push("");
             }
+            const stackLines = error.stack
+                .split("\n")
+                .map((line) => line.trimStart());
+            messageText.push(...stackLines);
         }
         return Diagnostic.error(messageText);
     }
     static isTsDiagnosticWithLocation(diagnostic) {
         return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
     }
-    static #normalizeMessage(text) {
-        if (text.endsWith(".")) {
-            return text;
-        }
-        return `${text}.`;
-    }
     static warning(text, origin) {
         return new Diagnostic(text, "warning", origin);
     }
@@ -1410,10 +1445,8 @@ class TestMember {
     }
     validate() {
         const diagnostics = [];
-        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()' helper.`;
+        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()'.`;
         switch (this.brand) {
-            case "expect":
-                break;
             case "describe":
                 for (const member of this.members) {
                     if (member.brand === "expect") {
@@ -1426,6 +1459,7 @@ class TestMember {
                 }
                 break;
             case "test":
+            case "expect":
                 for (const member of this.members) {
                     if (member.brand !== "expect") {
                         diagnostics.push(Diagnostic.error(getText(member.node), {
@@ -1609,8 +1643,11 @@ class TestTree {
 class CollectService {
     compiler;
     matcherIdentifiers = [
+        "toBe",
         "toBeAny",
         "toBeAssignable",
+        "toBeAssignableTo",
+        "toBeAssignableWith",
         "toBeBigInt",
         "toBeBoolean",
         "toBeNever",
@@ -1659,7 +1696,11 @@ class CollectService {
                 if (matcherNode == null || !this.#isMatcherNode(matcherNode)) {
                     return;
                 }
-                parent.members.push(new Assertion(meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode));
+                const assertion = new Assertion(meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
+                parent.members.push(assertion);
+                this.compiler.forEachChild(node, (node) => {
+                    this.#collectTestMembers(node, identifiers, assertion);
+                });
                 return;
             }
         }
@@ -1726,6 +1767,7 @@ class PrimitiveTypeMatcher {
 
 class RelationMatcherBase {
     typeChecker;
+    relationExplanationVerb = "is";
     constructor(typeChecker) {
         this.typeChecker = typeChecker;
     }
@@ -1733,8 +1775,12 @@ class RelationMatcherBase {
         const sourceTypeText = this.typeChecker.typeToString(sourceType);
         const targetTypeText = this.typeChecker.typeToString(targetType);
         return isNot
-            ? [Diagnostic.error(`Type '${targetTypeText}' is ${this.relationExplanationText} type '${sourceTypeText}'.`)]
-            : [Diagnostic.error(`Type '${targetTypeText}' is not ${this.relationExplanationText} type '${sourceTypeText}'.`)];
+            ? [
+                Diagnostic.error(`Type '${sourceTypeText}' ${this.relationExplanationVerb} ${this.relationExplanationText} type '${targetTypeText}'.`),
+            ]
+            : [
+                Diagnostic.error(`Type '${sourceTypeText}' ${this.relationExplanationVerb} not ${this.relationExplanationText} type '${targetTypeText}'.`),
+            ];
     }
     match(sourceType, targetType, isNot) {
         const isMatch = this.typeChecker.isTypeRelatedTo(sourceType, targetType, this.relation);
@@ -1745,9 +1791,19 @@ class RelationMatcherBase {
     }
 }
 
-class ToBeAssignable extends RelationMatcherBase {
+class ToBe extends RelationMatcherBase {
+    relation = this.typeChecker.relation.identity;
+    relationExplanationText = "identical to";
+}
+
+class ToBeAssignableTo extends RelationMatcherBase {
     relation = this.typeChecker.relation.assignable;
     relationExplanationText = "assignable to";
+}
+
+class ToBeAssignableWith extends RelationMatcherBase {
+    relation = this.typeChecker.relation.assignable;
+    relationExplanationText = "assignable with";
     match(sourceType, targetType, isNot) {
         const isMatch = this.typeChecker.isTypeRelatedTo(targetType, sourceType, this.relation);
         return {
@@ -1757,11 +1813,6 @@ class ToBeAssignable extends RelationMatcherBase {
     }
 }
 
-class ToEqual extends RelationMatcherBase {
-    relation = this.typeChecker.relation.identity;
-    relationExplanationText = "identical to";
-}
-
 class ToHaveProperty {
     compiler;
     typeChecker;
@@ -1805,7 +1856,8 @@ class ToHaveProperty {
 
 class ToMatch extends RelationMatcherBase {
     relation = this.typeChecker.relation.subtype;
-    relationExplanationText = "a subtype of";
+    relationExplanationText = "match";
+    relationExplanationVerb = "does";
 }
 
 class ToRaiseError {
@@ -1825,16 +1877,16 @@ class ToRaiseError {
                 Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
                 ...Diagnostic.fromDiagnostics(source.diagnostics, this.compiler),
             ];
-            const text = `${sourceText} raised ${source.diagnostics.length === 1 ? "a" : source.diagnostics.length} type error${source.diagnostics.length === 1 ? "" : "s"}.`;
+            const text = `${sourceText} raised ${source.diagnostics.length === 1 ? "a" : String(source.diagnostics.length)} type error${source.diagnostics.length === 1 ? "" : "s"}.`;
             return [Diagnostic.error(text).add({ related })];
         }
         if (source.diagnostics.length !== targetTypes.length) {
             const expectedText = source.diagnostics.length > targetTypes.length
-                ? `only ${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`
-                : `${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`;
+                ? `only ${String(targetTypes.length)} type error${targetTypes.length === 1 ? "" : "s"}`
+                : `${String(targetTypes.length)} type error${targetTypes.length === 1 ? "" : "s"}`;
             const foundText = source.diagnostics.length > targetTypes.length
-                ? `${source.diagnostics.length}`
-                : `only ${source.diagnostics.length}`;
+                ? String(source.diagnostics.length)
+                : `only ${String(source.diagnostics.length)}`;
             const related = [
                 Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
                 ...Diagnostic.fromDiagnostics(source.diagnostics, this.compiler),
@@ -1852,7 +1904,7 @@ class ToRaiseError {
             if (!isNot && !isMatch) {
                 const expectedText = this.#isStringLiteralType(argument)
                     ? `matching substring '${argument.value}'`
-                    : `with code ${argument.value}`;
+                    : `with code ${String(argument.value)}`;
                 const related = [
                     Diagnostic.error("The raised type error:"),
                     ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
@@ -1863,7 +1915,7 @@ class ToRaiseError {
             if (isNot && isMatch) {
                 const expectedText = this.#isStringLiteralType(argument)
                     ? `matching substring '${argument.value}'`
-                    : `with code ${argument.value}`;
+                    : `with code ${String(argument.value)}`;
                 const related = [
                     Diagnostic.error("The raised type error:"),
                     ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
@@ -1907,8 +1959,11 @@ class ToRaiseError {
 class Expect {
     compiler;
     typeChecker;
+    toBe;
     toBeAny;
     toBeAssignable;
+    toBeAssignableTo;
+    toBeAssignableWith;
     toBeBigInt;
     toBeBoolean;
     toBeNever;
@@ -1927,8 +1982,11 @@ class Expect {
     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 ToBeAssignable(this.typeChecker);
+        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);
@@ -1940,7 +1998,7 @@ class Expect {
         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 ToEqual(this.typeChecker);
+        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);
@@ -1970,6 +2028,10 @@ class Expect {
         switch (matcherNameText) {
             case "toBeAssignable":
             case "toEqual":
+                this.#onDeprecatedMatcher(assertion);
+            case "toBe":
+            case "toBeAssignableTo":
+            case "toBeAssignableWith":
             case "toMatch":
                 if (assertion.source[0] == null) {
                     this.#onSourceArgumentMustBeProvided(assertion, expectResult);
@@ -2037,6 +2099,22 @@ class Expect {
                 return;
         }
     }
+    #onDeprecatedMatcher(assertion) {
+        const matcherNameText = assertion.matcherName.getText();
+        const text = [
+            `'.${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(),
+        };
+        EventEmitter.dispatch([
+            "deprecation:info",
+            { diagnostics: [Diagnostic.warning(text, origin)] },
+        ]);
+    }
     #onKeyArgumentMustBeOfType(node, expectResult) {
         const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
         const text = `An argument for 'key' must be of type 'string | number | symbol', received: '${receivedTypeText}'.`;
@@ -2266,19 +2344,19 @@ class ProjectService {
 class TestTreeWorker {
     resolvedConfig;
     compiler;
+    #cancellationToken;
     #expect;
     #fileResult;
     #hasOnly;
     #position;
-    #signal;
     constructor(resolvedConfig, compiler, expect, options) {
         this.resolvedConfig = resolvedConfig;
         this.compiler = compiler;
+        this.#cancellationToken = options.cancellationToken;
         this.#expect = expect;
         this.#fileResult = options.fileResult;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
-        this.#signal = options.signal;
     }
     #resolveRunMode(mode, member) {
         if (member.flags & 1) {
@@ -2302,7 +2380,7 @@ class TestTreeWorker {
     }
     visit(members, runMode, parentResult) {
         for (const member of members) {
-            if (this.#signal?.aborted === true) {
+            if (this.#cancellationToken?.isCancellationRequested === true) {
                 break;
             }
             const validationError = member.validate();
@@ -2330,6 +2408,7 @@ class TestTreeWorker {
         }
     }
     #visitAssertion(assertion, runMode, parentResult) {
+        this.visit(assertion.members, runMode, parentResult);
         const expectResult = new ExpectResult(assertion, parentResult);
         EventEmitter.dispatch(["expect:start", { result: expectResult }]);
         runMode = this.#resolveRunMode(runMode, assertion);
@@ -2452,8 +2531,8 @@ class TestFileRunner {
         this.#collectService = new CollectService(compiler);
         this.#projectService = new ProjectService(compiler);
     }
-    run(testFile, signal) {
-        if (signal?.aborted === true) {
+    run(testFile, cancellationToken) {
+        if (cancellationToken?.isCancellationRequested === true) {
             return;
         }
         const testFilePath = fileURLToPath(testFile);
@@ -2461,11 +2540,11 @@ class TestFileRunner {
         this.#projectService.openFile(testFilePath, undefined, this.resolvedConfig.rootPath);
         const fileResult = new FileResult(testFile);
         EventEmitter.dispatch(["file:start", { result: fileResult }]);
-        this.#runFile(testFilePath, fileResult, position, signal);
+        this.#runFile(testFilePath, fileResult, position, cancellationToken);
         EventEmitter.dispatch(["file:end", { result: fileResult }]);
         this.#projectService.closeFile(testFilePath);
     }
-    #runFile(testFilePath, fileResult, position, signal) {
+    #runFile(testFilePath, fileResult, position, cancellationToken) {
         const languageService = this.#projectService.getLanguageService(testFilePath);
         if (!languageService) {
             return;
@@ -2509,10 +2588,10 @@ class TestFileRunner {
         }
         const expect = new Expect(this.compiler, typeChecker);
         const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, expect, {
+            cancellationToken,
             fileResult,
             hasOnly: testTree.hasOnly,
             position,
-            signal,
         });
         testTreeWorker.visit(testTree.members, 0, undefined);
     }
@@ -2530,32 +2609,160 @@ class TaskRunner {
             this.#resultManager.handleEvent(event);
         });
     }
-    async run(testFiles, target, signal) {
+    async run(testFiles, target, cancellationToken) {
         const result = new Result(this.resolvedConfig, testFiles);
-        EventEmitter.dispatch(["start", { result }]);
+        EventEmitter.dispatch(["run:start", { result }]);
         for (const versionTag of target) {
             const targetResult = new TargetResult(versionTag, testFiles);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
-            const compiler = await this.#storeService.load(versionTag, signal);
+            const compiler = await this.#storeService.load(versionTag, cancellationToken);
             if (compiler) {
                 const testFileRunner = new TestFileRunner(this.resolvedConfig, compiler);
                 for (const testFile of testFiles) {
-                    testFileRunner.run(testFile, signal);
+                    testFileRunner.run(testFile, cancellationToken);
                 }
             }
             EventEmitter.dispatch(["target:end", { result: targetResult }]);
         }
-        EventEmitter.dispatch(["end", { result }]);
+        EventEmitter.dispatch(["run:end", { result }]);
         return result;
     }
 }
 
-class TSTyche {
+class CancellationToken {
+    #isCancelled = false;
+    get isCancellationRequested() {
+        return this.#isCancelled;
+    }
+    cancel() {
+        if (!this.#isCancelled) {
+            this.#isCancelled = true;
+        }
+    }
+}
+
+class InputService {
+    #stdin;
+    constructor(options) {
+        this.#stdin = options?.stdin ?? process.stdin;
+        this.#stdin.setRawMode?.(true);
+        this.#stdin.setEncoding("utf8");
+        this.#stdin.on("data", (key) => {
+            EventEmitter.dispatch(["input:info", { key }]);
+        });
+        this.#stdin.unref();
+    }
+    dispose() {
+        this.#stdin.setRawMode?.(false);
+    }
+}
+
+class Watcher {
     resolvedConfig;
     #abortController = new AbortController();
+    #changedTestFiles = new Set();
+    #inputService;
+    #runCallback;
+    #runChangedDebounced;
+    #selectService;
+    #testFiles;
+    #watcher;
+    constructor(resolvedConfig, runCallback, selectService, testFiles) {
+        this.resolvedConfig = resolvedConfig;
+        this.#inputService = new InputService();
+        this.#runCallback = runCallback;
+        this.#runChangedDebounced = this.#debounce(this.#runChanged, 100);
+        this.#selectService = selectService;
+        this.#testFiles = new Set(testFiles);
+        EventEmitter.addHandler(([eventName, payload]) => {
+            if (eventName === "input:info") {
+                switch (payload.key) {
+                    case "\u000D":
+                    case "\u0041":
+                    case "\u0061":
+                        void this.#runAll();
+                        break;
+                    case "\u0003":
+                    case "\u0004":
+                    case "\u001B":
+                    case "\u0058":
+                    case "\u0078":
+                        this.#abortController.abort();
+                        break;
+                }
+            }
+        });
+    }
+    #debounce(target, delay) {
+        let timeout;
+        return function (...args) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => {
+                target.apply(this, args);
+            }, delay);
+        };
+    }
+    #onChanged(fileName) {
+        if (this.#testFiles.has(fileName)) {
+            this.#changedTestFiles.add(fileName);
+            return;
+        }
+        if (this.#selectService.isTestFile(fileName)) {
+            this.#changedTestFiles.add(fileName);
+            this.#testFiles.add(fileName);
+        }
+    }
+    #onExit() {
+        this.#inputService.dispose();
+        this.#watcher = undefined;
+    }
+    #onRemoved(fileName) {
+        this.#changedTestFiles.delete(fileName);
+        this.#testFiles.delete(fileName);
+    }
+    async #runAll() {
+        await this.#runCallback([...this.#testFiles].sort());
+    }
+    async #runChanged() {
+        await this.#runCallback([...this.#changedTestFiles].sort());
+        this.#changedTestFiles.clear();
+    }
+    async watch() {
+        this.#watcher = fs.watch(this.resolvedConfig.rootPath, { recursive: true, signal: this.#abortController.signal });
+        await this.#runAll();
+        try {
+            for await (const event of this.#watcher) {
+                if (event.filename != null) {
+                    const filePath = Path.resolve(this.resolvedConfig.rootPath, event.filename);
+                    if (!existsSync(filePath)) {
+                        this.#onRemoved(filePath);
+                        continue;
+                    }
+                    this.#onChanged(filePath);
+                }
+                if (this.#changedTestFiles.size !== 0) {
+                    await this.#runChangedDebounced();
+                }
+            }
+        }
+        catch (error) {
+            if (error != null && typeof error === "object" && "name" in error && error.name === "AbortError") ;
+            else {
+                throw error;
+            }
+        }
+        finally {
+            this.#onExit();
+        }
+    }
+}
+
+class TSTyche {
+    resolvedConfig;
+    #cancellationToken = new CancellationToken();
     #storeService;
     #taskRunner;
-    static version = "1.0.0";
+    static version = "2.0.0-beta.0";
     constructor(resolvedConfig, storeService) {
         this.resolvedConfig = resolvedConfig;
         this.#storeService = storeService;
@@ -2567,17 +2774,27 @@ class TSTyche {
             if (eventName.includes("error") || eventName.includes("fail")) {
                 if ("diagnostics" in payload
                     && payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
-                    process.exitCode = 1;
+                    if (this.resolvedConfig.watch !== true) {
+                        process.exitCode = 1;
+                    }
                     if (this.resolvedConfig.failFast) {
-                        this.#abortController.abort();
+                        this.#cancellationToken.cancel();
                     }
                 }
             }
         });
-        const outputHandlers = [new ThoroughReporter(this.resolvedConfig), new SummaryReporter(this.resolvedConfig)];
-        for (const outputHandler of outputHandlers) {
+        const reporters = [
+            new ThoroughReporter(this.resolvedConfig),
+        ];
+        if (this.resolvedConfig.watch === true) {
+            reporters.push(new WatchModeReporter(this.resolvedConfig));
+        }
+        else {
+            reporters.push(new SummaryReporter(this.resolvedConfig));
+        }
+        for (const reporter of reporters) {
             EventEmitter.addHandler((event) => {
-                outputHandler.handleEvent(event);
+                reporter.handleEvent(event);
             });
         }
     }
@@ -2593,7 +2810,12 @@ class TSTyche {
         });
     }
     async run(testFiles) {
-        await this.#taskRunner.run(this.#normalizePaths(testFiles), this.resolvedConfig.target, this.#abortController.signal);
+        await this.#taskRunner.run(this.#normalizePaths(testFiles), this.resolvedConfig.target, this.#cancellationToken);
+    }
+    async watch(testFiles, selectService) {
+        const runCallback = async (testFiles) => this.run(testFiles);
+        const watcher = new Watcher(this.resolvedConfig, runCallback, selectService, testFiles);
+        await watcher.watch();
     }
 }
 
@@ -2692,6 +2914,12 @@ class OptionDefinitionsMap {
             group: 2,
             name: "version",
         },
+        {
+            brand: "boolean",
+            description: "Watch for changes and rerun related tests files.",
+            group: 2,
+            name: "watch",
+        },
     ];
     static for(optionGroup) {
         const definitionMap = new Map();
@@ -2712,13 +2940,13 @@ class OptionDiagnosticText {
     doubleQuotesExpected() {
         return "String literal with double quotes expected.";
     }
-    expectsArgument(optionName) {
-        optionName = this.#optionName(optionName);
-        return `Option '${optionName}' expects an argument.`;
-    }
     expectsListItemType(optionName, optionBrand) {
         return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
     }
+    expectsValue(optionName) {
+        optionName = this.#optionName(optionName);
+        return `Option '${optionName}' expects a value.`;
+    }
     fileDoesNotExist(filePath) {
         return `The specified path '${filePath}' does not exist.`;
     }
@@ -2730,9 +2958,9 @@ class OptionDiagnosticText {
                 return optionName;
         }
     }
-    requiresArgumentType(optionName, optionBrand) {
+    requiresValueType(optionName, optionBrand) {
         optionName = this.#optionName(optionName);
-        return `Option '${optionName}' requires an argument of type ${optionBrand}.`;
+        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
     }
     unknownOption(optionName) {
         return `Unknown option '${optionName}'.`;
@@ -2743,6 +2971,9 @@ class OptionDiagnosticText {
         }
         return `TypeScript version '${value}' is not supported.`;
     }
+    watchCannotBeEnabledInCiEnvironment() {
+        return "The watch mode cannot be enabled in a continuous integration environment.";
+    }
 }
 
 class OptionUsageText {
@@ -2762,7 +2993,7 @@ class OptionUsageText {
                 const supportedTagsText = `Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`;
                 switch (this.#optionGroup) {
                     case 2:
-                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.", supportedTagsText);
+                        usageText.push("Value for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.", supportedTagsText);
                         break;
                     case 4:
                         usageText.push("Item of the 'target' list must be a supported version tag.", supportedTagsText);
@@ -2771,7 +3002,7 @@ class OptionUsageText {
                 break;
             }
             default:
-                usageText.push(this.#optionDiagnosticText.requiresArgumentType(optionName, optionBrand));
+                usageText.push(this.#optionDiagnosticText.requiresValueType(optionName, optionBrand));
         }
         return usageText;
     }
@@ -2795,18 +3026,26 @@ class OptionValidator {
             case "config":
             case "rootPath":
                 if (!existsSync(optionValue)) {
-                    const text = [this.#optionDiagnosticText.fileDoesNotExist(optionValue)];
-                    this.#onDiagnostic(Diagnostic.error(text, origin));
+                    this.#onDiagnostic(Diagnostic.error([
+                        this.#optionDiagnosticText.fileDoesNotExist(optionValue),
+                    ], origin));
                 }
                 break;
             case "target":
-                if (!(await this.#storeService.validateTag(optionValue))) {
+                if (await this.#storeService.validateTag(optionValue) === false) {
                     this.#onDiagnostic(Diagnostic.error([
                         this.#optionDiagnosticText.versionIsNotSupported(optionValue),
                         ...(await this.#optionUsageText.get(optionName, optionBrand)),
                     ], origin));
                 }
                 break;
+            case "watch":
+                if (Environment.isCi) {
+                    this.#onDiagnostic(Diagnostic.error([
+                        this.#optionDiagnosticText.watchCannotBeEnabledInCiEnvironment(),
+                    ], origin));
+                }
+                break;
         }
     }
 }
@@ -2830,9 +3069,9 @@ class CommandLineOptionsWorker {
         this.#optionUsageText = new OptionUsageText(2, this.#storeService);
         this.#optionValidator = new OptionValidator(2, this.#storeService, this.#onDiagnostic);
     }
-    async #onExpectsArgumentDiagnostic(optionDefinition) {
+    async #onExpectsValue(optionDefinition) {
         const text = [
-            this.#optionDiagnosticText.expectsArgument(optionDefinition.name),
+            this.#optionDiagnosticText.expectsValue(optionDefinition.name),
             ...(await this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand)),
         ];
         this.#onDiagnostic(Diagnostic.error(text));
@@ -2868,13 +3107,14 @@ class CommandLineOptionsWorker {
                 this.#commandLineOptions[optionDefinition.name] = true;
                 break;
             case "boolean":
+                await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
                     index++;
                 }
                 break;
             case "list":
-                if (optionValue != null) {
+                if (optionValue !== "") {
                     const optionValues = optionValue
                         .split(",")
                         .map((value) => value.trim())
@@ -2886,10 +3126,10 @@ class CommandLineOptionsWorker {
                     index++;
                     break;
                 }
-                await this.#onExpectsArgumentDiagnostic(optionDefinition);
+                await this.#onExpectsValue(optionDefinition);
                 break;
             case "string":
-                if (optionValue != null) {
+                if (optionValue !== "") {
                     if (optionDefinition.name === "config") {
                         optionValue = Path.resolve(optionValue);
                     }
@@ -2898,16 +3138,13 @@ class CommandLineOptionsWorker {
                     index++;
                     break;
                 }
-                await this.#onExpectsArgumentDiagnostic(optionDefinition);
+                await this.#onExpectsValue(optionDefinition);
                 break;
         }
         return index;
     }
-    #resolveOptionValue(optionValue) {
-        if (optionValue == null || optionValue.startsWith("-")) {
-            return;
-        }
-        return optionValue;
+    #resolveOptionValue(target = "") {
+        return target.startsWith("-") ? "" : target;
     }
 }
 
@@ -3032,7 +3269,7 @@ class ConfigFileOptionsWorker {
         };
         const text = isListItem
             ? this.#optionDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
-            : this.#optionDiagnosticText.requiresArgumentType(optionDefinition.name, optionDefinition.brand);
+            : this.#optionDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand);
         this.#onDiagnostic(Diagnostic.error(text, origin));
         return;
     }
@@ -3105,9 +3342,9 @@ class ConfigService {
     static get defaultOptions() {
         return ConfigService.#defaultOptions;
     }
-    #onDiagnostic = (diagnostic) => {
+    #onDiagnostic(diagnostic) {
         EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
-    };
+    }
     async parseCommandLine(commandLineArgs) {
         this.#commandLineOptions = {};
         this.#pathMatch = [];
@@ -3137,28 +3374,6 @@ class ConfigService {
         };
         return mergedOptions;
     }
-    selectTestFiles() {
-        const { pathMatch, rootPath, testFileMatch } = this.resolveConfig();
-        let testFilePaths = this.compiler.sys.readDirectory(rootPath, ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"], undefined, testFileMatch);
-        if (pathMatch.length > 0) {
-            testFilePaths = testFilePaths.filter((testFilePath) => pathMatch.some((match) => {
-                const relativeTestFilePath = Path.relative("", testFilePath);
-                return relativeTestFilePath.toLowerCase().includes(match.toLowerCase());
-            }));
-        }
-        if (testFilePaths.length === 0) {
-            const text = [
-                "No test files were selected using current configuration.",
-                `Root path:       ${rootPath}`,
-                `Test file match: ${testFileMatch.join(", ")}`,
-            ];
-            if (pathMatch.length > 0) {
-                text.push(`Path match:      ${pathMatch.join(", ")}`);
-            }
-            this.#onDiagnostic(Diagnostic.error(text));
-        }
-        return testFilePaths;
-    }
 }
 
 var OptionBrand;
@@ -3175,57 +3390,169 @@ var OptionGroup;
     OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
 })(OptionGroup || (OptionGroup = {}));
 
+class GlobPattern {
+    static #reservedCharacterRegex = /[^\w\s/]/g;
+    static #parse(pattern, usageTarget) {
+        const segments = pattern.split("/");
+        let resultPattern = "\\.";
+        let optionalSegmentCount = 0;
+        for (const segment of segments) {
+            if (segment === "**") {
+                resultPattern += "(\\/(?!(node_modules)(\\/|$))[^./][^/]*)*?";
+                continue;
+            }
+            if (usageTarget === "directories") {
+                resultPattern += "(";
+                optionalSegmentCount++;
+            }
+            resultPattern += `\\/`;
+            const segmentPattern = segment.replace(GlobPattern.#reservedCharacterRegex, GlobPattern.#replaceReservedCharacter);
+            if (segmentPattern !== segment) {
+                resultPattern += "(?!(node_modules)(\\/|$))";
+            }
+            resultPattern += segmentPattern;
+        }
+        resultPattern += ")?".repeat(optionalSegmentCount);
+        return resultPattern;
+    }
+    static #replaceReservedCharacter(match, offset) {
+        switch (match) {
+            case "*":
+                return (offset === 0) ? "([^./][^/]*)?" : "([^/]*)?";
+            case "?":
+                return (offset === 0) ? "[^./]" : "[^/]";
+            default:
+                return `\\${match}`;
+        }
+    }
+    static toRegex(patterns, usageTarget) {
+        const patternText = patterns.map((pattern) => `(${GlobPattern.#parse(pattern, usageTarget)})`).join("|");
+        return new RegExp(`^(${patternText})$`);
+    }
+}
+
+class SelectService {
+    resolvedConfig;
+    #includeDirectoryRegex;
+    #includeFileRegex;
+    constructor(resolvedConfig) {
+        this.resolvedConfig = resolvedConfig;
+        this.#includeDirectoryRegex = GlobPattern.toRegex(resolvedConfig.testFileMatch, "directories");
+        this.#includeFileRegex = GlobPattern.toRegex(resolvedConfig.testFileMatch, "files");
+    }
+    #isDirectoryIncluded(directoryPath) {
+        return this.#includeDirectoryRegex.test(directoryPath);
+    }
+    #isFileIncluded(filePath) {
+        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));
+    }
+    #onDiagnostic(diagnostic) {
+        EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
+    }
+    async selectFiles() {
+        const currentPath = ".";
+        const testFilePaths = [];
+        await this.#visitDirectory(currentPath, testFilePaths);
+        if (testFilePaths.length === 0) {
+            const text = [
+                "No test files were selected using current configuration.",
+                `Root path:       ${this.resolvedConfig.rootPath}`,
+                `Test file match: ${this.resolvedConfig.testFileMatch.join(", ")}`,
+            ];
+            if (this.resolvedConfig.pathMatch.length > 0) {
+                text.push(`Path match:      ${this.resolvedConfig.pathMatch.join(", ")}`);
+            }
+            this.#onDiagnostic(Diagnostic.error(text));
+        }
+        return testFilePaths.sort();
+    }
+    async #visitDirectory(currentPath, testFilePaths) {
+        const targetPath = Path.join(this.resolvedConfig.rootPath, currentPath);
+        let entries = [];
+        try {
+            entries = await fs.readdir(targetPath, { withFileTypes: true });
+        }
+        catch {
+        }
+        for (const entry of entries) {
+            let entryMeta;
+            if (entry.isSymbolicLink()) {
+                try {
+                    entryMeta = await fs.stat([targetPath, entry.name].join("/"));
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                entryMeta = entry;
+            }
+            const entryPath = [currentPath, entry.name].join("/");
+            if (entryMeta.isDirectory() && this.#isDirectoryIncluded(entryPath)) {
+                await this.#visitDirectory(entryPath, testFilePaths);
+                continue;
+            }
+            if (entryMeta.isFile() && this.#isFileIncluded(entryPath)) {
+                testFilePaths.push([targetPath, entry.name].join("/"));
+            }
+        }
+    }
+}
+
 class ManifestWorker {
     #manifestFileName = "store-manifest.json";
     #manifestFilePath;
     #onDiagnostic;
-    #prune;
     #registryUrl = new URL("https://registry.npmjs.org");
     #storePath;
     #timeout = Environment.timeout * 1000;
     #version = "1";
-    constructor(storePath, onDiagnostic, prune) {
+    constructor(storePath, onDiagnostic) {
         this.#storePath = storePath;
         this.#onDiagnostic = onDiagnostic;
         this.#manifestFilePath = Path.join(storePath, this.#manifestFileName);
-        this.#prune = prune;
     }
-    async #create(signal) {
-        const manifest = await this.#load(signal);
+    async #create() {
+        const manifest = await this.#load();
         if (manifest != null) {
             await this.persist(manifest);
         }
         return manifest;
     }
-    async #fetch(signal) {
+    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, */*" },
-                signal,
-            }, (result) => {
-                if (result.statusCode !== 200) {
-                    reject(new Error(`Request failed with status code ${String(result.statusCode)}.`));
-                    result.resume();
+                timeout: this.#timeout,
+            }, (response) => {
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Request failed with status code ${String(response.statusCode)}.`));
+                    response.resume();
                     return;
                 }
-                result.setEncoding("utf8");
+                response.setEncoding("utf8");
                 let rawData = "";
-                result.on("data", (chunk) => {
+                response.on("data", (chunk) => {
                     rawData += chunk;
                 });
-                result.on("end", () => {
-                    try {
-                        const packageMetadata = JSON.parse(rawData);
-                        resolve(packageMetadata);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
+                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) {
@@ -3234,7 +3561,7 @@ class ManifestWorker {
         }
         return false;
     }
-    async #load(signal, options = { quite: false }) {
+    async #load(options) {
         const manifest = {
             $version: this.#version,
             lastUpdated: Date.now(),
@@ -3242,27 +3569,21 @@ class ManifestWorker {
             versions: [],
         };
         let packageMetadata;
-        const abortController = new AbortController();
-        const timeoutSignal = AbortSignal.timeout(this.#timeout);
-        timeoutSignal.addEventListener("abort", () => {
-            abortController.abort(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`);
-        }, { once: true });
-        signal?.addEventListener("abort", () => {
-            abortController.abort("Fetch got canceled by request.");
-        }, { once: true });
         try {
-            packageMetadata = await this.#fetch(abortController.signal);
+            packageMetadata = await this.#fetch();
         }
         catch (error) {
-            if (!options.quite) {
-                const text = [`Failed to fetch metadata of the 'typescript' package from '${this.#registryUrl.toString()}'.`];
-                if (error instanceof Error && error.name !== "AbortError") {
-                    text.push("Might be there is an issue with the registry or the network connection.");
-                }
-                this.#onDiagnostic(Diagnostic.fromError(text, error));
+            if (options?.quite === true) {
+                return;
             }
-        }
-        if (!packageMetadata) {
+            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.`);
+            }
+            else {
+                text.push("Might be there is an issue with the registry or the network connection.");
+            }
+            this.#onDiagnostic(Diagnostic.fromError(text, error));
             return;
         }
         manifest.versions = Object.keys(packageMetadata.versions)
@@ -3283,10 +3604,10 @@ class ManifestWorker {
         }
         return manifest;
     }
-    async open(signal, options) {
+    async open(options) {
         let manifest;
         if (!existsSync(this.#manifestFilePath)) {
-            return this.#create(signal);
+            return this.#create();
         }
         let manifestText;
         try {
@@ -3304,12 +3625,12 @@ class ManifestWorker {
         catch {
         }
         if (manifest == null || manifest.$version !== this.#version) {
-            await this.#prune();
-            return this.#create(signal);
+            await fs.rm(this.#storePath, { force: true, recursive: true });
+            return this.#create();
         }
         if (this.isOutdated(manifest) || options?.refresh === true) {
             const quite = options?.refresh !== true;
-            const freshManifest = await this.#load(signal, { quite });
+            const freshManifest = await this.#load({ quite });
             if (freshManifest != null) {
                 await this.persist(freshManifest);
                 return freshManifest;
@@ -3348,11 +3669,11 @@ class Lock {
         }
         const waitStartTime = Date.now();
         while (isLocked) {
-            if (options.signal?.aborted === true) {
+            if (options.cancellationToken?.isCancellationRequested === true) {
                 break;
             }
             if (Date.now() - waitStartTime > options.timeout) {
-                options.onDiagnostic?.(`Lock wait timeout of ${options.timeout / 1000}s was exceeded.`);
+                options.onDiagnostic?.(`Lock wait timeout of ${String(options.timeout / 1000)}s was exceeded.`);
                 break;
             }
             await Lock.#sleep(1000);
@@ -3377,51 +3698,55 @@ class PackageInstaller {
         this.#storePath = storePath;
         this.#onDiagnostic = onDiagnostic;
     }
-    async ensure(compilerVersion, signal) {
+    async ensure(compilerVersion, cancellationToken) {
         const installationPath = Path.join(this.#storePath, compilerVersion);
         const readyFilePath = Path.join(installationPath, this.#readyFileName);
+        const modulePath = Path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
+        if (existsSync(readyFilePath)) {
+            return modulePath;
+        }
         if (await Lock.isLocked(installationPath, {
+            cancellationToken,
             onDiagnostic: (text) => {
                 this.#onDiagnostic(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
             },
-            signal,
             timeout: this.#timeout,
         })) {
             return;
         }
-        if (!existsSync(readyFilePath)) {
-            EventEmitter.dispatch(["store:info", { compilerVersion, installationPath }]);
-            try {
-                await fs.mkdir(installationPath, { recursive: true });
-                const lock = new Lock(installationPath);
-                const packageJson = {
-                    name: "tstyche-typescript",
-                    version: compilerVersion,
-                    description: "Do not change. This package was generated by TSTyche",
-                    private: true,
-                    license: "MIT",
-                    dependencies: {
-                        typescript: compilerVersion,
-                    },
-                };
-                await fs.writeFile(Path.join(installationPath, "package.json"), JSON.stringify(packageJson, null, 2));
-                await this.#install(installationPath, signal);
-                await fs.writeFile(readyFilePath, "");
-                lock.release();
-            }
-            catch (error) {
-                this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
-            }
+        const lock = new Lock(installationPath);
+        EventEmitter.dispatch(["store:info", { compilerVersion, installationPath }]);
+        try {
+            await fs.mkdir(installationPath, { recursive: true });
+            const packageJson = {
+                name: "tstyche-typescript",
+                version: compilerVersion,
+                description: "Do not change. This package was generated by TSTyche",
+                private: true,
+                license: "MIT",
+                dependencies: {
+                    typescript: compilerVersion,
+                },
+            };
+            await fs.writeFile(Path.join(installationPath, "package.json"), JSON.stringify(packageJson, null, 2));
+            await this.#install(installationPath);
+            await fs.writeFile(readyFilePath, "");
+            return modulePath;
+        }
+        catch (error) {
+            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
+        }
+        finally {
+            lock.release();
         }
-        return Path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
+        return;
     }
-    async #install(cwd, signal) {
+    async #install(cwd) {
         const args = ["install", "--ignore-scripts", "--no-bin-links", "--no-package-lock"];
         return new Promise((resolve, reject) => {
             const spawnedNpm = spawn("npm", args, {
                 cwd,
                 shell: true,
-                signal,
                 stdio: "ignore",
                 timeout: this.#timeout,
             });
@@ -3433,9 +3758,9 @@ class PackageInstaller {
                     resolve();
                 }
                 if (signal != null) {
-                    reject(new Error(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`));
+                    reject(new Error(`setup timeout of ${String(this.#timeout / 1000)}s was exceeded`));
                 }
-                reject(new Error(`Process exited with code ${String(code)}.`));
+                reject(new Error(`process exited with code ${String(code)}`));
             });
         });
     }
@@ -3450,27 +3775,27 @@ class StoreService {
     constructor() {
         this.#storePath = Environment.storePath;
         this.#packageInstaller = new PackageInstaller(this.#storePath, this.#onDiagnostic);
-        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostic, this.prune);
+        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostic);
     }
-    async getSupportedTags(signal) {
-        await this.open(signal);
+    async getSupportedTags() {
+        await this.open();
         if (!this.#manifest) {
             return [];
         }
         return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions, "current"].sort();
     }
-    async install(tag, signal) {
+    async install(tag, cancellationToken) {
         if (tag === "current") {
             return;
         }
-        const version = await this.resolveTag(tag, signal);
+        const version = await this.resolveTag(tag);
         if (version == null) {
             this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
             return;
         }
-        return this.#packageInstaller.ensure(version, signal);
+        return this.#packageInstaller.ensure(version, cancellationToken);
     }
-    async load(tag, signal) {
+    async load(tag, cancellationToken) {
         let compilerInstance = this.#compilerInstanceCache.get(tag);
         if (compilerInstance != null) {
             return compilerInstance;
@@ -3480,7 +3805,7 @@ class StoreService {
             modulePath = Environment.typescriptPath;
         }
         else {
-            const version = await this.resolveTag(tag, signal);
+            const version = await this.resolveTag(tag);
             if (version == null) {
                 this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
                 return;
@@ -3489,7 +3814,7 @@ class StoreService {
             if (compilerInstance != null) {
                 return compilerInstance;
             }
-            modulePath = await this.#packageInstaller.ensure(version, signal);
+            modulePath = await this.#packageInstaller.ensure(version, cancellationToken);
         }
         if (modulePath != null) {
             compilerInstance = await this.#loadModule(modulePath);
@@ -3518,23 +3843,20 @@ class StoreService {
         }
         return module.exports;
     }
-    #onDiagnostic = (diagnostic) => {
+    #onDiagnostic(diagnostic) {
         EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
-    };
-    async open(signal) {
+    }
+    async open() {
         if (this.#manifest) {
             return;
         }
-        this.#manifest = await this.#manifestWorker.open(signal);
+        this.#manifest = await this.#manifestWorker.open();
     }
-    prune = async () => {
-        await fs.rm(this.#storePath, { force: true, recursive: true });
-    };
-    async resolveTag(tag, signal) {
+    async resolveTag(tag) {
         if (tag === "current") {
             return tag;
         }
-        await this.open(signal);
+        await this.open();
         if (!this.#manifest) {
             return;
         }
@@ -3543,16 +3865,16 @@ class StoreService {
         }
         return this.#manifest.resolutions[tag];
     }
-    async update(signal) {
-        await this.#manifestWorker.open(signal, { refresh: true });
+    async update() {
+        await this.#manifestWorker.open({ refresh: true });
     }
-    async validateTag(tag, signal) {
+    async validateTag(tag) {
         if (tag === "current") {
             return Environment.typescriptPath != null;
         }
-        await this.open(signal);
+        await this.open();
         if (!this.#manifest) {
-            return false;
+            return undefined;
         }
         if (this.#manifestWorker.isOutdated(this.#manifest, 60)
             && (!Version.isVersionTag(tag)
@@ -3568,27 +3890,30 @@ class StoreService {
 }
 
 class Cli {
-    #logger;
+    #cancellationToken = new CancellationToken();
+    #outputService;
     #storeService;
     constructor() {
-        this.#logger = new Logger();
+        this.#outputService = new OutputService();
         this.#storeService = new StoreService();
     }
     #onStartupEvent = ([eventName, payload]) => {
         switch (eventName) {
             case "store:info":
-                this.#logger.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+                this.#outputService.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
                 break;
             case "config:error":
+            case "select:error":
             case "store:error":
                 for (const diagnostic of payload.diagnostics) {
                     switch (diagnostic.category) {
                         case "error":
+                            this.#cancellationToken.cancel();
+                            this.#outputService.writeError(diagnosticText(diagnostic));
                             process.exitCode = 1;
-                            this.#logger.writeError(diagnosticText(diagnostic));
                             break;
                         case "warning":
-                            this.#logger.writeWarning(diagnosticText(diagnostic));
+                            this.#outputService.writeWarning(diagnosticText(diagnostic));
                             break;
                     }
                 }
@@ -3599,15 +3924,15 @@ class Cli {
         EventEmitter.addHandler(this.#onStartupEvent);
         if (commandLineArguments.includes("--help")) {
             const commandLineOptionDefinitions = OptionDefinitionsMap.for(2);
-            this.#logger.writeMessage(helpText(commandLineOptionDefinitions, TSTyche.version));
+            this.#outputService.writeMessage(helpText(commandLineOptionDefinitions, TSTyche.version));
             return;
         }
         if (commandLineArguments.includes("--prune")) {
-            await this.#storeService.prune();
+            await fs.rm(Environment.storePath, { force: true, recursive: true });
             return;
         }
         if (commandLineArguments.includes("--version")) {
-            this.#logger.writeMessage(formattedText(TSTyche.version));
+            this.#outputService.writeMessage(formattedText(TSTyche.version));
             return;
         }
         if (commandLineArguments.includes("--update")) {
@@ -3620,16 +3945,16 @@ class Cli {
         }
         const configService = new ConfigService(compiler, this.#storeService);
         await configService.parseCommandLine(commandLineArguments);
-        if (process.exitCode === 1) {
+        if (this.#cancellationToken.isCancellationRequested) {
             return;
         }
         await configService.readConfigFile();
-        if (process.exitCode === 1) {
+        if (this.#cancellationToken.isCancellationRequested) {
             return;
         }
         const resolvedConfig = configService.resolveConfig();
-        if (configService.commandLineOptions.showConfig === true) {
-            this.#logger.writeMessage(formattedText({
+        if (commandLineArguments.includes("--showConfig")) {
+            this.#outputService.writeMessage(formattedText({
                 noColor: Environment.noColor,
                 noInteractive: Environment.noInteractive,
                 storePath: Environment.storePath,
@@ -3639,27 +3964,33 @@ class Cli {
             }));
             return;
         }
-        if (configService.commandLineOptions.install === true) {
+        if (commandLineArguments.includes("--install")) {
             for (const tag of resolvedConfig.target) {
                 await this.#storeService.install(tag);
             }
             return;
         }
+        const selectService = new SelectService(resolvedConfig);
         let testFiles = [];
         if (resolvedConfig.testFileMatch.length !== 0) {
-            testFiles = configService.selectTestFiles();
+            testFiles = await selectService.selectFiles();
             if (testFiles.length === 0) {
                 return;
             }
-            if (configService.commandLineOptions.listFiles === true) {
-                this.#logger.writeMessage(formattedText(testFiles));
+            if (commandLineArguments.includes("--listFiles")) {
+                this.#outputService.writeMessage(formattedText(testFiles));
                 return;
             }
         }
         EventEmitter.removeHandler(this.#onStartupEvent);
         const tstyche = new TSTyche(resolvedConfig, this.#storeService);
-        await tstyche.run(testFiles);
+        if (resolvedConfig.watch === true) {
+            await tstyche.watch(testFiles, selectService);
+        }
+        else {
+            await tstyche.run(testFiles);
+        }
     }
 }
 
-export { Assertion, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, Expect, ExpectResult, FileResult, Line, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, Path, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, Version, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText };
+export { Assertion, CancellationToken, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, Expect, ExpectResult, FileResult, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, SelectService, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, Version, WatchModeReporter, Watcher, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText, watchModeUsageText };