tstyche 2.0.0 → 2.1.0

package/build/tstyche.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { createRequire } from 'node:module';
 import os from 'node:os';
-import { existsSync, writeFileSync, rmSync } from 'node:fs';
+import { watch, existsSync, writeFileSync, rmSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import vm from 'node:vm';
 import { spawn } from 'node:child_process';
@@ -613,12 +613,27 @@ function describeNameText(name, indent = 0) {
     return jsx(Line, { indent: indent + 1, children: name });
 }
 
-function CodeSpanText(diagnosticOrigin) {
+function BreadcrumbsText({ ancestor }) {
+    const text = [];
+    while ("name" in ancestor) {
+        text.unshift(" ❭ ", ancestor.name);
+        ancestor = ancestor.parent;
+    }
+    return jsx(Text, { color: "90", children: text.join("") });
+}
+function CodeLineText({ lineText, gutterWidth, lineNumberColor = "90", lineNumberText }) {
+    return (jsx(Line, { children: [jsx(Text, { color: lineNumberColor, children: lineNumberText.padStart(gutterWidth) }), jsx(Text, { color: "90", children: " | " }), lineText] }));
+}
+function SquiggleLineText({ gutterWidth, indentWidth = 0, squiggleWidth }) {
+    return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: "90", children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: "31", children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
+}
+function CodeSpanText({ diagnosticOrigin }) {
     const lastLineInFile = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.sourceFile.text.length).line;
-    const { character: markedCharacter, line: markedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
-    const firstLine = Math.max(markedLine - 2, 0);
+    const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
+    const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
+    const firstLine = Math.max(firstMarkedLine - 2, 0);
     const lastLine = Math.min(firstLine + 5, lastLineInFile);
-    const lineNumberMaxWidth = String(lastLine + 1).length;
+    const gutterWidth = String(lastLine + 1).length + 2;
     const codeSpan = [];
     for (let index = firstLine; index <= lastLine; index++) {
         const lineStart = diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index, 0);
@@ -627,18 +642,26 @@ function CodeSpanText(diagnosticOrigin) {
             : diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index + 1, 0);
         const lineNumberText = String(index + 1);
         const lineText = diagnosticOrigin.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
-        if (index === markedLine) {
-            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: "^" })] }));
+        if (index >= firstMarkedLine && index <= lastMarkedLine) {
+            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumberColor: "31", lineNumberText: lineNumberText, lineText: lineText }));
+            if (index === firstMarkedLine) {
+                const squiggleLength = index === lastMarkedLine
+                    ? lastMarkedLineCharacter - firstMarkedLineCharacter
+                    : lineText.length - firstMarkedLineCharacter;
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleWidth: squiggleLength }));
+            }
+            else if (index === lastMarkedLine) {
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleWidth: lastMarkedLineCharacter }));
+            }
+            else {
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleWidth: lineText.length }));
+            }
         }
         else {
-            codeSpan.push(jsx(Line, { children: [" ".repeat(2), jsx(Text, { color: "90", children: [lineNumberText.padStart(lineNumberMaxWidth), " | ", lineText || ""] })] }));
+            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumberText: lineNumberText, lineText: lineText }));
         }
     }
-    const breadcrumbs = diagnosticOrigin.breadcrumbs?.flatMap((ancestor) => [
-        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, { children: " " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: [":", String(markedLine + 1), ":", String(markedCharacter + 1)] }), breadcrumbs] }));
+    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: [":", String(firstMarkedLine + 1), ":", String(firstMarkedLineCharacter + 1)] }), diagnosticOrigin.assertion && jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertion.parent })] }));
     return (jsx(Text, { children: [codeSpan, jsx(Line, {}), location] }));
 }
 
@@ -647,7 +670,7 @@ function DiagnosticText({ diagnostic }) {
     const text = Array.isArray(diagnostic.text) ? diagnostic.text : [diagnostic.text];
     const message = text.map((text, index) => (jsx(Text, { children: [index === 1 ? jsx(Line, {}) : undefined, jsx(Line, { children: [text, code] })] })));
     const related = diagnostic.related?.map((relatedDiagnostic) => jsx(DiagnosticText, { diagnostic: relatedDiagnostic }));
-    const codeSpan = diagnostic.origin ? (jsx(Text, { children: [jsx(Line, {}), jsx(CodeSpanText, { ...diagnostic.origin })] })) : undefined;
+    const codeSpan = diagnostic.origin ? (jsx(Text, { children: [jsx(Line, {}), jsx(CodeSpanText, { diagnosticOrigin: diagnostic.origin })] })) : undefined;
     return (jsx(Text, { children: [message, codeSpan, jsx(Line, {}), jsx(Text, { indent: 2, children: related })] }));
 }
 function diagnosticText(diagnostic) {
@@ -790,21 +813,21 @@ class OutputService {
     eraseLastLine() {
         this.#stdout.write("\u001B[1A\u001B[0K");
     }
-    #write(stream, body) {
-        const elements = Array.isArray(body) ? body : [body];
+    #writeTo(stream, element) {
+        const elements = Array.isArray(element) ? element : [element];
         for (const element of elements) {
             stream.write(this.#scribbler.render(element));
         }
         this.#isClear = false;
     }
-    writeError(body) {
-        this.#write(this.#stderr, body);
+    writeError(element) {
+        this.#writeTo(this.#stderr, element);
     }
-    writeMessage(body) {
-        this.#write(this.#stdout, body);
+    writeMessage(element) {
+        this.#writeTo(this.#stdout, element);
     }
-    writeWarning(body) {
-        this.#write(this.#stderr, body);
+    writeWarning(element) {
+        this.#writeTo(this.#stderr, element);
     }
 }
 
@@ -814,10 +837,8 @@ function RowText({ label, text }) {
 function CountText({ failed, passed, skipped, todo, total }) {
     return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "31", children: [String(failed), " failed"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [String(skipped), " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: "35", children: [String(todo), " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "32", children: [String(passed), " passed"] }), jsx(Text, { children: ", " })] })) : undefined, jsx(Text, { children: [String(total), jsx(Text, { children: " total" })] })] }));
 }
