tstyche 2.1.1 → 3.0.0-beta.0

package/README.md

@@ -2,10 +2,8 @@
 
 [![version][version-badge]][version-url]
 [![license][license-badge]][license-url]
-[![requirements][requirements-badge]][requirements-url]
 [![install-size][install-size-badge]][install-size-url]
 [![coverage][coverage-badge]][coverage-url]
-[![discord][discord-badge]][discord-url]
 
 The Essential Type Testing Tool.
 
@@ -80,7 +78,7 @@ Visit [https://tstyche.org](https://tstyche.org) to view the full documentation.
 
 ## Feedback
 
-If you have any questions or suggestions, [start a discussion](https://github.com/tstyche/tstyche/discussions/new/choose) or [open an issue](https://github.com/tstyche/tstyche/issues/new/choose) on GitHub. Preferring a chat? Join our [Discord server][discord-url].
+If you have any questions or suggestions, [start a discussion](https://github.com/tstyche/tstyche/discussions/new/choose) or [open an issue](https://github.com/tstyche/tstyche/issues/new/choose) on GitHub. Preferring a chat? Join our [Discord server](https://discord.gg/gCSasd3QJq).
 
 ## License
 
@@ -90,11 +88,7 @@ If you have any questions or suggestions, [start a discussion](https://github.co
 [version-url]: https://npmjs.com/package/tstyche
 [license-badge]: https://badgen.net/github/license/tstyche/tstyche
 [license-url]: https://github.com/tstyche/tstyche/blob/main/LICENSE.md
-[requirements-badge]: https://badgen.net/npm/node/tstyche
-[requirements-url]: https://tstyche.org/reference/requirements
 [install-size-badge]: https://badgen.net/packagephobia/install/tstyche
 [install-size-url]: https://packagephobia.com/result?p=tstyche
 [coverage-badge]: https://badgen.net/codacy/coverage/a581ca5c323a455886b7bdd9623c4ec8
 [coverage-url]: https://app.codacy.com/gh/tstyche/tstyche/coverage/dashboard
-[discord-badge]: https://badgen.net/static/chat/on%20Discord
-[discord-url]: https://discord.gg/gCSasd3QJq

package/build/tstyche.d.ts

@@ -1,26 +1,11 @@
 import type ts from 'typescript';
 
-declare enum CancellationReason {
-    ConfigChange = "configChange",
-    ConfigError = "configError",
-    FailFast = "failFast",
-    WatchClose = "watchClose"
-}
-
-declare class CancellationToken {
-    #private;
-    get isCancellationRequested(): boolean;
-    get reason(): CancellationReason | undefined;
-    cancel(reason: CancellationReason): void;
-    reset(): void;
-}
-
 declare class StoreService {
     #private;
     constructor();
     getSupportedTags(): Promise<Array<string>>;
-    install(tag: string, cancellationToken?: CancellationToken): Promise<string | undefined>;
-    load(tag: string, cancellationToken?: CancellationToken): Promise<typeof ts | undefined>;
+    install(tag: string): Promise<string | undefined>;
+    load(tag: string): Promise<typeof ts | undefined>;
     open(): Promise<void>;
     update(): Promise<void>;
     validateTag(tag: string): Promise<boolean | undefined>;
@@ -147,7 +132,6 @@ declare class Diagnostic {
     static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
     extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
     static fromDiagnostics(diagnostics: Array<ts.Diagnostic>, compiler: typeof ts): Array<Diagnostic>;
-    static fromError(text: string | Array<string>, error: unknown): Diagnostic;
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
@@ -320,7 +304,7 @@ interface TextProps {
 }
 declare function Text({ children, color, indent }: TextProps): ScribblerJsx.Element;
 
-declare function addsPackageStepText(compilerVersion: string, installationPath: string): ScribblerJsx.Element;
+declare function addsPackageStepText(packageVersion: string, packagePath: string): ScribblerJsx.Element;
 
 declare function describeNameText(name: string, indent?: number): ScribblerJsx.Element;
 
@@ -485,6 +469,21 @@ declare class SelectService {
     selectFiles(): Promise<Array<string>>;
 }
 
+declare enum CancellationReason {
+    ConfigChange = "configChange",
+    ConfigError = "configError",
+    FailFast = "failFast",
+    WatchClose = "watchClose"
+}
+
+declare class CancellationToken {
+    #private;
+    get isCancellationRequested(): boolean;
+    get reason(): CancellationReason | undefined;
+    cancel(reason: CancellationReason): void;
+    reset(): void;
+}
+
 declare class TSTyche {
     #private;
     static version: string;
@@ -512,6 +511,10 @@ declare class Environment {
      * Specifies whether interactive elements should be disabled in the output.
      */
     static get noInteractive(): boolean;
+    /**
+     * The base URL of the 'npm' registry to use.
+     */
+    static get npmRegistry(): string;
     /**
      * The directory where to store the 'typescript' packages.
      */
@@ -537,8 +540,8 @@ type Event = ["config:error", {
 }] | ["run:end", {
     result: Result;
 }] | ["store:info", {
-    compilerVersion: string;
-    installationPath: string;
+    packagePath: string;
+    packageVersion: string;
 }] | ["store:error", {
     diagnostics: Array<Diagnostic>;
 }] | ["target:start", {
@@ -656,7 +659,6 @@ declare class ExpectDiagnosticText {
     static argumentMustBeProvided(argumentNameText: string): string;
     static componentAcceptsProps(isTypeNode: boolean): string;
     static componentDoesNotAcceptProps(isTypeNode: boolean): string;
-    static matcherIsDeprecated(matcherNameText: string): Array<string>;
     static matcherIsNotSupported(matcherNameText: string): string;
     static overloadGaveTheFollowingError(index: number, count: number, signatureText: string): string;
     static raisedTypeError(count?: number): string;
@@ -729,7 +731,6 @@ declare class ExpectService {
     toAcceptProps: ToAcceptProps;
     toBe: ToBe;
     toBeAny: PrimitiveTypeMatcher;
-    toBeAssignable: ToBeAssignableWith;
     toBeAssignableTo: ToBeAssignableTo;
     toBeAssignableWith: ToBeAssignableWith;
     toBeBigInt: PrimitiveTypeMatcher;
@@ -743,12 +744,10 @@ declare class ExpectService {
     toBeUniqueSymbol: PrimitiveTypeMatcher;
     toBeUnknown: PrimitiveTypeMatcher;
     toBeVoid: PrimitiveTypeMatcher;
-    toEqual: ToBe;
     toHaveProperty: ToHaveProperty;
     toMatch: ToMatch;
     toRaiseError: ToRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker);
-    static assertTypeChecker(typeChecker: ts.TypeChecker): typeChecker is TypeChecker;
     match(assertion: Assertion, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
 }
 

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"]);
@@ -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) {
@@ -994,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;
             }
@@ -1118,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) {
@@ -1317,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;
     }
@@ -1453,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)));
         }
@@ -1464,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 {
         }
     }
 }
@@ -1895,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.`;
@@ -1911,12 +2029,6 @@ 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.`;
     }
@@ -2490,7 +2602,6 @@ class ExpectService {
     toAcceptProps;
     toBe;
     toBeAny;
-    toBeAssignable;
     toBeAssignableTo;
     toBeAssignableWith;
     toBeBigInt;
@@ -2504,7 +2615,6 @@ class ExpectService {
     toBeUniqueSymbol;
     toBeUnknown;
     toBeVoid;
-    toEqual;
     toHaveProperty;
     toMatch;
     toRaiseError;
@@ -2514,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);
@@ -2528,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;
@@ -2558,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);
@@ -2618,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;
@@ -2958,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,
@@ -3010,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) {
@@ -3039,7 +2999,7 @@ class TSTyche {
     #selectService;
     #storeService;
     #taskRunner;
-    static version = "2.1.1";
+    static version = "3.0.0-beta.0";
     constructor(resolvedConfig, outputService, selectService, storeService) {
         this.#resolvedConfig = resolvedConfig;
         this.#outputService = outputService;
@@ -3619,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 ${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 ${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();
@@ -3660,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;
-            }
-            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(),
-                ]));
+        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 };
             }
-            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;
@@ -3722,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;
@@ -3759,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 ${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 ${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 ${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();
@@ -3897,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;
@@ -3918,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);
@@ -3966,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 });
@@ -3992,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);
@@ -4057,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "2.1.1",
+  "version": "3.0.0-beta.0",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -47,14 +47,14 @@
     "generate:schema": "node ./scripts/generate-schema.js",
     "generate:types": "node ./scripts/generate-types.js",
     "lint": "biome lint --write",
