@cplieger/deadset-ts 5.1.0 → 5.2.0

package/README.md

@@ -90,7 +90,7 @@ A TypeScript caller that imports the source sets `allowImportingTsExtensions`, b
 
 ## Related projects
 
-deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus except one reflective-lookup fixture, the gap [`conformance.json`](conformance.json) declares.
+deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus.
 
 - [deadset-go](https://github.com/cplieger/deadset-go) is the same analysis for Go modules.
 - [deadset](https://github.com/cplieger/deadset) runs both analyzers as one command and merges their reports, resolving the edges between Go and TypeScript code.

package/dist/src/analysis.js

@@ -11,16 +11,17 @@ import { lineOf, readComponent } from "./component-files.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
-import { dependenciesOf, projectNeeds } from "./dependencies.js";
+import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
 import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { generatedFile } from "./generated-file.js";
+import { generatedFile, generatedFilesOf } from "./generated-file.js";
 import { sourceFilesOf } from "./source-files.js";
-import { detectExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
-import { heldByInclusion, sourceTree } from "./file-facts.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
+import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
@@ -29,9 +30,9 @@ import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
-import { readManifest } from "./manifest.js";
+import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { SetupError, setupLine } from "./setup-failure.js";
 import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
@@ -39,6 +40,7 @@ import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
+import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -107,7 +109,10 @@ function readProjects(engine, host, scope, config, stage) {
     const options = {
         host,
         manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-        workspaceEntries: workspace?.entries,
+        otherPackages: [
+            ...(workspace?.entries ?? []),
+            ...packageEntries(host, normalizePath(absoluteRoot), discovered.configFiles, new Set(workspace?.memberDirs ?? [])),
+        ],
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
         conventions,
@@ -127,6 +132,8 @@ function readProjects(engine, host, scope, config, stage) {
     const unbuildable = [];
     const setupDropped = [];
     const consumed = new Map();
+    const heldFiles = new Set();
+    let outsideTests = [];
     const setupMet = (configFile, met) => {
         const [first] = met;
         if (first !== undefined && isGuess(discovered, configFile)) {
@@ -217,6 +224,7 @@ function readProjects(engine, host, scope, config, stage) {
                         ...kept.map((id) => ({ id, kind: "type-error", source: "" })),
                     ],
                 };
+            const own = sourceFilesOf(project, targetRoot);
             return {
                 configuration,
                 configFile: project.configFile,
@@ -228,11 +236,17 @@ function readProjects(engine, host, scope, config, stage) {
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-                generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
+                generated: generatedFilesOf(own, generatedFiles(conventions, own)),
             };
         };
+        for (const file of project.ownSourceFiles()) {
+            heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
+        }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", workspace?.programs);
+    }, discovered.derived ? "record" : "refuse", workspace?.programs, () => {
+        const patterns = config.ts.testFiles.map(globExpression);
+        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && patterns.some((pattern) => pattern.test(path))), options.parse);
+    });
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
             throw new DiscoveryError(`${configFile} opened no project`, []);
@@ -263,6 +277,8 @@ function readProjects(engine, host, scope, config, stage) {
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
         conventionsApplied: conventions.applied,
+        conventionUses: conventions.uses,
+        outsideTests,
     };
 }
 /**
@@ -351,8 +367,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
-        const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
-        const detected = detectExemptions({
+        const evidence = evidenceRecords({
             project,
             held: projectRead.held,
             targetRoot,
@@ -362,52 +377,78 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             ...(config.analysis.generatedFiles === "include"
                 ? {}
                 : { generated: projectRead.generated }),
-        }, detectors, {
+        }, detectors, disabled);
+        const components = project.ownSourceFiles().filter(isComponentFile);
+        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
+        return {
+            projectRead,
+            references: resolved.references,
+            testFiles: resolved.testFilePaths,
+            evidence,
+            componentFiles: components.map(pathOf),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+                path: pathOf(file),
+                line: lineOf(file.originalText, warning.offset),
+                reason: warning.reason,
+            }))),
+            extra: extra(project, projectRead, resolved.references),
+        };
+    });
+    const outsidePaths = read.outsideTests.map((one) => one.path);
+    const withOutside = read.answers.map((one) => ({
+        ...one,
+        references: [
+            ...one.references,
+            ...outsideTestReferences(read.outsideTests, one.projectRead.held, targetRoot),
+        ],
+        testFiles: [...one.testFiles, ...outsidePaths],
+    }));
+    // Test-support code is code only test code imports in any configuration of the run: a
+    // configuration that holds no test file says nothing about what the tests import.
+    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
+    const answers = withOutside.map((one) => {
+        const { projectRead } = one;
+        const detected = heldRecords(one.evidence, {
             disabled,
             mode,
-            testFiles: new Set([...resolved.testFilePaths, ...support]),
+            testFiles: new Set([...one.testFiles, ...support]),
         });
         const exempt = detected.records;
-        const made = supportReferences(resolved.references, support);
+        const made = supportReferences(one.references, support);
+        const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
+        const supportFiles = [...support].filter((path) => held.has(path)).sort();
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
-            testFiles: resolved.testFilePaths,
-            ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+            testFiles: one.testFiles,
+            ...(supportFiles.length === 0 ? {} : { supportFiles }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
         };
-        const unanswered = [
-            ...projectRead.held.unanswered,
-            ...projectRead.rooted.unanswered,
-            ...made
-                .filter((reference) => reference.resolution === "by-name")
-                .map((reference) => reference.to),
-            ...exempt.filter(isUnansweredRecord).map((record) => record.id),
-        ];
-        const components = project.ownSourceFiles().filter(isComponentFile);
-        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
-            unanswered,
+            unanswered: [
+                ...projectRead.held.unanswered,
+                ...projectRead.rooted.unanswered,
+                ...made
+                    .filter((reference) => reference.resolution === "by-name")
+                    .map((reference) => reference.to),
+                ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+            ],
             typeErrorSkips: projectRead.typeErrorSkips,
             skipped: projectRead.skipped,
-            componentFiles: components.map(pathOf),
-            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
-                path: pathOf(file),
-                line: lineOf(file.originalText, warning.offset),
-                reason: warning.reason,
-            }))),
-            extra: extra(project, projectRead, made),
+            componentFiles: one.componentFiles,
+            componentWarnings: one.componentWarnings,
+            extra: one.extra,
         };
     });
     const consumed = read.consumers.references;
-    const projects = read.answers.map((one) => consumed.length === 0
+    const projects = answers.map((one) => consumed.length === 0
         ? one
         : {
             ...one,
@@ -421,7 +462,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         exempt: exemptionsOf(projects.flatMap((one) => one.exempt)),
         unansweredHeld: [
             ...new Set([
-                ...read.answers.flatMap((one) => one.unanswered),
+                ...answers.flatMap((one) => one.unanswered),
                 ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
             ]),
         ],
@@ -431,6 +472,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         unanswered: read.unanswered,
         componentsUnread: read.componentsUnread,
         conventionsApplied: read.conventionsApplied,
+        conventionUses: read.conventionUses,
     };
 }
 /**
@@ -607,7 +649,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             accessors: one.extra.accessors,
         })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, projects.map((one) => one.extra.needs), swept.sweep.candidates.map((candidate) => candidate.id)),
+        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id)),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),

package/dist/src/config.js

@@ -49,9 +49,12 @@ export function defaultConfig() {
         ts: {
             testFiles: [
                 "**/*.test.{ts,tsx,mts,cts}",
+                "**/*.test-d.{ts,tsx,mts,cts}",
+                "**/*.spec-d.{ts,tsx,mts,cts}",
                 "**/*.spec.*",
                 "**/__tests__/**",
                 "**/__mocks__/**",
+                "**/test-d/**",
             ],
             entryFiles: [],
             componentExtensions: [".vue", ".svelte", ".astro"],

package/dist/src/configuration-files.js

@@ -39,7 +39,7 @@ const COUNTERPARTS = [
 /** The extensions appended to a relative specifier from a configuration file, in order. */
 const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
-const RESOLVED_EXTENSIONS = [
+export const RESOLVED_EXTENSIONS = [
     ".ts",
     ".tsx",
     ".d.ts",
@@ -164,33 +164,31 @@ function relativeSpecifiers(file) {
     });
 }
 /**
- * The module one relative specifier from a configuration file reaches: the path it names,
- * that path with its JavaScript extension replaced by the TypeScript counterparts, that
- * path with an extension appended, and a directory's `index` with one appended.
+ * The paths one relative specifier from a configuration file may reach, in the order they
+ * are tried: the path it names where that ends with a module extension, that path with its
+ * JavaScript extension replaced by the TypeScript counterparts, that path with an
+ * extension appended, and a directory's `index` with one appended. A data file such as
+ * `./package.json` is no module, so it is no candidate.
  */
-function reachedBy(host, dir, specifier) {
+export function specifierCandidates(dir, specifier) {
     const path = resolvePath(dir, specifier);
-    const isFile = (candidate) => host.kindOf(candidate) === "file";
-    // A data file such as `./package.json` is no module, so its strings use no dependency.
-    if (isFile(path) && APPENDED.some((extension) => path.endsWith(extension))) {
-        return path;
+    const candidates = [];
+    if (APPENDED.some((extension) => path.endsWith(extension))) {
+        candidates.push(path);
     }
     for (const [extension, counterparts] of COUNTERPARTS) {
         if (path.endsWith(extension)) {
             const stem = path.slice(0, -extension.length);
-            const found = counterparts.map((one) => stem + one).find(isFile);
-            if (found !== undefined) {
-                return found;
-            }
+            candidates.push(...counterparts.map((one) => stem + one));
         }
     }
-    const appended = APPENDED.map((extension) => path + extension).find(isFile);
-    if (appended !== undefined) {
-        return appended;
-    }
-    return host.kindOf(path) === "directory"
-        ? APPENDED.map((extension) => joinPath(path, `index${extension}`)).find(isFile)
-        : undefined;
+    candidates.push(...APPENDED.map((extension) => path + extension));
+    candidates.push(...APPENDED.map((extension) => joinPath(path, `index${extension}`)));
+    return candidates;
+}
+/** The file on disk one relative specifier from a configuration file reaches, or undefined. */
+export function resolveRelativeSpecifier(host, dir, specifier) {
+    return specifierCandidates(dir, specifier).find((path) => host.kindOf(path) === "file");
 }
 /**
  * The configuration modules of the directories that hold a manifest which the program
@@ -233,7 +231,7 @@ function outsideModules(host, dirs, files, holdsManifest, parse) {
         const file = parse(next.path, text);
         found.push({ file, manifestDir: next.manifestDir });
         for (const specifier of relativeSpecifiers(file)) {
-            const reached = reachedBy(host, dirnamePath(next.path), specifier);
+            const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
             if (reached !== undefined) {
                 pending.push({ path: reached, manifestDir: next.manifestDir });
             }
@@ -267,12 +265,13 @@ export function dependenciesNamed(text, declared) {
     return declared.filter((name) => text === name || text.startsWith(`${name}/`));
 }
 /**
- * The own files one string names read against a directory: none unless it starts with
- * `./` or `../`, else the file it names directly or through the emit mapping, or the
- * file it names with an extension the module resolution appends.
+ * The own files one string names read against a directory: the file it names directly or
+ * through the emit mapping, or the file it names with an extension the module resolution
+ * appends. An empty string, one starting with `/` and one holding a glob character names
+ * none.
  */
 export function filesNamedBy(files, dir, text) {
-    if (!RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix)) || text.includes("*")) {
+    if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
         return [];
     }
     const path = resolvePath(dir, text);

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "2.2.0",
+        corpusVersion: "3.0.0",
         result: "pass",
-        digest: "sha256:ce7c9087ed7b2baf3de9fa2df436b500706f4f9e94fd9e0fed633054305f06a4",
+        digest: "sha256:db52e3164347cab70f45f438b4ac9ce89573be9303503daeb237a3c40361b001",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -32,8 +32,6 @@ function propertyName(property) {
     }
     return undefined;
 }
-/** How many element and signature steps the structural walk takes below a value's own type. */
-const MAX_DEPTH = 3;
 /**
  * The contextual uses of one project's literals and values, asked in batches: one
  * contextual type per literal and per value whose type carries a member of the target,
@@ -41,6 +39,7 @@ const MAX_DEPTH = 3;
  */
 export function contextualUses(project, held, chains, literals, flows, cap, properties) {
     const queries = project.queries;
+    const ownPaths = project.ownPaths();
     const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
     let batches = 0;
     let lookups = 0;
@@ -80,6 +79,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     .declarationsOf(property)
                     .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
                 handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
+                own: property.declarations.some((handle) => ownPaths.has(handle.path)),
             });
         }
         tables.set(type.id, table);
