@cplieger/deadset-ts 5.1.0 → 5.2.0

package/src/analysis.ts

@@ -22,7 +22,7 @@ import {
   declarationsNamed,
 } from "./configured-declarations.ts";
 import { decorator } from "./decorator.ts";
-import { dependenciesOf, projectNeeds } from "./dependencies.ts";
+import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
 import {
   discoverProjects,
@@ -43,10 +43,11 @@ import {
 } from "./conventions.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
-import { generatedFile } from "./generated-file.ts";
+import { generatedFile, generatedFilesOf } from "./generated-file.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import {
-  detectExemptions,
+  evidenceRecords,
+  heldRecords,
   disabledClasses,
   exemptionsOf,
   holdingWhile,
@@ -56,7 +57,8 @@ import {
   type Detectors,
 } from "./exempt.ts";
 import type { TSExemptionClass } from "./exempt-classes.ts";
-import { heldByInclusion, sourceTree } from "./file-facts.ts";
+import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.ts";
+import { globExpression } from "./glob.ts";
 import type { Finding } from "./finding.ts";
 import { findingsPass, recordedFindings, rowKey, type PassResult } from "./findings-pass.ts";
 import type { EmitterInput } from "./findings/emitter.ts";
@@ -72,7 +74,7 @@ import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { readManifest } from "./manifest.ts";
+import { packageEntries, readManifest } from "./manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -82,7 +84,7 @@ import {
   type Matrix,
   type SweepResult,
 } from "./matrix.ts";
