tstyche 3.0.0-beta.5 → 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,22 +130,17 @@ declare enum OptionBrand {
     List = "list"
 }
 
-declare enum OptionGroup {
-    CommandLine = 2,
-    ConfigFile = 4
-}
-
 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): Promise<Array<string>>;
     static versionIsNotSupported(value: string): string;
     static watchCannotBeEnabled(): string;
 }
@@ -283,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;
@@ -298,13 +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(optionName: string, optionValue: string, optionBrand: OptionBrand, onDiagnostics: DiagnosticsHandler, origin?: DiagnosticOrigin): Promise<void>;
 }
 
 declare const defaultOptions: Required<ConfigFileOptions>;
@@ -335,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;
@@ -549,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;
@@ -565,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 {
@@ -714,25 +608,6 @@ declare class ResultHandler implements EventHandler {
     on([event, payload]: Event): void;
 }
 
-interface Hooks {
-    /**
-     * Is called after configuration is resolved and allows to modify it.
-     */
-    config?: (resolvedConfig: ResolvedConfig) => ResolvedConfig | Promise<ResolvedConfig>;
-    /**
-     * Is called after test files are selected and allows to modify the list.
-     */
-    select?: (testFiles: Array<string>) => Array<string | URL> | Promise<Array<string | URL>>;
-}
-
-declare class HooksService {
-    #private;
-    static addHandler(hooks: Hooks): void;
-    static call(hook: "config", resolvedConfig: ResolvedConfig): Promise<ResolvedConfig>;
-    static call(hook: "select", testFiles: Array<string>): Promise<Array<string | URL>>;
-    static removeHandlers(): void;
-}
-
 type InputHandler = (chunk: string) => void;
 declare class InputService {
     #private;
@@ -849,6 +724,32 @@ declare class Path {
     static resolve(...filePaths: Array<string>): string;
 }
 
+interface SelectHookContext {
+    resolvedConfig: ResolvedConfig;
+}
+interface Plugin {
+    /**
+     * The name of this plugin.
+     */
+    name: string;
+    /**
+     * Is called after configuration is resolved and allows to modify it.
+     */
+    config?: (resolvedConfig: ResolvedConfig) => ResolvedConfig | Promise<ResolvedConfig>;
+    /**
+     * Is called after test files are selected and allows to modify the list.
+     */
+    select?: (this: SelectHookContext, testFiles: Array<string>) => Array<string | URL> | Promise<Array<string | URL>>;
+}
+
+type Hooks = Required<Omit<Plugin, "name">>;
+declare class PluginService {
+    #private;
+    static addHandler(plugin: Plugin): void;
+    static call<T extends keyof Hooks>(hook: T, argument: Parameters<Hooks[T]>[0], context: ThisParameterType<Hooks[T]>): Promise<Awaited<ReturnType<Hooks[T]>>>;
+    static removeHandlers(): void;
+}
+
 declare class ProjectService {
     #private;
     constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
@@ -917,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 Hooks, HooksService, type InputHandler, InputService, type ItemDefinition, Line, ListReporter, type MatchResult, OptionBrand, type OptionDefinition, OptionGroup, Options, OutputService, Path, 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,65 +1,13 @@
-import { writeFileSync, rmSync, existsSync, watch } from 'node:fs';
 import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL, fileURLToPath } from 'node:url';
 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';
 
-class ConfigDiagnosticText {
-    static expected(element) {
-        return `Expected ${element}.`;
-    }
-    static expectsListItemType(optionName, optionBrand) {
-        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
-    }
-    static expectsValue(optionName, optionGroup) {
-        optionName = ConfigDiagnosticText.#optionName(optionName, optionGroup);
-        return `Option '${optionName}' expects a value.`;
-    }
-    static fileDoesNotExist(filePath) {
-        return `The specified path '${filePath}' does not exist.`;
-    }
-    static moduleWasNotFound(specifier) {
-        return `The specified module '${specifier}' was not found.`;
-    }
-    static #optionName(optionName, optionGroup) {
-        switch (optionGroup) {
-            case 2:
-                return `--${optionName}`;
-            case 4:
-                return optionName;
-        }
-    }
-    static seen(element) {
-        return `The ${element} was seen here.`;
-    }
-    static testFileMatchCannotStartWith(segment) {
-        return [
-            `A test file match pattern cannot start with '${segment}'.`,
-            "The test files are only collected within the 'rootPath' directory.",
-        ];
-    }
-    static requiresValueType(optionName, optionBrand, optionGroup) {
-        optionName = ConfigDiagnosticText.#optionName(optionName, optionGroup);
-        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
-    }
-    static unknownOption(optionName) {
-        return `Unknown option '${optionName}'.`;
-    }
-    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 `TypeScript version '${value}' is not supported.`;
-    }
-    static watchCannotBeEnabled() {
-        return "Watch mode cannot be enabled in continuous integration environment.";
-    }
-}
-
 class DiagnosticOrigin {
     assertion;
     end;
@@ -169,49 +117,6 @@ class SourceFile {
     }
 }
 