-    "prepublish": "yarn clean && yarn build && yarn test",
+    "prepublish": "yarn clean && yarn build",
     "test": "yarn test:unit && yarn test:e2e",
     "test:coverage": "yarn test:coverage:collect && yarn test:coverage:report",
     "test:coverage:collect": "yarn build --sourcemap && NODE_V8_COVERAGE='./coverage/v8-coverage' yarn test:e2e",
     "test:coverage:report": "node ./scripts/report-coverage.js",
     "test:e2e": "yarn test:e2e:parallel && yarn test:e2e:serial",
-    "test:e2e:parallel": "yarn poku ./tests --exclude='store|target|update|versions|watch' --parallel",
-    "test:e2e:serial": "yarn poku tests/*-{store,target,update,versions,watch}.test.*",
+    "test:e2e:parallel": "yarn poku tests/*.test.* --exclude='install|npmRegistry|store|target|typescript|update|watch' --parallel",
+    "test:e2e:serial": "yarn poku tests/*-{install,npmRegistry,store*,target,typescript*,update,watch}.test.*",
     "test:examples": "tstyche examples",
     "test:types": "tstyche typetests",
     "test:unit": "yarn poku **/__tests__/*.test.* --parallel"
@@ -62,15 +62,15 @@
   "devDependencies": {
     "@biomejs/biome": "1.8.3",
     "@rollup/plugin-typescript": "11.1.6",
-    "@types/node": "20.14.12",
+    "@types/node": "20.14.15",
     "@types/react": "18.3.3",
     "ajv": "8.17.1",
-    "cspell": "8.12.1",
-    "magic-string": "0.30.10",
-    "monocart-coverage-reports": "2.9.3",
-    "poku": "2.2.3",
+    "cspell": "8.13.2",
+    "magic-string": "0.30.11",
+    "monocart-coverage-reports": "2.10.2",
+    "poku": "2.4.3",
     "pretty-ansi": "2.0.0",
-    "rollup": "4.19.1",
+    "rollup": "4.20.0",
     "rollup-plugin-dts": "6.1.1",
     "tslib": "2.6.3",
     "typescript": "5.5.4"
@@ -83,8 +83,8 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@3.8.3",
+  "packageManager": "yarn@4.4.0",
   "engines": {
-    "node": ">=16.14"
+    "node": ">=18.14"
   }
 }