tstyche 6.0.2 → 6.1.0

package/dist/tag.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Runs TSTyche in the same process, streaming error messages and test results to the `stderr` and `stdout` in real-time.
+ *
+ * @returns A promise that resolves if the test run is successful and rejects if it fails.
+ */
+declare function tstyche(template: TemplateStringsArray, ...substitutions: Array<string>): Promise<void>;
+
+export { tstyche as default };

package/dist/tag.js

@@ -0,0 +1,36 @@
+import { Cli, EventEmitter, CancellationToken } from './tstyche.js';
+
+class StatusHandler {
+    #hasError = false;
+    hasError() {
+        return this.#hasError;
+    }
+    on([event, payload]) {
+        if (event === "run:start") {
+            this.#hasError = false;
+            return;
+        }
+        if ("diagnostics" in payload) {
+            if (payload.diagnostics.some((diagnostic) => diagnostic.category === "error")) {
+                this.#hasError = true;
+            }
+        }
+    }
+}
+async function tstyche(template, ...substitutions) {
+    const cli = new Cli({ noErrorExitCode: true });
+    const commandLine = String.raw(template, ...substitutions).split(/\s+/);
+    const eventEmitter = new EventEmitter();
+    const statusHandler = new StatusHandler();
+    eventEmitter.addHandler(statusHandler);
+    await cli.run(commandLine, new CancellationToken());
+    eventEmitter.removeHandler(statusHandler);
+    return new Promise((resolve, reject) => {
+        if (statusHandler.hasError()) {
+            reject(new Error("TSTyche test run failed. Check the output above for details."));
+        }
+        resolve();
+    });
+}
+
+export { tstyche as default };

package/dist/tstyche.d.ts

@@ -1,4 +1,5 @@
 import type ts from 'typescript';