-class EventEmitter {
-    static instanceCount = 0;
-    static #handlers = new Map();
-    static #reporters = new Map();
-    #scope;
-    constructor() {
-        this.#scope = EventEmitter.instanceCount++;
-        EventEmitter.#handlers.set(this.#scope, new Set());
-        EventEmitter.#reporters.set(this.#scope, new Set());
-    }
-    addHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.add(handler);
-    }
-    addReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
-    }
-    static dispatch(event) {
-        function forEachHandler(handlers, event) {
-            for (const handler of handlers) {
-                handler.on(event);
-            }
-        }
-        for (const handlers of EventEmitter.#handlers.values()) {
-            forEachHandler(handlers, event);
-        }
-        for (const handlers of EventEmitter.#reporters.values()) {
-            forEachHandler(handlers, event);
-        }
-    }
-    removeHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
-    }
-    removeReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
-    }
-    removeHandlers() {
-        EventEmitter.#handlers.get(this.#scope)?.clear();
-    }
-    removeReporters() {
-        EventEmitter.#reporters.get(this.#scope)?.clear();
-    }
-}
-
 class Path {
     static normalizeSlashes;
     static {
@@ -249,7 +154,7 @@ class Environment {
             npmRegistry: Environment.#resolveNpmRegistry(),
             storePath: Environment.#resolveStorePath(),
             timeout: Environment.#resolveTimeout(),
-            typescriptPath: Environment.#resolveTypeScriptPath(),
+            typescriptModule: Environment.#resolveTypeScriptModule(),
         };
     }
     static #resolveIsCi() {
@@ -300,23 +205,66 @@ 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;
     }
 }
 
 const environmentOptions = Environment.resolve();
 
+class EventEmitter {
+    static instanceCount = 0;
+    static #handlers = new Map();
+    static #reporters = new Map();
+    #scope;
+    constructor() {
+        this.#scope = EventEmitter.instanceCount++;
+        EventEmitter.#handlers.set(this.#scope, new Set());
+        EventEmitter.#reporters.set(this.#scope, new Set());
+    }
+    addHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.add(handler);
+    }
+    addReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
+    }
+    static dispatch(event) {
+        function forEachHandler(handlers, event) {
+            for (const handler of handlers) {
+                handler.on(event);
+            }
+        }
+        for (const handlers of EventEmitter.#handlers.values()) {
+            forEachHandler(handlers, event);
+        }
+        for (const handlers of EventEmitter.#reporters.values()) {
+            forEachHandler(handlers, event);
+        }
+    }
+    removeHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
+    }
+    removeReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
+    }
+    removeHandlers() {
+        EventEmitter.#handlers.get(this.#scope)?.clear();
+    }
+    removeReporters() {
+        EventEmitter.#reporters.get(this.#scope)?.clear();
+    }
+}
+
 class Version {
     static isGreaterThan(source, target) {
         return !(source === target) && Version.#satisfies(source, target);
@@ -724,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();
@@ -793,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 }) &&
@@ -809,90 +757,64 @@ class Store {
     }
 }
 
