tstyche 2.1.0 → 3.0.0-beta.0

package/build/tstyche.js

@@ -6,7 +6,7 @@ import os from 'node:os';
 import { watch, existsSync, writeFileSync, rmSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import vm from 'node:vm';
-import { spawn } from 'node:child_process';
+import streamConsumers from 'node:stream/consumers';
 
 class EventEmitter {
     static #handlers = new Set();
@@ -446,6 +446,7 @@ class Environment {
     static #isCi = Environment.#resolveIsCi();
     static #noColor = Environment.#resolveNoColor();
     static #noInteractive = Environment.#resolveNoInteractive();
+    static #npmRegistry = Environment.#resolveNpmRegistry();
     static #storePath = Environment.#resolveStorePath();
     static #timeout = Environment.#resolveTimeout();
     static #typescriptPath = Environment.#resolveTypeScriptPath();
@@ -458,6 +459,9 @@ class Environment {
     static get noInteractive() {
         return Environment.#noInteractive;
     }
+    static get npmRegistry() {
+        return Environment.#npmRegistry;
+    }
     static get storePath() {
         return Environment.#storePath;
     }
@@ -488,6 +492,12 @@ class Environment {
         }
         return !process.stdout.isTTY;
     }
+    static #resolveNpmRegistry() {
+        if (process.env["TSTYCHE_NPM_REGISTRY"] != null) {
+            return process.env["TSTYCHE_NPM_REGISTRY"];
+        }
+        return "https://registry.npmjs.org";
+    }
     static #resolveStorePath() {
         if (process.env["TSTYCHE_STORE_PATH"] != null) {
             return Path.resolve(process.env["TSTYCHE_STORE_PATH"]);
@@ -505,7 +515,7 @@ class Environment {
     }
     static #resolveTimeout() {
         if (process.env["TSTYCHE_TIMEOUT"] != null) {
-            return Number(process.env["TSTYCHE_TIMEOUT"]);
+            return Number.parseFloat(process.env["TSTYCHE_TIMEOUT"]);
         }
         return 30;
     }
@@ -589,7 +599,7 @@ class Scribbler {
     #visitChildren(children) {
         const text = [];
         for (const child of children) {
-            if (typeof child === "string") {
+            if (typeof child === "string" || typeof child === "number") {
                 text.push(child);
                 continue;
             }
@@ -605,8 +615,8 @@ class Scribbler {
     }
 }
 
-function addsPackageStepText(compilerVersion, installationPath) {
-    return (jsx(Line, { children: [jsx(Text, { color: "90", children: "adds" }), " TypeScript ", compilerVersion, jsx(Text, { color: "90", children: [" to ", installationPath] })] }));
+function addsPackageStepText(packageVersion, packagePath) {
+    return (jsx(Line, { children: [jsx(Text, { color: "90", children: "adds" }), " TypeScript ", packageVersion, jsx(Text, { color: "90", children: [" to ", packagePath] })] }));
 }
 
 function describeNameText(name, indent = 0) {
@@ -616,61 +626,72 @@ function describeNameText(name, indent = 0) {
 function BreadcrumbsText({ ancestor }) {
     const text = [];
     while ("name" in ancestor) {
-        text.unshift(" ❭ ", ancestor.name);
+        text.push(ancestor.name);
         ancestor = ancestor.parent;
     }
-    return jsx(Text, { color: "90", children: text.join("") });
+    text.push("");
+    return jsx(Text, { color: "90", children: text.reverse().join(" ❭ ") });
 }
-function CodeLineText({ lineText, gutterWidth, lineNumberColor = "90", lineNumberText }) {
-    return (jsx(Line, { children: [jsx(Text, { color: lineNumberColor, children: lineNumberText.padStart(gutterWidth) }), jsx(Text, { color: "90", children: " | " }), lineText] }));
+function CodeLineText({ gutterWidth, lineNumber, lineNumberColor = "90", lineText }) {
+    return (jsx(Line, { children: [jsx(Text, { color: lineNumberColor, children: lineNumber.toString().padStart(gutterWidth) }), jsx(Text, { color: "90", children: " | " }), lineText] }));
 }
-function SquiggleLineText({ gutterWidth, indentWidth = 0, squiggleWidth }) {
-    return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: "90", children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: "31", children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
+function SquiggleLineText({ gutterWidth, indentWidth = 0, squiggleColor, squiggleWidth }) {
+    return (jsx(Line, { children: [" ".repeat(gutterWidth), jsx(Text, { color: "90", children: " | " }), " ".repeat(indentWidth), jsx(Text, { color: squiggleColor, children: "~".repeat(squiggleWidth === 0 ? 1 : squiggleWidth) })] }));
 }
-function CodeSpanText({ diagnosticOrigin }) {
+function CodeSpanText({ diagnosticCategory, diagnosticOrigin }) {
     const lastLineInFile = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.sourceFile.text.length).line;
     const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
     const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
     const firstLine = Math.max(firstMarkedLine - 2, 0);
     const lastLine = Math.min(firstLine + 5, lastLineInFile);
-    const gutterWidth = String(lastLine + 1).length + 2;
+    const gutterWidth = (lastLine + 1).toString().length + 2;
+    let highlightColor;
+    switch (diagnosticCategory) {
+        case "error": {
+            highlightColor = "31";
+            break;
+        }
+        case "warning": {
+            highlightColor = "33";
+            break;
+        }
+    }
     const codeSpan = [];
     for (let index = firstLine; index <= lastLine; index++) {
         const lineStart = diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index, 0);
         const lineEnd = index === lastLineInFile
             ? diagnosticOrigin.sourceFile.text.length
             : diagnosticOrigin.sourceFile.getPositionOfLineAndCharacter(index + 1, 0);
-        const lineNumberText = String(index + 1);
         const lineText = diagnosticOrigin.sourceFile.text.slice(lineStart, lineEnd).trimEnd().replace(/\t/g, " ");
         if (index >= firstMarkedLine && index <= lastMarkedLine) {
-            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumberColor: "31", lineNumberText: lineNumberText, lineText: lineText }));
+            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineNumberColor: highlightColor, lineText: lineText }));
             if (index === firstMarkedLine) {
                 const squiggleLength = index === lastMarkedLine
                     ? lastMarkedLineCharacter - firstMarkedLineCharacter
                     : lineText.length - firstMarkedLineCharacter;
-                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleWidth: squiggleLength }));
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleColor: highlightColor, squiggleWidth: squiggleLength }));
             }
             else if (index === lastMarkedLine) {
-                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleWidth: lastMarkedLineCharacter }));
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lastMarkedLineCharacter }));
             }
             else {
-                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleWidth: lineText.length }));
+                codeSpan.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lineText.length }));
             }
         }
         else {
-            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumberText: lineNumberText, lineText: lineText }));
+            codeSpan.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineText: lineText }));
         }
     }
