@cplieger/deadset-ts 5.1.1 → 5.2.1

package/dist/src/references.js

@@ -1,7 +1,9 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
+import { specifierCandidates } from "./configuration-files.js";
+import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
 import { overrideReferences } from "./overrides.js";
@@ -169,6 +171,44 @@ function markStores(node, writes, reads) {
         }
     }
 }
+/** Whether one node is `import.meta.url`. */
+function isImportMetaURL(node) {
+    const at = unparenthesized(node);
+    return (isPropertyAccessExpression(at) &&
+        isMetaProperty(at.expression) &&
+        at.expression.keywordToken === SyntaxKind.ImportKeyword &&
+        at.name.text === "url");
+}
+/** The module URL one node builds, where it builds one. */
+function moduleURLOf(node) {
+    const relative = (argument) => {
+        const at = argument === undefined ? undefined : unparenthesized(argument);
+        return at !== undefined &&
+            (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
+            /^\.\.?\//u.test(at.text)
+            ? at.text
+            : undefined;
+    };
+    if (isNewExpression(node) && isIdentifier(node.expression) && node.expression.text === "URL") {
+        const [reference, base] = node.arguments ?? [];
+        const specifier = relative(reference);
+        return specifier !== undefined && base !== undefined && isImportMetaURL(base)
+            ? { specifier, constructor: node.expression, at: node }
+            : undefined;
+    }
+    if (isCallExpression(node)) {
+        const callee = unparenthesized(node.expression);
+        const specifier = relative(node.arguments[0]);
+        if (specifier !== undefined &&
+            isPropertyAccessExpression(callee) &&
+            isMetaProperty(callee.expression) &&
+            callee.expression.keywordToken === SyntaxKind.ImportKeyword &&
+            callee.name.text === "resolve") {
+            return { specifier, constructor: undefined, at: node };
+        }
+    }
+    return undefined;
+}
 /** Whether one node is a string literal or a template literal with no substitution. */
 function isLiteralText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -286,7 +326,10 @@ function sitesOf(file, declarations, fileId, unread) {
     const reads = [];
     const links = [];
     const evaluations = [];
+    const wholes = [];
+    const urls = [];
     const decorated = [];
+    const namespaces = namespaceUses(file);
     const literals = [];
     const flows = [];
     const writes = new Set();
@@ -315,6 +358,13 @@ function sitesOf(file, declarations, fileId, unread) {
         if (unread.has(node)) {
             return;
         }
+        const namespace = namespaces.get(node);
+        if (namespace?.kind === "whole") {
+            wholes.push({ specifier: namespace.specifier, at: node, from: enclosing });
+        }
+        else if (namespace?.kind === "indexed") {
+            found.push({ node: namespace.literal, shorthand: undefined, from: enclosing, use: "read" });
+        }
         if (isName(node)) {
             if (!declared.has(node.pos)) {
                 const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
@@ -344,6 +394,10 @@ function sitesOf(file, declarations, fileId, unread) {
         if (evaluated !== undefined) {
             evaluations.push({ node: evaluated, from: enclosing });
         }
+        const url = moduleURLOf(node);
+        if (url !== undefined) {
+            urls.push(url);
+        }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -358,7 +412,7 @@ function sitesOf(file, declarations, fileId, unread) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, literals, flows, reads, links, evaluations, decorated };
+    return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
 }
 /** The declaration kinds of a property an object literal declares. */
 const LITERAL_PROPERTY_KINDS = new Set([
@@ -583,6 +637,30 @@ export function references(project, held, targetRoot, options) {
         }
         return topLevel.get(fileId) ?? [];
     };
+    const exportsCache = new Map();
+    /**
+     * Every declaration one module exports, each re-export walked along its chain. A module
+     * the checker left unanswered may be any file, so it reads every file's exports.
+     */
+    const exportsRead = (module) => {
+        if (module === UNANSWERED) {
+            return [...fileIds].flatMap((id) => declaredIn(id)
+                .filter((symbol) => symbol.exported)
+                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })));
+        }
+        const known = exportsCache.get(module.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const table = project.queries.exportsOfModule(module);
+        const read = table === UNANSWERED
+            ? chains.declarationsOf(module).flatMap((id) => declaredIn(id)
+                .filter((symbol) => symbol.exported)
+                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })))
+            : table.flatMap((exported) => chains.chainOf(exported));
+        exportsCache.set(module.id, read);
+        return read;
+    };
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
     /**
@@ -746,7 +824,7 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
-    for (const { file, fileId, uses, reads, links, evaluations, decorated } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } of walked) {
         const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
@@ -774,6 +852,8 @@ export function references(project, held, targetRoot, options) {
                 ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
                 ...links.map((link) => link.node),
                 ...evaluations.map((evaluation) => evaluation.node),
+                ...wholes.map((whole) => whole.specifier),
+                ...urls.flatMap((url) => url.constructor ?? []),
                 ...bindings.map((binding) => binding.node),
             ]),
         ];
@@ -842,6 +922,43 @@ export function references(project, held, targetRoot, options) {
                 }
             }
         }
+        for (const url of urls) {
+            const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+            if (typeof constructor === "object" &&
+                constructor.declarations.some((handle) => ownPaths.has(handle.path))) {
+                continue;
+            }
+            const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
+                .map((path) => fileIdByName.get(path))
+                .find((id) => id !== undefined);
+            if (loaded !== undefined) {
+                found.push({
+                    from: fileId,
+                    to: loaded,
+                    position: renderPosition(file, root, url.at.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
+        }
+        for (const whole of wholes) {
+            const module = answered.get(whole.specifier);
+            if (module === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, root, whole.at.getStart());
+            for (const target of exportsRead(module)) {
+                found.push({
+                    from: whole.from,
+                    to: target.id,
+                    position,
+                    use: "read",
+                    resolution: target.guessed ? "by-name" : "batch",
+                    test,
+                });
+            }
+        }
         if (markup) {
             for (const symbol of declaredIn(fileId)) {
                 found.push({

package/dist/src/roots.js

@@ -13,6 +13,7 @@ import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
+import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
@@ -23,6 +24,42 @@ const ENTRY_KINDS = {
     run: "manifest-binary",
     script: "script",
 };
+/** The rules whose rooted files a manifest target is read back to by name. */
+const READ_BACK_RULES = new Set([
+    "configuration-file",
+    "configuration-string",
+    "html-entry",
+]);
+/** The extensions a manifest target's name drops: the ones a build writes. */
+const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
+/** The extension a source file's name drops. */
+const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+/**
+ * The rooted files one manifest target reads back to by name: its path below the
+ * manifest's directory, past its first directory where it names one, without its output
+ * extension, is the name, and a rooted file is one whose path below the same directory,
+ * without its source extension, ends with that name at a directory boundary.
+ */
+function readBackByName(host, entry, rooted) {
+    const dir = resolvePath(host.workingDirectory(), entry.dir);
+    const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
+    if (below === undefined || below === "") {
+        return [];
+    }
+    const cut = below.indexOf("/");
+    const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
+    if (name === "") {
+        return [];
+    }
+    const found = new Map();
+    for (const file of rooted) {
+        const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
+        if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+            found.set(file.fileName, file);
+        }
+    }
+    return [...found.values()];
+}
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -125,6 +162,7 @@ export function roots(project, held, targetRoot, options) {
     const enter = (file, kind, source, exports) => {
         entered.push({ file, kind, source, exports });
     };
+    const points = entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse);
     const published = [];
     const entries = [
         ...options.manifest.entries.map((entry) => ({
@@ -134,14 +172,25 @@ export function roots(project, held, targetRoot, options) {
         })),
         ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
     ];
+    const scripted = entries.flatMap(({ entry }) => entry.role === "script" ? files.named(entry.path) : []);
+    const readBackTo = [
+        ...scripted,
+        ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
+    ];
+    const entryFiles = (entry) => {
+        const named = files.named(entry.path);
+        return named.length > 0 || entry.role === "script"
+            ? named
+            : readBackByName(options.host, entry, readBackTo);
+    };
     for (const { entry, publishes } of entries) {
         if (options.publishedAPI && publishes) {
-            published.push(...files.named(entry.path));
+            published.push(...entryFiles(entry));
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
     for (const { entry } of entries) {
-        for (const file of files.named(entry.path)) {
+        for (const file of entryFiles(entry)) {
             const kind = ENTRY_KINDS[entry.role];
             enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
@@ -159,7 +208,7 @@ export function roots(project, held, targetRoot, options) {
         : conventionEntries(options.conventions, files)) {
         enter(file, "convention", row, true);
     }
-    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse)) {
+    for (const point of points) {
         enter(point.file, point.rule, point.source, point.exports);
     }
     for (const file of files.byPath.values()) {

package/dist/src/sweep.js

@@ -70,6 +70,23 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/**
+ * Per declaration of the graph, whether the run that counts test references reaches it.
+ * That run's roots are the graph's own and each test file, being the file's top level
+ * and every declaration it exports, which a test runner may call; `held` seeds it as a
+ * mark or an exemption seeds a sweep.
+ */
+export function reachedWithTheTests(graph, held) {
+    const tests = graph.symbols.flatMap((symbol, at) => {
+        const top = symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+        return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+            ? [{ at, kind: "test-runner" }]
+            : [];
+    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
+        production: false,
+    });
+}
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
  * none a consumer's test file made, as it counts none of the target's.

package/dist/src/test-support.js

@@ -1,47 +1,59 @@
 /**
- * Test-support code: a file that is not a test file by name and that only test code
- * imports. At least one test file reaches it, directly or through other such files, and
- * nothing else does, so it is judged with the tests: what it references is referenced by
- * test code, and a declaration of it is live while test code references it.
+ * Test-support code: the files only tests reach. A test reaches each one through a chain
+ * of references, and every reference to a declaration of one, an import for its effects
+ * included, is written in a test file or in another such file, so it is judged with the
+ * tests: what it references is referenced by test code.
  */
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
- * The files of one project that are test-support code, below the target root. A file
- * holding a root is not one, because a root has a caller outside the import graph: a
- * runtime, a tool, a configuration, or a consumer of a library's published API.
- * `testFiles` are the files the test-file rules classified.
+ * The files of one project that are test-support code, below the target root: the
+ * largest set of files a test file reaches, none of them a test file or holding a root,
+ * whose every user outside the set is a test file. A root has a caller outside the
+ * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
+ * published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(symbols, references, roots, testFiles) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
     const users = new Map();
+    const uses = new Map();
+    const add = (map, key, value) => {
+        const held = map.get(key);
+        if (held === undefined) {
+            map.set(key, new Set([value]));
+        }
+        else {
+            held.add(value);
+        }
+    };
     for (const reference of references) {
         const used = fileOf.get(reference.to);
         const from = reference.position.path;
         if (reference.consumer !== undefined || used === undefined || used === from) {
             continue;
         }
-        const held = users.get(used);
-        if (held === undefined) {
-            users.set(used, new Set([from]));
-        }
-        else {
-            held.add(from);
-        }
+        add(users, used, from);
+        add(uses, from, used);
     }
     const tests = new Set(testFiles);
     const rooted = new Set(roots.filter((root) => root.kind !== SKIP_ROOT).flatMap((root) => fileOf.get(root.id) ?? []));
-    const candidates = [...users.keys()].filter((path) => !tests.has(path) && !rooted.has(path));
-    const support = new Set();
+    const reached = new Set();
+    const queue = [...tests];
+    for (let path = queue.pop(); path !== undefined; path = queue.pop()) {
+        for (const next of uses.get(path) ?? []) {
+            if (!reached.has(next) && !tests.has(next)) {
+                reached.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    const support = new Set([...reached].filter((path) => !rooted.has(path)));
     for (let changed = true; changed;) {
         changed = false;
-        for (const path of candidates) {
-            if (support.has(path)) {
-                continue;
-            }
+        for (const path of support) {
             const from = users.get(path) ?? new Set();
-            if ([...from].every((one) => tests.has(one) || support.has(one))) {
-                support.add(path);
+            if (![...from].every((one) => tests.has(one) || support.has(one))) {
+                support.delete(path);
                 changed = true;
             }
         }

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.2.0";
+export const CONTRACT_VERSION = "5.3.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.1.1",
+  "version": "5.2.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.1.1",
+  "version": "5.2.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "24.19.1",
-    "eslint": "10.11.0",
+    "eslint": "10.12.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",

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,7 +43,7 @@ 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 {
   evidenceRecords,
@@ -191,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>;
 }
 
@@ -222,6 +222,8 @@ 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[];
 }
@@ -435,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,
@@ -446,7 +449,7 @@ 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()) {
@@ -504,6 +507,7 @@ function readProjects<Answer>(
     unanswered: session.unanswered,
     componentsUnread: workspace?.componentsUnread ?? [],
     conventionsApplied: conventions.applied,
+    conventionUses: conventions.uses,
     outsideTests,
   };
 }
@@ -688,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[];
 }
 
 /**
@@ -839,6 +845,7 @@ function readRun<Extra>(
     unanswered: read.unanswered,
     componentsUnread: read.componentsUnread,
     conventionsApplied: read.conventionsApplied,
+    conventionUses: read.conventionUses,
   };
 }
 
@@ -1093,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

@@ -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;