tstyche 1.0.0-beta.6 → 1.0.0-beta.8

package/build/tstyche.js

@@ -1,11 +1,12 @@
-import { readFileSync, existsSync, writeFileSync, rmSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
+import { existsSync, writeFileSync, rmSync } from 'node:fs';
 import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { spawn } from 'node:child_process';
+import vm from 'node:vm';
 import https from 'node:https';
+import { spawn } from 'node:child_process';
 
 class EventEmitter {
     static #handlers = new Set();
@@ -22,10 +23,42 @@ class EventEmitter {
     }
 }
 
+class Path {
+    static basename(filePath) {
+        return Path.normalizeSlashes(path.basename(filePath));
+    }
+    static dirname(filePath) {
+        return Path.normalizeSlashes(path.dirname(filePath));
+    }
+    static join(...filePaths) {
+        return Path.normalizeSlashes(path.join(...filePaths));
+    }
+    static normalizeSlashes(filePath) {
+        if (path.sep === "/") {
+            return filePath;
+        }
+        return filePath.replaceAll("\\", "/");
+    }
+    static relative(from, to) {
+        let relativePath = path.relative(from, to);
+        if (!relativePath.startsWith(".")) {
+            relativePath = `./${relativePath}`;
+        }
+        return Path.normalizeSlashes(relativePath);
+    }
+    static resolve(...filePaths) {
+        return Path.normalizeSlashes(path.resolve(...filePaths));
+    }
+}
+
 class Environment {
+    static #isTypeScriptInstalled = Environment.#resolveIsTypeScriptInstalled();
     static #noColor = Environment.#resolveNoColor();
-    static #storePath = Environment.#normalizePath(Environment.#resolveStorePath());
+    static #storePath = Environment.#resolveStorePath();
     static #timeout = Environment.#resolveTimeout();
+    static get isTypeScriptInstalled() {
+        return Environment.#isTypeScriptInstalled;
+    }
     static get noColor() {
         return Environment.#noColor;
     }
@@ -35,18 +68,21 @@ class Environment {
     static get timeout() {
         return Environment.#timeout;
     }
-    static #normalizePath(value) {
-        if (path.sep === "/") {
-            return value;
-        }
-        return value.replace(/\\/g, "/");
-    }
     static #parseBoolean(value) {
         if (value != null) {
             return ["1", "on", "t", "true", "y", "yes"].includes(value.toLowerCase());
         }
         return false;
     }
+    static #resolveIsTypeScriptInstalled() {
+        try {
+            createRequire(import.meta.url).resolve("typescript");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     static #resolveNoColor() {
         if (process.env["TSTYCHE_NO_COLOR"] != null) {
             return Environment.#parseBoolean(process.env["TSTYCHE_NO_COLOR"]);
@@ -58,18 +94,18 @@ class Environment {
     }
     static #resolveStorePath() {
         if (process.env["TSTYCHE_STORE_PATH"] != null) {
-            return path.resolve(process.env["TSTYCHE_STORE_PATH"]);
+            return Path.resolve(process.env["TSTYCHE_STORE_PATH"]);
         }
         if (process.platform === "darwin") {
-            return path.resolve(os.homedir(), "Library", "TSTyche");
+            return Path.resolve(os.homedir(), "Library", "TSTyche");
         }
         if (process.env["LocalAppData"] != null) {
-            return path.resolve(process.env["LocalAppData"], "TSTyche");
+            return Path.resolve(process.env["LocalAppData"], "TSTyche");
         }
         if (process.env["XDG_DATA_HOME"] != null) {
-            return path.resolve(process.env["XDG_DATA_HOME"], "TSTyche");
+            return Path.resolve(process.env["XDG_DATA_HOME"], "TSTyche");
         }
-        return path.resolve(os.homedir(), ".local", "share", "TSTyche");
+        return Path.resolve(os.homedir(), ".local", "share", "TSTyche");
     }
     static #resolveTimeout() {
         if (process.env["TSTYCHE_TIMEOUT"] != null) {
@@ -105,12 +141,12 @@ class Scribbler {
         };
     }
     #escapeSequence(attributes) {
-        return ["\x1b[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
+        return ["\u001B[", Array.isArray(attributes) ? attributes.join(";") : attributes, "m"].join("");
     }
     #indentEachLine(lines, level) {
         const indentStep = "  ";
         const notEmptyLineRegExp = /^(?!$)/gm;
-        return lines.replace(notEmptyLineRegExp, indentStep.repeat(level));
+        return lines.replaceAll(notEmptyLineRegExp, indentStep.repeat(level));
     }
     render(element) {
         if (element != null) {
@@ -123,7 +159,7 @@ class Scribbler {
             }
             if (element.type === "ansi" && !this.#noColor) {
                 const flags = typeof element.props?.["escapes"] === "string" || Array.isArray(element.props?.["escapes"])
-                    ? element.props?.["escapes"]
+                    ? element.props["escapes"]
                     : undefined;
                 if (flags != null) {
                     return this.#escapeSequence(flags);
@@ -201,6 +237,58 @@ class Line {
     }
 }
 
+class Logger {
+    #noColor;
+    #scribbler;
+    #stderr;
+    #stdout;
+    constructor(options) {
+        this.#noColor = options?.noColor ?? Environment.noColor;
+        this.#stderr = options?.stderr ?? process.stderr;
+        this.#stdout = options?.stdout ?? process.stdout;
+        this.#scribbler = new Scribbler({ noColors: this.#noColor });
+    }
+    eraseLastLine() {
+        if (!this.isInteractive()) {
+            return;
+        }
+        this.#stdout.write("\u001B[1A\u001B[0K");
+    }
+    isInteractive() {
+        if ("isTTY" in this.#stdout && typeof this.#stdout.isTTY === "boolean") {
+            return this.#stdout.isTTY;
+        }
+        return false;
+    }
+    #write(stream, body) {
+        const elements = Array.isArray(body) ? body : [body];
+        for (const element of elements) {
+            if (element.$$typeof !== Symbol.for("tstyche:scribbler")) {
+                return;
+            }
+            stream.write(this.#scribbler.render(element));
+        }
+    }
+    writeError(body) {
+        this.#write(this.#stderr, body);
+    }
+    writeMessage(body) {
+        this.#write(this.#stdout, body);
+    }
+    writeWarning(body) {
+        this.#write(this.#stderr, body);
+    }
+}
+
+class Reporter {
+    resolvedConfig;
+    logger;
+    constructor(resolvedConfig) {
+        this.resolvedConfig = resolvedConfig;
+        this.logger = new Logger();
+    }
+}
+
 function addsPackageStepText(compilerVersion, installationPath) {
     return (Scribbler.createElement(Line, null,
         Scribbler.createElement(Text, { color: "90" }, "adds"),
@@ -215,23 +303,6 @@ function describeNameText(name, indent = 0) {
     return Scribbler.createElement(Line, { indent: indent + 1 }, name);
 }
 
-class RelativePathText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        const relativePath = path.relative("", this.props.to).replace(/\\/g, "/");
-        if (relativePath === "") {
-            return Scribbler.createElement(Text, null, "./");
-        }
-        return (Scribbler.createElement(Text, null,
-            relativePath.startsWith(".") ? "" : "./",
-            relativePath,
-            this.props.isDirectory === true ? "/" : ""));
-    }
-}
-
 class CodeSpanText {
     props;
     constructor(props) {
@@ -244,12 +315,14 @@ class CodeSpanText {
         const lastLine = Math.min(firstLine + 5, lastLineInFile);
         const lineNumberMaxWidth = `${lastLine + 1}`.length;
         const codeSpan = [];
-        for (let i = firstLine; i <= lastLine; i++) {
-            const lineStart = this.props.file.getPositionOfLineAndCharacter(i, 0);
-            const lineEnd = i === lastLineInFile ? this.props.file.text.length : this.props.file.getPositionOfLineAndCharacter(i + 1, 0);
-            const lineNumberText = String(i + 1);
-            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
-            if (i === markedLine) {
+        for (let index = firstLine; index <= lastLine; index++) {
+            const lineStart = this.props.file.getPositionOfLineAndCharacter(index, 0);
+            const lineEnd = index === lastLineInFile
+                ? this.props.file.text.length
+                : this.props.file.getPositionOfLineAndCharacter(index + 1, 0);
+            const lineNumberText = String(index + 1);
+            const lineText = this.props.file.text.slice(lineStart, lineEnd).trimEnd().replaceAll("\t", " ");
+            if (index === markedLine) {
                 codeSpan.push(Scribbler.createElement(Line, null,
                     Scribbler.createElement(Text, { color: "31" }, ">"),
                     " ",
@@ -257,8 +330,7 @@ class CodeSpanText {
                     " ",
                     Scribbler.createElement(Text, { color: "90" }, "|"),
                     " ",
-                    lineText));
-                codeSpan.push(Scribbler.createElement(Line, null,
+                    lineText), Scribbler.createElement(Line, null,
                     " ".repeat(lineNumberMaxWidth + 3),
                     Scribbler.createElement(Text, { color: "90" }, "|"),
                     " ".repeat(markedCharacter + 1),
@@ -281,8 +353,7 @@ class CodeSpanText {
             " ".repeat(lineNumberMaxWidth + 5),
             Scribbler.createElement(Text, { color: "90" }, "at"),
             " ",
-            Scribbler.createElement(Text, { color: "36" },
-                Scribbler.createElement(RelativePathText, { to: this.props.file.fileName })),
+            Scribbler.createElement(Text, { color: "36" }, Path.relative("", this.props.file.fileName)),
             Scribbler.createElement(Text, { color: "90" },
                 ":",
                 String(markedLine + 1),
@@ -343,10 +414,13 @@ class FileNameText {
         this.props = props;
     }
     render() {
+        const relativePath = Path.relative("", this.props.filePath);
+        const lastPathSeparator = relativePath.lastIndexOf("/");
+        const directoryNameText = relativePath.slice(0, lastPathSeparator + 1);
+        const fileNameText = relativePath.slice(lastPathSeparator + 1);
         return (Scribbler.createElement(Text, null,
-            Scribbler.createElement(Text, { color: "90" },
-                Scribbler.createElement(RelativePathText, { isDirectory: true, to: path.dirname(this.props.filePath) })),
-            path.basename(this.props.filePath)));
+            Scribbler.createElement(Text, { color: "90" }, directoryNameText),
+            fileNameText));
     }
 }
 function fileStatusText(status, testFile) {
@@ -378,6 +452,160 @@ function fileViewText(lines, addEmptyFinalLine) {
         addEmptyFinalLine ? Scribbler.createElement(Line, null) : undefined));
 }
 
+class JsonText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, null, JSON.stringify(this.#sortObject(this.props.input), null, 2));
+    }
+    #sortObject(target) {
+        if (Array.isArray(target)) {
+            return target;
+        }
+        return Object.keys(target)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = target[key];
+            return result;
+        }, {});
+    }
+}
+function formattedText(input) {
+    if (typeof input === "string") {
+        return Scribbler.createElement(Line, null, input);
+    }
+    return Scribbler.createElement(JsonText, { input: input });
+}
+
+const usageExamples = [
+    ["tstyche", "Run all tests."],
+    ["tstyche path/to/first.test.ts", "Only run the test files with matching path."],
+    ["tstyche --target 4.7,5.3.2,current", "Test on all specified versions of TypeScript."],
+];
+class HintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, { indent: 1, color: "90" }, this.props.children));
+    }
+}
+class HelpHeaderText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const hint = (Scribbler.createElement(HintText, null,
+            Scribbler.createElement(Text, null, this.props.tstycheVersion)));
+        return (Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, null, "The TSTyche Type Test Runner"),
+            hint));
+    }
+}
+class CommandText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        let hint;
+        if (this.props.hint != null) {
+            hint = Scribbler.createElement(HintText, null, this.props.hint);
+        }
+        return (Scribbler.createElement(Line, { indent: 1 },
+            Scribbler.createElement(Text, { color: "34" }, this.props.text),
+            hint));
+    }
+}
+class OptionDescriptionText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
+    }
+}
+class CommandLineUsageText {
+    render() {
+        const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
+            Scribbler.createElement(CommandText, { text: commandText }),
+            Scribbler.createElement(OptionDescriptionText, { text: descriptionText }),
+            Scribbler.createElement(Line, null))));
+        return Scribbler.createElement(Text, null, usageText);
+    }
+}
+class CommandLineOptionNameText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Text, null,
+            "--",
+            this.props.text);
+    }
+}
+class CommandLineOptionHintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        if (this.props.definition.brand === "list") {
+            return (Scribbler.createElement(Text, null,
+                this.props.definition.brand,
+                " of ",
+                this.props.definition.items.brand,
+                "s"));
+        }
+        return Scribbler.createElement(Text, null, this.props.definition.brand);
+    }
+}
+class CommandLineOptionsText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const definitions = [...this.props.optionDefinitions.values()];
+        const optionsText = definitions.map((definition) => {
+            let hint;
+            if (definition.brand !== "true") {
+                hint = Scribbler.createElement(CommandLineOptionHintText, { definition: definition });
+            }
+            return (Scribbler.createElement(Text, null,
+                Scribbler.createElement(CommandText, { text: Scribbler.createElement(CommandLineOptionNameText, { text: definition.name }), hint: hint }),
+                Scribbler.createElement(OptionDescriptionText, { text: definition.description }),
+                Scribbler.createElement(Line, null)));
+        });
+        return (Scribbler.createElement(Text, null,
+            Scribbler.createElement(Line, null, "Command Line Options"),
+            Scribbler.createElement(Line, null),
+            optionsText));
+    }
+}
+class HelpFooterText {
+    render() {
+        return Scribbler.createElement(Line, null, "To learn more, visit https://tstyche.org");
+    }
+}
+function helpText(optionDefinitions, tstycheVersion) {
+    return (Scribbler.createElement(Text, null,
+        Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CommandLineUsageText, null),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CommandLineOptionsText, { optionDefinitions: optionDefinitions }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(HelpFooterText, null),
+        Scribbler.createElement(Line, null)));
+}
+
 class RowText {
     props;
     constructor(props) {
@@ -550,11 +778,14 @@ class ProjectNameText {
     render() {
         return (Scribbler.createElement(Text, { color: "90" },
             " with ",
-            Scribbler.createElement(RelativePathText, { to: this.props.filePath })));
+            Path.relative("", this.props.filePath)));
     }
 }
 function usesCompilerStepText(compilerVersion, tsconfigFilePath, options) {
-    const projectPathText = typeof tsconfigFilePath === "string" ? Scribbler.createElement(ProjectNameText, { filePath: tsconfigFilePath }) : undefined;
+    let projectPathText;
+    if (tsconfigFilePath != null) {
+        projectPathText = Scribbler.createElement(ProjectNameText, { filePath: tsconfigFilePath });
+    }
     return (Scribbler.createElement(Text, null,
         options?.prependEmptyLine === true ? Scribbler.createElement(Line, null) : undefined,
         Scribbler.createElement(Line, null,
@@ -565,73 +796,21 @@ function usesCompilerStepText(compilerVersion, tsconfigFilePath, options) {
         Scribbler.createElement(Line, null)));
 }
 
-class Logger {
-    #noColor;
-    #scribbler;
-    #stderr;
-    #stdout;
-    constructor(options) {
-        this.#noColor = options?.noColor ?? Environment.noColor;
-        this.#stderr = options?.stderr ?? process.stderr;
-        this.#stdout = options?.stdout ?? process.stdout;
-        this.#scribbler = new Scribbler({ noColors: this.#noColor });
-    }
-    eraseLastLine() {
-        if (!this.isInteractive()) {
-            return;
-        }
-        this.#stdout.write("\x1b[1A\x1b[0K");
-    }
-    isInteractive() {
-        if ("isTTY" in this.#stdout && typeof this.#stdout.isTTY === "boolean") {
-            return this.#stdout.isTTY;
-        }
-        return false;
-    }
-    #write(stream, body) {
-        const elements = Array.isArray(body) ? body : [body];
-        for (const element of elements) {
-            if (element.$$typeof !== Symbol.for("tstyche:scribbler")) {
-                return;
-            }
-            stream.write(this.#scribbler.render(element));
-        }
-    }
-    writeError(body) {
-        this.#write(this.#stderr, body);
-    }
-    writeMessage(body) {
-        this.#write(this.#stdout, body);
-    }
-    writeWarning(body) {
-        this.#write(this.#stderr, body);
-    }
-}
-
-class Reporter {
-    resolvedConfig;
-    logger;
-    constructor(resolvedConfig) {
-        this.resolvedConfig = resolvedConfig;
-        this.logger = new Logger();
-    }
-}
-
-class SummaryReporter extends Reporter {
-    handleEvent([eventName, payload]) {
-        switch (eventName) {
-            case "end":
-                this.logger.writeMessage(summaryText({
-                    duration: payload.result.timing.duration,
-                    expectCount: payload.result.expectCount,
-                    fileCount: payload.result.fileCount,
-                    onlyMatch: payload.result.resolvedConfig.only,
-                    pathMatch: payload.result.resolvedConfig.pathMatch,
-                    skipMatch: payload.result.resolvedConfig.skip,
-                    targetCount: payload.result.targetCount,
-                    testCount: payload.result.testCount,
-                }));
-                break;
+class SummaryReporter extends Reporter {
+    handleEvent([eventName, payload]) {
+        switch (eventName) {
+            case "end":
+                this.logger.writeMessage(summaryText({
+                    duration: payload.result.timing.duration,
+                    expectCount: payload.result.expectCount,
+                    fileCount: payload.result.fileCount,
+                    onlyMatch: payload.result.resolvedConfig.only,
+                    pathMatch: payload.result.resolvedConfig.pathMatch,
+                    skipMatch: payload.result.resolvedConfig.skip,
+                    targetCount: payload.result.targetCount,
+                    testCount: payload.result.testCount,
+                }));
+                break;
         }
     }
 }
@@ -651,6 +830,9 @@ 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;
         }
@@ -727,10 +909,6 @@ class FileViewService {
         return this.#messages.length > 0;
     }
     addMessage(message) {
-        if (Array.isArray(message)) {
-            this.#messages.push(...message);
-            return;
-        }
         this.#messages.push(message);
     }
     addTest(status, name) {
@@ -1196,53 +1374,39 @@ class TestMember {
     parent;
     flags;
     compiler;
-    diagnostics;
+    diagnostics = new Set();
     members = [];
-    name;
-    typeChecker;
+    name = "";
     constructor(brand, node, parent, flags) {
         this.brand = brand;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
         this.compiler = parent.compiler;
-        this.typeChecker = parent.typeChecker;
-        this.diagnostics = this.#mapDiagnostics(node, this.parent);
-        this.name = this.#resolveName(node);
-    }
-    get ancestorNames() {
-        const ancestorNames = [];
-        let ancestor = this.parent;
-        while ("name" in ancestor) {
-            ancestorNames.unshift(ancestor.name);
-            ancestor = ancestor.parent;
+        if (node.arguments[0] != null && this.compiler.isStringLiteralLike(node.arguments[0])) {
+            this.name = node.arguments[0].text;
         }
-        return ancestorNames;
-    }
-    #mapDiagnostics(node, parent) {
-        const mapped = [];
-        const unmapped = [];
         if (node.arguments[1] != null &&
             parent.compiler.isFunctionLike(node.arguments[1]) &&
             parent.compiler.isBlock(node.arguments[1].body)) {
             const blockStart = node.arguments[1].body.getStart();
             const blockEnd = node.arguments[1].body.getEnd();
-            parent.diagnostics.forEach((diagnostic) => {
+            for (const diagnostic of parent.diagnostics) {
                 if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
-                    mapped.push(diagnostic);
-                }
-                else {
-                    unmapped.push(diagnostic);
+                    this.diagnostics.add(diagnostic);
+                    parent.diagnostics.delete(diagnostic);
                 }
-            });
-            parent.diagnostics = unmapped;
+            }
         }
-        return mapped;
     }
-    #resolveName(node) {
-        return node.arguments[0] !== undefined && this.compiler.isStringLiteral(node.arguments[0])
-            ? node.arguments[0].text
-            : "";
+    get ancestorNames() {
+        const ancestorNames = [];
+        let ancestor = this.parent;
+        while ("name" in ancestor) {
+            ancestorNames.unshift(ancestor.name);
+            ancestor = ancestor.parent;
+        }
+        return ancestorNames;
     }
     validate() {
         const diagnostics = [];
@@ -1282,14 +1446,24 @@ class Assertion extends TestMember {
     modifierNode;
     notNode;
     isNot;
-    name = "";
     constructor(brand, node, parent, flags, matcherNode, modifierNode, notNode) {
         super(brand, node, parent, flags);
         this.matcherNode = matcherNode;
         this.modifierNode = modifierNode;
         this.notNode = notNode;
-        this.diagnostics = this.#mapDiagnostics();
         this.isNot = notNode ? true : false;
+        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) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
     }
     get ancestorNames() {
         const ancestorNames = [];
@@ -1304,80 +1478,20 @@ class Assertion extends TestMember {
     get matcherName() {
         return this.matcherNode.expression.name;
     }
-    get sourceArguments() {
+    get source() {
+        if (this.node.typeArguments != null) {
+            return this.node.typeArguments;
+        }
         return this.node.arguments;
     }
-    get sourceType() {
-        if (!this.typeChecker) {
-            return;
-        }
-        if (this.node.typeArguments?.[0]) {
-            return {
-                source: 1,
-                type: this.typeChecker.getTypeFromTypeNode(this.node.typeArguments[0]),
-            };
-        }
-        if (this.node.arguments[0]) {
-            return {
-                source: 0,
-                type: this.typeChecker.getTypeAtLocation(this.node.arguments[0]),
-            };
+    get target() {
+        if (this.matcherNode.typeArguments != null) {
+            return this.matcherNode.typeArguments;
         }
-        return;
-    }
-    get targetArguments() {
         return this.matcherNode.arguments;
     }
-    get targetType() {
-        if (!this.typeChecker) {
-            return;
-        }
-        if (this.matcherNode.typeArguments?.[0]) {
-            return {
-                source: 1,
-                type: this.typeChecker.getTypeFromTypeNode(this.matcherNode.typeArguments[0]),
-            };
-        }
-        if (this.matcherNode.arguments[0]) {
-            return {
-                source: 0,
-                type: this.typeChecker.getTypeAtLocation(this.matcherNode.arguments[0]),
-            };
-        }
-        return;
-    }
-    #mapDiagnostics() {
-        const mapped = [];
-        const unmapped = [];
-        let argStart;
-        let argEnd;
-        if (this.node.typeArguments?.[0]) {
-            argStart = this.node.typeArguments[0].getStart();
-            argEnd = this.node.typeArguments[0].getEnd();
-        }
-        else if (this.node.arguments[0]) {
-            argStart = this.node.arguments[0].getStart();
-            argEnd = this.node.arguments[0].getEnd();
-        }
-        this.parent.diagnostics.forEach((diagnostic) => {
-            if (diagnostic.start != null && diagnostic.start >= argStart && diagnostic.start <= argEnd) {
-                mapped.push(diagnostic);
-            }
-            else {
-                unmapped.push(diagnostic);
-            }
-        });
-        this.parent.diagnostics = unmapped;
-        return mapped;
-    }
 }
 
-var AssertionSource;
-(function (AssertionSource) {
-    AssertionSource[AssertionSource["Argument"] = 0] = "Argument";
-    AssertionSource[AssertionSource["TypeArgument"] = 1] = "TypeArgument";
-})(AssertionSource || (AssertionSource = {}));
-
 class IdentifierLookup {
     compiler;
     #identifiers;
@@ -1478,13 +1592,11 @@ class TestTree {
     compiler;
     diagnostics;
     sourceFile;
-    typeChecker;
     members = [];
-    constructor(compiler, diagnostics, sourceFile, typeChecker) {
+    constructor(compiler, diagnostics, sourceFile) {
         this.compiler = compiler;
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
-        this.typeChecker = typeChecker;
     }
     get hasOnly() {
         function hasOnly(root) {
@@ -1561,8 +1673,8 @@ class CollectService {
             this.#collectTestMembers(node, identifiers, parent);
         });
     }
-    createTestTree(sourceFile, semanticDiagnostics = [], typeChecker) {
-        const testTree = new TestTree(this.compiler, semanticDiagnostics, sourceFile, typeChecker);
+    createTestTree(sourceFile, semanticDiagnostics = []) {
+        const testTree = new TestTree(this.compiler, new Set(semanticDiagnostics), sourceFile);
         this.#collectTestMembers(sourceFile, new IdentifierLookup(this.compiler), testTree);
         return testTree;
     }
@@ -1593,408 +1705,551 @@ var TestMemberFlags;
     TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
 })(TestMemberFlags || (TestMemberFlags = {}));
 
-class ProjectService {
-    compiler;
-    #service;
-    constructor(compiler) {
-        this.compiler = compiler;
-        function doNothing() {
-        }
-        function returnFalse() {
-            return false;
-        }
-        function returnUndefined() {
-            return undefined;
-        }
-        const noopWatcher = { close: doNothing };
-        const noopLogger = {
-            close: doNothing,
-            endGroup: doNothing,
-            getLogFileName: returnUndefined,
-            hasLevel: returnFalse,
-            info: doNothing,
-            loggingEnabled: returnFalse,
-            msg: doNothing,
-            perftrc: doNothing,
-            startGroup: doNothing,
-        };
-        const host = {
-            ...this.compiler.sys,
-            clearImmediate,
-            clearTimeout,
-            setImmediate,
-            setTimeout,
-            watchDirectory: () => noopWatcher,
-            watchFile: () => noopWatcher,
+class PrimitiveTypeMatcher {
+    typeChecker;
+    #targetTypeFlag;
+    #targetTypeText;
+    constructor(typeChecker, targetTypeFlag, targetTypeText) {
+        this.typeChecker = typeChecker;
+        this.#targetTypeFlag = targetTypeFlag;
+        this.#targetTypeText = targetTypeText;
+    }
+    #explain(sourceType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        return isNot
+            ? [Diagnostic.error(`Type '${this.#targetTypeText}' is identical to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${this.#targetTypeText}' is not identical to type '${sourceTypeText}'.`)];
+    }
+    match(sourceType, isNot) {
+        const isMatch = Boolean(sourceType.flags & this.#targetTypeFlag);
+        return {
+            explain: () => this.#explain(sourceType, isNot),
+            isMatch,
         };
-        this.#service = new this.compiler.server.ProjectService({
-            cancellationToken: this.compiler.server.nullCancellationToken,
-            host,
-            logger: noopLogger,
-            session: undefined,
-            useInferredProjectPerProjectRoot: true,
-            useSingleInferredProject: false,
-        });
     }
-    closeFile(filePath) {
-        this.#service.closeClientFile(filePath);
+}
+
+class ToBeAssignable {
+    typeChecker;
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
     }
-    getDefaultProject(filePath) {
-        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        const targetTypeText = this.typeChecker.typeToString(targetType);
+        return isNot
+            ? [Diagnostic.error(`Type '${targetTypeText}' is assignable to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not assignable to type '${sourceTypeText}'.`)];
     }
-    getLanguageService(filePath) {
-        const project = this.getDefaultProject(filePath);
-        if (!project) {
-            return;
-        }
-        return project.getLanguageService(true);
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeAssignableTo(targetType, sourceType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
     }
-    openFile(filePath, sourceText, projectRootPath) {
-        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
-        EventEmitter.dispatch([
-            "project:info",
-            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
-        ]);
-        if (configFileErrors && configFileErrors.length > 0) {
-            EventEmitter.dispatch([
-                "project:error",
-                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
-            ]);
-        }
+}
+
+class ToEqual {
+    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 '${targetTypeText}' is identical to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`)];
+    }
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeIdenticalTo(sourceType, targetType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
     }
 }
 
-class Checker {
+class ToHaveProperty {
     compiler;
-    constructor(compiler) {
+    typeChecker;
+    constructor(compiler, typeChecker) {
         this.compiler = compiler;
+        this.typeChecker = typeChecker;
     }
-    #assertNonNullish(value, message) {
-        if (value == null) {
-            throw Error(message);
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        let targetArgumentText;
+        if (this.#isStringOrNumberLiteralType(targetType)) {
+            targetArgumentText = String(targetType.value);
         }
+        else {
+            targetArgumentText = `[${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}'.`)];
     }
-    #assertNonNullishSourceType(assertion) {
-        this.#assertNonNullish(assertion.sourceType, "An argument for 'source' was not provided.");
-    }
-    #assertNonNullishTargetType(assertion) {
-        this.#assertNonNullish(assertion.targetType, "An argument for 'target' was not provided.");
+    #isStringOrNumberLiteralType(type) {
+        return Boolean(type.flags & this.compiler.TypeFlags.StringOrNumberLiteral);
     }
-    #assertNonNullishTypeChecker(assertion) {
-        this.#assertNonNullish(assertion.typeChecker, "The 'typeChecker' was not provided.");
+    match(sourceType, targetType, isNot) {
+        let targetArgumentText;
+        if (this.#isStringOrNumberLiteralType(targetType)) {
+            targetArgumentText = String(targetType.value);
+        }
+        else {
+            targetArgumentText = this.compiler.unescapeLeadingUnderscores(targetType.escapedName);
+        }
+        const isMatch = sourceType.getProperties().some((property) => {
+            return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
+        });
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
     }
-    #assertStringsOrNumber(expression) {
-        return (expression != null &&
-            (this.compiler.isStringLiteralLike(expression) || this.compiler.isNumericLiteral(expression)));
+}
+
+class ToMatch {
+    typeChecker;
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
     }
-    #assertStringsOrNumbers(nodes) {
-        return nodes.every((expression) => this.#assertStringsOrNumber(expression));
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        const targetTypeText = this.typeChecker.typeToString(targetType);
+        return isNot
+            ? [Diagnostic.error(`Type '${targetTypeText}' is a subtype of type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not a subtype of type '${sourceTypeText}'.`)];
     }
-    explain(assertion) {
-        this.#assertNonNullishTypeChecker(assertion);
-        const matcher = assertion.matcherName.getText();
-        const origin = {
-            breadcrumbs: assertion.ancestorNames,
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeSubtypeOf(sourceType, targetType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
         };
-        switch (matcher) {
-            case "toBeAssignable": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is assignable to type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not assignable to type '${sourceTypeText}'.`, origin),
+    }
+}
+
+class ToRaiseError {
+    compiler;
+    typeChecker;
+    constructor(compiler, typeChecker) {
+        this.compiler = compiler;
+        this.typeChecker = typeChecker;
+    }
+    #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.`)];
+        }
+        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" : source.diagnostics.length} type error${source.diagnostics.length === 1 ? "" : "s"}.`;
+            return [Diagnostic.error(text).add({ related })];
+        }
+        if (source.diagnostics.length !== targetTypes.length) {
+            const expectedText = source.diagnostics.length > targetTypes.length
+                ? `only ${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`
+                : `${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`;
+            const foundText = source.diagnostics.length > targetTypes.length
+                ? `${source.diagnostics.length}`
+                : `only ${source.diagnostics.length}`;
+            const related = [
+                Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
+                ...Diagnostic.fromDiagnostics(source.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 ${argument.value}`;
+                const related = [
+                    Diagnostic.error("The raised type error:"),
+                    ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
+                ];
+                const text = `${sourceText} did not raise a type error ${expectedText}.`;
+                diagnostics.push(Diagnostic.error(text).add({ related }));
+            }
+            if (isNot && isMatch) {
+                const expectedText = this.#isStringLiteralType(argument)
+                    ? `matching substring '${argument.value}'`
+                    : `with code ${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);
+    }
+    match(source, targetTypes, isNot) {
+        const explain = () => this.#explain(source, targetTypes, isNot);
+        if (targetTypes.length === 0) {
+            return {
+                explain,
+                isMatch: source.diagnostics.length > 0,
+            };
+        }
+        if (source.diagnostics.length !== targetTypes.length) {
+            return {
+                explain,
+                isMatch: false,
+            };
+        }
+        return {
+            explain,
+            isMatch: targetTypes.every((type, index) => this.#matchExpectedError(source.diagnostics[index], type)),
+        };
+    }
+    #matchExpectedError(diagnostic, type) {
+        if (this.#isStringLiteralType(type)) {
+            return this.compiler.flattenDiagnosticMessageText(diagnostic?.messageText, " ", 0).includes(type.value);
+        }
+        return type.value === diagnostic?.code;
+    }
+}
+
+class Expect {
+    compiler;
+    typeChecker;
+    toBeAny;
+    toBeAssignable;
+    toBeBigInt;
+    toBeBoolean;
+    toBeNever;
+    toBeNull;
+    toBeNumber;
+    toBeString;
+    toBeSymbol;
+    toBeUndefined;
+    toBeUniqueSymbol;
+    toBeUnknown;
+    toBeVoid;
+    toEqual;
+    toHaveProperty;
+    toMatch;
+    toRaiseError;
+    constructor(compiler, typeChecker) {
+        this.compiler = compiler;
+        this.typeChecker = typeChecker;
+        this.toBeAny = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Any, "any");
+        this.toBeAssignable = new ToBeAssignable(this.typeChecker);
+        this.toBeBigInt = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.BigInt, "bigint");
+        this.toBeBoolean = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Boolean, "boolean");
+        this.toBeNever = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Never, "never");
+        this.toBeNull = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Null, "null");
+        this.toBeNumber = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Number, "number");
+        this.toBeString = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.String, "string");
+        this.toBeSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.ESSymbol, "symbol");
+        this.toBeUndefined = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Undefined, "undefined");
+        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.UniqueESSymbol, "unique symbol");
+        this.toBeUnknown = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Unknown, "unknown");
+        this.toBeVoid = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Void, "void");
+        this.toEqual = new ToEqual(this.typeChecker);
+        this.toHaveProperty = new ToHaveProperty(this.compiler, this.typeChecker);
+        this.toMatch = new ToMatch(this.typeChecker);
+        this.toRaiseError = new ToRaiseError(this.compiler, this.typeChecker);
+    }
+    static assertTypeChecker(typeChecker) {
+        return ("isTypeAssignableTo" in typeChecker && "isTypeIdenticalTo" in typeChecker && "isTypeSubtypeOf" 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);
+    }
+    match(assertion, expectResult) {
+        const matcherNameText = assertion.matcherName.getText();
+        switch (matcherNameText) {
+            case "toBeAssignable":
+            case "toEqual":
+            case "toMatch":
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                if (assertion.target[0] == null) {
+                    this.#onTargetArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                return this[matcherNameText].match(this.#getType(assertion.source[0]), this.#getType(assertion.target[0]), assertion.isNot);
             case "toBeAny":
-                return this.#isType(assertion, "any");
             case "toBeBigInt":
-                return this.#isType(assertion, "bigint");
             case "toBeBoolean":
-                return this.#isType(assertion, "boolean");
             case "toBeNever":
-                return this.#isType(assertion, "never");
             case "toBeNull":
-                return this.#isType(assertion, "null");
             case "toBeNumber":
-                return this.#isType(assertion, "number");
             case "toBeString":
-                return this.#isType(assertion, "string");
             case "toBeSymbol":
-                return this.#isType(assertion, "symbol");
             case "toBeUndefined":
-                return this.#isType(assertion, "undefined");
             case "toBeUniqueSymbol":
-                return this.#isType(assertion, "unique symbol");
             case "toBeUnknown":
-                return this.#isType(assertion, "unknown");
             case "toBeVoid":
-                return this.#isType(assertion, "void");
-            case "toEqual": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is identical to type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`, origin),
-                ];
-            }
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                return this[matcherNameText].match(this.#getType(assertion.source[0]), assertion.isNot);
             case "toHaveProperty": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                let targetArgumentText;
-                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
-                    targetArgumentText = String(assertion.targetType.type.value);
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
-                    targetArgumentText = `[${this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.symbol.escapedName)}]`;
+                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.isTypeAssignableTo(sourceType, nonPrimitiveType)) {
+                    this.#onSourceArgumentMustBeObjectType(assertion.source[0], expectResult);
+                    return;
                 }
-                else {
-                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
+                if (assertion.target[0] == null) {
+                    this.#onKeyArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Property '${targetArgumentText}' exists on type '${sourceText}'.`
-                        : `Property '${targetArgumentText}' does not exist on type '${sourceText}'.`, origin),
-                ];
-            }
-            case "toMatch": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is a subtype of type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not a subtype of type '${sourceTypeText}'.`, origin),
-                ];
+                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);
             }
             case "toRaiseError": {
-                this.#assertNonNullishSourceType(assertion);
-                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
-                    throw new Error("An argument for 'target' must be of type 'string | number'.");
-                }
-                const sourceText = assertion.sourceType.source === 0 ? "Expression" : "Type definition";
-                if (assertion.diagnostics.length === 0) {
-                    return [Diagnostic.error(`${sourceText} did not raise a type error.`, origin)];
-                }
-                if (assertion.isNot && assertion.targetArguments.length === 0) {
-                    const related = [
-                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
-                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
-                    ];
-                    return [
-                        Diagnostic.error(`${sourceText} raised ${assertion.diagnostics.length === 1 ? "a" : assertion.diagnostics.length} type error${assertion.diagnostics.length === 1 ? "" : "s"}.`, origin).add({ related }),
-                    ];
-                }
-                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
-                    const expectedText = assertion.diagnostics.length > assertion.targetArguments.length
-                        ? `only ${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`
-                        : `${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`;
-                    const foundText = assertion.diagnostics.length > assertion.targetArguments.length
-                        ? `${assertion.diagnostics.length}`
-                        : `only ${assertion.diagnostics.length}`;
-                    const related = [
-                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
-                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
-                    ];
-                    const diagnostic = Diagnostic.error(`Expected ${expectedText}, but ${foundText} ${assertion.diagnostics.length === 1 ? "was" : "were"} raised.`, origin).add({
-                        related,
-                    });
-                    return [diagnostic];
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                const diagnostics = [];
-                assertion.targetArguments.forEach((argument, index) => {
-                    const diagnostic = assertion.diagnostics[index];
-                    if (!diagnostic) {
-                        return;
-                    }
-                    const isMatch = this.#matchExpectedError(diagnostic, argument);
-                    if (!assertion.isNot && !isMatch) {
-                        const expectedText = this.compiler.isStringLiteralLike(argument)
-                            ? `matching substring '${argument.text}'`
-                            : `with code ${argument.text}`;
-                        const related = [
-                            Diagnostic.error("The raised type error:"),
-                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
-                        ];
-                        diagnostics.push(Diagnostic.error(`${sourceText} did not raise a type error ${expectedText}.`, origin).add({ related }));
-                    }
-                    if (assertion.isNot && isMatch) {
-                        const expectedText = this.compiler.isStringLiteralLike(argument)
-                            ? `matching substring '${argument.text}'`
-                            : `with code ${argument.text}`;
-                        const related = [
-                            Diagnostic.error("The raised type error:"),
-                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
-                        ];
-                        diagnostics.push(Diagnostic.error(`${sourceText} raised a type error ${expectedText}.`, origin).add({ related }));
-                    }
-                });
-                return diagnostics;
+                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);
             }
             default:
-                throw new Error(`The '${matcher}' matcher is not supported.`);
+                this.#onNotSupportedMatcherName(assertion, expectResult);
+                return;
         }
     }
-    #hasTypeFlag(assertion, targetTypeFlag) {
-        this.#assertNonNullishSourceType(assertion);
-        return Boolean(assertion.sourceType.type.flags & targetTypeFlag);
+    #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 = {
+            end: node.getEnd(),
+            file: node.getSourceFile(),
+            start: node.getStart(),
+        };
+        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
     }
-    #isType(assertion, targetText) {
-        this.#assertNonNullishSourceType(assertion);
-        this.#assertNonNullishTypeChecker(assertion);
+    #onKeyArgumentMustBeProvided(assertion, expectResult) {
         const origin = {
-            breadcrumbs: assertion.ancestorNames,
             end: assertion.matcherName.getEnd(),
             file: assertion.matcherName.getSourceFile(),
             start: assertion.matcherName.getStart(),
         };
-        const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-        return [
-            Diagnostic.error(assertion.isNot
-                ? `Type '${targetText}' is identical to type '${sourceText}'.`
-                : `Type '${targetText}' is not identical to type '${sourceText}'.`, origin),
-        ];
+        EventEmitter.dispatch([
+            "expect:error",
+            {
+                diagnostics: [Diagnostic.error("An argument for 'key' must be provided.", origin)],
+                result: expectResult,
+            },
+        ]);
     }
-    match(assertion) {
-        const matcher = assertion.matcherName.getText();
-        switch (matcher) {
-            case "toBeAssignable":
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeAssignableTo, "The 'isTypeAssignableTo' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeAssignableTo(assertion.targetType.type, assertion.sourceType.type);
-            case "toBeAny": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Any);
-            }
-            case "toBeBigInt": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.BigInt);
-            }
-            case "toBeBoolean": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Boolean);
-            }
-            case "toBeNever": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Never);
-            }
-            case "toBeNull": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Null);
-            }
-            case "toBeNumber": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Number);
-            }
-            case "toBeString": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.String);
-            }
-            case "toBeSymbol": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.ESSymbol);
-            }
-            case "toBeUndefined": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Undefined);
-            }
-            case "toBeUniqueSymbol": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.UniqueESSymbol);
-            }
-            case "toBeUnknown": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Unknown);
-            }
-            case "toBeVoid": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Void);
-            }
-            case "toEqual": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeIdenticalTo, "The 'isTypeIdenticalTo' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeIdenticalTo(assertion.sourceType.type, assertion.targetType.type);
-            }
-            case "toHaveProperty": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                if (!(assertion.sourceType.type.flags & this.compiler.TypeFlags.StructuredType)) {
-                    const receivedText = assertion.typeChecker?.typeToString(assertion.sourceType.type);
-                    throw new Error(`An argument for 'source' must be of object type, received: '${receivedText}'.`);
-                }
-                let targetArgumentText;
-                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
-                    targetArgumentText = String(assertion.targetType.type.value);
-                }
-                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
-                    targetArgumentText = this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.escapedName);
-                }
-                else {
-                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
-                }
-                return assertion.sourceType.type.getProperties().some((property) => {
-                    return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
-                });
-            }
-            case "toMatch": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeSubtypeOf, "The 'isTypeSubtypeOf' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeSubtypeOf(assertion.sourceType.type, assertion.targetType.type);
-            }
-            case "toRaiseError": {
-                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
-                    throw new Error("An argument for 'target' must be of type 'string | number'.");
-                }
-                if (assertion.targetArguments.length === 0) {
-                    return assertion.diagnostics.length > 0;
-                }
-                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
-                    return false;
-                }
-                return assertion.targetArguments.every((expectedArgument, index) => {
-                    if (this.compiler.isStringLiteralLike(expectedArgument)) {
-                        return this.compiler
-                            .flattenDiagnosticMessageText(assertion.diagnostics[index]?.messageText, " ", 0)
-                            .includes(expectedArgument.text);
-                    }
-                    if (this.compiler.isNumericLiteral(expectedArgument)) {
-                        return Number(expectedArgument.text) === assertion.diagnostics[index]?.code;
-                    }
-                    return false;
-                });
+    #onNotSupportedMatcherName(assertion, expectResult) {
+        const matcherNameText = assertion.matcherName.getText();
+        const origin = {
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        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 = {
+            end: node.getEnd(),
+            file: node.getSourceFile(),
+            start: node.getStart(),
+        };
+        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
+    }
+    #onSourceArgumentMustBeProvided(assertion, expectResult) {
+        const origin = {
+            end: assertion.node.getEnd(),
+            file: assertion.node.getSourceFile(),
+            start: assertion.node.getStart(),
+        };
+        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 = {
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        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 = {
+                    end: node.getEnd(),
+                    file: node.getSourceFile(),
+                    start: node.getStart(),
+                };
+                diagnostics.push(Diagnostic.error(`An argument for 'target' must be of type 'string | number', received: '${receivedTypeText}'.`, origin));
             }
-            default:
-                throw new Error(`The '${matcher}' matcher is not supported.`);
         }
+        EventEmitter.dispatch(["expect:error", { diagnostics, result: expectResult }]);
+    }
+}
+
+class ProjectService {
+    compiler;
+    #service;
+    constructor(compiler) {
+        this.compiler = compiler;
+        function doNothing() {
+        }
+        function returnFalse() {
+            return false;
+        }
+        function returnUndefined() {
+            return undefined;
+        }
+        const noopWatcher = { close: doNothing };
+        const noopLogger = {
+            close: doNothing,
+            endGroup: doNothing,
+            getLogFileName: returnUndefined,
+            hasLevel: returnFalse,
+            info: doNothing,
+            loggingEnabled: returnFalse,
+            msg: doNothing,
+            perftrc: doNothing,
+            startGroup: doNothing,
+        };
+        const host = {
+            ...this.compiler.sys,
+            clearImmediate,
+            clearTimeout,
+            setImmediate,
+            setTimeout,
+            watchDirectory: () => noopWatcher,
+            watchFile: () => noopWatcher,
+        };
+        this.#service = new this.compiler.server.ProjectService({
+            allowLocalPluginLoads: true,
+            cancellationToken: this.compiler.server.nullCancellationToken,
+            host,
+            logger: noopLogger,
+            session: undefined,
+            useInferredProjectPerProjectRoot: true,
+            useSingleInferredProject: false,
+        });
+    }
+    closeFile(filePath) {
+        this.#service.closeClientFile(filePath);
+    }
+    getDefaultProject(filePath) {
+        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
     }
-    #matchExpectedError(diagnostic, argument) {
-        if (this.compiler.isStringLiteralLike(argument)) {
-            return this.compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(argument.text);
+    getLanguageService(filePath) {
+        const project = this.getDefaultProject(filePath);
+        if (!project) {
+            return;
         }
-        if (this.compiler.isNumericLiteral(argument)) {
-            return Number(argument.text) === diagnostic.code;
+        return project.getLanguageService(true);
+    }
+    openFile(filePath, sourceText, projectRootPath) {
+        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
+        EventEmitter.dispatch([
+            "project:info",
+            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
+        ]);
+        if (configFileErrors && configFileErrors.length > 0) {
+            EventEmitter.dispatch([
+                "project:error",
+                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
+            ]);
         }
-        throw new Error("An argument for 'target' must be of type 'string | number'.");
     }
 }
 
 class TestTreeWorker {
     resolvedConfig;
     compiler;
-    #checker;
+    #expect;
     #fileResult;
     #hasOnly;
     #position;
     #signal;
-    constructor(resolvedConfig, compiler, options) {
+    constructor(resolvedConfig, compiler, expect, options) {
         this.resolvedConfig = resolvedConfig;
         this.compiler = compiler;
-        this.#checker = new Checker(compiler);
+        this.#expect = expect;
+        this.#fileResult = options.fileResult;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
         this.#signal = options.signal;
-        this.#fileResult = options.fileResult;
     }
     #resolveRunMode(mode, member) {
         if (member.flags & 1) {
@@ -2052,18 +2307,21 @@ class TestTreeWorker {
             EventEmitter.dispatch(["expect:skip", { result: expectResult }]);
             return;
         }
-        if (assertion.diagnostics.length > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
             EventEmitter.dispatch([
                 "expect:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...assertion.diagnostics], this.compiler),
                     result: expectResult,
                 },
             ]);
             return;
         }
-        const isPass = this.#checker.match(assertion);
-        if (assertion.isNot ? !isPass : isPass) {
+        const matchResult = this.#expect.match(assertion, expectResult);
+        if (matchResult == null) {
+            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 = {
@@ -2073,10 +2331,7 @@ class TestTreeWorker {
                 };
                 EventEmitter.dispatch([
                     "expect:error",
-                    {
-                        diagnostics: [Diagnostic.error(text, origin)],
-                        result: expectResult,
-                    },
+                    { diagnostics: [Diagnostic.error(text, origin)], result: expectResult },
                 ]);
             }
             else {
@@ -2088,13 +2343,20 @@ class TestTreeWorker {
                 EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
             }
             else {
-                EventEmitter.dispatch([
-                    "expect:fail",
-                    {
-                        diagnostics: this.#checker.explain(assertion),
-                        result: expectResult,
-                    },
-                ]);
+                const origin = {
+                    breadcrumbs: assertion.ancestorNames,
+                    end: assertion.matcherName.getEnd(),
+                    file: assertion.matcherName.getSourceFile(),
+                    start: assertion.matcherName.getStart(),
+                };
+                const diagnostics = [];
+                for (const diagnostic of matchResult.explain()) {
+                    if (diagnostic.origin == null) {
+                        diagnostic.add({ origin });
+                    }
+                    diagnostics.push(diagnostic);
+                }
+                EventEmitter.dispatch(["expect:fail", { diagnostics, result: expectResult }]);
             }
         }
     }
@@ -2103,11 +2365,11 @@ class TestTreeWorker {
         EventEmitter.dispatch(["describe:start", { result: describeResult }]);
         runMode = this.#resolveRunMode(runMode, describe);
         if (!(runMode & 4 || (this.#hasOnly && !(runMode & 2)) || runMode & 8) &&
-            describe.diagnostics.length > 0) {
+            describe.diagnostics.size > 0) {
             EventEmitter.dispatch([
                 "file:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics(describe.diagnostics, this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...describe.diagnostics], this.compiler),
                     result: this.#fileResult,
                 },
             ]);
@@ -2125,11 +2387,11 @@ class TestTreeWorker {
             EventEmitter.dispatch(["test:todo", { result: testResult }]);
             return;
         }
-        if (!(runMode & 4 || (this.#hasOnly && !(runMode & 2))) && test.diagnostics.length > 0) {
+        if (!(runMode & 4 || (this.#hasOnly && !(runMode & 2))) && test.diagnostics.size > 0) {
             EventEmitter.dispatch([
                 "test:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics(test.diagnostics, this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...test.diagnostics], this.compiler),
                     result: testResult,
                 },
             ]);
@@ -2198,19 +2460,25 @@ class TestFileRunner {
         if (!sourceFile) {
             return;
         }
-        const typeChecker = program.getTypeChecker();
-        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics, typeChecker);
-        if (testTree.diagnostics.length > 0) {
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
+        if (testTree.diagnostics.size > 0) {
             EventEmitter.dispatch([
                 "file:error",
                 {
-                    diagnostics: Diagnostic.fromDiagnostics(testTree.diagnostics, this.compiler),
+                    diagnostics: Diagnostic.fromDiagnostics([...testTree.diagnostics], this.compiler),
                     result: fileResult,
                 },
             ]);
             return;
         }
-        const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, {
+        const typeChecker = program.getTypeChecker();
+        if (!Expect.assertTypeChecker(typeChecker)) {
+            const text = "The required 'isTypeAssignableTo()', 'isTypeIdenticalTo()' and 'isTypeSubtypeOf()' methods are 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, {
             fileResult,
             hasOnly: testTree.hasOnly,
             position,
@@ -2257,17 +2525,13 @@ class TSTyche {
     #abortController = new AbortController();
     #storeService;
     #taskRunner;
+    static version = "1.0.0-beta.8";
     constructor(resolvedConfig, storeService) {
         this.resolvedConfig = resolvedConfig;
         this.#storeService = storeService;
         this.#taskRunner = new TaskRunner(this.resolvedConfig, this.#storeService);
         this.#addEventHandlers();
     }
-    static get version() {
-        const packageConfig = readFileSync(new URL("../package.json", import.meta.url), { encoding: "utf8" });
-        const { version } = JSON.parse(packageConfig);
-        return version;
-    }
     #addEventHandlers() {
         EventEmitter.addHandler(([eventName, payload]) => {
             if (eventName.includes("error") || eventName.includes("fail")) {
@@ -2325,19 +2589,19 @@ class OptionDefinitionsMap {
             name: "failFast",
         },
         {
-            brand: "boolean",
-            description: "Print the list of CLI options with brief descriptions and exit.",
+            brand: "true",
+            description: "Print the list of command line options with brief descriptions and exit.",
             group: 2,
             name: "help",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Install specified versions of the 'typescript' package and exit.",
             group: 2,
             name: "install",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Print the list of the selected test files and exit.",
             group: 2,
             name: "listFiles",
@@ -2349,7 +2613,7 @@ class OptionDefinitionsMap {
             name: "only",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Remove all installed versions of the 'typescript' package and exit.",
             group: 2,
             name: "prune",
@@ -2361,7 +2625,7 @@ class OptionDefinitionsMap {
             name: "rootPath",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Print the resolved configuration and exit.",
             group: 2,
             name: "showConfig",
@@ -2394,13 +2658,13 @@ class OptionDefinitionsMap {
             name: "testFileMatch",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Fetch the 'typescript' package metadata from the registry and exit.",
             group: 2,
             name: "update",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Print the version number and exit.",
             group: 2,
             name: "version",
@@ -2467,15 +2731,15 @@ class OptionUsageText {
         this.#optionDiagnosticText = new OptionDiagnosticText(this.#optionGroup);
         this.#storeService = storeService;
     }
-    get(optionName, optionBrand) {
+    async get(optionName, optionBrand) {
         const usageText = [];
         switch (optionName) {
             case "target": {
-                const { supportedTags } = this.#storeService;
+                const supportedTags = await this.#storeService.getSupportedTags();
                 const supportedTagsText = `Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`;
                 switch (this.#optionGroup) {
                     case 2:
-                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target 5.0.4', '--target 4.7,4.8,latest'.", supportedTagsText);
+                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target 5.0.4', '--target 4.7,5.3.2,current'.", supportedTagsText);
                         break;
                     case 4:
                         usageText.push("Item of the 'target' list must be a supported version tag.", supportedTagsText);
@@ -2503,7 +2767,7 @@ class OptionValidator {
         this.#optionDiagnosticText = new OptionDiagnosticText(this.#optionGroup);
         this.#optionUsageText = new OptionUsageText(this.#optionGroup, this.#storeService);
     }
-    check(optionName, optionValue, optionBrand, origin) {
+    async check(optionName, optionValue, optionBrand, origin) {
         switch (optionName) {
             case "config":
             case "rootPath":
@@ -2513,13 +2777,11 @@ class OptionValidator {
                 }
                 break;
             case "target":
-                {
-                    if (!this.#storeService.validateTag(optionValue)) {
-                        this.#onDiagnostic(Diagnostic.error([
-                            this.#optionDiagnosticText.versionIsNotSupported(optionValue),
-                            ...this.#optionUsageText.get(optionName, optionBrand),
-                        ], origin));
-                    }
+                if (!(await this.#storeService.validateTag(optionValue))) {
+                    this.#onDiagnostic(Diagnostic.error([
+                        this.#optionDiagnosticText.versionIsNotSupported(optionValue),
+                        ...(await this.#optionUsageText.get(optionName, optionBrand)),
+                    ], origin));
                 }
                 break;
         }
@@ -2545,29 +2807,23 @@ class CommandLineOptionsWorker {
         this.#optionUsageText = new OptionUsageText(2, this.#storeService);
         this.#optionValidator = new OptionValidator(2, this.#storeService, this.#onDiagnostic);
     }
-    #normalizePath(filePath) {
-        if (path.sep === "/") {
-            return filePath;
-        }
-        return filePath.replace(/\\/g, "/");
-    }
-    #onExpectsArgumentDiagnostic(optionDefinition) {
+    async #onExpectsArgumentDiagnostic(optionDefinition) {
         const text = [
             this.#optionDiagnosticText.expectsArgument(optionDefinition.name),
-            ...this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand),
+            ...(await this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand)),
         ];
         this.#onDiagnostic(Diagnostic.error(text));
     }
-    parse(commandLineArgs) {
+    async parse(commandLineArgs) {
         let index = 0;
         let arg = commandLineArgs[index];
-        while (arg !== undefined) {
+        while (arg != null) {
             index++;
             if (arg.startsWith("--")) {
                 const optionName = arg.slice(2);
                 const optionDefinition = this.#commandLineOptionDefinitions.get(optionName);
                 if (optionDefinition) {
-                    index = this.#parseOptionValue(commandLineArgs, index, optionDefinition);
+                    index = await this.#parseOptionValue(commandLineArgs, index, optionDefinition);
                 }
                 else {
                     this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownOption(arg)));
@@ -2577,14 +2833,17 @@ class CommandLineOptionsWorker {
                 this.#onDiagnostic(Diagnostic.error(this.#optionDiagnosticText.unknownOption(arg)));
             }
             else {
-                this.#pathMatch.push(arg);
+                this.#pathMatch.push(Path.normalizeSlashes(arg));
             }
             arg = commandLineArgs[index];
         }
     }
-    #parseOptionValue(commandLineArgs, index, optionDefinition) {
+    async #parseOptionValue(commandLineArgs, index, optionDefinition) {
         let optionValue = this.#resolveOptionValue(commandLineArgs[index]);
         switch (optionDefinition.brand) {
+            case "true":
+                this.#commandLineOptions[optionDefinition.name] = true;
+                break;
             case "boolean":
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
@@ -2598,33 +2857,25 @@ class CommandLineOptionsWorker {
                         .map((value) => value.trim())
                         .filter((value) => value !== "");
                     for (const optionValue of optionValues) {
-                        this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                        await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
                     }
                     this.#commandLineOptions[optionDefinition.name] = optionValues;
                     index++;
                     break;
                 }
-                this.#onExpectsArgumentDiagnostic(optionDefinition);
-                break;
-            case "number":
-                if (optionValue != null) {
-                    this.#commandLineOptions[optionDefinition.name] = Number(optionValue);
-                    index++;
-                    break;
-                }
-                this.#onExpectsArgumentDiagnostic(optionDefinition);
+                await this.#onExpectsArgumentDiagnostic(optionDefinition);
                 break;
             case "string":
                 if (optionValue != null) {
                     if (optionDefinition.name === "config") {
-                        optionValue = this.#normalizePath(path.resolve(optionValue));
+                        optionValue = Path.resolve(optionValue);
                     }
-                    this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                    await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
                     this.#commandLineOptions[optionDefinition.name] = optionValue;
                     index++;
                     break;
                 }
-                this.#onExpectsArgumentDiagnostic(optionDefinition);
+                await this.#onExpectsArgumentDiagnostic(optionDefinition);
                 break;
         }
         return index;
@@ -2660,12 +2911,6 @@ class ConfigFileOptionsWorker {
         return (node.kind === this.compiler.SyntaxKind.StringLiteral &&
             sourceFile.text.slice(this.#skipTrivia(node.pos, sourceFile), node.end).startsWith('"'));
     }
-    #normalizePath(filePath) {
-        if (path.sep === "/") {
-            return filePath;
-        }
-        return filePath.replace(/\\/g, "/");
-    }
     async parse(sourceText) {
         if (sourceText === "") {
             return;
@@ -2744,22 +2989,17 @@ class ConfigFileOptionsWorker {
                 if (optionDefinition.brand === "string") {
                     let value = valueExpression.text;
                     if (optionDefinition.name === "rootPath") {
-                        value = this.#normalizePath(path.resolve(path.dirname(this.#configFilePath), value));
+                        value = Path.resolve(Path.dirname(this.#configFilePath), value);
                     }
                     const origin = {
                         end: valueExpression.end,
                         file: sourceFile,
                         start: this.#skipTrivia(valueExpression.pos, sourceFile),
                     };
-                    this.#optionValidator.check(optionDefinition.name, value, optionDefinition.brand, origin);
+                    await this.#optionValidator.check(optionDefinition.name, value, optionDefinition.brand, origin);
                     return value;
                 }
                 break;
-            case this.compiler.SyntaxKind.NumericLiteral:
-                if (optionDefinition.brand === "number") {
-                    return Number(valueExpression.text);
-                }
-                break;
             case this.compiler.SyntaxKind.ArrayLiteralExpression:
                 if (optionDefinition.brand === "list") {
                     const value = [];
@@ -2866,7 +3106,7 @@ class ConfigService {
         allowNoTestFiles: false,
         failFast: false,
         rootPath: "./",
-        target: ["latest"],
+        target: [Environment.isTypeScriptInstalled ? "current" : "latest"],
         testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
     };
     #pathMatch = [];
@@ -2884,25 +3124,19 @@ class ConfigService {
     static get defaultOptions() {
         return ConfigService.#defaultOptions;
     }
-    #normalizePath(filePath) {
-        if (path.sep === "/") {
-            return filePath;
-        }
-        return filePath.replace(/\\/g, "/");
-    }
     #onDiagnostic = (diagnostic) => {
         EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
     };
-    parseCommandLine(commandLineArgs) {
+    async parseCommandLine(commandLineArgs) {
         this.#commandLineOptions = {};
         this.#pathMatch = [];
         const commandLineWorker = new CommandLineOptionsWorker(this.#commandLineOptions, this.#pathMatch, this.#storeService, this.#onDiagnostic);
-        commandLineWorker.parse(commandLineArgs);
+        await commandLineWorker.parse(commandLineArgs);
     }
     async readConfigFile(filePath, sourceText) {
-        const configFilePath = filePath ?? this.#commandLineOptions.config ?? path.resolve("./tstyche.config.json");
+        const configFilePath = filePath ?? this.#commandLineOptions.config ?? Path.resolve("./tstyche.config.json");
         this.#configFileOptions = {
-            rootPath: this.#normalizePath(path.dirname(configFilePath)),
+            rootPath: Path.dirname(configFilePath),
         };
         let configFileText = sourceText ?? "";
         if (sourceText == null && existsSync(configFilePath)) {
@@ -2918,7 +3152,7 @@ class ConfigService {
             ...ConfigService.#defaultOptions,
             ...this.#configFileOptions,
             ...this.#commandLineOptions,
-            pathMatch: this.#pathMatch.map((match) => this.#normalizePath(match)),
+            pathMatch: this.#pathMatch,
         };
         return mergedOptions;
     }
@@ -2927,7 +3161,7 @@ class ConfigService {
         let testFilePaths = this.compiler.sys.readDirectory(rootPath, undefined, undefined, testFileMatch);
         if (pathMatch.length > 0) {
             testFilePaths = testFilePaths.filter((testFilePath) => pathMatch.some((match) => {
-                const relativeTestFilePath = this.#normalizePath(`./${path.relative("", testFilePath)}`);
+                const relativeTestFilePath = Path.relative("", testFilePath);
                 return relativeTestFilePath.toLowerCase().includes(match.toLowerCase());
             }));
         }
@@ -2951,6 +3185,7 @@ var OptionBrand;
     OptionBrand["String"] = "string";
     OptionBrand["Number"] = "number";
     OptionBrand["Boolean"] = "boolean";
+    OptionBrand["True"] = "true";
     OptionBrand["List"] = "list";
     OptionBrand["Object"] = "object";
 })(OptionBrand || (OptionBrand = {}));
@@ -2961,162 +3196,27 @@ var OptionGroup;
     OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
 })(OptionGroup || (OptionGroup = {}));
 
-class Lock {
-    #lockFilePath;
-    static #lockSuffix = "__lock__";
-    constructor(targetPath) {
-        this.#lockFilePath = Lock.#getLockFilePath(targetPath);
-        writeFileSync(this.#lockFilePath, "");
-        process.on("exit", () => {
-            this.release();
-        });
-    }
-    static #getLockFilePath(targetPath) {
-        return `${targetPath}${Lock.#lockSuffix}`;
+class ManifestWorker {
+    #manifestFileName = "store-manifest.json";
+    #manifestFilePath;
+    #onDiagnostic;
+    #prune;
+    #registryUrl = new URL("https://registry.npmjs.org");
+    #storePath;
+    #timeout = Environment.timeout * 1000;
+    #version = "1";
+    constructor(storePath, onDiagnostic, prune) {
+        this.#storePath = storePath;
+        this.#onDiagnostic = onDiagnostic;
+        this.#manifestFilePath = Path.join(storePath, this.#manifestFileName);
+        this.#prune = prune;
     }
-    static async isLocked(targetPath, options) {
-        let isLocked = existsSync(Lock.#getLockFilePath(targetPath));
-        if (!isLocked) {
-            return isLocked;
-        }
-        if (options?.timeout == null) {
-            return isLocked;
-        }
-        const waitStartTime = Date.now();
-        while (isLocked) {
-            if (options.signal?.aborted === true) {
-                break;
-            }
-            if (Date.now() - waitStartTime > options.timeout) {
-                options.onDiagnostic?.(`Lock wait timeout of ${options.timeout / 1000}s was exceeded.`);
-                break;
-            }
-            await Lock.#sleep(1000);
-            isLocked = existsSync(Lock.#getLockFilePath(targetPath));
+    async #create(signal) {
+        const manifest = await this.#load(signal);
+        if (manifest != null) {
+            await this.persist(manifest);
         }
-        return isLocked;
-    }
-    release() {
-        rmSync(this.#lockFilePath, { force: true });
-    }
-    static async #sleep(time) {
-        return new Promise((resolve) => setTimeout(resolve, time));
-    }
-}
-
-class CompilerModuleWorker {
-    #cachePath;
-    #onDiagnostic;
-    #readyFileName = "__ready__";
-    #timeout = Environment.timeout * 1000;
-    constructor(cachePath, onDiagnostic) {
-        this.#cachePath = cachePath;
-        this.#onDiagnostic = onDiagnostic;
-    }
-    async ensure(compilerVersion, signal) {
-        const installationPath = path.join(this.#cachePath, compilerVersion);
-        const readyFilePath = path.join(installationPath, this.#readyFileName);
-        const tsserverFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "tsserverlibrary.js");
-        const typescriptFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
-        if (await Lock.isLocked(installationPath, {
-            onDiagnostic: (text) => {
-                this.#onDiagnostic(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
-            },
-            signal,
-            timeout: this.#timeout,
-        })) {
-            return;
-        }
-        if (existsSync(readyFilePath)) {
-            return tsserverFilePath;
-        }
-        EventEmitter.dispatch(["store:info", { compilerVersion, installationPath: this.#normalizePath(installationPath) }]);
-        try {
-            await fs.mkdir(installationPath, { recursive: true });
-            const lock = new Lock(installationPath);
-            await fs.writeFile(path.join(installationPath, "package.json"), this.#getPackageJson(compilerVersion));
-            await this.#installPackage(installationPath, signal);
-            await fs.writeFile(tsserverFilePath, await this.#getPatched(compilerVersion, tsserverFilePath));
-            await fs.writeFile(typescriptFilePath, await this.#getPatched(compilerVersion, typescriptFilePath));
-            await fs.writeFile(readyFilePath, "");
-            lock.release();
-        }
-        catch (error) {
-            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
-        }
-        return tsserverFilePath;
-    }
-    #getPackageJson(version) {
-        const packageJson = {
-            name: "@tstyche/typescript",
-            version,
-            description: "Do not change. This package was generated by TSTyche",
-            private: true,
-            license: "MIT",
-            dependencies: {
-                typescript: version,
-            },
-        };
-        return JSON.stringify(packageJson, null, 2);
-    }
-    async #getPatched(version, filePath) {
-        function ts5Patch(match, indent) {
-            return [match, indent, "isTypeIdenticalTo,", indent, "isTypeSubtypeOf,"].join("");
-        }
-        function ts4Patch(match, indent) {
-            return [match, indent, "isTypeIdenticalTo: isTypeIdenticalTo,", indent, "isTypeSubtypeOf: isTypeSubtypeOf,"].join("");
-        }
-        const fileContent = await fs.readFile(filePath, { encoding: "utf8" });
-        if (version.startsWith("5")) {
-            return fileContent.replace(/(\s+)isTypeAssignableTo,/, ts5Patch);
-        }
-        else {
-            return fileContent.replace(/(\s+)isTypeAssignableTo: isTypeAssignableTo,/, ts4Patch);
-        }
-    }
-    async #installPackage(cwd, signal) {
-        const args = ["install", "--ignore-scripts", "--no-bin-links", "--no-package-lock"];
-        return new Promise((resolve, reject) => {
-            const spawnedNpm = spawn("npm", args, {
-                cwd,
-                shell: true,
-                signal,
-                stdio: "ignore",
-                timeout: this.#timeout,
-            });
-            spawnedNpm.on("error", (error) => {
-                reject(error);
-            });
-            spawnedNpm.on("close", (code, signal) => {
-                if (code === 0) {
-                    resolve();
-                }
-                if (signal != null) {
-                    reject(new Error(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`));
-                }
-                reject(new Error(`Process exited with code ${String(code)}.`));
-            });
-        });
-    }
-    #normalizePath(filePath) {
-        if (path.sep === "/") {
-            return filePath;
-        }
-        return filePath.replace(/\\/g, "/");
-    }
-}
-
-class ManifestWorker {
-    #cachePath;
-    #manifestFileName = "store-manifest.json";
-    #manifestFilePath;
-    #prune;
-    #registryUrl = new URL("https://registry.npmjs.org");
-    #timeout = Environment.timeout * 1000;
-    constructor(cachePath, prune) {
-        this.#cachePath = cachePath;
-        this.#manifestFilePath = path.join(cachePath, this.#manifestFileName);
-        this.#prune = prune;
+        return manifest;
     }
     async #fetch(signal) {
         return new Promise((resolve, reject) => {
@@ -3154,8 +3254,9 @@ class ManifestWorker {
         }
         return false;
     }
-    async #load(signal, isUpdate = false) {
+    async #load(signal, options = { quite: false }) {
         const manifest = {
+            $version: this.#version,
             lastUpdated: Date.now(),
             resolutions: {},
             versions: [],
@@ -3167,13 +3268,13 @@ class ManifestWorker {
             abortController.abort(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`);
         }, { once: true });
         signal?.addEventListener("abort", () => {
-            abortController.abort(`Fetch got canceled by request.`);
+            abortController.abort("Fetch got canceled by request.");
         }, { once: true });
         try {
             packageMetadata = await this.#fetch(abortController.signal);
         }
         catch (error) {
-            if (!isUpdate) {
+            if (!options.quite) {
                 const text = [`Failed to fetch metadata of the 'typescript' package from '${this.#registryUrl.href}'.`];
                 if (error instanceof Error && error.name !== "AbortError") {
                     text.push("Might be there is an issue with the registry or the network connection.");
@@ -3202,18 +3303,10 @@ class ManifestWorker {
         }
         return manifest;
     }
-    #onDiagnostic(diagnostic) {
-        EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
-    }
-    async open(signal) {
+    async open(signal, options) {
         let manifest;
         if (!existsSync(this.#manifestFilePath)) {
-            manifest = await this.#load(signal);
-            if (manifest == null) {
-                return;
-            }
-            await this.persist(manifest);
-            return manifest;
+            return this.#create(signal);
         }
         let manifestText;
         try {
@@ -3228,85 +3321,248 @@ class ManifestWorker {
         try {
             manifest = JSON.parse(manifestText);
         }
-        catch (error) {
-            this.#onDiagnostic(Diagnostic.fromError([
-                `Failed to parse '${this.#manifestFilePath}'.`,
-                "Cached files appeared to be corrupt and got removed. Try running 'tstyche' again.",
-            ], error));
+        catch {
         }
-        if (manifest == null) {
+        if (manifest == null || manifest.$version !== this.#version) {
             await this.#prune();
-            return;
+            return this.#create(signal);
         }
-        if (this.isOutdated(manifest)) {
-            manifest = await this.update(manifest, signal);
+        if (this.isOutdated(manifest) || options?.refresh === true) {
+            const quite = options?.refresh !== true;
+            const freshManifest = await this.#load(signal, { quite });
+            if (freshManifest != null) {
+                manifest = { ...manifest, ...freshManifest };
+                await this.persist(manifest);
+            }
         }
         return manifest;
     }
     async persist(manifest) {
-        if (!existsSync(this.#cachePath)) {
-            await fs.mkdir(this.#cachePath, { recursive: true });
+        if (!existsSync(this.#storePath)) {
+            await fs.mkdir(this.#storePath, { recursive: true });
         }
         await fs.writeFile(this.#manifestFilePath, JSON.stringify(manifest));
     }
-    async update(manifest, signal) {
-        const freshManifest = await this.#load(signal, true);
-        if (freshManifest != null) {
-            manifest = { ...manifest, ...freshManifest };
-            await this.persist(manifest);
+}
+
+class Lock {
+    #lockFilePath;
+    static #lockSuffix = "__lock__";
+    constructor(targetPath) {
+        this.#lockFilePath = Lock.#getLockFilePath(targetPath);
+        writeFileSync(this.#lockFilePath, "");
+        process.on("exit", () => {
+            this.release();
+        });
+    }
+    static #getLockFilePath(targetPath) {
+        return `${targetPath}${Lock.#lockSuffix}`;
+    }
+    static async isLocked(targetPath, options) {
+        let isLocked = existsSync(Lock.#getLockFilePath(targetPath));
+        if (!isLocked) {
+            return isLocked;
         }
-        return manifest;
+        if (options?.timeout == null) {
+            return isLocked;
+        }
+        const waitStartTime = Date.now();
+        while (isLocked) {
+            if (options.signal?.aborted === true) {
+                break;
+            }
+            if (Date.now() - waitStartTime > options.timeout) {
+                options.onDiagnostic?.(`Lock wait timeout of ${options.timeout / 1000}s was exceeded.`);
+                break;
+            }
+            await Lock.#sleep(1000);
+            isLocked = existsSync(Lock.#getLockFilePath(targetPath));
+        }
+        return isLocked;
+    }
+    release() {
+        rmSync(this.#lockFilePath, { force: true });
+    }
+    static async #sleep(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+}
+
+class Version {
+    static satisfies(source, target) {
+        const sourceElements = source.split(/\.|-/);
+        const targetElements = target.split(/\.|-/);
+        function compare(index = 0) {
+            const sourceElement = sourceElements[index];
+            const targetElement = targetElements[index];
+            if (sourceElement > targetElement) {
+                return true;
+            }
+            if (sourceElement === targetElement) {
+                if (index === targetElements.length - 1) {
+                    return true;
+                }
+                return compare(index + 1);
+            }
+            return false;
+        }
+        return compare();
+    }
+}
+
+class PackageInstaller {
+    #onDiagnostic;
+    #readyFileName = "__ready__";
+    #storePath;
+    #timeout = Environment.timeout * 1000;
+    constructor(storePath, onDiagnostic) {
+        this.#storePath = storePath;
+        this.#onDiagnostic = onDiagnostic;
+    }
+    async ensure(compilerVersion, signal) {
+        const installationPath = Path.join(this.#storePath, compilerVersion);
+        const readyFilePath = Path.join(installationPath, this.#readyFileName);
+        if (await Lock.isLocked(installationPath, {
+            onDiagnostic: (text) => {
+                this.#onDiagnostic(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
+            },
+            signal,
+            timeout: this.#timeout,
+        })) {
+            return;
+        }
+        if (!existsSync(readyFilePath)) {
+            EventEmitter.dispatch(["store:info", { compilerVersion, installationPath }]);
+            try {
+                await fs.mkdir(installationPath, { recursive: true });
+                const lock = new Lock(installationPath);
+                const packageJson = {
+                    name: "tstyche-typescript",
+                    version: compilerVersion,
+                    description: "Do not change. This package was generated by TSTyche",
+                    private: true,
+                    license: "MIT",
+                    dependencies: {
+                        typescript: compilerVersion,
+                    },
+                };
+                await fs.writeFile(Path.join(installationPath, "package.json"), JSON.stringify(packageJson, null, 2));
+                await this.#install(installationPath, signal);
+                await fs.writeFile(readyFilePath, "");
+                lock.release();
+            }
+            catch (error) {
+                this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
+            }
+        }
+        if (Version.satisfies(compilerVersion, "5.3")) {
+            return Path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
+        }
+        return Path.join(installationPath, "node_modules", "typescript", "lib", "tsserverlibrary.js");
+    }
+    async #install(cwd, signal) {
+        const args = ["install", "--ignore-scripts", "--no-bin-links", "--no-package-lock"];
+        return new Promise((resolve, reject) => {
+            const spawnedNpm = spawn("npm", args, {
+                cwd,
+                shell: true,
+                signal,
+                stdio: "ignore",
+                timeout: this.#timeout,
+            });
+            spawnedNpm.on("error", (error) => {
+                reject(error);
+            });
+            spawnedNpm.on("close", (code, signal) => {
+                if (code === 0) {
+                    resolve();
+                }
+                if (signal != null) {
+                    reject(new Error(`Setup timeout of ${this.#timeout / 1000}s was exceeded.`));
+                }
+                reject(new Error(`Process exited with code ${String(code)}.`));
+            });
+        });
     }
 }
 
 class StoreService {
-    #cachePath;
-    #compilerModuleWorker;
+    #compilerInstanceCache = new Map();
     #manifest;
     #manifestWorker;
     #nodeRequire = createRequire(import.meta.url);
+    #packageInstaller;
+    #storePath;
     constructor() {
-        this.#cachePath = Environment.storePath;
-        this.#compilerModuleWorker = new CompilerModuleWorker(this.#cachePath, this.#onDiagnostic);
-        this.#manifestWorker = new ManifestWorker(this.#cachePath, async () => this.prune());
+        this.#storePath = Environment.storePath;
+        this.#packageInstaller = new PackageInstaller(this.#storePath, this.#onDiagnostic);
+        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostic, this.prune);
     }
-    get supportedTags() {
+    async getSupportedTags(signal) {
+        await this.open(signal);
         if (!this.#manifest) {
-            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return [];
         }
         return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions, "current"].sort();
     }
     async install(tag, signal) {
-        if (!this.#manifest) {
-            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
+        if (tag === "current") {
             return;
         }
-        const version = this.resolveTag(tag);
+        const version = await this.resolveTag(tag, signal);
         if (version == null) {
             this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
             return;
         }
-        return this.#compilerModuleWorker.ensure(version, signal);
+        return this.#packageInstaller.ensure(version, signal);
     }
     async load(tag, signal) {
+        let compilerInstance = this.#compilerInstanceCache.get(tag);
+        if (compilerInstance != null) {
+            return compilerInstance;
+        }
         let modulePath;
-        if (tag === "local") {
+        if (tag === "current") {
             try {
-                modulePath = this.#nodeRequire.resolve("typescript/lib/tsserverlibrary.js");
+                modulePath = this.#nodeRequire.resolve("typescript");
             }
-            catch {
-                tag = "latest";
+            catch (error) {
+                this.#onDiagnostic(Diagnostic.fromError("Failed to resolve locally installed 'typescript' package. It might be not installed.", error));
             }
         }
         if (modulePath == null) {
-            modulePath = await this.install(tag, signal);
+            if (tag === "current") {
+                return;
+            }
+            const version = await this.resolveTag(tag, signal);
+            if (version == null) {
+                this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+                return;
+            }
+            compilerInstance = this.#compilerInstanceCache.get(version);
+            if (compilerInstance != null) {
+                return compilerInstance;
+            }
+            modulePath = await this.#packageInstaller.ensure(version, signal);
         }
         if (modulePath != null) {
-            return this.#nodeRequire(modulePath);
+            compilerInstance = await this.#loadModule(modulePath);
+            this.#compilerInstanceCache.set(tag, compilerInstance);
+            this.#compilerInstanceCache.set(compilerInstance.version, compilerInstance);
+            return compilerInstance;
         }
         return;
     }
+    async #loadModule(modulePath) {
+        const exports = {};
+        const require = createRequire(modulePath);
+        const module = { exports };
+        let sourceText = await fs.readFile(modulePath, { encoding: "utf8" });
+        sourceText = sourceText.replace("isTypeAssignableTo,", "isTypeAssignableTo, isTypeIdenticalTo, isTypeSubtypeOf,");
+        const compiledWrapper = vm.compileFunction(sourceText, ["exports", "require", "module", "__filename", "__dirname"], { filename: modulePath });
+        compiledWrapper(exports, require, module, modulePath, Path.dirname(modulePath));
+        return module.exports;
+    }
     #onDiagnostic = (diagnostic) => {
         EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
     };
@@ -3316,22 +3572,17 @@ class StoreService {
         }
         this.#manifest = await this.#manifestWorker.open(signal);
     }
-    async prune() {
-        await fs.rm(this.#cachePath, { force: true, recursive: true });
-    }
-    resolveTag(tag) {
+    prune = async () => {
+        await fs.rm(this.#storePath, { force: true, recursive: true });
+    };
+    async resolveTag(tag, signal) {
+        if (tag === "current") {
+            return tag;
+        }
+        await this.open(signal);
         if (!this.#manifest) {
-            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return;
         }
-        if (tag === "current") {
-            try {
-                tag = this.#nodeRequire("typescript").version;
-            }
-            catch (error) {
-                this.#onDiagnostic(Diagnostic.fromError("Failed to resolve tag 'current'. The 'typescript' package might be not installed.", error));
-            }
-        }
         if (this.#manifest.versions.includes(tag)) {
             return tag;
         }
@@ -3346,15 +3597,14 @@ class StoreService {
         return version;
     }
     async update(signal) {
-        if (!this.#manifest) {
-            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
-            return;
-        }
-        await this.#manifestWorker.update(this.#manifest, signal);
+        await this.#manifestWorker.open(signal, { refresh: true });
     }
-    validateTag(tag) {
+    async validateTag(tag, signal) {
+        if (tag === "current") {
+            return true;
+        }
+        await this.open(signal);
         if (!this.#manifest) {
-            this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return false;
         }
         if (this.#manifest.versions.includes(tag) || tag in this.#manifest.resolutions || tag === "current") {
@@ -3371,154 +3621,6 @@ class StoreService {
     }
 }
 
-class JsonText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Line, null, JSON.stringify(this.#sortObject(this.props.input), null, 2));
-    }
-    #sortObject(target) {
-        if (Array.isArray(target)) {
-            return target;
-        }
-        return Object.keys(target)
-            .sort()
-            .reduce((result, key) => {
-            result[key] = target[key];
-            return result;
-        }, {});
-    }
-}
-function formattedText(input) {
-    if (typeof input === "string") {
-        return Scribbler.createElement(Line, null, input);
-    }
-    return Scribbler.createElement(JsonText, { input: input });
-}
-
-const usageExamples = [
-    ["tstyche", "Run all tests."],
-    ["tstyche path/to/first.test.ts second", "Only run the test files with matching path."],
-    ["tstyche --target 4.7,4.8,latest", "Test on all specified versions of TypeScript."],
-];
-class HintText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return (Scribbler.createElement(Text, { indent: 1, color: "90" }, this.props.children));
-    }
-}
-class HelpHeaderText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        const hint = (Scribbler.createElement(HintText, null,
-            Scribbler.createElement(Text, null, this.props.tstycheVersion)));
-        return (Scribbler.createElement(Line, null,
-            Scribbler.createElement(Text, null, "The TSTyche Type Test Runner"),
-            hint));
-    }
-}
-class CommandText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        let hint = undefined;
-        if (this.props.hint != null) {
-            hint = Scribbler.createElement(HintText, null, this.props.hint);
-        }
-        return (Scribbler.createElement(Line, { indent: 1 },
-            Scribbler.createElement(Text, { color: "34" }, this.props.text),
-            hint));
-    }
-}
-class OptionDescriptionText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
-    }
-}
-class CliUsageText {
-    render() {
-        const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
-            Scribbler.createElement(CommandText, { text: commandText }),
-            Scribbler.createElement(OptionDescriptionText, { text: descriptionText }),
-            Scribbler.createElement(Line, null))));
-        return Scribbler.createElement(Text, null, usageText);
-    }
-}
-class OptionNameText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Text, null,
-            "--",
-            this.props.text);
-    }
-}
-class OptionHintText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        if (this.props.definition.brand === "list") {
-            return (Scribbler.createElement(Text, null,
-                this.props.definition.brand,
-                " of ",
-                this.props.definition.items.brand,
-                "s"));
-        }
-        return Scribbler.createElement(Text, null, this.props.definition.brand);
-    }
-}
-class CliOptionsText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        const definitions = Array.from(this.props.optionDefinitions.values());
-        const optionsText = definitions.map((definition) => (Scribbler.createElement(Text, null,
-            Scribbler.createElement(CommandText, { text: Scribbler.createElement(OptionNameText, { text: definition.name }), hint: Scribbler.createElement(OptionHintText, { definition: definition }) }),
-            Scribbler.createElement(OptionDescriptionText, { text: definition.description }),
-            Scribbler.createElement(Line, null))));
-        return (Scribbler.createElement(Text, null,
-            Scribbler.createElement(Line, null, "CLI Options"),
-            Scribbler.createElement(Line, null),
-            optionsText));
-    }
-}
-class HelpFooterText {
-    render() {
-        return Scribbler.createElement(Line, null, "To learn more, visit https://tstyche.org");
-    }
-}
-function helpText(optionDefinitions, tstycheVersion) {
-    return (Scribbler.createElement(Text, null,
-        Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliUsageText, null),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliOptionsText, { optionDefinitions: optionDefinitions }),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(HelpFooterText, null),
-        Scribbler.createElement(Line, null)));
-}
-
 class Cli {
     #abortController = new AbortController();
     #logger;
@@ -3551,36 +3653,35 @@ class Cli {
                 break;
         }
     };
-    async run(commandLineArgs) {
+    async run(commandLineArguments) {
         EventEmitter.addHandler(this.#onStartupEvent);
-        await this.#storeService.open(this.#abortController.signal);
-        if (this.#process.exitCode === 1) {
+        if (commandLineArguments.includes("--help")) {
+            const commandLineOptionDefinitions = OptionDefinitionsMap.for(2);
+            this.#logger.writeMessage(helpText(commandLineOptionDefinitions, TSTyche.version));
             return;
         }
-        const compiler = await this.#storeService.load("local", this.#abortController.signal);
-        if (!compiler) {
+        if (commandLineArguments.includes("--prune")) {
+            await this.#storeService.prune();
             return;
         }
-        const configService = new ConfigService(compiler, this.#storeService);
-        configService.parseCommandLine(commandLineArgs);
-        if (this.#process.exitCode === 1) {
+        if (commandLineArguments.includes("--version")) {
+            this.#logger.writeMessage(formattedText(TSTyche.version));
             return;
         }
-        if (configService.commandLineOptions.prune === true) {
-            await this.#storeService.prune();
+        if (commandLineArguments.includes("--update")) {
+            await this.#storeService.update(this.#abortController.signal);
             return;
         }
-        if (configService.commandLineOptions.help === true) {
-            const commandLineOptionDefinitions = OptionDefinitionsMap.for(2);
-            this.#logger.writeMessage(helpText(commandLineOptionDefinitions, TSTyche.version));
+        if (this.#process.exitCode === 1) {
             return;
         }
-        if (configService.commandLineOptions.update === true) {
-            await this.#storeService.update();
+        const compiler = await this.#storeService.load(Environment.isTypeScriptInstalled ? "current" : "latest", this.#abortController.signal);
+        if (!compiler) {
             return;
         }
-        if (configService.commandLineOptions.version === true) {
-            this.#logger.writeMessage(formattedText(TSTyche.version));
+        const configService = new ConfigService(compiler, this.#storeService);
+        await configService.parseCommandLine(commandLineArguments);
+        if (this.#process.exitCode === 1) {
             return;
         }
         await configService.readConfigFile();
@@ -3617,4 +3718,4 @@ class Cli {
     }
 }
 
-export { Assertion, AssertionSource, Checker, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, ExpectResult, FileResult, Line, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, summaryText, testNameText, usesCompilerStepText };
+export { Assertion, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, Expect, ExpectResult, FileResult, Line, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, Path, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText };