tstyche 1.0.0-beta.7 → 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) {
@@ -79,6 +115,18 @@ class Environment {
     }
 }
 
+var Color;
+(function (Color) {
+    Color["Reset"] = "0";
+    Color["Red"] = "31";
+    Color["Green"] = "32";
+    Color["Yellow"] = "33";
+    Color["Blue"] = "34";
+    Color["Magenta"] = "35";
+    Color["Cyan"] = "36";
+    Color["Gray"] = "90";
+})(Color || (Color = {}));
+
 class Scribbler {
     #noColor;
     constructor(options) {
@@ -93,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) {
@@ -189,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"),
@@ -203,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) {
@@ -232,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" }, ">"),
                     " ",
@@ -245,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),
@@ -269,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),
@@ -331,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) {
@@ -395,8 +481,8 @@ function formattedText(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."],
+    ["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;
@@ -426,7 +512,7 @@ class CommandText {
         this.props = props;
     }
     render() {
-        let hint = undefined;
+        let hint;
         if (this.props.hint != null) {
             hint = Scribbler.createElement(HintText, null, this.props.hint);
         }
@@ -444,7 +530,7 @@ class OptionDescriptionText {
         return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
     }
 }
-class CliUsageText {
+class CommandLineUsageText {
     render() {
         const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
             Scribbler.createElement(CommandText, { text: commandText }),
@@ -453,7 +539,7 @@ class CliUsageText {
         return Scribbler.createElement(Text, null, usageText);
     }
 }
-class OptionNameText {
+class CommandLineOptionNameText {
     props;
     constructor(props) {
         this.props = props;
@@ -464,7 +550,7 @@ class OptionNameText {
             this.props.text);
     }
 }
-class OptionHintText {
+class CommandLineOptionHintText {
     props;
     constructor(props) {
         this.props = props;
@@ -480,19 +566,25 @@ class OptionHintText {
         return Scribbler.createElement(Text, null, this.props.definition.brand);
     }
 }
-class CliOptionsText {
+class CommandLineOptionsText {
     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))));
+        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, "CLI Options"),
+            Scribbler.createElement(Line, null, "Command Line Options"),
             Scribbler.createElement(Line, null),
             optionsText));
     }
@@ -506,9 +598,9 @@ function helpText(optionDefinitions, tstycheVersion) {
     return (Scribbler.createElement(Text, null,
         Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
         Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliUsageText, null),
+        Scribbler.createElement(CommandLineUsageText, null),
         Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliOptionsText, { optionDefinitions: optionDefinitions }),
+        Scribbler.createElement(CommandLineOptionsText, { optionDefinitions: optionDefinitions }),
         Scribbler.createElement(Line, null),
         Scribbler.createElement(HelpFooterText, null),
         Scribbler.createElement(Line, null)));
@@ -686,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,
@@ -701,58 +796,6 @@ 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) {
@@ -1331,51 +1374,39 @@ class TestMember {
     parent;
     flags;
     compiler;
-    diagnostics;
+    diagnostics = new Set();
     members = [];
-    name;
+    name = "";
     constructor(brand, node, parent, flags) {
         this.brand = brand;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
         this.compiler = parent.compiler;
-        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);
+                    this.diagnostics.add(diagnostic);
+                    parent.diagnostics.delete(diagnostic);
                 }
-                else {
-                    unmapped.push(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 = [];
@@ -1415,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 = [];
@@ -1449,30 +1490,6 @@ class Assertion extends TestMember {
         }
         return this.matcherNode.arguments;
     }
-    #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;
-    }
 }
 
 class IdentifierLookup {
@@ -1657,7 +1674,7 @@ class CollectService {
         });
     }
     createTestTree(sourceFile, semanticDiagnostics = []) {
-        const testTree = new TestTree(this.compiler, semanticDiagnostics, sourceFile);
+        const testTree = new TestTree(this.compiler, new Set(semanticDiagnostics), sourceFile);
         this.#collectTestMembers(sourceFile, new IdentifierLookup(this.compiler), testTree);
         return testTree;
     }
@@ -2038,7 +2055,7 @@ class Expect {
                     this.#onTargetArgumentsMustBeStringOrNumberLiteralTypes(assertion.target, expectResult);
                     return;
                 }