-import { joinPath, relativePath, resolvePath } from "./paths.ts";
+import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
@@ -99,6 +101,7 @@ import { references, testFileRulesOf, type Reference, type TestFileRule } from "
 import { roots, unmatchedEverywhere, type RootKind, type Roots } from "./roots.ts";
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
+import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
 import { supportReferences, testSupportFiles } from "./test-support.ts";
 import { diagnosticsOf, ownedAs, runSession, type Engine, type ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
@@ -188,7 +191,7 @@ interface ProjectRead {
   readonly typeErrorSkips: readonly TypeErrorSkip[];
   /** The lines each of those skips withholds every finding on. */
   readonly skipped: readonly SkippedUnit[];
-  /** The project's generated files, by path below the target root, each with the row naming it. */
+  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
   readonly generated: ReadonlyMap<string, string>;
 }
 
@@ -219,6 +222,10 @@ interface ReadProjects<Answer> {
   readonly componentsUnread: readonly ComponentsUnread[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The dependencies the applied rows' short names use. */
+  readonly conventionUses: readonly string[];
+  /** The test files below the target root no project the run reads holds, parsed. */
+  readonly outsideTests: readonly OutsideTest[];
 }
 
 /**
@@ -284,7 +291,15 @@ function readProjects<Answer>(
   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,
@@ -304,6 +319,8 @@ function readProjects<Answer>(
   const unbuildable: SetupFailure[] = [];
   const setupDropped: SetupFailure[] = [];
   const consumed = new Map<string, Reference>();
+  const heldFiles = new Set<string>();
+  let outsideTests: readonly OutsideTest[] = [];
   const setupMet = (configFile: string, met: readonly SetupFailure[]): void => {
     const [first] = met;
     if (first !== undefined && isGuess(discovered, configFile)) {
@@ -420,6 +437,7 @@ function readProjects<Answer>(
                   ...kept.map((id) => ({ id, kind: "type-error" as const, source: "" })),
                 ],
               };
+        const own = sourceFilesOf(project, targetRoot);
         return {
           configuration,
           configFile: project.configFile,
@@ -431,13 +449,27 @@ function readProjects<Answer>(
             .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,
+    () => {
+      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)) {
@@ -475,6 +507,8 @@ function readProjects<Answer>(
     unanswered: session.unanswered,
     componentsUnread: workspace?.componentsUnread ?? [],
     conventionsApplied: conventions.applied,
+    conventionUses: conventions.uses,
+    outsideTests,
   };
 }
 
@@ -630,6 +664,17 @@ interface SweptProject<Extra> {
   readonly extra: Extra;
 }
 
+/** What one project's stage reads while its view is open, before the run's test-support code is known. */
+interface ReadProject<Extra> {
+  readonly projectRead: ProjectRead;
+  readonly references: readonly Reference[];
+  readonly testFiles: readonly string[];
+  readonly evidence: readonly Exemption[];
+  readonly componentFiles: readonly string[];
+  readonly componentWarnings: readonly ComponentWarning[];
+  readonly extra: Extra;
+}
+
 /** What a run read of its projects before any sweep: the matrix, its exemptions, and each project's answers. */
 interface ReadRun<Extra> {
   readonly matrix: Matrix;
@@ -647,6 +692,8 @@ interface ReadRun<Extra> {
   readonly componentsUnread: readonly ComponentsUnread[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The dependencies the applied rows' short names use. */
+  readonly conventionUses: readonly string[];
 }
 
 /**
@@ -674,18 +721,12 @@ function readRun<Extra>(
     ? { delimiters: config.analysis.templateDelimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
-  const read = readProjects<SweptProject<Extra>>(engine, host, scope, config, (project, opened) => {
+  const read = readProjects<ReadProject<Extra>>(engine, host, scope, config, (project, opened) => {
     const projectRead = opened.read();
     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,
@@ -698,56 +739,87 @@ function readRun<Extra>(
           : { generated: projectRead.generated }),
       },
       detectors,
-      {
-        disabled,
-        mode,
-        testFiles: new Set([...resolved.testFilePaths, ...support]),
-      },
+      disabled,
     );
+    const components = project.ownSourceFiles().filter(isComponentFile);
+    const pathOf = (file: (typeof components)[number]): string =>
+      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): SweptProject<Extra> => {
+    const { projectRead } = one;
+    const detected = heldRecords(one.evidence, {
+      disabled,
+      mode,
+      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: 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: (typeof components)[number]): string =>
-      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) =>
+  const projects = answers.map((one) =>
     consumed.length === 0
       ? one
       : {
@@ -763,7 +835,7 @@ function readRun<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),
       ]),
     ],
@@ -773,6 +845,7 @@ function readRun<Extra>(
     unanswered: read.unanswered,
     componentsUnread: read.componentsUnread,
     conventionsApplied: read.conventionsApplied,
+    conventionUses: read.conventionUses,
   };
 }
 
@@ -1027,7 +1100,7 @@ function emitterInputOver(
     dependencies: dependenciesOf(
       host,
       targetRoot,
-      projects.map((one) => one.extra.needs),
+      [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
     ),
     implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),

package/src/config.ts

@@ -232,9 +232,12 @@ export function defaultConfig(): Config {
     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/src/configuration-files.ts

@@ -57,7 +57,7 @@ const COUNTERPARTS: readonly (readonly [string, readonly string[]])[] = [
 const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"] as const;
 
 /** 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",
@@ -237,33 +237,36 @@ function relativeSpecifiers(file: SourceFile): readonly string[] {
 }
 
 /**
- * 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: Host, dir: string, specifier: string): string | undefined {
+export function specifierCandidates(dir: string, specifier: string): readonly string[] {
   const path = resolvePath(dir, specifier);
-  const isFile = (candidate: string): boolean => 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: string[] = [];
+  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: Host,
+  dir: string,
+  specifier: string,
+): string | undefined {
+  return specifierCandidates(dir, specifier).find((path) => host.kindOf(path) === "file");
 }
 
 /**
@@ -311,7 +314,7 @@ function outsideModules(
     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 });
       }
@@ -347,12 +350,13 @@ export function dependenciesNamed(text: string, declared: readonly string[]): re
 }
 
 /**
- * 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: SourceFiles, dir: string, text: string): readonly SourceFile[] {
-  if (!RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix)) || text.includes("*")) {
+  if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
     return [];
   }
   const path = resolvePath(dir, text);

package/src/conformance-record.ts

@@ -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: [],
 } as const;

package/src/contextual-uses.ts

@@ -97,15 +97,19 @@ interface Called {
 interface Checked {
   readonly source: Type;
   readonly targets: readonly Type[];
+  /**
+   * Whether the source is declared outside the target, so code the analysis does not
+   * hold reads the members of the target's types it declares.
+   */
+  readonly outside: boolean;
 }
 
-/** How many element and signature steps the structural walk takes below a value's own type. */
-const MAX_DEPTH = 3;
-
 /** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
 interface Member {
   readonly ids: readonly string[];
   readonly handles: ReadonlySet<string>;
+  /** Whether a declaration of it is in one of the target's own files. */
+  readonly own: boolean;
 }
 
 /**
@@ -123,6 +127,7 @@ export function contextualUses<Brand>(
   properties: PropertyTables,
 ): ContextualUses {
   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;
@@ -165,6 +170,7 @@ export function contextualUses<Brand>(
         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);
@@ -206,6 +212,11 @@ export function contextualUses<Brand>(
     member.ids.filter((id) => kinds.get(id) === "type-member");
   const carries = (part: Type): boolean =>
     [...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: Type): boolean => {
+    const members = [...membersOf(part).values()];
+    return members.length > 0 && members.every((member) => !member.own);
+  };
 
   const elements = new Map<number, Type | undefined>();
   /** The element type of an array type, read once per type. */
@@ -254,12 +265,12 @@ export function contextualUses<Brand>(
    * 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: Type | undefined,
     target: Type | undefined,
-    depth: number,
     into: Checked[],
     seen: Set<string>,
   ): void => {
@@ -267,7 +278,7 @@ export function contextualUses<Brand>(
     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);
@@ -275,13 +286,15 @@ export function contextualUses<Brand>(
     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);
@@ -289,30 +302,37 @@ export function contextualUses<Brand>(
           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: Type, depth: number): boolean =>
-    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: Type, seen: Set<number> = new Set()): boolean => {
+    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(
@@ -326,11 +346,22 @@ export function contextualUses<Brand>(
       return;
     }
     const checked: Checked[] = [];
-    compared(type, position, 0, checked, new Set());
+    compared(type, position, checked, new Set());
     const ids = new Set<string>();
-    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 (

package/src/convention-rows.ts

@@ -25,6 +25,12 @@ interface MoveReading {
   readonly call?: OptionsCall;
 }
 
+/** One configuration property whose value names a package by a short name. */
+export interface ShortNameReading extends MoveReading {
+  /** The package name a value stands for, written with `{}` where the value goes. */
+  readonly package: string;
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -56,6 +62,8 @@ export interface ConventionRow {
   readonly generated?: readonly string[];
   /** The directories configuration moves, in the order their placeholders depend on each other. */
   readonly moves: readonly DirectoryMove[];
+  /** The properties that name a package the configuration uses by a short name. */
+  readonly shortNames?: readonly ShortNameReading[];
 }
 
 const SCRIPT = "{js,jsx,ts,tsx}";
@@ -444,5 +452,12 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       `**/{vitest,vite}.*.config.${ANY_MODULE}`,
     ],
     moves: [],
+    shortNames: [
+      {
+        property: "test.coverage.provider",
+        files: [`{vitest,vite}.config.${ANY_MODULE}`],
+        package: "@vitest/coverage-{}",
+      },
+    ],
   },
 ];