-class OptionUsageText {
-    #optionGroup;
-    constructor(optionGroup) {
-        this.#optionGroup = optionGroup;
-    }
-    async get(optionName, optionBrand) {
-        const usageText = [];
-        switch (optionName) {
+class ConfigDiagnosticText {
+    static expected(element) {
+        return `Expected ${element}.`;
+    }
+    static expectsListItemType(optionName, optionBrand) {
+        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
+    }
+    static expectsValue(optionName) {
+        return `Option '${optionName}' expects a value.`;
+    }
+    static fileDoesNotExist(filePath) {
+        return `The specified path '${filePath}' does not exist.`;
+    }
+    static moduleWasNotFound(specifier) {
+        return `The specified module '${specifier}' was not found.`;
+    }
+    static seen(element) {
+        return `The ${element} was seen here.`;
+    }
+    static testFileMatchCannotStartWith(segment) {
+        return [
+            `A test file match pattern cannot start with '${segment}'.`,
+            "The test files are only collected within the 'rootPath' directory.",
+        ];
+    }
+    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) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
             case "target": {
-                switch (this.#optionGroup) {
-                    case 2:
-                        usageText.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:
-                        usageText.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) {
-                    usageText.push(`Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`);
+                    text.push(`Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`);
                 }
-                break;
+                return text;
             }
-            default:
-                usageText.push(ConfigDiagnosticText.requiresValueType(optionName, optionBrand, this.#optionGroup));
         }
-        return usageText;
-    }
-}
-
-class OptionValidator {
-    #onDiagnostics;
-    #optionGroup;
-    #optionUsageText;
-    constructor(optionGroup, onDiagnostics) {
-        this.#optionGroup = optionGroup;
-        this.#onDiagnostics = onDiagnostics;
-        this.#optionUsageText = new OptionUsageText(this.#optionGroup);
+        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
     }
-    async check(optionName, optionValue, optionBrand, origin) {
-        switch (optionName) {
-            case "tsconfig":
-                if (["findup", "ignore"].includes(optionValue)) {
-                    break;
-                }
-            case "config":
-            case "rootPath":
-                if (!existsSync(optionValue)) {
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
-                }
-                break;
-            case "reporters":
-                if (["list", "summary"].includes(optionValue)) {
-                    break;
-                }
-            case "plugins":
-                try {
-                    await import(optionValue);
-                }
-                catch {
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.moduleWasNotFound(optionValue), origin));
-                }
-                break;
-            case "target":
-                if ((await Store.validateTag(optionValue)) === false) {
-                    this.#onDiagnostics(Diagnostic.error([
-                        ConfigDiagnosticText.versionIsNotSupported(optionValue),
-                        ...(await this.#optionUsageText.get(optionName, optionBrand)),
-                    ], origin));
-                }
-                break;
-            case "testFileMatch":
-                for (const segment of ["/", "../"]) {
-                    if (optionValue.startsWith(segment)) {
-                        this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
-                    }
-                }
-                break;
-            case "watch":
-                if (environmentOptions.isCi) {
-                    this.#onDiagnostics(Diagnostic.error(ConfigDiagnosticText.watchCannotBeEnabled(), origin));
-                }
-                break;
+    static versionIsNotSupported(value) {
+        if (value === "current") {
+            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
         }
+        return `TypeScript version '${value}' is not supported.`;
+    }
+    static watchCannotBeEnabled() {
+        return "Watch mode cannot be enabled in continuous integration environment.";
     }
 }
 
@@ -1039,29 +961,98 @@ class Options {
         }
         return definitionMap;
     }
+    static resolve(optionName, optionValue, rootPath = ".") {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "config":
+            case "rootPath":
+            case "tsconfig":
+                if (optionName.endsWith("tsconfig") && ["findup", "ignore"].includes(optionValue)) {
+                    break;
+                }
+                optionValue = Path.resolve(rootPath, optionValue);
+                break;
+            case "plugins":
+            case "reporters":
+                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(optionName, optionValue, optionBrand, onDiagnostics, origin) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "config":
+            case "rootPath":
+            case "tsconfig":
+                if (optionName.endsWith("tsconfig") && ["findup", "ignore"].includes(optionValue)) {
+                    break;
+                }
+                if (existsSync(optionValue)) {
+                    break;
+                }
+                onDiagnostics(Diagnostic.error(ConfigDiagnosticText.fileDoesNotExist(optionValue), origin));
+                break;
+            case "plugins":
+            case "reporters":
+                if (optionName.endsWith("reporters") && ["list", "summary"].includes(optionValue)) {
+                    break;
+                }
+                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(optionName, optionBrand),
+                    ].flat(), origin));
+                }
+                break;
+            case "testFileMatch":
+                for (const segment of ["/", "../"]) {
+                    if (optionValue.startsWith(segment)) {
+                        onDiagnostics(Diagnostic.error(ConfigDiagnosticText.testFileMatchCannotStartWith(segment), origin));
+                    }
+                }
+                break;
+            case "watch":
+                if (environmentOptions.isCi) {
+                    onDiagnostics(Diagnostic.error(ConfigDiagnosticText.watchCannotBeEnabled(), origin));
+                }
+                break;
+        }
+    }
 }
 
 class CommandLineParser {
     #commandLineOptions;
     #onDiagnostics;
     #options;
-    #optionGroup = 2;
-    #optionUsageText;
-    #optionValidator;
     #pathMatch;
     constructor(commandLine, pathMatch, onDiagnostics) {
         this.#commandLineOptions = commandLine;
         this.#pathMatch = pathMatch;
         this.#onDiagnostics = onDiagnostics;
-        this.#options = Options.for(this.#optionGroup);
-        this.#optionUsageText = new OptionUsageText(this.#optionGroup);
-        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#onDiagnostics);
+        this.#options = Options.for(2);
     }
-    async #onExpectsValue(optionDefinition) {
+    async #onExpectsValue(optionName, optionBrand) {
         const text = [
-            ConfigDiagnosticText.expectsValue(optionDefinition.name, this.#optionGroup),
-            ...(await this.#optionUsageText.get(optionDefinition.name, optionDefinition.brand)),
-        ];
+            ConfigDiagnosticText.expectsValue(optionName),
+            await ConfigDiagnosticText.usage(optionName, optionBrand),
+        ].flat();
         this.#onDiagnostics(Diagnostic.error(text));
     }
     async parse(commandLineArgs) {
@@ -1070,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)));
@@ -1088,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 this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = true;
                 break;
             case "boolean":