-                return this.toRaiseError.match({ diagnostics: assertion.diagnostics, node: assertion.source[0] }, targetTypes, assertion.isNot);
+                return this.toRaiseError.match({ diagnostics: [...assertion.diagnostics], node: assertion.source[0] }, targetTypes, assertion.isNot);
             }
             default:
                 this.#onNotSupportedMatcherName(assertion, expectResult);
@@ -2290,11 +2307,11 @@ 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,
                 },
             ]);
@@ -2348,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,
                 },
             ]);
@@ -2370,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,
                 },
             ]);
@@ -2444,11 +2461,11 @@ class TestFileRunner {
             return;
         }
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
-        if (testTree.diagnostics.length > 0) {
+        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,
                 },
             ]);
@@ -2508,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")) {
@@ -2576,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",
@@ -2600,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",
@@ -2612,7 +2625,7 @@ class OptionDefinitionsMap {
             name: "rootPath",
         },
         {
-            brand: "boolean",
+            brand: "true",
             description: "Print the resolved configuration and exit.",
             group: 2,
             name: "showConfig",
@@ -2645,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",
@@ -2718,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);
@@ -2754,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":
@@ -2764,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;
         }
@@ -2796,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)));
@@ -2828,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") {
@@ -2849,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;
@@ -2911,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;
@@ -2995,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 = [];
@@ -3117,7 +3106,7 @@ class ConfigService {
         allowNoTestFiles: false,
         failFast: false,
         rootPath: "./",
-        target: ["latest"],
+        target: [Environment.isTypeScriptInstalled ? "current" : "latest"],
         testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
     };
     #pathMatch = [];
@@ -3135,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)) {
@@ -3169,7 +3152,7 @@ class ConfigService {
             ...ConfigService.#defaultOptions,
             ...this.#configFileOptions,
             ...this.#commandLineOptions,
-            pathMatch: this.#pathMatch.map((match) => this.#normalizePath(match)),
+            pathMatch: this.#pathMatch,
         };
         return mergedOptions;
     }
@@ -3178,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());
             }));
         }
@@ -3202,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 = {}));
@@ -3212,165 +3196,28 @@ 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}`;
-    }
-    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));
-        }
-        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;
     #onDiagnostic;
     #prune;
     #registryUrl = new URL("https://registry.npmjs.org");
+    #storePath;
     #timeout = Environment.timeout * 1000;
-    constructor(cachePath, onDiagnostic, prune) {
-        this.#cachePath = cachePath;
+    #version = "1";
+    constructor(storePath, onDiagnostic, prune) {
+        this.#storePath = storePath;
         this.#onDiagnostic = onDiagnostic;
-        this.#manifestFilePath = path.join(cachePath, this.#manifestFileName);
+        this.#manifestFilePath = Path.join(storePath, this.#manifestFileName);
         this.#prune = prune;
     }
+    async #create(signal) {
+        const manifest = await this.#load(signal);
+        if (manifest != null) {
+            await this.persist(manifest);
+        }
+        return manifest;
+    }
     async #fetch(signal) {
         return new Promise((resolve, reject) => {
             const request = https.get(new URL("typescript", this.#registryUrl), {
@@ -3407,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: [],
@@ -3420,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.");
@@ -3455,15 +3303,10 @@ class ManifestWorker {
         }
         return manifest;
     }
-    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 {
@@ -3478,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;
-        }
-        if (this.isOutdated(manifest)) {
-            manifest = await this.update(manifest, signal);
+            return this.#create(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, this.#onDiagnostic, 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] }]);
     };
@@ -3567,21 +3573,16 @@ class StoreService {
         this.#manifest = await this.#manifestWorker.open(signal);
     }
     prune = async () => {
-        await fs.rm(this.#cachePath, { force: true, recursive: true });
+        await fs.rm(this.#storePath, { force: true, recursive: true });
     };
-    resolveTag(tag) {
+    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;
         }
@@ -3596,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") {
@@ -3653,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();
@@ -3719,4 +3718,4 @@ class Cli {
     }
 }
 
-export { Assertion, Cli, CollectService, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, Expect, ExpectResult, FileResult, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, 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 };