@@ -111,6 +111,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     /** The members a position may read structurally: those of object types, not of classes. */
     const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
     const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
+    /** Whether an object type has members and declares none of them in the target. */
+    const outside = (part) => {
+        const members = [...membersOf(part).values()];
+        return members.length > 0 && members.every((member) => !member.own);
+    };
     const elements = new Map();
     /** The element type of an array type, read once per type. */
     const elementOf = (type) => {
@@ -154,14 +159,15 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
      * Each object type a value of `source` is checked as against the object types of
      * `target`: the value's own, and through array elements and through a function's
      * parameters, checked the other way, and its result. A source that is one of the
-     * target's own object types matches it as it stands.
+     * target's own object types matches it as it stands. Each pair is compared once, which
+     * ends the walk over a recursive type.
      */
-    const compared = (source, target, depth, into, seen) => {
+    const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
         if (source === undefined || target === undefined || source.id === target.id) {
             return;
         }
-        if (depth > MAX_DEPTH || seen.has(key)) {
+        if (seen.has(key)) {
             return;
         }
         seen.add(key);
@@ -169,13 +175,16 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
         for (const one of sources) {
             if (carries(one)) {
-                into.push({ source: one, targets });
+                into.push({ source: one, targets, outside: false });
+            }
+            else if (outside(one)) {
+                into.push({ source: one, targets, outside: true });
             }
             const element = elementOf(one);
             const called = element === undefined ? callOf(one) : undefined;
             for (const part of targets) {
                 if (element !== undefined) {
-                    compared(element, elementOf(part), depth + 1, into, seen);
+                    compared(element, elementOf(part), into, seen);
                     continue;
                 }
                 const other = called === undefined ? undefined : callOf(part);
@@ -183,27 +192,35 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     continue;
                 }
                 other.parameters.forEach((parameter, index) => {
-                    compared(parameter, called.parameters[index], depth + 1, into, seen);
+                    compared(parameter, called.parameters[index], into, seen);
                 });
-                compared(called.result, other.result, depth + 1, into, seen);
+                compared(called.result, other.result, into, seen);
             }
         }
     };
-    /** Whether a value of one type may carry a member a position reads, at any depth the walk takes. */
-    const mayCarry = (type, depth) => depth <= MAX_DEPTH &&
-        partsOf(type).some((part) => {
-            if (carries(part)) {
+    /**
+     * Whether a value of one type may carry a member a position reads, at any depth the
+     * walk takes. A type met again on the way adds nothing its first visit did not.
+     */
+    const mayCarry = (type, seen = new Set()) => {
+        if (seen.has(type.id)) {
+            return false;
+        }
+        seen.add(type.id);
+        return partsOf(type).some((part) => {
+            if (carries(part) || outside(part)) {
                 return true;
             }
             const element = elementOf(part);
             if (element !== undefined) {
-                return mayCarry(element, depth + 1);
+                return mayCarry(element, seen);
             }
             return callOf(part) !== undefined;
         });
+    };
     const sourced = carried.flatMap((flow, index) => {
         const type = types[index];
-        return type === undefined || !isAnswered(type) || !mayCarry(type, 0) ? [] : [{ flow, type }];
+        return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
     });
     batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
@@ -214,11 +231,22 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             return;
         }
         const checked = [];
-        compared(type, position, 0, checked, new Set());
+        compared(type, position, checked, new Set());
         const ids = new Set();
-        for (const { source, targets } of checked) {
+        for (const { source, targets, outside: held } of checked) {
             const tables = targets.map(membersOf);
-            for (const [name, member] of membersOf(source)) {
+            const sourceMembers = membersOf(source);
+            if (held) {
+                for (const table of tables) {
+                    for (const [name, member] of table) {
+                        if (sourceMembers.has(name)) {
+                            member.ids.forEach((id) => ids.add(id));
+                        }
+                    }
+                }
+                continue;
+            }
+            for (const [name, member] of sourceMembers) {
                 const read = tables.some((table) => {
                     const declared = table.get(name);
                     return (declared !== undefined &&

package/dist/src/convention-rows.js

@@ -385,5 +385,12 @@ export const CONVENTION_ROWS = [
             `**/{vitest,vite}.*.config.${ANY_MODULE}`,
         ],
         moves: [],
+        shortNames: [
+            {
+                property: "test.coverage.provider",
+                files: [`{vitest,vite}.config.${ANY_MODULE}`],
+                package: "@vitest/coverage-{}",
+            },
+        ],
     },
 ];