-    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: [":", String(firstMarkedLine + 1), ":", String(firstMarkedLineCharacter + 1)] }), diagnosticOrigin.assertion && jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertion.parent })] }));
+    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: `:${firstMarkedLine + 1}:${firstMarkedLineCharacter + 1}` }), diagnosticOrigin.assertion && jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertion.parent })] }));
     return (jsx(Text, { children: [codeSpan, jsx(Line, {}), location] }));
 }
 
 function DiagnosticText({ diagnostic }) {
-    const code = typeof diagnostic.code === "string" ? jsx(Text, { color: "90", children: [" ", diagnostic.code] }) : undefined;
+    const code = diagnostic.code ? jsx(Text, { color: "90", children: [" ", diagnostic.code] }) : undefined;
     const text = Array.isArray(diagnostic.text) ? diagnostic.text : [diagnostic.text];
     const message = text.map((text, index) => (jsx(Text, { children: [index === 1 ? jsx(Line, {}) : undefined, jsx(Line, { children: [text, code] })] })));
     const related = diagnostic.related?.map((relatedDiagnostic) => jsx(DiagnosticText, { diagnostic: relatedDiagnostic }));
-    const codeSpan = diagnostic.origin ? (jsx(Text, { children: [jsx(Line, {}), jsx(CodeSpanText, { diagnosticOrigin: diagnostic.origin })] })) : undefined;
+    const codeSpan = diagnostic.origin ? (jsx(Text, { children: [jsx(Line, {}), jsx(CodeSpanText, { diagnosticCategory: diagnostic.category, diagnosticOrigin: diagnostic.origin })] })) : undefined;
     return (jsx(Text, { children: [message, codeSpan, jsx(Line, {}), jsx(Text, { indent: 2, children: related })] }));
 }
 function diagnosticText(diagnostic) {
@@ -747,11 +768,7 @@ function HelpHeaderText({ tstycheVersion }) {
     return (jsx(Line, { children: ["The TSTyche Type Test Runner", jsx(HintText, { children: tstycheVersion })] }));
 }
 function CommandText({ hint, text }) {
-    let hintText;
-    if (hint != null) {
-        hintText = jsx(HintText, { children: hint });
-    }
-    return (jsx(Line, { indent: 1, children: [jsx(Text, { color: "34", children: text }), hintText] }));
+    return (jsx(Line, { indent: 1, children: [jsx(Text, { color: "34", children: text }), hint && jsx(HintText, { children: hint })] }));
 }
 function OptionDescriptionText({ text }) {
     return jsx(Line, { indent: 1, children: text });
@@ -766,11 +783,11 @@ function CommandLineUsageText() {
     return jsx(Text, { children: usageText });
 }
 function CommandLineOptionNameText({ text }) {
-    return jsx(Text, { children: ["--", text] });
+    return jsx(Text, { children: `--${text}` });
 }
 function CommandLineOptionHintText({ definition }) {
     if (definition.brand === "list") {
-        return (jsx(Text, { children: [definition.brand, " of ", definition.items.brand, "s"] }));
+        return jsx(Text, { children: `${definition.brand} of ${definition.items.brand}s` });
     }
     return jsx(Text, { children: definition.brand });
 }
@@ -835,16 +852,16 @@ function RowText({ label, text }) {
     return (jsx(Line, { children: [`${label}:`.padEnd(12), text] }));
 }
 function CountText({ failed, passed, skipped, todo, total }) {
-    return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "31", children: [String(failed), " failed"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [String(skipped), " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: "35", children: [String(todo), " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "32", children: [String(passed), " passed"] }), jsx(Text, { children: ", " })] })) : undefined, jsx(Text, { children: [String(total), jsx(Text, { children: " total" })] })] }));
+    return (jsx(Text, { children: [failed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "31", children: [failed, " failed"] }), jsx(Text, { children: ", " })] })) : undefined, skipped > 0 ? (jsx(Text, { children: [jsx(Text, { color: "33", children: [skipped, " skipped"] }), jsx(Text, { children: ", " })] })) : undefined, todo > 0 ? (jsx(Text, { children: [jsx(Text, { color: "35", children: [todo, " todo"] }), jsx(Text, { children: ", " })] })) : undefined, passed > 0 ? (jsx(Text, { children: [jsx(Text, { color: "32", children: [passed, " passed"] }), jsx(Text, { children: ", " })] })) : undefined, jsx(Text, { children: [total, " total"] })] }));
 }
 function DurationText({ seconds }) {
-    return jsx(Text, { children: `${String(Math.round(seconds * 10) / 10)}s` });
+    return jsx(Text, { children: `${Math.round(seconds * 10) / 10}s` });
 }
 function MatchText({ text }) {
     if (typeof text === "string") {
         return jsx(Text, { children: ["'", text, "'"] });
     }
-    if (text.length <= 1) {
+    if (text.length === 1) {
         return jsx(Text, { children: ["'", ...text, "'"] });
     }
     const lastItem = text.pop();
@@ -856,7 +873,7 @@ function RanFilesText({ onlyMatch, pathMatch, skipMatch }) {
         testNameMatchText.push(jsx(Text, { children: [jsx(Text, { color: "90", children: "matching " }), jsx(MatchText, { text: onlyMatch })] }));
     }
     if (skipMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [onlyMatch != null ? jsx(Text, { color: "90", children: " and " }) : undefined, jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
+        testNameMatchText.push(jsx(Text, { children: [onlyMatch && jsx(Text, { color: "90", children: " and " }), jsx(Text, { color: "90", children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
     }
     let pathMatchText;
     if (pathMatch.length > 0) {
@@ -987,7 +1004,7 @@ class RunReporter extends Reporter {
                 break;
             }
             case "store:info": {
-                this.outputService.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+                this.outputService.writeMessage(addsPackageStepText(payload.packageVersion, payload.packagePath));
                 this.#hasReportedAdds = true;
                 break;
             }
@@ -1111,7 +1128,7 @@ class RunReporter extends Reporter {
 class SetupReporter extends Reporter {
     handleEvent([eventName, payload]) {
         if (eventName === "store:info") {
-            this.outputService.writeMessage(addsPackageStepText(payload.compilerVersion, payload.installationPath));
+            this.outputService.writeMessage(addsPackageStepText(payload.packageVersion, payload.packagePath));
             return;
         }
         if ("diagnostics" in payload) {
@@ -1297,7 +1314,7 @@ class Diagnostic {
     }
     static fromDiagnostics(diagnostics, compiler) {
         return diagnostics.map((diagnostic) => {
-            const code = `ts(${String(diagnostic.code)})`;
+            const code = `ts(${diagnostic.code})`;
             let origin;
             if (Diagnostic.#isTsDiagnosticWithLocation(diagnostic)) {
                 origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file);
@@ -1310,17 +1327,6 @@ class Diagnostic {
             return new Diagnostic(text, "error", origin).add({ code, related });
         });
     }
-    static fromError(text, error) {
-        const messageText = Array.isArray(text) ? text : [text];
-        if (error instanceof Error && error.stack != null) {
-            if (messageText.length > 1) {
-                messageText.push("");
-            }
-            const stackLines = error.stack.split("\n").map((line) => line.trimStart());
-            messageText.push(...stackLines);
-        }
-        return Diagnostic.error(messageText);
-    }
     static #isTsDiagnosticWithLocation(diagnostic) {
         return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
     }
@@ -1446,10 +1452,21 @@ class SelectService {
     #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
     }
+    async #resolveEntryMeta(entry, targetPath) {
+        if (!entry.isSymbolicLink()) {
+            return entry;
+        }
+        let entryMeta;
+        try {
+            entryMeta = await fs.stat([targetPath, entry.name].join("/"));
+        }
+        catch {
+        }
+        return entryMeta;
+    }
     async selectFiles() {
-        const currentPath = ".";
         const testFilePaths = [];
-        await this.#visitDirectory(currentPath, testFilePaths);
+        await this.#visitDirectory(".", testFilePaths);
         if (testFilePaths.length === 0) {
             this.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(this.#resolvedConfig)));
         }
@@ -1457,38 +1474,20 @@ class SelectService {
     }
     async #visitDirectory(currentPath, testFilePaths) {
         const targetPath = Path.join(this.#resolvedConfig.rootPath, currentPath);
-        let entries;
         try {
-            entries = await fs.readdir(targetPath, { withFileTypes: true });
-        }
-        catch {
-        }
-        if (!entries) {
-            return;
-        }
-        for (const entry of entries) {
-            let entryMeta;
-            if (entry.isSymbolicLink()) {
-                try {
-                    entryMeta = await fs.stat([targetPath, entry.name].join("/"));
+            const entries = await fs.readdir(targetPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryMeta = await this.#resolveEntryMeta(entry, targetPath);
+                const entryPath = [currentPath, entry.name].join("/");
+                if (entryMeta?.isDirectory() && this.#isDirectoryIncluded(entryPath)) {
+                    await this.#visitDirectory(entryPath, testFilePaths);
                 }
-                catch {
+                else if (entryMeta?.isFile() && this.#isFileIncluded(entryPath)) {
+                    testFilePaths.push([targetPath, entry.name].join("/"));
                 }
             }
-            else {
-                entryMeta = entry;
-            }
-            if (!entryMeta) {
-                continue;
-            }
-            const entryPath = [currentPath, entry.name].join("/");
-            if (entryMeta.isDirectory() && this.#isDirectoryIncluded(entryPath)) {
-                await this.#visitDirectory(entryPath, testFilePaths);
-                continue;
-            }
-            if (entryMeta.isFile() && this.#isFileIncluded(entryPath)) {
-                testFilePaths.push([targetPath, entry.name].join("/"));
-            }
+        }
+        catch {
         }
     }
 }
@@ -1888,6 +1887,132 @@ var TestMemberFlags;
     TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
 })(TestMemberFlags || (TestMemberFlags = {}));
 
+class Version {
+    static isGreaterThan(source, target) {
+        return !(source === target) && Version.#satisfies(source, target);
+    }
+    static isSatisfiedWith(source, target) {
+        return source === target || Version.#satisfies(source, target);
+    }
+    static isVersionTag(target) {
+        return /^\d+/.test(target);
+    }
+    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) {
+                return false;
+            }
+            if (index === sourceElements.length - 1 || index === targetElements.length - 1) {
+                return true;
+            }
+            return compare(index + 1);
+        }
+        return compare();
+    }
+}
+
+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,
+        });
+        this.#service.setCompilerOptionsForInferredProjects(this.#getDefaultCompilerOptions());
+    }
+    closeFile(filePath) {
+        this.#service.closeClientFile(filePath);
+    }
+    #getDefaultCompilerOptions() {
+        const defaultCompilerOptions = {
+            allowJs: true,
+            checkJs: true,
+            esModuleInterop: true,
+            jsx: "preserve",
+            module: "esnext",
+            moduleResolution: "node",
+            resolveJsonModule: true,
+            strictFunctionTypes: true,
+            strictNullChecks: true,
+            target: "esnext",
+        };
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.4")) {
+            defaultCompilerOptions.module = "preserve";
+        }
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
+            defaultCompilerOptions.allowImportingTsExtensions = true;
+            defaultCompilerOptions.moduleResolution = "bundler";
+        }
+        return defaultCompilerOptions;
+    }
+    getDefaultProject(filePath) {
+        return this.#service.getDefaultProjectForFile(this.#compiler.server.toNormalizedPath(filePath), true);
+    }
+    getLanguageService(filePath) {
+        const project = this.getDefaultProject(filePath);
+        if (!project) {
+            return;
+        }
+        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) },
+            ]);
+        }
+    }
+}
+
 class ExpectDiagnosticText {
     static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
         return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
@@ -1904,17 +2029,11 @@ class ExpectDiagnosticText {
     static componentDoesNotAcceptProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
     }
-    static matcherIsDeprecated(matcherNameText) {
-        return [
-            `The '.${matcherNameText}()' matcher is deprecated and will be removed in TSTyche 3.`,
-            "To learn more, visit https://tstyche.org/releases/tstyche-2",
-        ];
-    }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
-    static overloadGaveTheFollowingError(indexText, countText, signatureText) {
-        return `Overload ${indexText} of ${countText}, '${signatureText}', gave the following error.`;
+    static overloadGaveTheFollowingError(index, count, signatureText) {
+        return `Overload ${index} of ${count}, '${signatureText}', gave the following error.`;
     }
     static raisedTypeError(count = 1) {
         return `The raised type error${count === 1 ? "" : "s"}:`;
@@ -1967,7 +2086,7 @@ class ExpectDiagnosticText {
     static typeRaisedError(isTypeNode, count, targetCount) {
         let countText = "a";
         if (count > 1 || targetCount > 1) {
-            countText = count > targetCount ? String(count) : `only ${String(count)}`;
+            countText = count > targetCount ? `${count}` : `only ${count}`;
         }
         return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
     }
@@ -2058,19 +2177,19 @@ class MatchWorker {
         return type;
     }
     isAnyOrNeverType(type) {
-        return Boolean(type.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never));
+        return !!(type.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never));
     }
     isStringOrNumberLiteralType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
+        return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
     }
     isObjectType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.Object);