-function DurationText({ duration }) {
-    const minutes = Math.floor(duration / 60);
-    const seconds = duration % 60;
-    return (jsx(Text, { children: [minutes > 0 ? `${String(minutes)}m ` : undefined, `${String(Math.round(seconds * 10) / 10)}s`] }));
+function DurationText({ seconds }) {
+    return jsx(Text, { children: `${String(Math.round(seconds * 10) / 10)}s` });
 }
 function MatchText({ text }) {
     if (typeof text === "string") {
@@ -835,7 +856,7 @@ function RanFilesText({ onlyMatch, pathMatch, skipMatch }) {
         testNameMatchText.push(jsx(Text, { children: [jsx(Text, { color: "90", children: "matching " }), jsx(MatchText, { text: onlyMatch })] }));
     }
     if (skipMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [onlyMatch == null ? undefined : jsx(Text, { color: "90", children: " and " }), jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
+        testNameMatchText.push(jsx(Text, { children: [onlyMatch != null ? jsx(Text, { color: "90", children: " and " }) : undefined, jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
     }
     let pathMatchText;
     if (pathMatch.length > 0) {
@@ -851,7 +872,7 @@ function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, s
     const fileCountText = (jsx(RowText, { label: "Test files", text: jsx(CountText, { failed: fileCount.failed, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
     const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
     const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
-    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { duration: duration / 1000 }) }), jsx(Line, {}), jsx(RanFilesText, { onlyMatch: onlyMatch, pathMatch: pathMatch, skipMatch: skipMatch })] }));
+    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) }), jsx(Line, {}), jsx(RanFilesText, { onlyMatch: onlyMatch, pathMatch: pathMatch, skipMatch: skipMatch })] }));
 }
 
 function StatusText({ status }) {
@@ -1155,7 +1176,6 @@ class WatchReporter extends Reporter {
 
 class CancellationToken {
     #isCancelled = false;
-    #handlers = new Set();
     #reason;
     get isCancellationRequested() {
         return this.#isCancelled;
@@ -1165,16 +1185,10 @@ class CancellationToken {
     }
     cancel(reason) {
         if (!this.#isCancelled) {
-            for (const handler of this.#handlers) {
-                handler(reason);
-            }
             this.#isCancelled = true;
             this.#reason = reason;
         }
     }
-    onCancellationRequested(handler) {
-        this.#handlers.add(handler);
-    }
     reset() {
         if (this.#isCancelled) {
             this.#isCancelled = false;
@@ -1188,10 +1202,10 @@ var CancellationReason;
     CancellationReason["ConfigChange"] = "configChange";
     CancellationReason["ConfigError"] = "configError";
     CancellationReason["FailFast"] = "failFast";
+    CancellationReason["WatchClose"] = "watchClose";
 })(CancellationReason || (CancellationReason = {}));
 
 class Watcher {
-    #abortController = new AbortController();
     #onChanged;
     #onRemoved;
     #recursive;
@@ -1204,34 +1218,28 @@ class Watcher {
         this.#recursive = options?.recursive;
     }
     close() {
-        this.#abortController.abort();
-    }
-    async watch() {
-        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);
-                    if (existsSync(filePath)) {
-                        await this.#onChanged(filePath);
-                    }
-                    else {
-                        await this.#onRemoved(filePath);
-                    }
+        this.#watcher?.close();
+    }
+    watch() {
+        this.#watcher = watch(this.#targetPath, { recursive: this.#recursive }, (_eventType, fileName) => {
+            if (fileName != null) {
+                const filePath = Path.resolve(this.#targetPath, fileName);
+                if (existsSync(filePath)) {
+                    this.#onChanged(filePath);
+                }
+                else {
+                    this.#onRemoved(filePath);
                 }
             }
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") ;
-        }
+        });
     }
 }
 
 class FileWatcher extends Watcher {
     constructor(targetPath, onChanged) {
-        const onChangedFile = async (filePath) => {
+        const onChangedFile = (filePath) => {
             if (filePath === targetPath) {
-                await onChanged();
+                onChanged();
             }
         };
         super(Path.dirname(targetPath), onChangedFile);
@@ -1239,29 +1247,33 @@ class FileWatcher extends Watcher {
 }
 
 class DiagnosticOrigin {
-    breadcrumbs;
+    assertion;
     end;
     sourceFile;
     start;
-    constructor(start, end, sourceFile, breadcrumbs) {
+    constructor(start, end, sourceFile, assertion) {
         this.start = start;
         this.end = end;
         this.sourceFile = sourceFile;
-        this.breadcrumbs = breadcrumbs;
+        this.assertion = assertion;
+    }
+    static fromAssertion(assertion) {
+        const node = assertion.matcherName;
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
     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);
+    static fromNode(node, assertion) {
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
 }
 
 class Diagnostic {
     category;
     code;
-    related;
     origin;
+    related;
     text;
     constructor(text, category, origin) {
         this.text = text;
@@ -1272,9 +1284,6 @@ class Diagnostic {
         if (options.code != null) {
             this.code = options.code;
         }
-        if (options.origin != null) {
-            this.origin = options.origin;
-        }
         if (options.related != null) {
             this.related = options.related;
         }
@@ -1283,16 +1292,22 @@ class Diagnostic {
     static error(text, origin) {
         return new Diagnostic(text, "error", origin);
     }
+    extendWith(text, origin) {
+        return new Diagnostic([this.text, text].flat(), this.category, origin ?? this.origin);
+    }
     static fromDiagnostics(diagnostics, compiler) {
         return diagnostics.map((diagnostic) => {
-            const category = "error";
             const code = `ts(${String(diagnostic.code)})`;
             let origin;
-            const text = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-            if (Diagnostic.isTsDiagnosticWithLocation(diagnostic)) {
+            if (Diagnostic.#isTsDiagnosticWithLocation(diagnostic)) {
                 origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file);
             }
-            return new Diagnostic(text, category, origin).add({ code });
+            let related;
+            if (diagnostic.relatedInformation != null) {
+                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, compiler);
+            }
+            const text = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+            return new Diagnostic(text, "error", origin).add({ code, related });
         });
     }
     static fromError(text, error) {
@@ -1306,7 +1321,7 @@ class Diagnostic {
         }
         return Diagnostic.error(messageText);
     }
-    static isTsDiagnosticWithLocation(diagnostic) {
+    static #isTsDiagnosticWithLocation(diagnostic) {
         return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
     }
     static warning(text, origin) {
@@ -1428,7 +1443,7 @@ class SelectService {
     isTestFile(filePath) {
         return this.#isFileIncluded(Path.relative(this.#resolvedConfig.rootPath, filePath));
     }
-    #onDiagnostic(diagnostic) {
+    #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
     }
     async selectFiles() {
@@ -1436,18 +1451,21 @@ class SelectService {
         const testFilePaths = [];
         await this.#visitDirectory(currentPath, testFilePaths);
         if (testFilePaths.length === 0) {
-            this.#onDiagnostic(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(this.#resolvedConfig)));
+            this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(this.#resolvedConfig)));
         }
         return testFilePaths.sort();
     }
     async #visitDirectory(currentPath, testFilePaths) {
         const targetPath = Path.join(this.#resolvedConfig.rootPath, currentPath);
-        let entries = [];
+        let entries;
         try {
             entries = await fs.readdir(targetPath, { withFileTypes: true });
         }
         catch {
         }
+        if (!entries) {
+            return;
+        }
         for (const entry of entries) {
             let entryMeta;
             if (entry.isSymbolicLink()) {
@@ -1455,12 +1473,14 @@ class SelectService {
                     entryMeta = await fs.stat([targetPath, entry.name].join("/"));
                 }
                 catch {
-                    continue;
                 }
             }
             else {
                 entryMeta = entry;
             }
+            if (!entryMeta) {
+                continue;
+            }
             const entryPath = [currentPath, entry.name].join("/");
             if (entryMeta.isDirectory() && this.#isDirectoryIncluded(entryPath)) {
                 await this.#visitDirectory(entryPath, testFilePaths);
@@ -1473,16 +1493,30 @@ class SelectService {
     }
 }
 
-class Timer {
+class Debounce {
+    #delay;
+    #onResolve;
+    #resolve;
     #timeout;
-    clear() {
+    constructor(delay, onResolve) {
+        this.#delay = delay;
+        this.#onResolve = onResolve;
+    }
+    clearTimeout() {
         clearTimeout(this.#timeout);
     }
-    set(callback, delay, arg) {
-        new Promise((resolve) => {
-            this.#timeout = setTimeout(resolve, delay, arg);
-        }).then(async (arg) => {
-            await callback(arg);
+    refreshTimeout() {
+        this.clearTimeout();
+        this.#timeout = setTimeout(() => {
+            this.#resolve?.(this.#onResolve());
+        }, this.#delay);
+    }
+    resolveWith(value) {
+        this.#resolve?.(value);
+    }
+    setup() {
+        return new Promise((resolve) => {
+            this.#resolve = resolve;
         });
     }
 }
@@ -1491,16 +1525,33 @@ class WatchService {
     #changedTestFiles = new Map();
     #inputService;
     #resolvedConfig;
-    #runCallback;
     #selectService;
-    #timer = new Timer();
     #watchers = [];
     #watchedTestFiles;
-    constructor(resolvedConfig, runCallback, selectService, testFiles) {
+    constructor(resolvedConfig, selectService, testFiles) {
         this.#resolvedConfig = resolvedConfig;
-        this.#runCallback = runCallback;
         this.#selectService = selectService;
         this.#watchedTestFiles = new Map(testFiles.map((testFile) => [testFile.path, testFile]));
+    }
+    #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["watch:error", { diagnostics: [diagnostic] }]);
+    }
+    async *watch(cancellationToken) {
+        const onResolve = () => {
+            const testFiles = [...this.#changedTestFiles.values()];
+            this.#changedTestFiles.clear();
+            return testFiles;
+        };
+        const debounce = new Debounce(100, onResolve);
+        const onClose = (reason) => {
+            debounce.clearTimeout();
+            this.#inputService?.close();
+            for (const watcher of this.#watchers) {
+                watcher.close();
+            }
+            cancellationToken.cancel(reason);
+            debounce.resolveWith([]);
+        };
         const onInput = (chunk) => {
             switch (chunk.toLowerCase()) {
                 case "\u0003":
@@ -1508,47 +1559,23 @@ class WatchService {
                 case "\u001B":
                 case "q":
                 case "x": {
-                    this.close();
+                    onClose("watchClose");
                     break;
                 }
                 case "\u000D":
                 case "\u0020":
                 case "a": {
-                    this.#runAll();
+                    debounce.clearTimeout();
+                    if (this.#watchedTestFiles.size !== 0) {
+                        debounce.resolveWith([...this.#watchedTestFiles.values()]);
+                    }
                     break;
                 }
             }
         };
         this.#inputService = new InputService(onInput);
-    }
-    close() {
-        this.#inputService.close();
-        this.#timer.clear();
-        for (const watcher of this.#watchers) {
-            watcher.close();
-        }
-    }
-    #onDiagnostic(diagnostic) {
-        EventEmitter.dispatch(["watch:error", { diagnostics: [diagnostic] }]);
-    }
-    #runAll() {
-        if (this.#watchedTestFiles.size !== 0) {
-            this.#runCallback([...this.#watchedTestFiles.values()]);
-        }
-    }
-    #runChanged() {
-        this.#timer.clear();
-        if (this.#changedTestFiles.size !== 0) {
-            const runCallback = async (changedTestFiles) => {
-                const testFiles = [...changedTestFiles.values()];
-                this.#changedTestFiles.clear();
-                await this.#runCallback(testFiles);
-            };
-            this.#timer.set(runCallback, 100, this.#changedTestFiles);
-        }
-    }
-    watch(cancellationToken) {
         const onChangedFile = (filePath) => {
+            debounce.refreshTimeout();
             let testFile = this.#watchedTestFiles.get(filePath);
             if (testFile != null) {
                 this.#changedTestFiles.set(filePath, testFile);
@@ -1558,26 +1585,35 @@ class WatchService {
                 this.#changedTestFiles.set(filePath, testFile);
                 this.#watchedTestFiles.set(filePath, testFile);
             }
-            this.#runChanged();
         };
         const onRemovedFile = (filePath) => {
             this.#changedTestFiles.delete(filePath);
             this.#watchedTestFiles.delete(filePath);
             if (this.#watchedTestFiles.size === 0) {
-                this.#onDiagnostic(Diagnostic.error(SelectDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
+                debounce.clearTimeout();
+                this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereLeft(this.#resolvedConfig)));
             }
         };
         this.#watchers.push(new Watcher(this.#resolvedConfig.rootPath, onChangedFile, onRemovedFile, { recursive: true }));
         const onChangedConfigFile = () => {
-            cancellationToken?.cancel("configChange");
+            onClose("configChange");
         };
         this.#watchers.push(new FileWatcher(this.#resolvedConfig.configFilePath, onChangedConfigFile));
-        return Promise.all(this.#watchers.map((watcher) => watcher.watch()));
+        for (const watcher of this.#watchers) {
+            watcher.watch();
+        }
+        while (!cancellationToken.isCancellationRequested) {
+            const testFiles = await debounce.setup();
+            if (testFiles.length > 0) {
+                yield testFiles;
+            }
+        }
     }
 }
 
 class TestMember {
     brand;
+    #compiler;
     diagnostics = new Set();
     flags;
     members = [];
@@ -1586,6 +1622,7 @@ class TestMember {
     parent;
     constructor(compiler, brand, node, parent, flags) {
         this.brand = brand;
+        this.#compiler = compiler;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
@@ -1605,23 +1642,20 @@ class TestMember {
             }
         }
     }
-    get ancestorNames() {
-        const ancestorNames = [];
-        let ancestor = this.parent;
-        while ("name" in ancestor) {
-            ancestorNames.unshift(ancestor.name);
-            ancestor = ancestor.parent;
-        }
-        return ancestorNames;
-    }
     validate() {
         const diagnostics = [];
         const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()'.`;
+        const getParentCallExpression = (node) => {
+            while (!this.#compiler.isCallExpression(node.parent)) {
+                node = node.parent;
+            }
+            return node.parent;
+        };
         switch (this.brand) {
             case "describe": {
                 for (const member of this.members) {
                     if (member.brand === "expect") {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
+                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
                     }
                 }
                 break;
@@ -1650,43 +1684,21 @@ class Assertion extends TestMember {
         this.isNot = notNode != null;
         this.matcherNode = matcherNode;
         this.modifierNode = modifierNode;
-        const argStart = this.source[0]?.getStart();
-        const argEnd = this.source[0]?.getEnd();
         for (const diagnostic of parent.diagnostics) {
-            if (diagnostic.start != null &&
-                argStart != null &&
-                argEnd != null &&
-                diagnostic.start >= argStart &&
-                diagnostic.start <= argEnd) {
+            if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
                 this.diagnostics.add(diagnostic);
                 parent.diagnostics.delete(diagnostic);
             }
         }
     }
-    get ancestorNames() {
-        const ancestorNames = [];
-        if ("ancestorNames" in this.parent) {
-            ancestorNames.push(...this.parent.ancestorNames);
-        }
-        if ("name" in this.parent) {
-            ancestorNames.push(this.parent.name);
-        }
-        return ancestorNames;
-    }
     get matcherName() {
         return this.matcherNode.expression.name;
     }
     get source() {
-        if (this.node.typeArguments != null) {
-            return this.node.typeArguments;
-        }
-        return this.node.arguments;
+        return this.node.typeArguments ?? this.node.arguments;
     }
     get target() {
-        if (this.matcherNode.typeArguments != null) {
-            return this.matcherNode.typeArguments;
-        }
-        return this.matcherNode.arguments;
+        return this.matcherNode.typeArguments ?? this.matcherNode.arguments;
     }
 }
 
@@ -1707,12 +1719,6 @@ class IdentifierLookup {
             namespace: undefined,
         };
     }
-    clone() {
-        return {
-            namedImports: { ...this.#identifiers.namedImports },
-            namespace: this.#identifiers.namespace,
-        };
-    }
     handleImportDeclaration(node) {
         if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
             node.importClause?.isTypeOnly !== true &&
@@ -1774,7 +1780,7 @@ class IdentifierLookup {
         else {
             identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
         }
-        if (identifierName == null) {
+        if (!identifierName) {
             return;
         }
         switch (identifierName) {
@@ -1808,40 +1814,10 @@ class TestTree {
 
 class CollectService {
     #compiler;
-    #matcherIdentifiers = [
-        "toBe",
-        "toBeAny",
-        "toBeAssignable",
-        "toBeAssignableTo",
-        "toBeAssignableWith",
-        "toBeBigInt",
-        "toBeBoolean",
-        "toBeNever",
-        "toBeNull",
-        "toBeNumber",
-        "toBeString",
-        "toBeSymbol",
-        "toBeUndefined",
-        "toBeUniqueSymbol",
-        "toBeUnknown",
-        "toBeVoid",
-        "toEqual",
-        "toHaveProperty",
-        "toMatch",
-        "toRaiseError",
-    ];
-    #modifierIdentifiers = ["type"];
-    #notIdentifier = "not";
     constructor(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);
-            });
-            return;
-        }
         if (this.#compiler.isCallExpression(node)) {
             const meta = identifiers.resolveTestMemberMeta(node);
             if (meta != null && (meta.brand === "describe" || meta.brand === "test")) {
@@ -1853,13 +1829,13 @@ class CollectService {
                 return;
             }
             if (meta != null && meta.brand === "expect") {
-                const modifierNode = this.#getMatchingChainNode(node, this.#modifierIdentifiers);
+                const modifierNode = this.#getChainedNode(node, "type");
                 if (!modifierNode) {
                     return;
                 }
-                const notNode = this.#getMatchingChainNode(modifierNode, [this.#notIdentifier]);
-                const matcherNode = this.#getMatchingChainNode(notNode ?? modifierNode, this.#matcherIdentifiers)?.parent;
-                if (matcherNode == null || !this.#isMatcherNode(matcherNode)) {
+                const notNode = this.#getChainedNode(modifierNode, "not");
+                const matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
+                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
                     return;
                 }
                 const assertion = new Assertion(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
@@ -1874,8 +1850,6 @@ class CollectService {
             identifiers.handleImportDeclaration(node);
             return;
         }
-        if (this.#compiler.isVariableDeclaration(node)) ;
-        if (this.#compiler.isBinaryExpression(node)) ;
         this.#compiler.forEachChild(node, (node) => {
             this.#collectTestMembers(node, identifiers, parent);
         });
@@ -1885,11 +1859,14 @@ class CollectService {
         this.#collectTestMembers(sourceFile, new IdentifierLookup(this.#compiler), testTree);
         return testTree;
     }
-    #getMatchingChainNode({ parent }, name) {
-        if (this.#compiler.isPropertyAccessExpression(parent) && name.includes(parent.name.getText())) {
-            return parent;
+    #getChainedNode({ parent }, name) {
+        if (!this.#compiler.isPropertyAccessExpression(parent)) {
+            return;
         }
-        return;
+        if (name != null && name !== parent.name.getText()) {
+            return;
+        }
+        return parent;
     }
     #isMatcherNode(node) {
         return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
@@ -1911,220 +1888,599 @@ var TestMemberFlags;
     TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
 })(TestMemberFlags || (TestMemberFlags = {}));
 
+class ExpectDiagnosticText {
+    static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
+        return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
+    }
+    static argumentMustBe(argumentNameText, expectedText) {
+        return `An argument for '${argumentNameText}' must be ${expectedText}.`;
+    }
+    static argumentMustBeProvided(argumentNameText) {
+        return `An argument for '${argumentNameText}' must be provided.`;
+    }
+    static componentAcceptsProps(isTypeNode) {
+        return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
+    }
+    static componentDoesNotAcceptProps(isTypeNode) {
+        return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
+    }
+    static matcherIsDeprecated(matcherNameText) {
+        return [
+            `The '.${matcherNameText}()' matcher is deprecated and will be removed in TSTyche 3.`,
+            "To learn more, visit https://tstyche.org/releases/tstyche-2",
+        ];
+    }
+    static matcherIsNotSupported(matcherNameText) {
+        return `The '.${matcherNameText}()' matcher is not supported.`;
+    }
+    static overloadGaveTheFollowingError(indexText, countText, signatureText) {
+        return `Overload ${indexText} of ${countText}, '${signatureText}', gave the following error.`;
+    }
+    static raisedTypeError(count = 1) {
+        return `The raised type error${count === 1 ? "" : "s"}:`;
+    }
+    static typeArgumentMustBe(argumentNameText, expectedText) {
+        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
+    }
+    static typeDidNotRaiseError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
+    }
+    static typeDidNotRaiseMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
+    }
+    static typeDoesNotHaveProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    }
+    static typeDoesMatch(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' does match type '${targetTypeText}'.`;
+    }
+    static typeDoesNotMatch(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' does not match type '${targetTypeText}'.`;
+    }
+    static typeHasProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' has property '${propertyNameText}'.`;
+    }
+    static typeIs(typeText) {
+        return `Type is '${typeText}'.`;
+    }
+    static typeIsAssignableTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
+    }
+    static typeIsAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
+    }
+    static typeIsIdenticalTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
+    }
+    static typeIsNotAssignableTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not assignable to type '${targetTypeText}'.`;
+    }
+    static typeIsNotAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
+    }
+    static typeIsNotCompatibleWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
+    }
+    static typeIsNotIdenticalTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
+    }
+    static typeRaisedError(isTypeNode, count, targetCount) {
+        let countText = "a";
+        if (count > 1 || targetCount > 1) {
+            countText = count > targetCount ? String(count) : `only ${String(count)}`;
+        }
+        return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
+    }
+    static typeRaisedMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
+    }
+    static typeRequiresProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' requires property '${propertyNameText}'.`;
+    }
+    static typesOfPropertyAreNotCompatible(propertyNameText) {
+        return `Types of property '${propertyNameText}' are not compatible.`;
+    }
+}
+
+class MatchWorker {
+    assertion;
+    #compiler;
+    #signatureCache = new Map();
+    #typeCache = new Map();
+    #typeChecker;
+    constructor(compiler, typeChecker, assertion) {
+        this.#compiler = compiler;
+        this.#typeChecker = typeChecker;
+        this.assertion = assertion;
+    }
+    checkIsAssignableTo(sourceNode, targetNode) {
+        const relation = this.#typeChecker.relation.assignable;
+        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
+    }
+    checkIsAssignableWith(sourceNode, targetNode) {
+        const relation = this.#typeChecker.relation.assignable;
+        return this.#checkIsRelatedTo(targetNode, sourceNode, relation);
+    }
+    checkIsIdenticalTo(sourceNode, targetNode) {
+        const relation = this.#typeChecker.relation.identity;
+        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
+    }
+    checkIsSubtype(sourceNode, targetNode) {
+        const relation = this.#typeChecker.relation.subtype;
+        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
+    }
+    #checkIsRelatedTo(sourceNode, targetNode, relation) {
+        const sourceType = this.getType(sourceNode);
+        const targetType = this.getType(targetNode);
+        return this.#typeChecker.isTypeRelatedTo(sourceType, targetType, relation);
+    }
+    extendsObjectType(type) {
+        const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
+        return this.#typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
+    }
+    getParameterType(signature, index) {
+        const parameter = signature.getDeclaration().parameters[index];
+        if (!parameter) {
+            return;
+        }
+        return this.#getTypeOfNode(parameter);
+    }
+    getSignatures(node) {
+        let signatures = this.#signatureCache.get(node);
+        if (!signatures) {
+            const type = this.getType(node);
+            signatures = type.getCallSignatures();
+            if (signatures.length === 0) {
+                signatures = type.getConstructSignatures();
+            }
+        }
+        return signatures;
+    }
+    getTypeText(node) {
+        const type = this.getType(node);
+        return this.#typeChecker.typeToString(type);
+    }
+    getType(node) {
+        return this.#compiler.isExpression(node) ? this.#getTypeOfNode(node) : this.#getTypeOfTypeNode(node);
+    }
+    #getTypeOfNode(node) {
+        let type = this.#typeCache.get(node);
+        if (!type) {
+            type = this.#typeChecker.getTypeAtLocation(node);
+        }
+        return type;
+    }
+    #getTypeOfTypeNode(node) {
+        let type = this.#typeCache.get(node);
+        if (!type) {
+            type = this.#typeChecker.getTypeFromTypeNode(node);
+        }
+        return type;
+    }
+    isAnyOrNeverType(type) {
+        return Boolean(type.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never));
+    }
+    isStringOrNumberLiteralType(type) {
+        return Boolean(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
+    }
+    isObjectType(type) {
+        return Boolean(type.flags & this.#compiler.TypeFlags.Object);
+    }
+    isUnionType(type) {
+        return Boolean(type.flags & this.#compiler.TypeFlags.Union);
+    }
+    isUniqueSymbolType(type) {
+        return Boolean(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
+    }
+    resolveDiagnosticOrigin(symbol, enclosingNode) {
+        if (symbol.valueDeclaration != null &&
+            (this.#compiler.isPropertySignature(symbol.valueDeclaration) ||
+                this.#compiler.isPropertyAssignment(symbol.valueDeclaration) ||
+                this.#compiler.isShorthandPropertyAssignment(symbol.valueDeclaration)) &&
+            symbol.valueDeclaration.getStart() >= enclosingNode.getStart() &&
+            symbol.valueDeclaration.getEnd() <= enclosingNode.getEnd()) {
+            return DiagnosticOrigin.fromNode(symbol.valueDeclaration.name, this.assertion);
+        }
+        return DiagnosticOrigin.fromNode(enclosingNode, this.assertion);
+    }
+}
+
 class PrimitiveTypeMatcher {
     #targetTypeFlag;
-    typeChecker;
-    constructor(typeChecker, targetTypeFlag) {
-        this.typeChecker = typeChecker;
+    constructor(targetTypeFlag) {
         this.#targetTypeFlag = targetTypeFlag;
     }
-    #explain(sourceType) {
-        const sourceTypeText = this.typeChecker.typeToString(sourceType);
-        return [Diagnostic.error(`The source type is '${sourceTypeText}'.`)];
+    #explain(matchWorker, sourceNode) {
+        const sourceTypeText = matchWorker.getTypeText(sourceNode);
+        const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+        return [Diagnostic.error(ExpectDiagnosticText.typeIs(sourceTypeText), origin)];
     }
-    match(sourceType) {
+    match(matchWorker, sourceNode) {
+        const sourceType = matchWorker.getType(sourceNode);
         const isMatch = Boolean(sourceType.flags & this.#targetTypeFlag);
         return {
-            explain: () => this.#explain(sourceType),
+            explain: () => this.#explain(matchWorker, sourceNode),
             isMatch,
         };
     }
 }
 
-class RelationMatcherBase {
-    relationExplanationVerb = "is";
-    typeChecker;
-    constructor(typeChecker) {
-        this.typeChecker = typeChecker;
-    }
-    explain(sourceType, targetType, isNot) {
-        const sourceTypeText = this.typeChecker.typeToString(sourceType);
-        const targetTypeText = this.typeChecker.typeToString(targetType);
-        return isNot
-            ? [
-                Diagnostic.error(`Type '${sourceTypeText}' ${this.relationExplanationVerb} ${this.relationExplanationText} type '${targetTypeText}'.`),
-            ]
-            : [
-                Diagnostic.error(`Type '${sourceTypeText}' ${this.relationExplanationVerb} not ${this.relationExplanationText} type '${targetTypeText}'.`),
-            ];
+class ToAcceptProps {
+    #compiler;
+    #typeChecker;
+    constructor(compiler, typeChecker) {
+        this.#compiler = compiler;
+        this.#typeChecker = typeChecker;
+    }
+    #explain(matchWorker, sourceNode, targetNode) {
+        const signatures = matchWorker.getSignatures(sourceNode);
+        return signatures.reduce((accumulator, signature, index) => {
+            let diagnostic;
+            const introText = matchWorker.assertion.isNot
+                ? ExpectDiagnosticText.componentAcceptsProps(this.#compiler.isTypeNode(sourceNode))
+                : ExpectDiagnosticText.componentDoesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
+            const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+            if (signatures.length > 1) {
+                const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
+                const overloadText = ExpectDiagnosticText.overloadGaveTheFollowingError(String(index + 1), String(signatures.length), signatureText);
+                diagnostic = Diagnostic.error([introText, overloadText], origin);
+            }
+            else {
+                diagnostic = Diagnostic.error([introText], origin);
+            }
+            const { diagnostics, isMatch } = this.#explainProperties(matchWorker, signature, targetNode, diagnostic);
+            if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
+                accumulator.push(...diagnostics);
+            }
+            return accumulator;
+        }, []);
+    }
+    #isOptionalProperty(symbol) {
+        return symbol.declarations?.every((declaration) => this.#compiler.isPropertySignature(declaration) && declaration.questionToken != null);
+    }
+    #checkProperties(matchWorker, sourceType, targetType) {
+        const check = (sourceType, targetType) => {
+            for (const targetProperty of targetType.getProperties()) {
+                const targetPropertyName = targetProperty.getName();
+                const sourceProperty = sourceType?.getProperty(targetPropertyName);
+                if (!sourceProperty) {
+                    return false;
+                }
+                if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
+                    return false;
+                }
+                const targetPropertyType = this.#typeChecker.getTypeOfSymbol(targetProperty);
+                const sourcePropertyType = this.#typeChecker.getTypeOfSymbol(sourceProperty);
+                if (!this.#typeChecker.isTypeAssignableTo(targetPropertyType, sourcePropertyType)) {
+                    return false;
+                }
+            }
+            if (sourceType != null) {
+                const sourceProperties = sourceType.getProperties();
+                for (const sourceProperty of sourceProperties) {
+                    const targetProperty = targetType.getProperty(sourceProperty.getName());
+                    if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+            return sourceType.types.some((sourceType) => check(sourceType, targetType));
+        }
+        return check(sourceType, targetType);
+    }
+    #explainProperties(matchWorker, signature, targetNode, diagnostic) {
+        const sourceType = matchWorker.getParameterType(signature, 0);
+        const sourceTypeText = sourceType != null ? this.#typeChecker.typeToString(sourceType) : "{}";
+        const targetType = matchWorker.getType(targetNode);
+        const targetTypeText = this.#typeChecker.typeToString(targetType);
+        const explain = (sourceType, targetType, diagnostic) => {
+            const sourceTypeText = sourceType != null ? this.#typeChecker.typeToString(sourceType) : "{}";
+            const diagnostics = [];
+            for (const targetProperty of targetType.getProperties()) {
+                const targetPropertyName = targetProperty.getName();
+                const sourceProperty = sourceType?.getProperty(targetPropertyName);
+                if (!sourceProperty) {
+                    const text = [
+                        ExpectDiagnosticText.typeIsNotCompatibleWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, targetPropertyName),
+                    ];
+                    const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
+                    diagnostics.push(diagnostic.extendWith(text, origin));
+                    continue;
+                }
+                if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
+                    const text = [
+                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, targetPropertyName),
+                    ];
+                    const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
+                    diagnostics.push(diagnostic.extendWith(text, origin));
+                    continue;
+                }
+                const targetPropertyType = this.#typeChecker.getTypeOfSymbol(targetProperty);
+                const sourcePropertyType = this.#typeChecker.getTypeOfSymbol(sourceProperty);
+                if (!this.#typeChecker.isTypeAssignableTo(targetPropertyType, sourcePropertyType)) {
+                    const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
+                    const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
+                    const text = [
+                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
+                        ExpectDiagnosticText.typeIsNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
+                    ];
+                    const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
+                    diagnostics.push(diagnostic.extendWith(text, origin));
+                }
+            }
+            if (sourceType != null) {
+                for (const sourceProperty of sourceType.getProperties()) {
+                    const sourcePropertyName = sourceProperty.getName();
+                    const targetProperty = targetType.getProperty(sourcePropertyName);
+                    if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
+                        const text = [
+                            ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                            ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, sourcePropertyName),
+                        ];
+                        diagnostics.push(diagnostic.extendWith(text));
+                    }
+                }
+            }
+            if (diagnostics.length === 0) {
+                const text = ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText);
+                diagnostics.push(diagnostic.extendWith(text));
+                return { diagnostics, isMatch: true };
+            }
+            return { diagnostics, isMatch: false };
+        };
+        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+            let accumulator = [];
+            const isMatch = sourceType.types.some((sourceType) => {
+                const text = matchWorker.assertion.isNot
+                    ? ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText);
+                const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
+                if (isMatch) {
+                    accumulator = diagnostics;
+                }
+                else {
+                    accumulator.push(...diagnostics);
+                }
+                return isMatch;
+            });
+            return { diagnostics: accumulator, isMatch };
+        }
+        return explain(sourceType, targetType, diagnostic);
     }
-    match(sourceType, targetType, isNot) {
-        const isMatch = this.typeChecker.isTypeRelatedTo(sourceType, targetType, this.relation);
+    match(matchWorker, sourceNode, targetNode, onDiagnostics) {
+        const diagnostics = [];
+        const signatures = matchWorker.getSignatures(sourceNode);
+        if (signatures.length === 0) {
+            const expectedText = "of a function or class type";
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        const targetType = matchWorker.getType(targetNode);
+        if (!matchWorker.isObjectType(targetType)) {
+            const expectedText = "of an object type";
+            const text = this.#compiler.isTypeNode(targetNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("target", expectedText);
+            const origin = DiagnosticOrigin.fromNode(targetNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        if (diagnostics.length > 0) {
+            onDiagnostics(diagnostics);
+            return;
+        }
+        const isMatch = signatures.some((signature) => {
+            const sourceType = matchWorker.getParameterType(signature, 0);
+            return this.#checkProperties(matchWorker, sourceType, targetType);
+        });
         return {
-            explain: () => this.explain(sourceType, targetType, isNot),
+            explain: () => this.#explain(matchWorker, sourceNode, targetNode),
             isMatch,
         };
     }
 }
 
+class RelationMatcherBase {
+    explain(matchWorker, sourceNode, targetNode) {
+        const sourceTypeText = matchWorker.getTypeText(sourceNode);
+        const targetTypeText = matchWorker.getTypeText(targetNode);
+        const text = matchWorker.assertion.isNot
+            ? this.explainText(sourceTypeText, targetTypeText)
+            : this.explainNotText(sourceTypeText, targetTypeText);
+        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+        return [Diagnostic.error(text, origin)];
+    }
+}
+
 class ToBe extends RelationMatcherBase {
-    relation = this.typeChecker.relation.identity;
-    relationExplanationText = "identical to";
+    explainText = ExpectDiagnosticText.typeIsIdenticalTo;
+    explainNotText = ExpectDiagnosticText.typeIsNotIdenticalTo;
+    match(matchWorker, sourceNode, targetNode) {
+        return {
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.checkIsIdenticalTo(sourceNode, targetNode),
+        };
+    }
 }
 
 class ToBeAssignableTo extends RelationMatcherBase {
-    relation = this.typeChecker.relation.assignable;
-    relationExplanationText = "assignable to";
+    explainText = ExpectDiagnosticText.typeIsAssignableTo;
+    explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
+    match(matchWorker, sourceNode, targetNode) {
+        return {
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.checkIsAssignableTo(sourceNode, targetNode),
+        };
+    }
 }
 
 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);
+    explainText = ExpectDiagnosticText.typeIsAssignableWith;
+    explainNotText = ExpectDiagnosticText.typeIsNotAssignableWith;
+    match(matchWorker, sourceNode, targetNode) {
         return {
-            explain: () => this.explain(sourceType, targetType, isNot),
-            isMatch,
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.checkIsAssignableWith(sourceNode, targetNode),
         };
     }
 }
 
 class ToHaveProperty {
-    compiler;
-    typeChecker;
-    constructor(compiler, typeChecker) {
-        this.compiler = compiler;
-        this.typeChecker = typeChecker;
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
     }
-    #explain(sourceType, targetType, isNot) {
-        const sourceTypeText = this.typeChecker.typeToString(sourceType);
-        let targetArgumentText;
-        if (this.#isStringOrNumberLiteralType(targetType)) {
-            targetArgumentText = String(targetType.value);
+    #explain(matchWorker, sourceNode, targetNode) {
+        const sourceTypeText = matchWorker.getTypeText(sourceNode);
+        const targetType = matchWorker.getType(targetNode);
+        let propertyNameText;
+        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+            propertyNameText = String(targetType.value);
         }
         else {
-            targetArgumentText = `[${this.compiler.unescapeLeadingUnderscores(targetType.symbol.escapedName)}]`;
+            propertyNameText = `[${this.#compiler.unescapeLeadingUnderscores(targetType.symbol.escapedName)}]`;
         }
-        return isNot
-            ? [Diagnostic.error(`Property '${targetArgumentText}' exists on type '${sourceTypeText}'.`)]
-            : [Diagnostic.error(`Property '${targetArgumentText}' does not exist on type '${sourceTypeText}'.`)];
-    }
-    #isStringOrNumberLiteralType(type) {
-        return Boolean(type.flags & this.compiler.TypeFlags.StringOrNumberLiteral);
+        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
+        return matchWorker.assertion.isNot
+            ? [Diagnostic.error(ExpectDiagnosticText.typeHasProperty(sourceTypeText, propertyNameText), origin)]
+            : [Diagnostic.error(ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
     }
-    match(sourceType, targetType, isNot) {
-        let targetArgumentText;
-        if (this.#isStringOrNumberLiteralType(targetType)) {
-            targetArgumentText = String(targetType.value);
+    match(matchWorker, sourceNode, targetNode, onDiagnostics) {
+        const diagnostics = [];
+        const sourceType = matchWorker.getType(sourceNode);
+        if (matchWorker.isAnyOrNeverType(sourceType) || !matchWorker.extendsObjectType(sourceType)) {
+            const expectedText = "of an object type";
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        const targetType = matchWorker.getType(targetNode);
+        let propertyNameText;
+        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+            propertyNameText = String(targetType.value);
+        }
+        else if (matchWorker.isUniqueSymbolType(targetType)) {
+            propertyNameText = this.#compiler.unescapeLeadingUnderscores(targetType.escapedName);
         }
         else {
-            targetArgumentText = this.compiler.unescapeLeadingUnderscores(targetType.escapedName);
+            const expectedText = "of type 'string | number | symbol'";
+            const text = ExpectDiagnosticText.argumentMustBe("key", expectedText);
+            const origin = DiagnosticOrigin.fromNode(targetNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        if (diagnostics.length > 0) {
+            onDiagnostics(diagnostics);
+            return;
         }
         const isMatch = sourceType.getProperties().some((property) => {
-            return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
+            return this.#compiler.unescapeLeadingUnderscores(property.escapedName) === propertyNameText;
         });
         return {
-            explain: () => this.#explain(sourceType, targetType, isNot),
+            explain: () => this.#explain(matchWorker, sourceNode, targetNode),
             isMatch,
         };
     }
 }
 
 class ToMatch extends RelationMatcherBase {
-    relation = this.typeChecker.relation.subtype;
-    relationExplanationText = "match";
-    relationExplanationVerb = "does";
+    explainText = ExpectDiagnosticText.typeDoesMatch;
+    explainNotText = ExpectDiagnosticText.typeDoesNotMatch;
+    match(matchWorker, sourceNode, targetNode) {
+        return {
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.checkIsSubtype(sourceNode, targetNode),
+        };
+    }
 }
 
 class ToRaiseError {
-    compiler;
-    typeChecker;
-    constructor(compiler, typeChecker) {
-        this.compiler = compiler;
-        this.typeChecker = typeChecker;
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
     }
-    #explain(source, targetTypes, isNot) {
-        const sourceText = this.compiler.isTypeNode(source.node) ? "Type expression" : "Expression";
-        if (source.diagnostics.length === 0) {
-            return [Diagnostic.error(`${sourceText} did not raise a type error.`)];
+    #explain(matchWorker, sourceNode, targetNodes) {
+        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+        if (matchWorker.assertion.diagnostics.size === 0) {
+            const text = ExpectDiagnosticText.typeDidNotRaiseError(isTypeNode);
+            return [Diagnostic.error(text, origin)];
         }
-        if (isNot && targetTypes.length === 0) {
-            const related = [
-                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" : 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 ${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
-                ? String(source.diagnostics.length)
-                : `only ${String(source.diagnostics.length)}`;
+        if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
+            const count = matchWorker.assertion.diagnostics.size;
+            const text = ExpectDiagnosticText.typeRaisedError(isTypeNode, count, targetNodes.length);
             const related = [
-                Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
-                ...Diagnostic.fromDiagnostics(source.diagnostics, this.compiler),
+                Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
+                ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics], this.#compiler),
             ];
-            const text = `Expected ${expectedText}, but ${foundText} ${source.diagnostics.length === 1 ? "was" : "were"} raised.`;
-            return [Diagnostic.error(text).add({ related })];
-        }
-        const diagnostics = [];
-        targetTypes.forEach((argument, index) => {
-            const diagnostic = source.diagnostics[index];
-            if (!diagnostic) {
-                return;
-            }
-            const isMatch = this.#matchExpectedError(diagnostic, argument);
-            if (!isNot && !isMatch) {
-                const expectedText = this.#isStringLiteralType(argument)
-                    ? `matching substring '${argument.value}'`
-                    : `with code ${String(argument.value)}`;
+            return [Diagnostic.error(text, origin).add({ related })];
+        }
+        return [...matchWorker.assertion.diagnostics].reduce((accumulator, diagnostic, index) => {
+            const targetNode = targetNodes[index];
+            const isMatch = this.#matchExpectedError(diagnostic, targetNode);
+            if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
+                const text = matchWorker.assertion.isNot
+                    ? ExpectDiagnosticText.typeRaisedMatchingError(isTypeNode)
+                    : ExpectDiagnosticText.typeDidNotRaiseMatchingError(isTypeNode);
+                const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
                 const related = [
-                    Diagnostic.error("The raised type error:"),
-                    ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
+                    Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
+                    ...Diagnostic.fromDiagnostics([diagnostic], this.#compiler),
                 ];
-                const text = `${sourceText} did not raise a type error ${expectedText}.`;
-                diagnostics.push(Diagnostic.error(text).add({ related }));
+                accumulator.push(Diagnostic.error(text, origin).add({ related }));
             }
-            if (isNot && isMatch) {
-                const expectedText = this.#isStringLiteralType(argument)
-                    ? `matching substring '${argument.value}'`
-                    : `with code ${String(argument.value)}`;
-                const related = [
-                    Diagnostic.error("The raised type error:"),
-                    ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
-                ];
-                const text = `${sourceText} raised a type error ${expectedText}.`;
-                diagnostics.push(Diagnostic.error(text).add({ related }));
-            }
-        });
-        return diagnostics;
-    }
-    #isStringLiteralType(type) {
-        return Boolean(type.flags & this.compiler.TypeFlags.StringLiteral);
+            return accumulator;
+        }, []);
     }
-    match(source, targetTypes, isNot) {
-        const explain = () => this.#explain(source, targetTypes, isNot);
-        if (targetTypes.length === 0) {
-            return {
-                explain,
-                isMatch: source.diagnostics.length > 0,
-            };
+    match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
+        const diagnostics = [];
+        for (const targetNode of targetNodes) {
+            if (!(this.#compiler.isStringLiteralLike(targetNode) || this.#compiler.isNumericLiteral(targetNode))) {
+                const expectedText = "a string or number literal";
+                const text = ExpectDiagnosticText.argumentMustBe("target", expectedText);
+                const origin = DiagnosticOrigin.fromNode(targetNode);
+                diagnostics.push(Diagnostic.error(text, origin));
+            }
         }
-        if (source.diagnostics.length !== targetTypes.length) {
-            return {
-                explain,
-                isMatch: false,
-            };
+        if (diagnostics.length > 0) {
+            onDiagnostics(diagnostics);
+            return;
+        }
+        let isMatch;
+        if (targetNodes.length === 0) {
+            isMatch = matchWorker.assertion.diagnostics.size > 0;
+        }
+        else {
+            isMatch =
+                matchWorker.assertion.diagnostics.size === targetNodes.length &&
+                    [...matchWorker.assertion.diagnostics].every((diagnostic, index) => this.#matchExpectedError(diagnostic, targetNodes[index]));
         }
         return {
-            explain,
-            isMatch: targetTypes.every((type, index) => this.#matchExpectedError(source.diagnostics[index], type)),
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch,
         };
     }
-    #matchExpectedError(diagnostic, type) {
-        if (this.#isStringLiteralType(type)) {
-            return this.compiler.flattenDiagnosticMessageText(diagnostic?.messageText, " ", 0).includes(type.value);
+    #matchExpectedError(diagnostic, targetNode) {
+        if (this.#compiler.isStringLiteralLike(targetNode)) {
+            return this.#compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(targetNode.text);
         }
-        return type.value === diagnostic?.code;
+        return Number(targetNode.text) === diagnostic.code;
     }
 }
 
-class Expect {
+class ExpectService {
     #compiler;
     #typeChecker;
+    toAcceptProps;
     toBe;
     toBeAny;
     toBeAssignable;
@@ -2148,66 +2504,63 @@ class Expect {
     constructor(compiler, 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);
+        this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
+        this.toBe = new ToBe();
+        this.toBeAny = new PrimitiveTypeMatcher(compiler.TypeFlags.Any);
+        this.toBeAssignable = new ToBeAssignableWith();
+        this.toBeAssignableTo = new ToBeAssignableTo();
+        this.toBeAssignableWith = new ToBeAssignableWith();
+        this.toBeBigInt = new PrimitiveTypeMatcher(compiler.TypeFlags.BigInt);
+        this.toBeBoolean = new PrimitiveTypeMatcher(compiler.TypeFlags.Boolean);
+        this.toBeNever = new PrimitiveTypeMatcher(compiler.TypeFlags.Never);
+        this.toBeNull = new PrimitiveTypeMatcher(compiler.TypeFlags.Null);
+        this.toBeNumber = new PrimitiveTypeMatcher(compiler.TypeFlags.Number);
+        this.toBeString = new PrimitiveTypeMatcher(compiler.TypeFlags.String);
+        this.toBeSymbol = new PrimitiveTypeMatcher(compiler.TypeFlags.ESSymbol);
+        this.toBeUndefined = new PrimitiveTypeMatcher(compiler.TypeFlags.Undefined);
+        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(compiler.TypeFlags.UniqueESSymbol);
+        this.toBeUnknown = new PrimitiveTypeMatcher(compiler.TypeFlags.Unknown);
+        this.toBeVoid = new PrimitiveTypeMatcher(compiler.TypeFlags.Void);
+        this.toEqual = new ToBe();
+        this.toHaveProperty = new ToHaveProperty(compiler);
+        this.toMatch = new ToMatch();
+        this.toRaiseError = new ToRaiseError(compiler);
     }
     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);
-    }
-    #getTypes(nodes) {
-        return nodes.map((node) => this.#getType(node));
-    }
-    #isArrayOfStringOrNumberLiteralTypes(types) {
-        return types.every((type) => this.#isStringOrNumberLiteralType(type));
-    }
-    #isStringOrNumberLiteralType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
-    }
-    #isUniqueSymbolType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
+    #handleDeprecated(matcherNameText, assertion) {
+        switch (matcherNameText) {
+            case "toBeAssignable":
+            case "toEqual": {
+                const text = ExpectDiagnosticText.matcherIsDeprecated(matcherNameText);
+                const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+                EventEmitter.dispatch(["deprecation:info", { diagnostics: [Diagnostic.warning(text, origin)] }]);
+                break;
+            }
+        }
     }
-    match(assertion, expectResult) {
+    match(assertion, onDiagnostics) {
         const matcherNameText = assertion.matcherName.getText();
+        this.#handleDeprecated(matcherNameText, assertion);
+        if (!assertion.source[0]) {
+            this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
+            return;
+        }
+        const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
         switch (matcherNameText) {
-            case "toBeAssignable":
-            case "toEqual":
-                this.#onDeprecatedMatcher(assertion);
+            case "toAcceptProps":
             case "toBe":
+            case "toBeAssignable":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
+            case "toEqual":
             case "toMatch": {
-                if (assertion.source[0] == null) {
-                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
-                    return;
-                }
-                if (assertion.target[0] == null) {
-                    this.#onTargetArgumentMustBeProvided(assertion, expectResult);
+                if (!assertion.target[0]) {
+                    this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
-                return this[matcherNameText].match(this.#getType(assertion.source[0]), this.#getType(assertion.target[0]), assertion.isNot);
+                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             }
             case "toBeAny":
             case "toBeBigInt":
@@ -2221,131 +2574,40 @@ class Expect {
             case "toBeUniqueSymbol":
             case "toBeUnknown":
             case "toBeVoid": {
-                if (assertion.source[0] == null) {
-                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
-                    return;
-                }
-                return this[matcherNameText].match(this.#getType(assertion.source[0]));
+                return this[matcherNameText].match(matchWorker, assertion.source[0]);
             }
             case "toHaveProperty": {
-                if (assertion.source[0] == null) {
-                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                if (!assertion.target[0]) {
+                    this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     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)) {
-                    this.#onSourceArgumentMustBeObjectType(assertion.source[0], expectResult);
-                    return;
-                }
-                if (assertion.target[0] == null) {
-                    this.#onKeyArgumentMustBeProvided(assertion, expectResult);
-                    return;
-                }
-                const targetType = this.#getType(assertion.target[0]);
-                if (!(this.#isStringOrNumberLiteralType(targetType) || this.#isUniqueSymbolType(targetType))) {
-                    this.#onKeyArgumentMustBeOfType(assertion.target[0], expectResult);
-                    return;
-                }
-                return this.toHaveProperty.match(sourceType, targetType, assertion.isNot);
+                return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             }
             case "toRaiseError": {
-                if (assertion.source[0] == null) {
-                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
-                    return;
-                }
-                const targetTypes = this.#getTypes(assertion.target);
-                if (!this.#isArrayOfStringOrNumberLiteralTypes(targetTypes)) {
-                    this.#onTargetArgumentsMustBeStringOrNumberLiteralTypes(assertion.target, expectResult);
-                    return;
-                }
-                return this.toRaiseError.match({ diagnostics: [...assertion.diagnostics], node: assertion.source[0] }, targetTypes, assertion.isNot);
+                return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             }
             default: {
-                this.#onNotSupportedMatcherName(assertion, expectResult);
-                return;
+                const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
+                const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+                onDiagnostics(Diagnostic.error(text, origin));
             }
         }
+        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 = 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 text = `An argument for 'key' must be of type 'string | number | symbol', received: '${receivedTypeText}'.`;
-        const origin = DiagnosticOrigin.fromNode(node);
-        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
+    #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
+        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("source", "Source");
+        const origin = DiagnosticOrigin.fromNode(assertion.node.expression);
+        onDiagnostics(Diagnostic.error(text, origin));
     }
-    #onKeyArgumentMustBeProvided(assertion, expectResult) {
+    #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
+        const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
         const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-        EventEmitter.dispatch([
-            "expect:error",
-            {
-                diagnostics: [Diagnostic.error("An argument for 'key' must be provided.", origin)],
-                result: expectResult,
-            },
-        ]);
+        onDiagnostics(Diagnostic.error(text, origin));
     }
-    #onNotSupportedMatcherName(assertion, expectResult) {
-        const matcherNameText = assertion.matcherName.getText();
+    #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
+        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
         const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-        EventEmitter.dispatch([
-            "expect:error",
-            {
-                diagnostics: [Diagnostic.error(`The '${matcherNameText}()' matcher is not supported.`, origin)],
-                result: expectResult,
-            },
-        ]);
-    }
-    #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 text = `${sourceText} must be of an object type, received: '${receivedTypeText}'.`;
-        const origin = DiagnosticOrigin.fromNode(node);
-        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
-    }
-    #onSourceArgumentMustBeProvided(assertion, expectResult) {
-        const origin = DiagnosticOrigin.fromNode(assertion.node);
-        EventEmitter.dispatch([
-            "expect:error",
-            {
-                diagnostics: [
-                    Diagnostic.error("An argument for 'source' or type argument for 'Source' must be provided.", origin),
-                ],
-                result: expectResult,
-            },
-        ]);
-    }
-    #onTargetArgumentMustBeProvided(assertion, expectResult) {
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-        EventEmitter.dispatch([
-            "expect:error",
-            {
-                diagnostics: [
-                    Diagnostic.error("An argument for 'target' or type argument for 'Target' must be provided.", origin),
-                ],
-                result: expectResult,
-            },
-        ]);
-    }
-    #onTargetArgumentsMustBeStringOrNumberLiteralTypes(nodes, expectResult) {
-        const diagnostics = [];
-        for (const node of nodes) {
-            const receivedType = this.#getType(node);
-            if (!this.#isStringOrNumberLiteralType(receivedType)) {
-                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));
-            }
-        }
-        EventEmitter.dispatch(["expect:error", { diagnostics, result: expectResult }]);
+        onDiagnostics(Diagnostic.error(text, origin));
     }
 }
 
@@ -2445,7 +2707,7 @@ class ProjectService {
             defaultCompilerOptions.module = "preserve";
         }
         if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
-            defaultCompilerOptions["allowImportingTsExtensions"] = true;
+            defaultCompilerOptions.allowImportingTsExtensions = true;
             defaultCompilerOptions.moduleResolution = "bundler";
         }
         return defaultCompilerOptions;
@@ -2478,19 +2740,19 @@ class ProjectService {
 class TestTreeWorker {
     #compiler;
     #cancellationToken;
-    #expect;
+    #expectService;
     #fileResult;
     #hasOnly;
     #position;
     #resolvedConfig;
-    constructor(resolvedConfig, compiler, expect, options) {
+    constructor(resolvedConfig, compiler, typeChecker, options) {
         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;
+        this.#expectService = new ExpectService(compiler, typeChecker);
     }
     #resolveRunMode(mode, member) {
         if (member.flags & 1) {
@@ -2520,13 +2782,7 @@ class TestTreeWorker {
             }
             const validationError = member.validate();
             if (validationError.length > 0) {
-                EventEmitter.dispatch([
-                    "file:error",
-                    {
-                        diagnostics: validationError,
-                        result: this.#fileResult,
-                    },
-                ]);
+                EventEmitter.dispatch(["file:error", { diagnostics: validationError, result: this.#fileResult }]);
                 break;
             }
             switch (member.brand) {
@@ -2554,28 +2810,25 @@ class TestTreeWorker {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
         }
-        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        const onExpectDiagnostics = (diagnostics) => {
             EventEmitter.dispatch([
                 "expect:error",
-                {
-                    diagnostics: Diagnostic.fromDiagnostics([...assertion.diagnostics], this.#compiler),
-                    result: expectResult,
-                },
+                { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
+        };
+        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+            onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics], this.#compiler));
             return;
         }
-        const matchResult = this.#expect.match(assertion, expectResult);
-        if (matchResult == null) {
+        const matchResult = this.#expectService.match(assertion, onExpectDiagnostics);
+        if (!matchResult) {
             return;
         }
         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 = DiagnosticOrigin.fromNode(assertion.node);
-                EventEmitter.dispatch([
-                    "expect:error",
-                    { diagnostics: [Diagnostic.error(text, origin)], result: expectResult },
-                ]);
+                const origin = DiagnosticOrigin.fromNode(assertion.node.expression.name);
+                onExpectDiagnostics(Diagnostic.error(text, origin));
             }
             else {
                 EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
@@ -2585,14 +2838,7 @@ class TestTreeWorker {
             EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
         }
         else {
-            const origin = DiagnosticOrigin.fromNode(assertion.matcherName, assertion.ancestorNames);
-            const diagnostics = matchResult.explain().map((diagnostic) => {
-                if (diagnostic.origin == null) {
-                    return diagnostic.add({ origin });
-                }
-                return diagnostic;
-            });
-            EventEmitter.dispatch(["expect:fail", { diagnostics, result: expectResult }]);
+            EventEmitter.dispatch(["expect:fail", { diagnostics: matchResult.explain(), result: expectResult }]);
         }
     }
     #visitDescribe(describe, runMode, parentResult) {
@@ -2705,13 +2951,12 @@ class TestFileRunner {
             return;
         }
         const typeChecker = program.getTypeChecker();
-        if (!Expect.assertTypeChecker(typeChecker)) {
+        if (!ExpectService.assertTypeChecker(typeChecker)) {
             const text = "The required 'isTypeRelatedTo()' method is missing in the provided type checker.";
             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 testTreeWorker = new TestTreeWorker(this.#resolvedConfig, this.#compiler, typeChecker, {
             cancellationToken,
             fileResult,
             hasOnly: testTree.hasOnly,
@@ -2742,6 +2987,7 @@ class TaskRunner {
             this.#eventEmitter.addHandler(cancellationHandler);
         }
         if (this.#resolvedConfig.watch === true) {
+            await this.#run(testFiles, cancellationToken);
             await this.#watch(testFiles, cancellationToken);
         }
         else {
@@ -2767,22 +3013,15 @@ class TaskRunner {
             EventEmitter.dispatch(["target:end", { result: targetResult }]);
         }
         EventEmitter.dispatch(["run:end", { result }]);
-        if (cancellationToken?.reason === "failFast") {
+        if (cancellationToken.reason === "failFast") {
             cancellationToken.reset();
         }
     }
     async #watch(testFiles, cancellationToken) {
-        await this.#run(testFiles, cancellationToken);
-        const runCallback = async (testFiles) => {
+        const watchService = new WatchService(this.#resolvedConfig, this.#selectService, testFiles);
+        for await (const testFiles of watchService.watch(cancellationToken)) {
             await this.#run(testFiles, cancellationToken);
-        };
-        const watchModeManager = new WatchService(this.#resolvedConfig, runCallback, this.#selectService, testFiles);
-        cancellationToken?.onCancellationRequested((reason) => {
-            if (reason !== "failFast") {
-                watchModeManager.close();
-            }
-        });
-        await watchModeManager.watch(cancellationToken);
+        }
     }
 }
 
@@ -2793,7 +3032,7 @@ class TSTyche {
     #selectService;
     #storeService;
     #taskRunner;
-    static version = "2.0.0";
+    static version = "2.1.0";
     constructor(resolvedConfig, outputService, selectService, storeService) {
         this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
@@ -3009,14 +3248,14 @@ class OptionUsageText {
 }
 
 class OptionValidator {
-    #onDiagnostic;
+    #onDiagnostics;
     #optionGroup;
     #optionUsageText;
     #storeService;
-    constructor(optionGroup, storeService, onDiagnostic) {
+    constructor(optionGroup, storeService, onDiagnostics) {
         this.#optionGroup = optionGroup;
         this.#storeService = storeService;
-        this.#onDiagnostic = onDiagnostic;
+        this.#onDiagnostics = onDiagnostics;
         this.#optionUsageText = new OptionUsageText(this.#optionGroup, this.#storeService);
     }
     async check(optionName, optionValue, optionBrand, origin) {
@@ -3024,13 +3263,13 @@ class OptionValidator {
             case "config":
             case "rootPath": {
                 if (!existsSync(optionValue)) {
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
                 }
                 break;
             }
             case "target": {
                 if ((await this.#storeService.validateTag(optionValue)) === false) {
-                    this.#onDiagnostic(Diagnostic.error([
+                    this.#onDiagnostics(Diagnostic.error([
                         ConfigDiagnosticText.versionIsNotSupported(optionValue),
                         ...(await this.#optionUsageText.get(optionName, optionBrand)),
                     ], origin));
@@ -3040,14 +3279,14 @@ class OptionValidator {
             case "testFileMatch": {
                 for (const segment of ["/", "../"]) {
                     if (optionValue.startsWith(segment)) {
-                        this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
+                        this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
                     }
                 }
                 break;
             }
             case "watch": {
                 if (Environment.isCi) {
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.watchCannotBeEnabled(), origin));
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.watchCannotBeEnabled(), origin));
                 }
                 break;
             }
@@ -3058,27 +3297,27 @@ class OptionValidator {
 class CommandLineOptionsWorker {
     #commandLineOptionDefinitions;
     #commandLineOptions;
-    #onDiagnostic;
+    #onDiagnostics;
     #optionGroup = 2;
     #optionUsageText;
     #optionValidator;
     #pathMatch;
     #storeService;
-    constructor(commandLineOptions, pathMatch, storeService, onDiagnostic) {
+    constructor(commandLineOptions, pathMatch, storeService, onDiagnostics) {
         this.#commandLineOptions = commandLineOptions;
         this.#pathMatch = pathMatch;
         this.#storeService = storeService;
-        this.#onDiagnostic = onDiagnostic;
+        this.#onDiagnostics = onDiagnostics;
         this.#commandLineOptionDefinitions = OptionDefinitionsMap.for(this.#optionGroup);
         this.#optionUsageText = new OptionUsageText(this.#optionGroup, this.#storeService);
-        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostic);
+        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostics);
     }
     async #onExpectsValue(optionDefinition) {
         const text = [
             ConfigDiagnosticText.expectsValue(optionDefinition.name, this.#optionGroup),
             ...(await this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand)),
         ];
-        this.#onDiagnostic(Diagnostic.error(text));
+        this.#onDiagnostics(Diagnostic.error(text));
     }
     async parse(commandLineArgs) {
         let index = 0;
@@ -3092,11 +3331,11 @@ class CommandLineOptionsWorker {
                     index = await this.#parseOptionValue(commandLineArgs, index, optionDefinition);
                 }
                 else {
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.unknownOption(arg)));
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.unknownOption(arg)));
                 }
             }
             else if (arg.startsWith("-")) {
-                this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.unknownOption(arg)));
+                this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.unknownOption(arg)));
             }
             else {
                 this.#pathMatch.push(Path.normalizeSlashes(arg));
@@ -3162,18 +3401,18 @@ class ConfigFileOptionsWorker {
     #configFileOptionDefinitions;
     #configFileOptions;
     #configFilePath;
-    #onDiagnostic;
+    #onDiagnostics;
     #optionGroup = 4;
     #optionValidator;
     #storeService;
-    constructor(compiler, configFileOptions, configFilePath, storeService, onDiagnostic) {
+    constructor(compiler, configFileOptions, configFilePath, storeService, onDiagnostics) {
         this.#compiler = compiler;
         this.#configFileOptions = configFileOptions;
         this.#configFilePath = configFilePath;
         this.#storeService = storeService;
-        this.#onDiagnostic = onDiagnostic;
+        this.#onDiagnostics = onDiagnostics;
         this.#configFileOptionDefinitions = OptionDefinitionsMap.for(this.#optionGroup);
-        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostic);
+        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#storeService, this.#onDiagnostics);
     }
     #isDoubleQuotedString(node, sourceFile) {
         return (node.kind === this.#compiler.SyntaxKind.StringLiteral &&
@@ -3182,25 +3421,26 @@ class ConfigFileOptionsWorker {
     async parse(sourceText) {
         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);
-            }
+            this.#onDiagnostics(Diagnostic.fromDiagnostics(sourceFile.parseDiagnostics, this.#compiler));
             return;
         }
         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));
+        if (!rootExpression) {
+            return;
+        }
+        if (!this.#compiler.isObjectLiteralExpression(rootExpression)) {
+            const origin = DiagnosticOrigin.fromJsonNode(rootExpression, sourceFile, this.#skipTrivia);
+            this.#onDiagnostics(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, sourceFile)) {
-                    const origin = DiagnosticOrigin.fromJsonNode(property, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
+                    const origin = DiagnosticOrigin.fromJsonNode(property.name, sourceFile, this.#skipTrivia);
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
                     continue;
                 }
-                const optionName = this.#resolvePropertyName(property);
+                const optionName = property.name.text;
                 if (optionName === "$schema") {
                     continue;
                 }
@@ -3209,8 +3449,8 @@ class ConfigFileOptionsWorker {
                     this.#configFileOptions[optionDefinition.name] = await this.#parseOptionValue(sourceFile, property.initializer, optionDefinition);
                 }
                 else {
-                    const origin = DiagnosticOrigin.fromJsonNode(property, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.unknownOption(optionName), origin));
+                    const origin = DiagnosticOrigin.fromJsonNode(property.name, sourceFile, this.#skipTrivia);
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.unknownOption(optionName), origin));
                 }
             }
         }
@@ -3233,7 +3473,7 @@ class ConfigFileOptionsWorker {
             case this.#compiler.SyntaxKind.StringLiteral: {
                 if (!this.#isDoubleQuotedString(valueExpression, sourceFile)) {
                     const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
-                    this.#onDiagnostic(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
+                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.doubleQuotesExpected(), origin));
                     return;
                 }
                 if (optionDefinition.brand === "string") {
@@ -3262,15 +3502,9 @@ class ConfigFileOptionsWorker {
             ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
             : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, this.#optionGroup);
         const origin = DiagnosticOrigin.fromJsonNode(valueExpression, sourceFile, this.#skipTrivia);
-        this.#onDiagnostic(Diagnostic.error(text, origin));
+        this.#onDiagnostics(Diagnostic.error(text, origin));
         return;
     }
-    #resolvePropertyName({ name }) {
-        if ("text" in name) {
-            return name.text;
-        }
-        return "";
-    }
     #skipTrivia(position, sourceFile) {
         const { text } = sourceFile.getSourceFile();
         while (position < text.length) {
@@ -3312,7 +3546,7 @@ class ConfigFileOptionsWorker {
 const defaultOptions = {
     failFast: false,
     rootPath: "./",
-    target: [Environment.typescriptPath == null ? "latest" : "current"],
+    target: [Environment.typescriptPath != null ? "current" : "latest"],
     testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
 };
 class ConfigService {
@@ -3326,13 +3560,13 @@ class ConfigService {
         this.#compiler = compiler;
         this.#storeService = storeService;
     }
-    #onDiagnostic(diagnostic) {
-        EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
+    #onDiagnostics(diagnostics) {
+        EventEmitter.dispatch(["config:error", { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics] }]);
     }
     async parseCommandLine(commandLineArgs) {
         this.#commandLineOptions = {};
         this.#pathMatch = [];
-        const commandLineWorker = new CommandLineOptionsWorker(this.#commandLineOptions, this.#pathMatch, this.#storeService, this.#onDiagnostic);
+        const commandLineWorker = new CommandLineOptionsWorker(this.#commandLineOptions, this.#pathMatch, this.#storeService, this.#onDiagnostics);
         await commandLineWorker.parse(commandLineArgs);
         if (this.#commandLineOptions.config != null) {
             this.#configFilePath = this.#commandLineOptions.config;
@@ -3349,7 +3583,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.#onDiagnostics);
         await configFileWorker.parse(configFileText);
     }
     resolveConfig() {
@@ -3395,14 +3629,14 @@ class StoreDiagnosticText {
 class ManifestWorker {
     #manifestFileName = "store-manifest.json";
     #manifestFilePath;
-    #onDiagnostic;
+    #onDiagnostics;
     #registryUrl = new URL("https://registry.npmjs.org");
     #storePath;
     #timeout = Environment.timeout * 1000;
     #version = "1";
-    constructor(storePath, onDiagnostic) {
+    constructor(storePath, onDiagnostics) {
         this.#storePath = storePath;
-        this.#onDiagnostic = onDiagnostic;
+        this.#onDiagnostics = onDiagnostics;
         this.#manifestFilePath = Path.join(storePath, this.#manifestFileName);
     }
     async #create() {
@@ -3432,7 +3666,7 @@ class ManifestWorker {
                 signal: AbortSignal.timeout(this.#timeout),
             });
             if (!response.ok) {
-                this.#onDiagnostic(Diagnostic.error([
+                this.#onDiagnostics(Diagnostic.error([
                     StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
                     StoreDiagnosticText.failedWithStatusCode(response.status),
                 ]));
@@ -3445,13 +3679,13 @@ class ManifestWorker {
                 return;
             }
             if (error instanceof Error && error.name === "TimeoutError") {
-                this.#onDiagnostic(Diagnostic.error([
+                this.#onDiagnostics(Diagnostic.error([
                     StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
                     StoreDiagnosticText.setupTimeoutExceeded(this.#timeout),
                 ]));
             }
             else {
-                this.#onDiagnostic(Diagnostic.error([
+                this.#onDiagnostics(Diagnostic.error([
                     StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
                     StoreDiagnosticText.maybeNetworkConnectionIssue(),
                 ]));
@@ -3486,9 +3720,9 @@ class ManifestWorker {
             manifestText = await fs.readFile(this.#manifestFilePath, { encoding: "utf8" });
         }
         catch (error) {
-            this.#onDiagnostic(Diagnostic.fromError("Failed to open store manifest.", error));
+            this.#onDiagnostics(Diagnostic.fromError("Failed to open store manifest.", error));
         }
-        if (manifestText == null) {
+        if (!manifestText) {
             return;
         }
         try {
@@ -3496,7 +3730,7 @@ class ManifestWorker {
         }
         catch {
         }
-        if (manifest == null || manifest.$version !== this.#version) {
+        if (!manifest || manifest.$version !== this.#version) {
             await fs.rm(this.#storePath, { force: true, recursive: true });
             return this.#create();
         }
@@ -3536,7 +3770,7 @@ class Lock {
         if (!isLocked) {
             return isLocked;
         }
-        if (options?.timeout == null) {
+        if (!options?.timeout) {
             return isLocked;
         }
         const waitStartTime = Date.now();
@@ -3545,7 +3779,7 @@ class Lock {
                 break;
             }
             if (Date.now() - waitStartTime > options.timeout) {
-                options.onDiagnostic?.(`Lock wait timeout of ${String(options.timeout / 1000)}s was exceeded.`);
+                options.onDiagnostics?.(`Lock wait timeout of ${String(options.timeout / 1000)}s was exceeded.`);
                 break;
             }
             await Lock.#sleep(1000);
@@ -3562,13 +3796,13 @@ class Lock {
 }
 
 class PackageInstaller {
-    #onDiagnostic;
+    #onDiagnostics;
     #readyFileName = "__ready__";
     #storePath;
     #timeout = Environment.timeout * 1000;
-    constructor(storePath, onDiagnostic) {
+    constructor(storePath, onDiagnostics) {
         this.#storePath = storePath;
-        this.#onDiagnostic = onDiagnostic;
+        this.#onDiagnostics = onDiagnostics;
     }
     async ensure(compilerVersion, cancellationToken) {
         const installationPath = Path.join(this.#storePath, compilerVersion);
@@ -3579,8 +3813,8 @@ class PackageInstaller {
         }
         if (await Lock.isLocked(installationPath, {
             cancellationToken,
-            onDiagnostic: (text) => {
-                this.#onDiagnostic(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
+            onDiagnostics: (text) => {
+                this.#onDiagnostics(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
             },
             timeout: this.#timeout,
         })) {
@@ -3606,7 +3840,7 @@ class PackageInstaller {
             return modulePath;
         }
         catch (error) {
-            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
+            this.#onDiagnostics(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
         }
         finally {
             lock.release();
@@ -3646,8 +3880,8 @@ class StoreService {
     #storePath;
     constructor() {
         this.#storePath = Environment.storePath;
-        this.#packageInstaller = new PackageInstaller(this.#storePath, this.#onDiagnostic);
-        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostic);
+        this.#packageInstaller = new PackageInstaller(this.#storePath, this.#onDiagnostics);
+        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostics);
     }
     async getSupportedTags() {
         await this.open();
@@ -3660,9 +3894,9 @@ class StoreService {
         if (tag === "current") {
             return;
         }
-        const version = await this.resolveTag(tag);
-        if (version == null) {
-            this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+        const version = await this.#resolveTag(tag);
+        if (!version) {
+            this.#onDiagnostics(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
             return;
         }
         return this.#packageInstaller.ensure(version, cancellationToken);
@@ -3677,9 +3911,9 @@ class StoreService {
             modulePath = Environment.typescriptPath;
         }
         else {
-            const version = await this.resolveTag(tag);
-            if (version == null) {
-                this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+            const version = await this.#resolveTag(tag);
+            if (!version) {
+                this.#onDiagnostics(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
                 return;
             }
             compilerInstance = this.#compilerInstanceCache.get(version);
@@ -3715,7 +3949,7 @@ class StoreService {
         }
         return module.exports;
     }
-    #onDiagnostic(diagnostic) {
+    #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
     }
     async open() {
@@ -3724,10 +3958,7 @@ class StoreService {
         }
         this.#manifest = await this.#manifestWorker.open();
     }
-    async resolveTag(tag) {
-        if (tag === "current") {
-            return tag;
-        }
+    async #resolveTag(tag) {
         await this.open();
         if (!this.#manifest) {
             return;
@@ -3752,7 +3983,7 @@ class StoreService {
             (!Version.isVersionTag(tag) ||
                 (this.#manifest.resolutions["latest"] != null &&
                     Version.isGreaterThan(tag, this.#manifest.resolutions["latest"])))) {
-            this.#onDiagnostic(Diagnostic.warning([
+            this.#onDiagnostics(Diagnostic.warning([
                 "Failed to update metadata of the 'typescript' package from the registry.",
                 `The resolution of the '${tag}' tag may be outdated.`,
             ]));
@@ -3789,7 +4020,7 @@ class Cli {
             await this.#storeService.update();
             return;
         }
-        const compiler = await this.#storeService.load(Environment.typescriptPath == null ? "latest" : "current");
+        const compiler = await this.#storeService.load(Environment.typescriptPath != null ? "current" : "latest");
         if (!compiler) {
             return;
         }
@@ -3855,28 +4086,33 @@ class Cli {
         this.#eventEmitter.removeHandlers();
     }
     #waitForChangedFiles(resolvedConfig, selectService, cancellationToken) {
-        const watchers = [];
-        cancellationToken.reset();
-        this.#outputService.writeMessage(waitingForFileChangesText());
-        const onChanged = () => {
-            cancellationToken.cancel("configChange");
-            for (const watcher of watchers) {
-                watcher.close();
-            }
-        };
-        watchers.push(new FileWatcher(resolvedConfig.configFilePath, onChanged));
-        if (selectService != null) {
-            const onChangedTestFile = (filePath) => {
-                if (selectService.isTestFile(filePath)) {
-                    onChanged();
+        return new Promise((resolve) => {
+            const watchers = [];
+            cancellationToken.reset();
+            this.#outputService.writeMessage(waitingForFileChangesText());
+            const onChanged = () => {
+                cancellationToken.cancel("configChange");
+                for (const watcher of watchers) {
+                    watcher.close();
                 }
+                resolve();
             };
-            const onRemoved = () => {
-            };
-            watchers.push(new Watcher(resolvedConfig.rootPath, onChangedTestFile, onRemoved, { recursive: true }));
-        }
-        return Promise.all(watchers.map((watcher) => watcher.watch()));
+            watchers.push(new FileWatcher(resolvedConfig.configFilePath, onChanged));
+            if (selectService != null) {
+                const onChangedTestFile = (filePath) => {
+                    if (selectService.isTestFile(filePath)) {
+                        onChanged();
+                    }
+                };
+                const onRemoved = () => {
+                };
+                watchers.push(new Watcher(resolvedConfig.rootPath, onChangedTestFile, onRemoved, { recursive: true }));
+            }
+            for (const watcher of watchers) {
+                watcher.watch();
+            }
+        });
     }
 }
 
-export { Assertion, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, ConfigDiagnosticText, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Environment, EventEmitter, ExitCodeHandler, Expect, ExpectResult, FileResult, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Scribbler, SelectDiagnosticText, 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, ConfigDiagnosticText, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Environment, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileResult, FileWatcher, InputService, Line, OptionBrand, OptionDefinitionsMap, OptionGroup, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, RunReporter, Scribbler, SelectDiagnosticText, 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 };