tstyche 3.0.0-beta.6 → 3.0.0-rc.0

package/build/tstyche.d.ts

@@ -65,7 +65,7 @@ declare class Diagnostic {
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
-type DiagnosticsHandler$1 = (this: void, diagnostic: Diagnostic) => void;
+type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
 
 declare enum TestMemberBrand {
     Describe = "describe",
@@ -130,24 +130,17 @@ declare enum OptionBrand {
     List = "list"
 }
 
-declare enum OptionGroup {
-    CommandLine = 2,
-    ConfigFile = 4,
-    ResolvedConfig = 6
-}
-
 declare class ConfigDiagnosticText {
-    #private;
     static expected(element: string): string;
     static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
-    static expectsValue(optionName: string, optionGroup: OptionGroup): string;
+    static expectsValue(optionName: string): string;
     static fileDoesNotExist(filePath: string): string;
     static moduleWasNotFound(specifier: string): string;
     static seen(element: string): string;
     static testFileMatchCannotStartWith(segment: string): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand, optionGroup: OptionGroup): string;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
     static unknownOption(optionName: string): string;
-    static usage(optionName: string, optionBrand: OptionBrand, optionGroup: OptionGroup): Promise<Array<string>>;
+    static usage(optionName: string, optionBrand: OptionBrand): Promise<Array<string>>;
     static versionIsNotSupported(value: string): string;
     static watchCannotBeEnabled(): string;
 }
@@ -285,12 +278,12 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
-interface ItemDefinition {
-    brand: OptionBrand.String;
-    name: string;
-    pattern?: string;
+declare enum OptionGroup {
+    CommandLine = 2,
+    ConfigFile = 4,
+    ResolvedConfig = 6
 }
-type OptionDefinition = PrimitiveTypeOptionDefinition | ListTypeOptionDefinition;
+
 interface BaseOptionDefinition {
     brand: OptionBrand;
     description: string;
@@ -300,15 +293,21 @@ interface BaseOptionDefinition {
 interface PrimitiveTypeOptionDefinition extends BaseOptionDefinition {
     brand: OptionBrand.String | OptionBrand.Number | OptionBrand.Boolean | OptionBrand.BareTrue;
 }
+interface ItemDefinition {
+    brand: OptionBrand.String;
+    name: string;
+    pattern?: string;
+}
 interface ListTypeOptionDefinition extends BaseOptionDefinition {
     brand: OptionBrand.List;
     items: ItemDefinition;
 }
+type OptionDefinition = PrimitiveTypeOptionDefinition | ListTypeOptionDefinition;
 declare class Options {
     #private;
     static for(optionGroup: OptionGroup): Map<string, OptionDefinition>;
     static resolve(optionName: string, optionValue: string, rootPath?: string): string;
-    static validate(optionDefinition: OptionDefinition | ItemDefinition, optionValue: string, optionGroup: OptionGroup, onDiagnostics: DiagnosticsHandler$1, origin?: DiagnosticOrigin): Promise<void>;
+    static validate(optionName: string, optionValue: string, optionBrand: OptionBrand, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
 declare const defaultOptions: Required<ConfigFileOptions>;
@@ -339,9 +338,9 @@ interface EnvironmentOptions {
      */
     timeout: number;
     /**
-     * The path to the currently installed TypeScript module.
+     * The specifier of the TypeScript module.
      */
-    typescriptPath: string | undefined;
+    typescriptModule: string | undefined;
 }
 
 declare const environmentOptions: EnvironmentOptions;
@@ -553,8 +552,6 @@ declare class EventEmitter {
     removeReporters(): void;
 }
 
-type ArgumentNode = ts.Expression | ts.TypeNode;
-type DiagnosticsHandler = (diagnostics: Diagnostic | Array<Diagnostic>) => void;
 interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
@@ -569,136 +566,29 @@ interface TypeChecker extends ts.TypeChecker {
     };
 }
 
-declare class MatchWorker {
-    #private;
-    assertion: Assertion;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker, assertion: Assertion);
-    checkIsAssignableTo(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
-    checkIsAssignableWith(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
-    checkIsIdenticalTo(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
-    checkIsSubtype(sourceNode: ArgumentNode, targetNode: ArgumentNode): boolean;
-    extendsObjectType(type: ts.Type): boolean;
-    getParameterType(signature: ts.Signature, index: number): ts.Type | undefined;
-    getSignatures(node: ArgumentNode): Array<ts.Signature>;
-    getTypeText(node: ArgumentNode): string;
-    getType(node: ArgumentNode): ts.Type;
-    isAnyOrNeverType(type: ts.Type): type is ts.StringLiteralType | ts.NumberLiteralType;
-    isStringOrNumberLiteralType(type: ts.Type): type is ts.StringLiteralType | ts.NumberLiteralType;
-    isObjectType(type: ts.Type): type is ts.ObjectType;
-    isUnionType(type: ts.Type): type is ts.UnionType;
-    isUniqueSymbolType(type: ts.Type): type is ts.UniqueESSymbolType;
-    resolveDiagnosticOrigin(symbol: ts.Symbol, enclosingNode: ts.Node): DiagnosticOrigin;
-}
-
-declare class PrimitiveTypeMatcher {
-    #private;
-    constructor(targetTypeFlag: ts.TypeFlags);
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode): MatchResult;
-}
-
-declare class ToAcceptProps {
-    #private;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker);
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
-}
-
-declare class ExpectDiagnosticText {
-    static argumentOrTypeArgumentMustBeProvided(argumentNameText: string, typeArgumentNameText: string): string;
-    static argumentMustBe(argumentNameText: string, expectedText: string): string;
-    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;
-    static typeArgumentMustBe(argumentNameText: string, expectedText: string): string;
-    static typeDidNotRaiseError(isTypeNode: boolean): string;
-    static typeDidNotRaiseMatchingError(isTypeNode: boolean): string;
-    static typeDoesNotHaveProperty(typeText: string, propertyNameText: string): string;
-    static typeDoesMatch(sourceTypeText: string, targetTypeText: string): string;
-    static typeDoesNotMatch(sourceTypeText: string, targetTypeText: string): string;
-    static typeHasProperty(typeText: string, propertyNameText: string): string;
-    static typeIs(typeText: string): string;
-    static typeIsAssignableTo(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsAssignableWith(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsIdenticalTo(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsNotAssignableTo(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsNotAssignableWith(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsNotCompatibleWith(sourceTypeText: string, targetTypeText: string): string;
-    static typeIsNotIdenticalTo(sourceTypeText: string, targetTypeText: string): string;
-    static typeRaisedError(isTypeNode: boolean, count: number, targetCount: number): string;
-    static typeRaisedMatchingError(isTypeNode: boolean): string;
-    static typeRequiresProperty(typeText: string, propertyNameText: string): string;
-    static typesOfPropertyAreNotCompatible(propertyNameText: string): string;
-}
-
-declare abstract class RelationMatcherBase {
-    abstract explainText(sourceTypeText: string, targetTypeText: string): string;
-    abstract explainNotText(sourceTypeText: string, targetTypeText: string): string;
-    protected explain(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): Diagnostic[];
-    abstract match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
-}
-
-declare class ToBe extends RelationMatcherBase {
-    explainText: typeof ExpectDiagnosticText.typeIsIdenticalTo;
-    explainNotText: typeof ExpectDiagnosticText.typeIsNotIdenticalTo;
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
-}
-
-declare class ToBeAssignableTo extends RelationMatcherBase {
-    explainText: typeof ExpectDiagnosticText.typeIsAssignableTo;
-    explainNotText: typeof ExpectDiagnosticText.typeIsNotAssignableTo;
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
-}
-
-declare class ToBeAssignableWith extends RelationMatcherBase {
-    explainText: typeof ExpectDiagnosticText.typeIsAssignableWith;
-    explainNotText: typeof ExpectDiagnosticText.typeIsNotAssignableWith;
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
-}
-
-declare class ToHaveProperty {
-    #private;
-    constructor(compiler: typeof ts);
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
-}
-
-declare class ToMatch extends RelationMatcherBase {
-    explainText: typeof ExpectDiagnosticText.typeDoesMatch;
-    explainNotText: typeof ExpectDiagnosticText.typeDoesNotMatch;
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNode: ArgumentNode): MatchResult;
-}
-
-declare class ToRaiseError {
-    #private;
-    constructor(compiler: typeof ts);
-    match(matchWorker: MatchWorker, sourceNode: ArgumentNode, targetNodes: Array<ArgumentNode>, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
-}
-
 declare class ExpectService {
     #private;
-    toAcceptProps: ToAcceptProps;
-    toBe: ToBe;
-    toBeAny: PrimitiveTypeMatcher;
-    toBeAssignableTo: ToBeAssignableTo;
-    toBeAssignableWith: ToBeAssignableWith;
-    toBeBigInt: PrimitiveTypeMatcher;
-    toBeBoolean: PrimitiveTypeMatcher;
-    toBeNever: PrimitiveTypeMatcher;
-    toBeNull: PrimitiveTypeMatcher;
-    toBeNumber: PrimitiveTypeMatcher;
-    toBeString: PrimitiveTypeMatcher;
-    toBeSymbol: PrimitiveTypeMatcher;
-    toBeUndefined: PrimitiveTypeMatcher;
-    toBeUniqueSymbol: PrimitiveTypeMatcher;
-    toBeUnknown: PrimitiveTypeMatcher;
-    toBeVoid: PrimitiveTypeMatcher;
-    toHaveProperty: ToHaveProperty;
-    toMatch: ToMatch;
-    toRaiseError: ToRaiseError;
+    private toAcceptProps;
+    private toBe;
+    private toBeAny;
+    private toBeAssignableTo;
+    private toBeAssignableWith;
+    private toBeBigInt;
+    private toBeBoolean;
+    private toBeNever;
+    private toBeNull;
+    private toBeNumber;
+    private toBeString;
+    private toBeSymbol;
+    private toBeUndefined;
+    private toBeUniqueSymbol;
+    private toBeUnknown;
+    private toBeVoid;
+    private toHaveProperty;
+    private toMatch;
+    private toRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker);
-    match(assertion: Assertion, onDiagnostics: DiagnosticsHandler): MatchResult | undefined;
+    match(assertion: Assertion, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
 }
 
 declare class CancellationHandler implements EventHandler {
@@ -928,4 +818,4 @@ declare class WatchService {
     watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
 }
 
-export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, Config, ConfigDiagnosticText, type ConfigFileOptions, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, type DiagnosticsHandler$1 as DiagnosticsHandler, type EnvironmentOptions, type Event, EventEmitter, type EventHandler, ExitCodeHandler, ExpectResult, ExpectService, type FileWatchHandler, FileWatcher, type InputHandler, InputService, type ItemDefinition, Line, ListReporter, type MatchResult, OptionBrand, type OptionDefinition, OptionGroup, Options, OutputService, Path, type Plugin, PluginService, ProjectResult, ProjectService, type Reporter, type ReporterEvent, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, type ScribblerOptions, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, type TargetResultStatus, Task, TaskResult, type TaskResultStatus, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, type TypeChecker, Version, type WatchHandler, WatchReporter, WatchService, Watcher, type WatcherOptions, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, type CommandLineOptions, Config, ConfigDiagnosticText, type ConfigFileOptions, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, type DiagnosticsHandler, type EnvironmentOptions, type Event, EventEmitter, type EventHandler, ExitCodeHandler, ExpectResult, ExpectService, type FileWatchHandler, FileWatcher, type InputHandler, InputService, type ItemDefinition, Line, ListReporter, type MatchResult, OptionBrand, type OptionDefinition, OptionGroup, Options, OutputService, Path, type Plugin, PluginService, ProjectResult, ProjectService, type Reporter, type ReporterEvent, type ResolvedConfig, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, type ScribblerOptions, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, type TargetResultStatus, Task, TaskResult, type TaskResultStatus, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, type TypeChecker, Version, type WatchHandler, WatchReporter, WatchService, Watcher, type WatcherOptions, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };

package/build/tstyche.js

@@ -1,12 +1,12 @@
 import fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm from 'node:vm';
 import os from 'node:os';
 import process from 'node:process';
 import path from 'node:path';
 import { writeFileSync, rmSync, existsSync, watch } from 'node:fs';
 import streamConsumers from 'node:stream/consumers';
-import { pathToFileURL, fileURLToPath } from 'node:url';
 
 class DiagnosticOrigin {
     assertion;
@@ -154,7 +154,7 @@ class Environment {
             npmRegistry: Environment.#resolveNpmRegistry(),
             storePath: Environment.#resolveStorePath(),
             timeout: Environment.#resolveTimeout(),
-            typescriptPath: Environment.#resolveTypeScriptPath(),
+            typescriptModule: Environment.#resolveTypeScriptModule(),
         };
     }
     static #resolveIsCi() {
@@ -205,18 +205,18 @@ class Environment {
         }
         return 30;
     }
-    static #resolveTypeScriptPath() {
+    static #resolveTypeScriptModule() {
         let specifier = "typescript";
-        if (process.env["TSTYCHE_TYPESCRIPT_PATH"] != null) {
-            specifier = process.env["TSTYCHE_TYPESCRIPT_PATH"];
+        if (process.env["TSTYCHE_TYPESCRIPT_MODULE"] != null) {
+            specifier = process.env["TSTYCHE_TYPESCRIPT_MODULE"];
         }
-        let resolvedPath;
+        let resolvedModule;
         try {
-            resolvedPath = Path.normalizeSlashes(createRequire(import.meta.url).resolve(specifier));
+            resolvedModule = import.meta.resolve(specifier);
         }
         catch {
         }
-        return resolvedPath;
+        return resolvedModule;
     }
 }
 
@@ -672,8 +672,8 @@ class Store {
             return compilerInstance;
         }
         let modulePath;
-        if (tag === "current" && environmentOptions.typescriptPath != null) {
-            modulePath = environmentOptions.typescriptPath;
+        if (tag === "current" && environmentOptions.typescriptModule != null) {
+            modulePath = fileURLToPath(environmentOptions.typescriptModule);
         }
         else {
             await Store.open();
@@ -741,7 +741,7 @@ class Store {
     }
     static async validateTag(tag) {
         if (tag === "current") {
-            return environmentOptions.typescriptPath != null;
+            return environmentOptions.typescriptModule != null;
         }
         await Store.open();
         if (Store.#manifest?.isOutdated({ ageTolerance: 60 }) &&
@@ -764,8 +764,7 @@ class ConfigDiagnosticText {
     static expectsListItemType(optionName, optionBrand) {
         return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
     }
-    static expectsValue(optionName, optionGroup) {
-        optionName = ConfigDiagnosticText.#optionName(optionName, optionGroup);
+    static expectsValue(optionName) {
         return `Option '${optionName}' expects a value.`;
     }
     static fileDoesNotExist(filePath) {
@@ -774,9 +773,6 @@ class ConfigDiagnosticText {
     static moduleWasNotFound(specifier) {
         return `The specified module '${specifier}' was not found.`;
     }
-    static #optionName(optionName, optionGroup) {
-        return optionGroup === 2 ? `--${optionName}` : optionName;
-    }
     static seen(element) {
         return `The ${element} was seen here.`;
     }
@@ -786,39 +782,34 @@ class ConfigDiagnosticText {
             "The test files are only collected within the 'rootPath' directory.",
         ];
     }
-    static requiresValueType(optionName, optionBrand, optionGroup) {
-        const optionNameText = ConfigDiagnosticText.#optionName(optionName, optionGroup);
-        return `Option '${optionNameText}' requires a value of type ${optionBrand}.`;
+    static requiresValueType(optionName, optionBrand) {
+        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
     }
     static unknownOption(optionName) {
         return `Unknown option '${optionName}'.`;
     }
-    static async usage(optionName, optionBrand, optionGroup) {
-        const text = [];
-        switch (optionName) {
+    static async usage(optionName, optionBrand) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
             case "target": {
-                switch (optionGroup) {
-                    case 2:
-                        text.push("Value for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.");
-                        break;
-                    case 4:
-                        text.push("Item of the 'target' list must be a supported version tag.");
-                        break;
+                const text = [];
+                if (optionName.startsWith("--")) {
+                    text.push("Value for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.");
+                }
+                else {
+                    text.push("Item of the 'target' list must be a supported version tag.");
                 }
                 const supportedTags = await Store.getSupportedTags();
                 if (supportedTags != null) {
                     text.push(`Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`);
                 }
-                break;
+                return text;
             }
-            default:
-                text.push(ConfigDiagnosticText.requiresValueType(optionName, optionBrand, optionGroup));
         }
-        return text;
+        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
     }
     static versionIsNotSupported(value) {
         if (value === "current") {
-            return "Cannot use 'current' as a target. Failed to resolve the path to the currently installed TypeScript module.";
+            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
         }
         return `TypeScript version '${value}' is not supported.`;
     }
@@ -971,53 +962,62 @@ class Options {
         return definitionMap;
     }
     static resolve(optionName, optionValue, rootPath = ".") {
-        switch (optionName) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "config":
+            case "rootPath":
             case "tsconfig":
-                if (["findup", "ignore"].includes(optionValue)) {
+                if (optionName.endsWith("tsconfig") && ["findup", "ignore"].includes(optionValue)) {
                     break;
                 }
-            case "config":
-            case "rootPath":
                 optionValue = Path.resolve(rootPath, optionValue);
                 break;
             case "plugins":
             case "reporters":
-                if (optionValue.startsWith(".")) {
-                    optionValue = pathToFileURL(Path.join(Path.relative(".", rootPath), optionValue)).toString();
+                if (optionName.endsWith("reporters") && ["list", "summary"].includes(optionValue)) {
+                    break;
+                }
+                try {
+                    if (optionValue.startsWith(".")) {
+                        optionValue = pathToFileURL(Path.relative(".", Path.resolve(rootPath, optionValue))).toString();
+                    }
+                    else {
+                        optionValue = import.meta.resolve(optionValue);
+                    }
+                }
+                catch {
                 }
                 break;
         }
         return optionValue;
     }
-    static async validate(optionDefinition, optionValue, optionGroup, onDiagnostics, origin) {
-        switch (optionDefinition.name) {
+    static async validate(optionName, optionValue, optionBrand, onDiagnostics, origin) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "config":
+            case "rootPath":
             case "tsconfig":
-                if (["findup", "ignore"].includes(optionValue)) {
+                if (optionName.endsWith("tsconfig") && ["findup", "ignore"].includes(optionValue)) {
                     break;
                 }
-            case "config":
-            case "rootPath":
-                if (!existsSync(optionValue)) {
-                    onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
+                if (existsSync(optionValue)) {
+                    break;
                 }
+                onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
                 break;
+            case "plugins":
             case "reporters":
-                if (["list", "summary"].includes(optionValue)) {
+                if (optionName.endsWith("reporters") && ["list", "summary"].includes(optionValue)) {
                     break;
                 }
-            case "plugins":
-                try {
-                    await import(optionValue);
-                }
-                catch {
-                    onDiagnostics(Diagnostic.error(ConfigDiagnosticText.moduleWasNotFound(optionValue), origin));
+                if (optionValue.startsWith("file:") && existsSync(new URL(optionValue))) {
+                    break;
                 }
+                onDiagnostics(Diagnostic.error(ConfigDiagnosticText.moduleWasNotFound(optionValue), origin));
                 break;
             case "target":
                 if ((await Store.validateTag(optionValue)) === false) {
                     onDiagnostics(Diagnostic.error([
                         ConfigDiagnosticText.versionIsNotSupported(optionValue),
-                        await ConfigDiagnosticText.usage(optionDefinition.name, optionDefinition.brand, optionGroup),
+                        await ConfigDiagnosticText.usage(optionName, optionBrand),
                     ].flat(), origin));
                 }
                 break;
@@ -1048,10 +1048,10 @@ class CommandLineParser {
         this.#onDiagnostics = onDiagnostics;
         this.#options = Options.for(2);
     }
-    async #onExpectsValue(optionDefinition) {
+    async #onExpectsValue(optionName, optionBrand) {
         const text = [
-            ConfigDiagnosticText.expectsValue(optionDefinition.name, 2),
-            await ConfigDiagnosticText.usage(optionDefinition.name, optionDefinition.brand, 2),
+            ConfigDiagnosticText.expectsValue(optionName),
+            await ConfigDiagnosticText.usage(optionName, optionBrand),
         ].flat();
         this.#onDiagnostics(Diagnostic.error(text));
     }
@@ -1061,10 +1061,9 @@ class CommandLineParser {
         while (arg != null) {
             index++;
             if (arg.startsWith("--")) {
-                const optionName = arg.slice(2);
-                const optionDefinition = this.#options.get(optionName);
+                const optionDefinition = this.#options.get(arg.slice(2));
                 if (optionDefinition) {
-                    index = await this.#parseOptionValue(commandLineArgs, index, optionDefinition);
+                    index = await this.#parseOptionValue(commandLineArgs, index, arg, optionDefinition);
                 }
                 else {
                     this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.unknownOption(arg)));
@@ -1079,15 +1078,15 @@ class CommandLineParser {
             arg = commandLineArgs[index];
         }
     }
-    async #parseOptionValue(commandLineArgs, index, optionDefinition) {
+    async #parseOptionValue(commandLineArgs, index, optionName, optionDefinition) {
         let optionValue = this.#resolveOptionValue(commandLineArgs[index]);
         switch (optionDefinition.brand) {
             case "bareTrue":
-                await Options.validate(optionDefinition, optionValue, 2, this.#onDiagnostics);
+                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = true;
                 break;
             case "boolean":
-                await Options.validate(optionDefinition, optionValue, 2, this.#onDiagnostics);
+                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
                     index++;
@@ -1099,25 +1098,25 @@ class CommandLineParser {
                         .split(",")
                         .map((value) => value.trim())
                         .filter((value) => value !== "")
-                        .map((value) => Options.resolve(optionDefinition.name, value));
+                        .map((value) => Options.resolve(optionName, value));
                     for (const optionValue of optionValues) {
-                        await Options.validate(optionDefinition, optionValue, 2, this.#onDiagnostics);
+                        await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                     }
                     this.#commandLineOptions[optionDefinition.name] = optionValues;
                     index++;
                     break;
                 }
-                await this.#onExpectsValue(optionDefinition);
+                await this.#onExpectsValue(optionName, optionDefinition.brand);
                 break;
             case "string":
                 if (optionValue !== "") {
-                    optionValue = Options.resolve(optionDefinition.name, optionValue);
-                    await Options.validate(optionDefinition, optionValue, 2, this.#onDiagnostics);
+                    optionValue = Options.resolve(optionName, optionValue);
+                    await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                     this.#commandLineOptions[optionDefinition.name] = optionValue;
                     index++;
                     break;
                 }
-                await this.#onExpectsValue(optionDefinition);
+                await this.#onExpectsValue(optionName, optionDefinition.brand);
                 break;
         }
         return index;
@@ -1271,7 +1270,7 @@ class ConfigFileParser {
     #onRequiresValue(optionDefinition, jsonNode, isListItem) {
         const text = isListItem
             ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
-            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, 4);
+            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand);
         this.#onDiagnostics(Diagnostic.error(text, jsonNode.origin));
     }
     async #parseValue(optionDefinition, isListItem = false) {
@@ -1296,7 +1295,7 @@ class ConfigFileParser {
                 }
                 const rootPath = Path.dirname(this.#sourceFile.fileName);
                 optionValue = Options.resolve(optionDefinition.name, optionValue, rootPath);
-                await Options.validate(optionDefinition, optionValue, 4, this.#onDiagnostics, jsonNode.origin);
+                await Options.validate(optionDefinition.name, optionValue, optionDefinition.brand, this.#onDiagnostics, jsonNode.origin);
                 break;
             }
             case "list": {
@@ -1400,14 +1399,14 @@ const defaultOptions = {
     plugins: [],
     reporters: ["list", "summary"],
     rootPath: Path.resolve("./"),
-    target: environmentOptions.typescriptPath != null ? ["current"] : ["latest"],
+    target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
     testFileMatch: ["**/*.tst.*", "**/__typetests__/*.test.*", "**/typetests/*.test.*"],
     tsconfig: "findup",
 };
 
 class Config {
-    static #onDiagnostics(diagnostics) {
-        EventEmitter.dispatch(["config:error", { diagnostics: [diagnostics] }]);
+    static #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["config:error", { diagnostics: [diagnostic] }]);
     }
     static async parseCommandLine(commandLine) {
         const commandLineOptions = {};
@@ -4097,7 +4096,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "3.0.0-beta.6";
+    static version = "3.0.0-rc.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4221,8 +4220,8 @@ class Cli {
                 }
                 continue;
             }
-            for (const pluginIdentifier of resolvedConfig.plugins) {
-                const plugin = (await import(pluginIdentifier)).default;
+            for (const pluginSpecifier of resolvedConfig.plugins) {
+                const plugin = (await import(pluginSpecifier)).default;
                 PluginService.addHandler(plugin);
             }
             resolvedConfig = await PluginService.call("config", resolvedConfig, {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "3.0.0-beta.6",
+  "version": "3.0.0-rc.0",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -63,14 +63,14 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.1",
-    "@types/node": "20.17.1",
+    "@types/node": "22.8.4",
     "@types/react": "18.3.12",
     "ajv": "8.17.1",
     "cspell": "8.15.4",
     "magic-string": "0.30.12",
     "monocart-coverage-reports": "2.11.1",
     "pretty-ansi": "2.0.0",
-    "rollup": "4.24.2",
+    "rollup": "4.24.3",
     "rollup-plugin-dts": "6.1.1",
     "tslib": "2.8.0",
     "typescript": "5.6.3"
@@ -85,6 +85,6 @@
   },
   "packageManager": "yarn@4.5.1",
   "engines": {
-    "node": ">=18.17"
+    "node": ">=18.19"
   }
 }