+        return !!(type.flags & this.#compiler.TypeFlags.Object);
     }
     isUnionType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.Union);
+        return !!(type.flags & this.#compiler.TypeFlags.Union);
     }
     isUniqueSymbolType(type) {
-        return Boolean(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
+        return !!(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
     }
     resolveDiagnosticOrigin(symbol, enclosingNode) {
         if (symbol.valueDeclaration != null &&
@@ -2097,7 +2216,7 @@ class PrimitiveTypeMatcher {
     }
     match(matchWorker, sourceNode) {
         const sourceType = matchWorker.getType(sourceNode);
-        const isMatch = Boolean(sourceType.flags & this.#targetTypeFlag);
+        const isMatch = !!(sourceType.flags & this.#targetTypeFlag);
         return {
             explain: () => this.#explain(matchWorker, sourceNode),
             isMatch,
@@ -2122,7 +2241,7 @@ class ToAcceptProps {
             const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
-                const overloadText = ExpectDiagnosticText.overloadGaveTheFollowingError(String(index + 1), String(signatures.length), signatureText);
+                const overloadText = ExpectDiagnosticText.overloadGaveTheFollowingError(index + 1, signatures.length, signatureText);
                 diagnostic = Diagnostic.error([introText, overloadText], origin);
             }
             else {
@@ -2343,7 +2462,7 @@ class ToHaveProperty {
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText;
         if (matchWorker.isStringOrNumberLiteralType(targetType)) {
-            propertyNameText = String(targetType.value);
+            propertyNameText = targetType.value.toString();
         }
         else {
             propertyNameText = `[${this.#compiler.unescapeLeadingUnderscores(targetType.symbol.escapedName)}]`;
@@ -2367,7 +2486,7 @@ class ToHaveProperty {
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText;
         if (matchWorker.isStringOrNumberLiteralType(targetType)) {
-            propertyNameText = String(targetType.value);
+            propertyNameText = targetType.value.toString();
         }
         else if (matchWorker.isUniqueSymbolType(targetType)) {
             propertyNameText = this.#compiler.unescapeLeadingUnderscores(targetType.escapedName);
@@ -2473,7 +2592,7 @@ class ToRaiseError {
         if (this.#compiler.isStringLiteralLike(targetNode)) {
             return this.#compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(targetNode.text);
         }
-        return Number(targetNode.text) === diagnostic.code;
+        return Number.parseInt(targetNode.text) === diagnostic.code;
     }
 }
 
@@ -2483,7 +2602,6 @@ class ExpectService {
     toAcceptProps;
     toBe;
     toBeAny;
-    toBeAssignable;
     toBeAssignableTo;
     toBeAssignableWith;
     toBeBigInt;
@@ -2497,7 +2615,6 @@ class ExpectService {
     toBeUniqueSymbol;
     toBeUnknown;
     toBeVoid;
-    toEqual;
     toHaveProperty;
     toMatch;
     toRaiseError;
@@ -2507,7 +2624,6 @@ class ExpectService {
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
         this.toBeAny = new PrimitiveTypeMatcher(compiler.TypeFlags.Any);
-        this.toBeAssignable = new ToBeAssignableWith();
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
         this.toBeBigInt = new PrimitiveTypeMatcher(compiler.TypeFlags.BigInt);
@@ -2521,28 +2637,12 @@ class ExpectService {
         this.toBeUniqueSymbol = new PrimitiveTypeMatcher(compiler.TypeFlags.UniqueESSymbol);
         this.toBeUnknown = new PrimitiveTypeMatcher(compiler.TypeFlags.Unknown);
         this.toBeVoid = new PrimitiveTypeMatcher(compiler.TypeFlags.Void);
-        this.toEqual = new ToBe();
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toMatch = new ToMatch();
         this.toRaiseError = new ToRaiseError(compiler);
     }
-    static assertTypeChecker(typeChecker) {
-        return "isTypeRelatedTo" in typeChecker && "relation" in typeChecker;
-    }
-    #handleDeprecated(matcherNameText, assertion) {
-        switch (matcherNameText) {
-            case "toBeAssignable":
-            case "toEqual": {
-                const text = ExpectDiagnosticText.matcherIsDeprecated(matcherNameText);
-                const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-                EventEmitter.dispatch(["deprecation:info", { diagnostics: [Diagnostic.warning(text, origin)] }]);
-                break;
-            }
-        }
-    }
     match(assertion, onDiagnostics) {
         const matcherNameText = assertion.matcherName.getText();
-        this.#handleDeprecated(matcherNameText, assertion);
         if (!assertion.source[0]) {
             this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
             return;
@@ -2551,10 +2651,8 @@ class ExpectService {
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
-            case "toBeAssignable":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-            case "toEqual":
             case "toMatch": {
                 if (!assertion.target[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
@@ -2611,132 +2709,6 @@ class ExpectService {
     }
 }
 
-class Version {
-    static isGreaterThan(source, target) {
-        return !(source === target) && Version.#satisfies(source, target);
-    }
-    static isSatisfiedWith(source, target) {
-        return source === target || Version.#satisfies(source, target);
-    }
-    static isVersionTag(target) {
-        return /^\d+/.test(target);
-    }
-    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) {
-                return false;
-            }
-            if (index === sourceElements.length - 1 || index === targetElements.length - 1) {
-                return true;
-            }
-            return compare(index + 1);
-        }
-        return compare();
-    }
-}
-
-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,
-        });
-        this.#service.setCompilerOptionsForInferredProjects(this.#getDefaultCompilerOptions());
-    }
-    closeFile(filePath) {
-        this.#service.closeClientFile(filePath);
-    }
-    #getDefaultCompilerOptions() {
-        const defaultCompilerOptions = {
-            allowJs: true,
-            checkJs: true,
-            esModuleInterop: true,
-            jsx: "preserve",
-            module: "esnext",
-            moduleResolution: "node",
-            resolveJsonModule: true,
-            strictFunctionTypes: true,
-            strictNullChecks: true,
-            target: "esnext",
-        };
-        if (Version.isSatisfiedWith(this.#compiler.version, "5.4")) {
-            defaultCompilerOptions.module = "preserve";
-        }
-        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
-            defaultCompilerOptions.allowImportingTsExtensions = true;
-            defaultCompilerOptions.moduleResolution = "bundler";
-        }
-        return defaultCompilerOptions;
-    }
-    getDefaultProject(filePath) {
-        return this.#service.getDefaultProjectForFile(this.#compiler.server.toNormalizedPath(filePath), true);
-    }
-    getLanguageService(filePath) {
-        const project = this.getDefaultProject(filePath);
-        if (!project) {
-            return;
-        }
-        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) },
-            ]);
-        }
-    }
-}
-
 class TestTreeWorker {
     #compiler;
     #cancellationToken;
@@ -2951,11 +2923,6 @@ class TestFileRunner {
             return;
         }
         const typeChecker = program.getTypeChecker();
-        if (!ExpectService.assertTypeChecker(typeChecker)) {
-            const text = "The required 'isTypeRelatedTo()' method is missing in the provided type checker.";
-            EventEmitter.dispatch(["file:error", { diagnostics: [Diagnostic.error(text)], result: fileResult }]);
-            return;
-        }
         const testTreeWorker = new TestTreeWorker(this.#resolvedConfig, this.#compiler, typeChecker, {
             cancellationToken,
             fileResult,
@@ -3003,7 +2970,7 @@ class TaskRunner {
         for (const versionTag of this.#resolvedConfig.target) {
             const targetResult = new TargetResult(versionTag, testFiles);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
-            const compiler = await this.#storeService.load(versionTag, cancellationToken);
+            const compiler = await this.#storeService.load(versionTag);
             if (compiler) {
                 const testFileRunner = new TestFileRunner(this.#resolvedConfig, compiler);
                 for (const testFile of testFiles) {
@@ -3032,7 +2999,7 @@ class TSTyche {
     #selectService;
     #storeService;
     #taskRunner;
-    static version = "2.1.0";
+    static version = "3.0.0-beta.0";
     constructor(resolvedConfig, outputService, selectService, storeService) {
         this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
@@ -3612,32 +3579,124 @@ var OptionGroup;
 })(OptionGroup || (OptionGroup = {}));
 
 class StoreDiagnosticText {
-    static failedToFetchMetadata(registryUrl) {
-        return `Failed to fetch metadata of the 'typescript' package from '${registryUrl.toString()}'.`;
+    static cannotAddTypeScriptPackage(tag) {
+        return `Cannot add the 'typescript' package for the '${tag}' tag.`;
+    }
+    static failedToFetchMetadata(registry) {
+        return `Failed to fetch metadata of the 'typescript' package from '${registry}'.`;
     }
-    static failedWithStatusCode(code) {
-        return `Request failed with status code ${String(code)}.`;
+    static failedToInstalTypeScript(version) {
+        return `Failed to install 'typescript@${version}'.`;
+    }
+    static failedToUpdateMetadata(registry) {
+        return `Failed to update metadata of the 'typescript' package from '${registry}'.`;
     }
     static maybeNetworkConnectionIssue() {
         return "Might be there is an issue with the registry or the network connection.";
     }
-    static setupTimeoutExceeded(timeout) {
-        return `Setup timeout of ${String(timeout / 1000)}s was exceeded.`;
+    static maybeOutdatedResolution(tag) {
+        return `The resolution of the '${tag}' tag may be outdated.`;
+    }
+    static requestFailedWithStatusCode(code) {
+        return `The request failed with status code ${code}.`;
+    }
+    static requestTimeoutWasExceeded(timeout) {
+        return `The request timeout of ${timeout / 1000}s was exceeded.`;
+    }
+    static lockWaitTimeoutWasExceeded(timeout) {
+        return `Lock wait timeout of ${timeout / 1000}s was exceeded.`;
+    }
+}
+
+class Fetcher {
+    #onDiagnostics;
+    constructor(onDiagnostics) {
+        this.#onDiagnostics = onDiagnostics;
+    }
+    async get(request, timeout, diagnostic, options) {
+        try {
+            const response = await fetch(request, { signal: AbortSignal.timeout(timeout) });
+            if (!response.ok) {
+                !options?.suppressErrors &&
+                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.requestFailedWithStatusCode(response.status)));
+                return;
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "TimeoutError") {
+                !options?.suppressErrors &&
+                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.requestTimeoutWasExceeded(timeout)));
+            }
+            else {
+                !options?.suppressErrors &&
+                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.maybeNetworkConnectionIssue()));
+            }
+        }
+        return;
+    }
+}
+
+class Lock {
+    #lockFilePath;
+    constructor(lockFilePath) {
+        this.#lockFilePath = lockFilePath;
+        writeFileSync(this.#lockFilePath, "");
+        process.on("exit", () => {
+            this.release();
+        });
+    }
+    release() {
+        rmSync(this.#lockFilePath, { force: true });
+    }
+}
+
+class LockService {
+    #onDiagnostics;
+    constructor(onDiagnostics) {
+        this.#onDiagnostics = onDiagnostics;
+    }
+    #getLockFilePath(targetPath) {
+        return `${targetPath}__lock__`;
+    }
+    getLock(targetPath) {
+        const lockFilePath = this.#getLockFilePath(targetPath);
+        return new Lock(lockFilePath);
+    }
+    async isLocked(targetPath, timeout, diagnostic) {
+        const lockFilePath = this.#getLockFilePath(targetPath);
+        let isLocked = existsSync(lockFilePath);
+        if (!isLocked) {
+            return isLocked;
+        }
+        const waitStartTime = Date.now();
+        while (isLocked) {
+            if (Date.now() - waitStartTime > timeout) {
+                this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.lockWaitTimeoutWasExceeded(timeout)));
+                break;
+            }
+            await this.#sleep(1000);
+            isLocked = existsSync(lockFilePath);
+        }
+        return isLocked;
+    }
+    async #sleep(delay) {
+        return new Promise((resolve) => setTimeout(resolve, delay));
     }
 }
 
 class ManifestWorker {
-    #manifestFileName = "store-manifest.json";
+    #fetcher;
     #manifestFilePath;
-    #onDiagnostics;
-    #registryUrl = new URL("https://registry.npmjs.org");
+    #npmRegistry;
     #storePath;
     #timeout = Environment.timeout * 1000;
-    #version = "1";
-    constructor(storePath, onDiagnostics) {
+    #version = "2";
+    constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
-        this.#onDiagnostics = onDiagnostics;
-        this.#manifestFilePath = Path.join(storePath, this.#manifestFileName);
+        this.#npmRegistry = npmRegistry;
+        this.#fetcher = fetcher;
+        this.#manifestFilePath = Path.join(storePath, "store-manifest.json");
     }
     async #create() {
         const manifest = await this.#load();
@@ -3653,59 +3712,48 @@ class ManifestWorker {
         return false;
     }
     async #load(options) {
+        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToFetchMetadata(this.#npmRegistry));
+        const request = new Request(new URL("typescript", this.#npmRegistry), {
+            headers: {
+                ["Accept"]: "application/vnd.npm.install-v1+json;q=1.0, application/json;q=0.8, */*",
+            },
+        });
+        const response = await this.#fetcher.get(request, this.#timeout, diagnostic, {
+            suppressErrors: options?.suppressErrors,
+        });
+        if (!response) {
+            return;
+        }
         const manifest = {
             $version: this.#version,
             lastUpdated: Date.now(),
+            npmRegistry: this.#npmRegistry,
             resolutions: {},
+            packages: {},
             versions: [],
         };
-        let packageMetadata;
-        try {
-            const response = await fetch(new URL("typescript", this.#registryUrl), {
-                headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
-                signal: AbortSignal.timeout(this.#timeout),
-            });
-            if (!response.ok) {
-                this.#onDiagnostics(Diagnostic.error([
-                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
-                    StoreDiagnosticText.failedWithStatusCode(response.status),
-                ]));
-                return;
+        const packageMetadata = (await response.json());
+        for (const [tag, meta] of Object.entries(packageMetadata.versions)) {
+            if (/^(4|5)\.\d\.\d$/.test(tag)) {
+                manifest.versions.push(tag);
+                manifest.packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
-            packageMetadata = (await response.json());
         }
-        catch (error) {
-            if (options?.quite === true) {
-                return;
-            }
-            if (error instanceof Error && error.name === "TimeoutError") {
-                this.#onDiagnostics(Diagnostic.error([
-                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
-                    StoreDiagnosticText.setupTimeoutExceeded(this.#timeout),
-                ]));
-            }
-            else {
-                this.#onDiagnostics(Diagnostic.error([
-                    StoreDiagnosticText.failedToFetchMetadata(this.#registryUrl),
-                    StoreDiagnosticText.maybeNetworkConnectionIssue(),
-                ]));
-            }
-            return;
-        }
-        manifest.versions = Object.keys(packageMetadata.versions)
-            .filter((version) => /^(4|5)\.\d\.\d$/.test(version))
-            .sort();
         const minorVersions = [...new Set(manifest.versions.map((version) => version.slice(0, -2)))];
         for (const tag of minorVersions) {
-            const resolvedVersion = manifest.versions.filter((version) => version.startsWith(tag)).pop();
+            const resolvedVersion = manifest.versions.findLast((version) => version.startsWith(tag));
             if (resolvedVersion != null) {
                 manifest.resolutions[tag] = resolvedVersion;
             }
         }
-        for (const tagKey of ["beta", "latest", "next", "rc"]) {
-            const distributionTagValue = packageMetadata["dist-tags"][tagKey];
-            if (distributionTagValue != null) {
-                manifest.resolutions[tagKey] = distributionTagValue;
+        for (const tag of ["beta", "latest", "next", "rc"]) {
+            const version = packageMetadata["dist-tags"][tag];
+            if (version != null) {
+                manifest.resolutions[tag] = version;
+                const meta = packageMetadata.versions[version];
+                if (meta != null) {
+                    manifest.packages[version] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
+                }
             }
         }
         return manifest;
@@ -3715,28 +3763,18 @@ class ManifestWorker {
         if (!existsSync(this.#manifestFilePath)) {
             return this.#create();
         }
-        let manifestText;
-        try {
-            manifestText = await fs.readFile(this.#manifestFilePath, { encoding: "utf8" });
-        }
-        catch (error) {
-            this.#onDiagnostics(Diagnostic.fromError("Failed to open store manifest.", error));
-        }
-        if (!manifestText) {
-            return;
-        }
+        const manifestText = await fs.readFile(this.#manifestFilePath, { encoding: "utf8" });
         try {
             manifest = JSON.parse(manifestText);
         }
         catch {
         }
-        if (!manifest || manifest.$version !== this.#version) {
+        if (!manifest || manifest.$version !== this.#version || manifest.npmRegistry !== this.#npmRegistry) {
             await fs.rm(this.#storePath, { force: true, recursive: true });
             return this.#create();
         }
         if (this.isOutdated(manifest) || options?.refresh === true) {
-            const quite = options?.refresh !== true;
-            const freshManifest = await this.#load({ quite });
+            const freshManifest = await this.#load({ suppressErrors: !options?.refresh });
             if (freshManifest != null) {
                 await this.persist(freshManifest);
                 return freshManifest;
@@ -3752,136 +3790,106 @@ class ManifestWorker {
     }
 }
 
-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) {
-            return isLocked;
-        }
-        const waitStartTime = Date.now();
-        while (isLocked) {
-            if (options.cancellationToken?.isCancellationRequested === true) {
+class TarReader {
+    static #textDecoder = new TextDecoder();
+    static async *extract(stream) {
+        const buffer = await streamConsumers.arrayBuffer(stream);
+        let offset = 0;
+        while (offset < buffer.byteLength - 512) {
+            const name = TarReader.#read(buffer, offset, 100);
+            if (name.length === 0) {
                 break;
             }
-            if (Date.now() - waitStartTime > options.timeout) {
-                options.onDiagnostics?.(`Lock wait timeout of ${String(options.timeout / 1000)}s was exceeded.`);
-                break;
+            const size = Number.parseInt(TarReader.#read(buffer, offset + 124, 12), 8);
+            const contents = new Uint8Array(buffer, offset + 512, size);
+            yield { name, contents };
+            offset += 512 + 512 * Math.trunc(size / 512);
+            if (size % 512) {
+                offset += 512;
             }
-            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));
+    static #read(buffer, byteOffset, length) {
+        let view = new Uint8Array(buffer, byteOffset, length);
+        const zeroIndex = view.indexOf(0);
+        if (zeroIndex !== -1) {
+            view = view.subarray(0, zeroIndex);
+        }
+        return TarReader.#textDecoder.decode(view);
     }
 }
 
-class PackageInstaller {
-    #onDiagnostics;
-    #readyFileName = "__ready__";
+class PackageService {
+    #fetcher;
+    #lockService;
     #storePath;
     #timeout = Environment.timeout * 1000;
-    constructor(storePath, onDiagnostics) {
+    constructor(storePath, fetcher, lockService) {
         this.#storePath = storePath;
-        this.#onDiagnostics = onDiagnostics;
+        this.#fetcher = fetcher;
+        this.#lockService = lockService;
     }
-    async ensure(compilerVersion, cancellationToken) {
-        const installationPath = Path.join(this.#storePath, compilerVersion);
-        const readyFilePath = Path.join(installationPath, this.#readyFileName);
-        const modulePath = Path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
+    async ensure(packageVersion, manifest) {
+        const packagePath = Path.join(this.#storePath, `typescript@${packageVersion}`);
+        const readyFilePath = Path.join(packagePath, "__ready__");
+        const modulePath = Path.join(packagePath, "lib", "typescript.js");
         if (existsSync(readyFilePath)) {
             return modulePath;
         }
-        if (await Lock.isLocked(installationPath, {
-            cancellationToken,
-            onDiagnostics: (text) => {
-                this.#onDiagnostics(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
-            },
-            timeout: this.#timeout,
-        })) {
+        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToInstalTypeScript(packageVersion));
+        if (await this.#lockService.isLocked(packagePath, this.#timeout, diagnostic)) {
             return;
         }
-        const lock = new Lock(installationPath);
-        EventEmitter.dispatch(["store:info", { compilerVersion, installationPath }]);
-        try {
-            await fs.mkdir(installationPath, { recursive: true });
-            const packageJson = {
-                name: "tstyche-typescript",
-                version: compilerVersion,
-                description: "Do not change. This package was generated by TSTyche",
-                private: true,
-                license: "MIT",
-                dependencies: {
-                    typescript: compilerVersion,
-                },
-            };
-            await fs.writeFile(Path.join(installationPath, "package.json"), JSON.stringify(packageJson, null, 2));
-            await this.#install(installationPath);
-            await fs.writeFile(readyFilePath, "");
+        EventEmitter.dispatch(["store:info", { packagePath, packageVersion }]);
+        const resource = manifest.packages[packageVersion];
+        if (resource != null) {
+            const lock = this.#lockService.getLock(packagePath);
+            try {
+                await this.#add(packagePath, resource, diagnostic);
+                await fs.writeFile(readyFilePath, "");
+            }
+            finally {
+                lock.release();
+            }
             return modulePath;
         }
-        catch (error) {
-            this.#onDiagnostics(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
-        }
-        finally {
-            lock.release();
-        }
         return;
     }
-    async #install(cwd) {
-        const args = ["install", "--ignore-scripts", "--no-bin-links", "--no-package-lock"];
-        return new Promise((resolve, reject) => {
-            const spawnedNpm = spawn("npm", args, {
-                cwd,
-                shell: true,
-                stdio: "ignore",
-                timeout: this.#timeout,
-            });
-            spawnedNpm.on("error", (error) => {
-                reject(error);
-            });
-            spawnedNpm.on("close", (code, signal) => {
-                if (code === 0) {
-                    resolve();
+    async #add(targetPath, resource, diagnostic) {
+        const request = new Request(resource.tarball, { integrity: resource.integrity });
+        const response = await this.#fetcher.get(request, this.#timeout, diagnostic);
+        if (response?.body != null) {
+            const decompressedStream = response.body.pipeThrough(new DecompressionStream("gzip"));
+            for await (const file of TarReader.extract(decompressedStream)) {
+                if (!file.name.startsWith("package/")) {
+                    continue;
                 }
-                if (signal != null) {
-                    reject(new Error(`setup timeout of ${String(this.#timeout / 1000)}s was exceeded`));
+                const filePath = Path.join(targetPath, file.name.replace("package/", ""));
+                const directoryPath = Path.dirname(filePath);
+                if (!existsSync(directoryPath)) {
+                    await fs.mkdir(directoryPath, { recursive: true });
                 }
-                reject(new Error(`process exited with code ${String(code)}`));
-            });
-        });
+                await fs.writeFile(filePath, file.contents);
+            }
+        }
     }
 }
 
 class StoreService {
     #compilerInstanceCache = new Map();
+    #fetcher;
+    #lockService;
     #manifest;
     #manifestWorker;
-    #packageInstaller;
+    #packageService;
+    #npmRegistry = Environment.npmRegistry;
     #storePath;
     constructor() {
         this.#storePath = Environment.storePath;
-        this.#packageInstaller = new PackageInstaller(this.#storePath, this.#onDiagnostics);
-        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#onDiagnostics);
+        this.#fetcher = new Fetcher(this.#onDiagnostics);
+        this.#lockService = new LockService(this.#onDiagnostics);
+        this.#packageService = new PackageService(this.#storePath, this.#fetcher, this.#lockService);
+        this.#manifestWorker = new ManifestWorker(this.#storePath, this.#npmRegistry, this.#fetcher);
     }
     async getSupportedTags() {
         await this.open();
@@ -3890,18 +3898,22 @@ class StoreService {
         }
         return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions, "current"].sort();
     }
-    async install(tag, cancellationToken) {
+    async install(tag) {
         if (tag === "current") {
             return;
         }
-        const version = await this.#resolveTag(tag);
+        await this.open();
+        if (!this.#manifest) {
+            return;
+        }
+        const version = this.#resolveTag(tag, this.#manifest);
         if (!version) {
-            this.#onDiagnostics(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+            this.#onDiagnostics(Diagnostic.error(StoreDiagnosticText.cannotAddTypeScriptPackage(tag)));
             return;
         }
-        return this.#packageInstaller.ensure(version, cancellationToken);
+        return this.#packageService.ensure(version, this.#manifest);
     }
-    async load(tag, cancellationToken) {
+    async load(tag) {
         let compilerInstance = this.#compilerInstanceCache.get(tag);
         if (compilerInstance != null) {
             return compilerInstance;
@@ -3911,16 +3923,20 @@ class StoreService {
             modulePath = Environment.typescriptPath;
         }
         else {
-            const version = await this.#resolveTag(tag);
+            await this.open();
+            if (!this.#manifest) {
+                return;
+            }
+            const version = this.#resolveTag(tag, this.#manifest);
             if (!version) {
-                this.#onDiagnostics(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
+                this.#onDiagnostics(Diagnostic.error(StoreDiagnosticText.cannotAddTypeScriptPackage(tag)));
                 return;
             }
             compilerInstance = this.#compilerInstanceCache.get(version);
             if (compilerInstance != null) {
                 return compilerInstance;
             }
-            modulePath = await this.#packageInstaller.ensure(version, cancellationToken);
+            modulePath = await this.#packageService.ensure(version, this.#manifest);
         }
         if (modulePath != null) {
             compilerInstance = await this.#loadModule(modulePath);
@@ -3939,6 +3955,7 @@ class StoreService {
                 continue;
             }
             const toExpose = [
+                "getTypeOfSymbol",
                 "isTypeRelatedTo",
                 "relation: { assignable: assignableRelation, identity: identityRelation, subtype: strictSubtypeRelation }",
             ];
@@ -3958,15 +3975,11 @@ class StoreService {
         }
         this.#manifest = await this.#manifestWorker.open();
     }
-    async #resolveTag(tag) {
-        await this.open();
-        if (!this.#manifest) {
-            return;
-        }
-        if (this.#manifest.versions.includes(tag)) {
+    #resolveTag(tag, manifest) {
+        if (manifest.versions.includes(tag)) {
             return tag;
         }
-        return this.#manifest.resolutions[tag];
+        return manifest.resolutions[tag];
     }
     async update() {
         await this.#manifestWorker.open({ refresh: true });
@@ -3984,8 +3997,8 @@ class StoreService {
                 (this.#manifest.resolutions["latest"] != null &&
                     Version.isGreaterThan(tag, this.#manifest.resolutions["latest"])))) {
             this.#onDiagnostics(Diagnostic.warning([
-                "Failed to update metadata of the 'typescript' package from the registry.",
-                `The resolution of the '${tag}' tag may be outdated.`,
+                StoreDiagnosticText.failedToUpdateMetadata(this.#npmRegistry),
+                StoreDiagnosticText.maybeOutdatedResolution(tag),
             ]));
         }
         return tag in this.#manifest.resolutions || this.#manifest.versions.includes(tag);
@@ -4049,6 +4062,7 @@ class Cli {
                 this.#outputService.writeMessage(formattedText({
                     noColor: Environment.noColor,
                     noInteractive: Environment.noInteractive,
+                    npmRegistry: Environment.npmRegistry,
                     storePath: Environment.storePath,
                     timeout: Environment.timeout,
                     typescriptPath: Environment.typescriptPath,