-                await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                await Options.validate(optionName, optionValue, optionDefinition.brand, this.#onDiagnostics);
                 this.#commandLineOptions[optionDefinition.name] = optionValue !== "false";
                 if (optionValue === "false" || optionValue === "true") {
                     index++;
@@ -1104,39 +1094,29 @@ class CommandLineParser {
                 break;
             case "list":
                 if (optionValue !== "") {
-                    let optionValues = optionValue
+                    const optionValues = optionValue
                         .split(",")
                         .map((value) => value.trim())
-                        .filter((value) => value !== "");
-                    if (optionDefinition.name === "plugins" || optionDefinition.name === "reporters") {
-                        optionValues = optionValues.map((optionValue) => {
-                            if (optionValue.startsWith(".")) {
-                                return pathToFileURL(optionValue).toString();
-                            }
-                            return optionValue;
-                        });
-                    }
+                        .filter((value) => value !== "")
+                        .map((value) => Options.resolve(optionName, value));
                     for (const optionValue of optionValues) {
-                        await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                        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 !== "") {
-                    if (optionDefinition.name === "config" ||
-                        (optionDefinition.name === "tsconfig" && !["findup", "ignore"].includes(optionValue))) {
-                        optionValue = Path.resolve(optionValue);
-                    }
-                    await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand);
+                    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;
@@ -1279,21 +1259,18 @@ class ConfigFileParser {
     #jsonScanner;
     #onDiagnostics;
     #options;
-    #optionGroup = 4;
-    #optionValidator;
     #sourceFile;
     constructor(configFileOptions, sourceFile, onDiagnostics) {
         this.#configFileOptions = configFileOptions;
         this.#sourceFile = sourceFile;
         this.#onDiagnostics = onDiagnostics;
-        this.#options = Options.for(this.#optionGroup);
+        this.#options = Options.for(4);
         this.#jsonScanner = new JsonScanner(this.#sourceFile);
-        this.#optionValidator = new OptionValidator(this.#optionGroup, this.#onDiagnostics);
     }
     #onRequiresValue(optionDefinition, jsonNode, isListItem) {
         const text = isListItem
             ? ConfigDiagnosticText.expectsListItemType(optionDefinition.name, optionDefinition.brand)
-            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand, this.#optionGroup);
+            : ConfigDiagnosticText.requiresValueType(optionDefinition.name, optionDefinition.brand);
         this.#onDiagnostics(Diagnostic.error(text, jsonNode.origin));
     }
     async #parseValue(optionDefinition, isListItem = false) {
@@ -1316,17 +1293,9 @@ class ConfigFileParser {
                     this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
                     break;
                 }
-                if (optionDefinition.name === "plugins" || optionDefinition.name === "reporters") {
-                    if (optionValue.startsWith(".")) {
-                        const configFilePath = Path.relative(".", Path.dirname(this.#sourceFile.fileName));
-                        optionValue = pathToFileURL(Path.join(configFilePath, optionValue)).toString();
-                    }
-                }
-                if (optionDefinition.name === "rootPath" ||
-                    (optionDefinition.name === "tsconfig" && !["findup", "ignore"].includes(optionValue))) {
-                    optionValue = Path.resolve(Path.dirname(this.#sourceFile.fileName), optionValue);
-                }
-                await this.#optionValidator.check(optionDefinition.name, optionValue, optionDefinition.brand, jsonNode.origin);
+                const rootPath = Path.dirname(this.#sourceFile.fileName);
+                optionValue = Options.resolve(optionDefinition.name, optionValue, rootPath);
+                await Options.validate(optionDefinition.name, optionValue, optionDefinition.brand, this.#onDiagnostics, jsonNode.origin);
                 break;
             }
             case "list": {
@@ -1430,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 = {};
@@ -1492,6 +1461,7 @@ var OptionGroup;
 (function (OptionGroup) {
     OptionGroup[OptionGroup["CommandLine"] = 2] = "CommandLine";
     OptionGroup[OptionGroup["ConfigFile"] = 4] = "ConfigFile";
+    OptionGroup[OptionGroup["ResolvedConfig"] = 6] = "ResolvedConfig";
 })(OptionGroup || (OptionGroup = {}));
 
 class CancellationHandler {
@@ -1837,25 +1807,6 @@ class ResultHandler {
     }
 }
 
-class HooksService {
-    static #handlers = new Set();
-    static addHandler(hooks) {
-        HooksService.#handlers.add(hooks);
-    }
-    static async call(hook, options) {
-        for (const handler of HooksService.#handlers) {
-            const result = await handler[hook]?.(options);
-            if (result != null) {
-                options = result;
-            }
-        }
-        return options;
-    }
-    static removeHandlers() {
-        HooksService.#handlers.clear();
-    }
-}
-
 function jsx(type, props) {
     return { props, type };
 }
@@ -2237,6 +2188,25 @@ function watchUsageText() {
     return jsx(Text, { children: usageText });
 }
 
+class PluginService {
+    static #handlers = new Map();
+    static addHandler(plugin) {
+        PluginService.#handlers.set(plugin.name, plugin);
+    }
+    static async call(hook, argument, context) {
+        let result = argument;
+        for (const [, plugin] of PluginService.#handlers) {
+            if (hook in plugin) {
+                result = await plugin[hook].call(context, result);
+            }
+        }
+        return result;
+    }
+    static removeHandlers() {
+        PluginService.#handlers.clear();
+    }
+}
+
 class BaseReporter {
     resolvedConfig;
     constructor(resolvedConfig) {
@@ -3781,7 +3751,7 @@ class ToRaiseError {
         if (this.#compiler.isStringLiteralLike(targetNode)) {
             return this.#compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(targetNode.text);
         }
-        return Number.parseInt(targetNode.text) === diagnostic.code;
+        return Number.parseInt(targetNode.text, 10) === diagnostic.code;
     }
 }
 
@@ -4126,7 +4096,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "3.0.0-beta.5";
+    static version = "3.0.0-rc.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4250,11 +4220,11 @@ class Cli {
                 }
                 continue;
             }
-            for (const plugin of resolvedConfig.plugins) {
-                const hooks = (await import(plugin)).default;
-                HooksService.addHandler(hooks);
+            for (const pluginSpecifier of resolvedConfig.plugins) {
+                const plugin = (await import(pluginSpecifier)).default;
+                PluginService.addHandler(plugin);
             }
-            resolvedConfig = await HooksService.call("config", resolvedConfig);
+            resolvedConfig = await PluginService.call("config", resolvedConfig, {});
             if (commandLine.includes("--showConfig")) {
                 OutputService.writeMessage(formattedText({ ...resolvedConfig, ...environmentOptions }));
                 continue;
@@ -4275,7 +4245,7 @@ class Cli {
                     continue;
                 }
             }
-            testFiles = await HooksService.call("select", testFiles);
+            testFiles = await PluginService.call("select", testFiles, { resolvedConfig });
             if (commandLine.includes("--listFiles")) {
                 OutputService.writeMessage(formattedText(testFiles.map((testFile) => testFile.toString())));
                 continue;
@@ -4284,7 +4254,7 @@ class Cli {
             this.#eventEmitter.removeReporter(setupReporter);
             const runner = new Runner(resolvedConfig);
             await runner.run(testFiles, cancellationToken);
-            HooksService.removeHandlers();
+            PluginService.removeHandlers();
         } while (cancellationToken.reason === "configChange");
         this.#eventEmitter.removeHandlers();
     }
@@ -4316,4 +4286,4 @@ class Cli {
     }
 }
 
-export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, HooksService, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { Assertion, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "3.0.0-beta.5",
+  "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.16.14",
-    "@types/react": "18.3.11",
+    "@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.0",
+    "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"
   }
 }