+import type { WriteStream } from 'node:tty';
 
 declare enum CancellationReason {
     ConfigChange = "configChange",
@@ -15,9 +16,13 @@ declare class CancellationToken {
     reset(): void;
 }
 
+interface CliOptions {
+    noErrorExitCode?: boolean;
+}
 declare class Cli {
     #private;
-    run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
+    constructor(options?: CliOptions);
+    run(commandLine: ReadonlyArray<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
 declare enum DiagnosticCategory {
@@ -143,7 +148,9 @@ interface CommandLineOptions {
     listFiles?: boolean;
     only?: string;
     prune?: boolean;
+    quiet?: boolean;
     reporters?: Array<string>;
+    root?: string;
     showConfig?: boolean;
     skip?: string;
     target?: Array<string>;
@@ -157,6 +164,7 @@ interface ConfigFileOptions {
     checkSuppressedErrors?: boolean;
     failFast?: boolean;
     fixtureFileMatch?: Array<string>;
+    quiet?: boolean;
     rejectAnyType?: boolean;
     rejectNeverType?: boolean;
     reporters?: Array<string>;
@@ -191,11 +199,11 @@ interface DirectiveRange {
 
 declare class Config {
     #private;
-    static parseCommandLine(commandLine: Array<string>): Promise<{
+    static parseCommandLine(commandLine: ReadonlyArray<string>): Promise<{
         commandLineOptions: CommandLineOptions;
         pathMatch: Array<string>;
     }>;
-    static parseConfigFile(filePath?: string): Promise<{
+    static parseConfigFile(configPath?: string, rootPath?: string): Promise<{
         configFileOptions: ConfigFileOptions;
         configFilePath: string;
     }>;
@@ -205,7 +213,7 @@ declare class Config {
         commandLineOptions?: Omit<CommandLineOptions, "config">;
         pathMatch?: Array<string>;
     }): ResolvedConfig;
-    static resolveConfigFilePath(filePath?: string): string;
+    static resolveConfigFilePath(configPath?: string, rootPath?: string): string;
 }
 
 declare enum OptionBrand {
@@ -604,8 +612,18 @@ declare function formattedText(input: string | Array<string> | Record<string, un
 
 declare function helpText(options: Map<string, OptionDefinition>, version: string): ScribblerJsx.Element;
 
+declare class StreamController {
+    #private;
+    constructor(stream: WriteStream);
+    disable(): void;
+    enable(): void;
+    write(text: string): void;
+}
+
 declare class OutputService {
     #private;
+    static errorStream: StreamController;
+    static outputStream: StreamController;
     static clearTerminal(): void;
     static eraseLastLine(): void;
     static writeError(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
@@ -714,5 +732,5 @@ declare class Version {
     static isSatisfiedWith(source: string, target: string): boolean;
 }
 
-export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectResult, Result, ResultStatus, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, Store, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectResult, Result, ResultStatus, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, Store, StreamController, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
 export type { AssertionCounts, AssertionResultStatus, CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, EnvironmentOptions, Event, EventHandler, FileCounts, FileResultStatus, InlineConfig, ItemDefinition, OptionDefinition, Reporter, ReporterEvent, ResolvedConfig, ResultCounts, ResultTiming, ScribblerOptions, SuppressedCounts, SuppressedResultStatus, TargetCounts, TargetResultStatus, TestCounts, TestResultStatus, TextRange };

package/dist/tstyche.js

@@ -1099,6 +1099,12 @@ class Options {
             group: 2,
             name: "prune",
         },
+        {
+            brand: "boolean",
+            description: "Silence all test runner output except errors and warnings.",
+            group: 2 | 4,
+            name: "quiet",
+        },
         {
             brand: "boolean",
             description: "Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.",
@@ -1121,6 +1127,12 @@ class Options {
             },
             name: "reporters",
         },
+        {
+            brand: "string",
+            description: "The path to a directory containing files of a test project.",
+            group: 2,
+            name: "root",
+        },
         {
             brand: "string",
             description: "The path to a directory containing files of a test project.",
@@ -1202,11 +1214,15 @@ class Options {
         const canonicalOptionName = Options.#getCanonicalOptionName(optionName);
         switch (canonicalOptionName) {
             case "config":
+            case "root":
             case "rootPath":
             case "tsconfig":
                 if (canonicalOptionName === "tsconfig" && Options.#isLookupStrategy(optionValue)) {
                     break;
                 }
+                if (optionValue.startsWith("file:")) {
+                    optionValue = fileURLToPath(optionValue);
+                }
                 optionValue = Path.resolve(rootPath, optionValue);
                 break;
             case "reporters":
@@ -1231,6 +1247,7 @@ class Options {
         const canonicalOptionName = Options.#getCanonicalOptionName(optionName);
         switch (canonicalOptionName) {
             case "config":
+            case "root":
             case "rootPath":
             case "tsconfig":
                 if (canonicalOptionName === "tsconfig" && Options.#isLookupStrategy(optionValue)) {
@@ -1553,6 +1570,7 @@ const defaultOptions = {
     checkSuppressedErrors: true,
     failFast: false,
     fixtureFileMatch: ["**/__fixtures__/*.{ts,tsx}", "**/fixtures/*.{ts,tsx}"],
+    quiet: false,
     rejectAnyType: true,
     rejectNeverType: true,
     reporters: ["list", "summary"],
@@ -1573,10 +1591,10 @@ class Config {
         await commandLineParser.parse(commandLine);
         return { commandLineOptions, pathMatch };
     }
-    static async parseConfigFile(filePath) {
-        const configFilePath = Config.resolveConfigFilePath(filePath);
+    static async parseConfigFile(configPath, rootPath) {
+        const configFilePath = Config.resolveConfigFilePath(configPath, rootPath);
         const configFileOptions = {
-            rootPath: Path.dirname(configFilePath),
+            rootPath: rootPath ?? Path.dirname(configFilePath),
         };
         if (existsSync(configFilePath)) {
             const configFileText = await fs.readFile(configFilePath, {
@@ -1599,10 +1617,16 @@ class Config {
         if ("config" in resolvedConfig) {
             delete resolvedConfig.config;
         }
+        if ("root" in resolvedConfig) {
+            delete resolvedConfig.root;
+        }
         return resolvedConfig;
     }
-    static resolveConfigFilePath(filePath) {
-        return filePath != null ? Path.resolve(filePath) : Path.resolve("./tstyche.config.json");
+    static resolveConfigFilePath(configPath, rootPath = ".") {
+        if (configPath != null) {
+            return Path.resolve(configPath);
+        }
+        return Path.resolve(rootPath, "./tstyche.config.json");
     }
 }
 
@@ -2415,19 +2439,36 @@ function helpText(options, version) {
     return (jsx(Text, { children: [jsx(HelpHeaderText, { tstycheVersion: version }), jsx(Line, {}), jsx(CommandLineUsageText, {}), jsx(Line, {}), jsx(CommandLineOptionsText, { optionDefinitions: options }), jsx(Line, {}), jsx(HelpFooterText, {}), jsx(Line, {})] }));
 }
 
+class StreamController {
+    #isEnabled = true;
+    #stream;
+    constructor(stream) {
+        this.#stream = stream;
+    }
+    disable() {
+        this.#isEnabled = false;
+    }
+    enable() {
+        this.#isEnabled = true;
+    }
+    write(text) {
+        this.#isEnabled && this.#stream.write(text);
+    }
+}
+
 class OutputService {
+    static errorStream = new StreamController(process.stderr);
+    static outputStream = new StreamController(process.stdout);
     static #isClear = false;
     static #scribbler = new Scribbler();
-    static #stderr = process.stderr;
-    static #stdout = process.stdout;
     static clearTerminal() {
         if (!OutputService.#isClear) {
-            OutputService.#stdout.write("\u001B[2J\u001B[3J\u001B[H");
+            OutputService.outputStream.write("\u001B[2J\u001B[3J\u001B[H");
             OutputService.#isClear = true;
         }
     }
     static eraseLastLine() {
-        OutputService.#stdout.write("\u001B[1A\u001B[0K");
+        OutputService.outputStream.write("\u001B[1A\u001B[0K");
     }
     static #writeTo(stream, element) {
         const elements = Array.isArray(element) ? element : [element];
@@ -2437,13 +2478,13 @@ class OutputService {
         OutputService.#isClear = false;
     }
     static writeError(element) {
-        OutputService.#writeTo(OutputService.#stderr, element);
+        OutputService.#writeTo(OutputService.errorStream, element);
     }
     static writeMessage(element) {
-        OutputService.#writeTo(OutputService.#stdout, element);
+        OutputService.#writeTo(OutputService.outputStream, element);
     }
     static writeWarning(element) {
-        OutputService.#writeTo(OutputService.#stderr, element);
+        OutputService.#writeTo(OutputService.errorStream, element);
     }
 }
 
@@ -4569,9 +4610,6 @@ function getSignatures(type, kind, compiler, typeChecker) {
 function getThisTypeOfSignature(signature, typeChecker) {
     return signature.thisParameter && typeChecker.getTypeOfSymbol(signature.thisParameter);
 }
-function getTypeParametersOfSignature(signature) {
-    return signature.typeParameters ?? [];
-}
 function getTypeParameterModifiers(typeParameter, compiler) {
     if (!typeParameter.symbol.declarations) {
         return compiler.ModifierFlags.None;
@@ -4676,7 +4714,7 @@ class Structure {
     compare(a, b) {
         a = this.#normalize(a);
         b = this.#normalize(b);
-        if (a.id === b.id) {
+        if (a === b) {
             return true;
         }
         if (a.flags & this.#compiler.TypeFlags.Any) {
@@ -4688,17 +4726,24 @@ class Structure {
         if (a.flags & this.#compiler.TypeFlags.Undefined) {
             return !!(b.flags & this.#compiler.TypeFlags.Undefined);
         }
-        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Intersection) {
-            if (a.flags & b.flags & this.#compiler.TypeFlags.Intersection) {
-                if (this.compareIntersections(a, b)) {
-                    return true;
-                }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.StructuredType) {
+            if (a.flags & this.#compiler.TypeFlags.StructuredType && b.flags & this.#compiler.TypeFlags.StructuredType) {
+                return this.#memoize(a, b, () => this.compareStructured(a, b));
             }
-            if (containsInstantiable(a, this.#compiler) || containsInstantiable(b, this.#compiler)) {
-                return false;
+            return false;
+        }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Instantiable) {
+            if (a.flags & this.#compiler.TypeFlags.Instantiable && b.flags & this.#compiler.TypeFlags.Instantiable) {
+                return this.#memoize(a, b, () => this.compareInstantiable(a, b));
             }
-            if ((a.flags & b.flags) | this.#compiler.TypeFlags.StructuredType) {
-                return this.#memoize(a, b, () => this.compareStructuredTypes(a, b));
+            return false;
+        }
+        return false;
+    }
+    compareStructured(a, b) {
+        if (this.#typeChecker.isTupleType(a) || this.#typeChecker.isTupleType(b)) {
+            if (this.#typeChecker.isTupleType(a) && this.#typeChecker.isTupleType(b)) {
+                return this.compareTuples(a, b);
             }
             return false;
         }
@@ -4708,24 +4753,30 @@ class Structure {
             }
             return false;
         }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Intersection) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Intersection) {
+                if (this.compareIntersections(a, b)) {
+                    return true;
+                }
+            }
+            if (containsInstantiable(a, this.#compiler) || containsInstantiable(b, this.#compiler)) {
+                return false;
+            }
+        }
         if ((a.flags | b.flags) & this.#compiler.TypeFlags.Object) {
             if (a.flags & b.flags & this.#compiler.TypeFlags.Object) {
-                return this.#memoize(a, b, () => this.compareObjects(a, b));
+                return this.compareObjects(a, b);
             }
-            return false;
         }
+        return this.compareStructures(a, b);
+    }
+    compareInstantiable(a, b) {
         if ((a.flags | b.flags) & this.#compiler.TypeFlags.TypeParameter) {
             if (a.flags & b.flags & this.#compiler.TypeFlags.TypeParameter) {
                 return this.compareTypeParameters(a, b);
             }
             return false;
         }
-        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Index) {
-            if (a.flags & b.flags & this.#compiler.TypeFlags.Index) {
-                return this.compare(a.type, b.type);
-            }
-            return false;
-        }
         if ((a.flags | b.flags) & this.#compiler.TypeFlags.IndexedAccess) {
             if (a.flags & b.flags & this.#compiler.TypeFlags.IndexedAccess) {
                 return this.compareIndexedAccessTypes(a, b);
@@ -4744,6 +4795,12 @@ class Structure {
             }
             return false;
         }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Index) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Index) {
+                return this.compare(a.type, b.type);
+            }
+            return false;
+        }
         if ((a.flags | b.flags) & this.#compiler.TypeFlags.TemplateLiteral) {
             if (a.flags & b.flags & this.#compiler.TypeFlags.TemplateLiteral) {
                 return this.compareTemplateLiteralTypes(a, b);
@@ -4754,7 +4811,6 @@ class Structure {
             if (a.flags & b.flags & this.#compiler.TypeFlags.StringMapping) {
                 return this.compareStringMappingTypes(a, b);
             }
-            return false;
         }
         return false;
     }
@@ -4780,29 +4836,23 @@ class Structure {
                 return this.compareTypeReferences(a, b);
             }
         }
-        return this.compareStructuredTypes(a, b);
+        return this.compareStructures(a, b);
     }
     compareTypeReferences(a, b) {
-        if ((a.target.objectFlags | b.target.objectFlags) & this.#compiler.ObjectFlags.Tuple) {
-            if (a.target.objectFlags & b.target.objectFlags & this.#compiler.ObjectFlags.Tuple) {
-                return this.compareTuples(a, b);
-            }
-            return false;
-        }
-        if (!this.compare(a.target, b.target)) {
-            return this.compareStructuredTypes(a, b);
-        }
-        const aTypeArguments = this.#typeChecker.getTypeArguments(a);
-        const bTypeArguments = this.#typeChecker.getTypeArguments(b);
-        if (aTypeArguments.length !== bTypeArguments.length) {
-            return false;
-        }
-        for (let i = 0; i < aTypeArguments.length; i++) {
-            if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+        if (this.compare(a.target, b.target)) {
+            const aTypeArguments = this.#typeChecker.getTypeArguments(a);
+            const bTypeArguments = this.#typeChecker.getTypeArguments(b);
+            if (aTypeArguments.length !== bTypeArguments.length) {
                 return false;
             }
+            for (let i = 0; i < aTypeArguments.length; i++) {
+                if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
+        return this.compareStructures(a, b);
     }
     compareTuples(a, b) {
         if (a.target.readonly !== b.target.readonly) {
@@ -4823,7 +4873,7 @@ class Structure {
         }
         return true;
     }
-    compareStructuredTypes(a, b) {
+    compareStructures(a, b) {
         if (!this.compareProperties(a, b)) {
             return false;
         }
@@ -4885,56 +4935,41 @@ class Structure {
             return false;
         }
         for (let i = 0; i < aSignatures.length; i++) {
-            if (!this.#compareSignature(aSignatures[i], bSignatures[i])) {
+            const aThisType = getThisTypeOfSignature(aSignatures[i], this.#typeChecker);
+            const bThisType = getThisTypeOfSignature(bSignatures[i], this.#typeChecker);
+            if (!this.#compareMaybeNullish(aThisType, bThisType)) {
                 return false;
             }
-        }
-        return true;
-    }
-    #compareSignature(a, b) {
-        const aTypeParameters = getTypeParametersOfSignature(a);
-        const bTypeParameters = getTypeParametersOfSignature(b);
-        if (aTypeParameters.length !== bTypeParameters.length) {
-            return false;
-        }
-        for (let i = 0; i < aTypeParameters.length; i++) {
-            if (!this.compareTypeParameters(aTypeParameters[i], bTypeParameters[i])) {
+            const aParametersCount = getParameterCount(aSignatures[i], this.#compiler, this.#typeChecker);
+            const bParametersCount = getParameterCount(bSignatures[i], this.#compiler, this.#typeChecker);
+            if (aParametersCount !== bParametersCount) {
                 return false;
             }
-        }
-        if (!this.#compareMaybeNullish(getThisTypeOfSignature(a, this.#typeChecker), getThisTypeOfSignature(b, this.#typeChecker))) {
-            return false;
-        }
-        if (!this.compareParameters(a, b)) {
-            return false;
-        }
-        if (!this.compare(this.#typeChecker.getReturnTypeOfSignature(a), this.#typeChecker.getReturnTypeOfSignature(b))) {
-            return false;
-        }
-        const aTypePredicate = this.#typeChecker.getTypePredicateOfSignature(a);
-        const bTypePredicate = this.#typeChecker.getTypePredicateOfSignature(b);
-        if (aTypePredicate?.kind !== bTypePredicate?.kind ||
-            !this.#compareMaybeNullish(aTypePredicate?.type, bTypePredicate?.type)) {
-            return false;
-        }
-        return true;
-    }
-    compareParameters(a, b) {
-        const aParametersCount = getParameterCount(a, this.#compiler, this.#typeChecker);
-        const bParametersCount = getParameterCount(b, this.#compiler, this.#typeChecker);
-        if (aParametersCount !== bParametersCount) {
-            return false;
-        }
-        for (let i = 0; i < aParametersCount; i++) {
-            const aParameter = getParameterFacts(a, i, this.#compiler, this.#typeChecker);
-            const bParameter = getParameterFacts(b, i, this.#compiler, this.#typeChecker);
-            if (aParameter.isOptional !== bParameter.isOptional) {
+            for (let j = 0; j < aParametersCount; j++) {
+                const aParameter = getParameterFacts(aSignatures[i], j, this.#compiler, this.#typeChecker);
+                const bParameter = getParameterFacts(bSignatures[i], j, this.#compiler, this.#typeChecker);
+                if (aParameter.isOptional !== bParameter.isOptional) {
+                    return false;
+                }
+                if (aParameter.isRest !== bParameter.isRest) {
+                    return false;
+                }
+                if (!this.compare(aParameter.getType(this.#typeChecker), bParameter.getType(this.#typeChecker))) {
+                    return false;
+                }
+            }
+            const aReturnType = this.#typeChecker.getReturnTypeOfSignature(aSignatures[i]);
+            const bReturnType = this.#typeChecker.getReturnTypeOfSignature(bSignatures[i]);
+            if (!this.compare(aReturnType, bReturnType)) {
                 return false;
             }
-            if (aParameter.isRest !== bParameter.isRest) {
+            const aTypePredicate = this.#typeChecker.getTypePredicateOfSignature(aSignatures[i]);
+            const bTypePredicate = this.#typeChecker.getTypePredicateOfSignature(bSignatures[i]);
+            if (aTypePredicate?.parameterIndex !== bTypePredicate?.parameterIndex) {
                 return false;
             }
-            if (!this.compare(aParameter.getType(this.#typeChecker), bParameter.getType(this.#typeChecker))) {
+            if (aTypePredicate?.kind !== bTypePredicate?.kind ||
+                !this.#compareMaybeNullish(aTypePredicate?.type, bTypePredicate?.type)) {
                 return false;
             }
         }
@@ -5920,7 +5955,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.2";
+    static version = "6.1.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5958,6 +5993,9 @@ class Runner {
         }
     }
     async run(files, cancellationToken = new CancellationToken()) {
+        if (this.#resolvedConfig.quiet) {
+            OutputService.outputStream.disable();
+        }
         if (!this.#resolvedConfig.watch) {
             OutputService.writeMessage(prologueText(Runner.version, this.#resolvedConfig.rootPath));
         }
@@ -5970,6 +6008,9 @@ class Runner {
         }
         this.#eventEmitter.removeReporters();
         this.#eventEmitter.removeHandlers();
+        if (this.#resolvedConfig.quiet) {
+            OutputService.outputStream.enable();
+        }
     }
     async #run(files, cancellationToken) {
         const result = new Result(files);
@@ -6001,11 +6042,15 @@ class Runner {
 
 class Cli {
     #eventEmitter = new EventEmitter();
+    #noErrorExitCode;
+    constructor(options) {
+        this.#noErrorExitCode = options?.noErrorExitCode ?? false;
+    }
     async run(commandLine, cancellationToken = new CancellationToken()) {
         const cancellationHandler = new CancellationHandler(cancellationToken, "configError");
         this.#eventEmitter.addHandler(cancellationHandler);
         const exitCodeHandler = new ExitCodeHandler();
-        this.#eventEmitter.addHandler(exitCodeHandler);
+        !this.#noErrorExitCode && this.#eventEmitter.addHandler(exitCodeHandler);
         const setupReporter = new SetupReporter();
         this.#eventEmitter.addReporter(setupReporter);
         if (commandLine.includes("--help")) {
@@ -6044,7 +6089,7 @@ class Cli {
                 this.#eventEmitter.addHandler(cancellationHandler);
                 this.#eventEmitter.addReporter(setupReporter);
             }
-            const { configFileOptions, configFilePath } = await Config.parseConfigFile(commandLineOptions.config);
+            const { configFileOptions, configFilePath } = await Config.parseConfigFile(commandLineOptions.config, commandLineOptions.root);
             const resolvedConfig = Config.resolve({
                 configFileOptions,
                 configFilePath,
@@ -6116,4 +6161,4 @@ class Cli {
     }
 }
 
-export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectResult, Result, ResultStatus, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, Store, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectResult, Result, ResultStatus, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, Store, StreamController, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileStatusText, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "6.0.2",
+  "version": "6.1.0",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",
@@ -25,6 +25,7 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./tag": "./dist/tag.js",
     "./tstyche": "./dist/tstyche.js",
     "./package.json": "./package.json"
   },