@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/src/exempt-classes.ts

@@ -1,16 +1,12 @@
 /**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on, the confidence it is recorded at and, for a class that runs
- * on TypeScript, which private members it may retain.
- *
- * The rows are written out rather than read from the Contract at run time, for the
- * reason the fixed severity codes are, and a test holds them equal to the Contract
- * release this analyzer implements. A class name is a type, so a detector table or a
- * record naming a class the vocabulary does not hold, or one that runs on another
- * language only, does not compile.
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
+ * languages and, for a TypeScript class, which private members it may retain. The rows are
+ * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
+ * A class name is a type, so a table or a record naming a class outside the vocabulary, or
+ * one of another language only, does not compile.
  */
 
-import type { Confidence, Language } from "./config.ts";
+import type { Language } from "./config.ts";
 
 /**
  * Whether a class may retain a member declared with the `private` modifier, and one
@@ -27,7 +23,6 @@ export interface TypeScriptVisibility {
 interface ExemptionClassRow {
   readonly class: string;
   readonly languages: readonly Language[];
-  readonly confidence: Confidence;
   /** Present exactly on a class that runs on TypeScript. */
   readonly typescriptVisibility?: TypeScriptVisibility;
 }
@@ -37,59 +32,50 @@ export const EXEMPTION_CLASSES = [
   {
     class: "interface-satisfaction",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: false, privateName: false },
   },
-  { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
-  { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
-  { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+  { class: "encoding-reflection", languages: ["go"] },
+  { class: "format-verb-contract", languages: ["go"] },
+  { class: "errors-duck-typing", languages: ["go"] },
   {
     class: "enum-group",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: false, privateName: false },
   },
   {
     class: "generated-file",
     languages: ["go", "ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
-  { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+  { class: "linkname-cgo-asm-plugin", languages: ["go"] },
   {
     class: "template-field",
     languages: ["go", "ts"],
-    confidence: "possible",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "reflective-lookup",
     languages: ["go", "ts"],
-    confidence: "possible",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "decorator",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "injection-container",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "framework-lifecycle",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
   {
     class: "serialization-contract",
     languages: ["ts"],
-    confidence: "certain",
     typescriptVisibility: { private: true, privateName: false },
   },
 ] as const satisfies readonly ExemptionClassRow[];

package/src/exempt.ts

@@ -64,9 +64,7 @@ export type Detector = <Brand>(input: DetectorInput<Brand>) => readonly Evidence
 export type Detectors = ReadonlyMap<TSExemptionClass, Detector>;
 
 /** What decides which records of one project stand. */
-export interface Holding {
-  /** The classes the configuration switches off, whose detectors do not run. */
-  readonly disabled: ReadonlySet<ExemptionClass>;
+interface Holding {
   readonly mode: Mode;
   /** The paths the reference pass classified as test files. */
   readonly testFiles: ReadonlySet<string>;
@@ -154,23 +152,8 @@ function detected<Brand>(
   }
 }
 
-/**
- * The records one project's detectors found, each class in the vocabulary's order and
- * none of a switched-off class. Evidence on a private member the class's row says it
- * cannot retain is dropped first, whatever the detector found. Under a production mode
- * a record whose evidence is written in a test file holds nothing, as a reference a
- * test file makes is none there.
- */
-export function computeExemptions<Brand>(
-  input: DetectorInput<Brand>,
-  detectors: Detectors,
-  holding: Holding,
-): readonly Exemption[] {
-  return detectExemptions(input, detectors, holding).records;
-}
-
 /** One project's records, and the evidence a production mode found in a test file. */
-export interface Detected {
+interface Detected {
   readonly records: readonly Exemption[];
   /**
    * Under a production mode, each record whose evidence is written in a test file. It
@@ -180,18 +163,11 @@ export interface Detected {
   readonly inTestFiles: readonly Exemption[];
 }
 
-/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
-export function detectExemptions<Brand>(
-  input: DetectorInput<Brand>,
-  detectors: Detectors,
-  holding: Holding,
-): Detected {
-  return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
-}
-
 /**
  * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads.
+ * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
+ * vocabulary's order and a switched-off class runs not at all; evidence on a private
+ * member the class's row says it cannot retain is dropped, whatever the detector found.
  */
 export function evidenceRecords<Brand>(
   input: DetectorInput<Brand>,

package/src/file-facts.ts

@@ -22,7 +22,7 @@ const DECLARATION_FILE = /\.d\.(?:[^./]+\.)?[mc]?ts$/u;
 const LINE_BREAK = /\r\n|[\n\r\u2028\u2029]/gu;
 
 /** One source file below the target root. */
-export interface TreeFile {
+interface TreeFile {
   /** The path below the target root, with the solidus as separator. */
   readonly path: string;
   /** The stable reference of the file's module. */

package/src/finding.ts

@@ -25,7 +25,7 @@ export interface FindingPosition {
 }
 
 /** What a finding is about. */
-export interface FindingSubject {
+interface FindingSubject {
   /** The stable symbol reference, or for a configured root the root as written. */
   readonly ref: string;
   /** The subject kind, from the closed vocabulary of the finding schema. */
@@ -65,6 +65,8 @@ export interface FindingDetails {
   readonly entry?: SuppressionEntry;
   /** On the intra-function kinds: the external rules that report the same kind, as the vocabulary lists them. */
   readonly overlap?: readonly string[];
+  /** On a deletable finding: the dependencies whose last use deleting the subject removes. */
+  readonly removesLastUseOf?: readonly string[];
 }
 
 /** One suppression in the four-member form the ignore file and the baseline share. */
@@ -83,6 +85,8 @@ export interface Finding {
   readonly message: string;
   /** Absent where the code carries nothing. */
   readonly details?: FindingDetails;
+  /** The reachability class of a subject that is no declaration, where it is not `certain`. */
+  readonly reachabilityClass?: Confidence;
 }
 
 /** The dead component a finding names, as the finding schema spells its members. */

package/src/findings/completion.ts

@@ -84,6 +84,35 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   };
 }
 
+/**
+ * The confidence ceiling of a test of dead code: the lowest reachability class among the
+ * target symbols it references, because its deadness is theirs, whether or not they share
+ * its component. Every other declaration has none below `certain`.
+ */
+function testCeilings(
+  input: EmitterInput,
+  classOf: (id: string) => Confidence,
+): (id: string) => Confidence {
+  const union = input.swept.matrix.union;
+  const tests = new Set(
+    input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),
+  );
+  return (id) => {
+    let lowest: Confidence = "certain";
+    if (!tests.has(id)) {
+      return lowest;
+    }
+    for (const edge of union.out[union.at(id)] ?? []) {
+      const target = union.symbols[edge.to];
+      const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+      if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+        lowest = capped(lowest, classOf(target.id));
+      }
+    }
+    return lowest;
+  };
+}
+
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
@@ -136,12 +165,11 @@ function findingComponents(
 
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
- * candidate's relation, counts, configurations and component; a live one carries no
- * relation and holds where it is declared; a file or a manifest row is `certain` and
- * holds in every configuration. A subject in no dead component gets one of its own,
- * numbered past the computed ones in finding order, so no two families mint one; nothing
- * falls with it, so its deletion removes no line. `kinds` is the vocabulary each code's
- * row is read from, the shipped one unless a caller supplies its own.
+ * candidate's relation, counts, configurations and component; a live one carries no relation and
+ * holds where it is declared; a file or a manifest row carries the class its emitter states,
+ * `certain` by default, and holds in every configuration. A subject in no dead component gets one
+ * of its own, numbered past the computed ones in finding order so no two families mint one, whose
+ * deletion removes no line. `kinds` defaults to the shipped vocabulary.
  */
 export function completed(
   input: EmitterInput,
@@ -155,6 +183,7 @@ export function completed(
   );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
+  const ceilingOf = testCeilings(input, classOf);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
   let minted = swept.sweep.components.length;
   const dead = new Set(swept.sweep.components.map((component) => component.id));
@@ -210,8 +239,14 @@ export function completed(
       candidate === undefined
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
-    const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+    const reachabilityClass =
+      judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
     const generated = input.files.generated?.has(finding.position.path) === true;
+    const fixability = generated ? "none" : row.fixability;
+    const lastUses =
+      fixability === "deletable" && candidate !== undefined
+        ? input.dependencies.lastUses.get(candidate.id)
+        : undefined;
     return {
       code: finding.code,
       kind: row.name,
@@ -219,7 +254,10 @@ export function completed(
       position: finding.position,
       symbol: finding.symbol,
       reachabilityClass,
-      confidence: capped(reachabilityClass, row.maxClass),
+      confidence: capped(
+        capped(reachabilityClass, row.maxClass),
+        judged === undefined ? "certain" : ceilingOf(judged.id),
+      ),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
       testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
       generated,
@@ -231,10 +269,13 @@ export function completed(
           ? swept.matrix.configurations
           : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
       consumersLoaded: input.boundary.consumers.loaded,
-      fixability: generated ? "none" : row.fixability,
+      fixability,
       severity: severityOf(input, finding.code, row.defaultSeverity),
       message: finding.message,
-      details: finding.details ?? {},
+      details:
+        lastUses === undefined
+          ? (finding.details ?? {})
+          : { ...finding.details, removesLastUseOf: lastUses },
     };
   });
   return componentCapped(done, dead);
@@ -287,6 +328,7 @@ export function dialsOf(
 ): Dials<CompletedFinding> {
   const minConfidence = input.config.analysis.minConfidence;
   const classOf = reachabilityClasses(input);
+  const ceilingOf = testCeilings(input, classOf);
   const components = new Set(
     findings
       .filter((finding) => finding.component.root && dialed(finding, minConfidence))
@@ -300,7 +342,7 @@ export function dialsOf(
         dialed(
           {
             severity: severityOf(input, code, row.defaultSeverity),
-            confidence: capped(classOf(id), row.maxClass),
+            confidence: capped(capped(classOf(id), row.maxClass), ceilingOf(id)),
           },
           minConfidence,
         )

package/src/findings/dependencies-and-module-machinery.ts

@@ -1,4 +1,4 @@
-import type { Dependencies } from "../dependencies.ts";
+import { declarationKey, type Dependencies } from "../dependencies.ts";
 import type { Finding } from "../finding.ts";
 import { renderRef, type DependencySection } from "../ref.ts";
 import type { Emitter } from "./emitter.ts";
@@ -11,39 +11,17 @@ const MESSAGES: Readonly<Record<DependencySection, string>> = {
   "peer-dependency": "no import in the target needs the declared peer dependency",
 };
 
-/**
- * The dependencies the target needs: every package the projects' uses name, every
- * declared dependency that ships a command, which a script, a workflow or a shell
- * runs outside anything the analysis reads, and every peer a needed package
- * requires, which the target satisfies by declaring it.
- */
-function neededBy(dependencies: Dependencies): ReadonlySet<string> {
-  const needed = new Set(dependencies.needed);
-  for (const [name, installed] of dependencies.installed) {
-    if (installed.command) {
-      needed.add(name);
-    }
-  }
-  const pending = [...needed];
-  for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
-    for (const peer of dependencies.installed.get(name)?.peers ?? []) {
-      if (!needed.has(peer)) {
-        needed.add(peer);
-        pending.push(peer);
-      }
-    }
-  }
-  return needed;
-}
-
 /**
  * A dependency, development dependency or peer dependency of a manifest the run reads
  * that the target does not need, at the position of its key.
  */
 function unusedDependencies(dependencies: Dependencies): Finding[] {
-  const needed = neededBy(dependencies);
   return dependencies.declared
-    .filter((dependency) => !needed.has(dependency.name))
+    .filter(
+      (dependency) =>
+        !dependencies.needed.has(dependency.name) &&
+        !dependencies.ran.has(declarationKey(dependency)),
+    )
     .map((dependency) => ({
       code: UNUSED_DEPENDENCY,
       position: dependency.position,
@@ -59,6 +37,9 @@ function unusedDependencies(dependencies: Dependencies): Finding[] {
       },
       message: MESSAGES[dependency.section],
       details: { dependencyClass: dependency.section },
+      ...(dependencies.unbuilt.has(dependency.position.path)
+        ? { reachabilityClass: "possible" as const }
+        : {}),
     }));
 }
 

package/src/findings/emitters.ts

@@ -67,7 +67,7 @@ function markupKeys(input: EmitterInput): ReadonlySet<string> {
 }
 
 /** What the suppressions of a run swept under their marks are decided against. */
-export interface Suppressed {
+interface Suppressed {
   /** The same run swept with no mark, which is where a kind about liveness reports a marked declaration. */
   readonly unmarked: EmitterInput;
   /** The run's suppression records, in reading order. */
@@ -75,13 +75,13 @@ export interface Suppressed {
 }
 
 /** What the emitter table answers about one run. */
-export interface DecidedFindings {
+interface DecidedFindings {
   /** Every finding the run reports, each family's in table order. */
   readonly findings: readonly CompletedFinding[];
   /** One evaluation per declared edge side of this language, ordered by edge, then by side. */
   readonly evaluations: readonly EdgeEvaluation<CompletedFinding>[];
   /** What every suppression record did, in reading order. */
-  readonly ledger: Ledger<CompletedFinding>;
+  readonly ledger: Ledger;
   /** Every finding a record could name: the run's with no mark, then the run's as swept. */
   readonly would: readonly CompletedFinding[];
   /** The findings the minimum confidence withheld, by confidence. */
@@ -198,8 +198,3 @@ function withheldOf(input: EmitterInput, candidates: readonly CompletedFinding[]
   }
   return counts;
 }
-
-/** Every finding the run reports, each family's in table order. */
-export function findingsOf(input: EmitterInput): readonly CompletedFinding[] {
-  return decidedFindings(input).findings;
-}

package/src/findings/self-check.ts

@@ -1,8 +1,10 @@
 import { REPOSITORY_DOCUMENT } from "../config.ts";
 import type { Finding, FindingDetails, SuppressionEntry } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
+import { FIXED_SEVERITY_CODES } from "../kinds.ts";
 import type { Position } from "../position.ts";
 import {
+  isRowCode,
   STALE_SUPPRESSION,
   SUPPRESSION_WITHOUT_REASON,
   type Mechanism,
@@ -58,14 +60,6 @@ interface UnmatchedDeclaration {
   readonly document: string;
 }
 
-/** A run with nothing for the self-check family to report. */
-export const NO_SELF_CHECK: SelfCheckFacts = {
-  refusals: [],
-  unmatchedRoots: [],
-  rootsDocument: "",
-  unmatchedDeclarations: [],
-};
-
 /** The words a message names a mechanism by. */
 const WRITTEN: Readonly<Record<Mechanism, string>> = {
   inline: "inline directive",
@@ -122,7 +116,7 @@ function writtenEntry(refused: Refusal): SuppressionEntry {
 }
 
 /** Each file of the run by its path, as the reference of the file it is. */
-export type FileRefs = (path: string) => string | undefined;
+type FileRefs = (path: string) => string | undefined;
 
 /**
  * The reference a finding about a suppression names: the symbol it names or bound, else
@@ -133,10 +127,7 @@ function suppressionRef(symbol: string, path: string, files: FileRefs): string {
 }
 
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
-export function refusedSuppressions(
-  refusals: readonly Refusal[],
-  files: FileRefs,
-): readonly Finding[] {
+function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): readonly Finding[] {
   return refusals.map((refused) =>
     aboutSuppression(
       refused.reported,
@@ -190,7 +181,19 @@ export function staleSuppressions(
     const reports = [...new Set(records.flatMap((one) => one.reports))]
       .filter((code) => !codes.includes(code))
       .sort();
-    const instead = reports.length === 0 ? "" : `, and its declaration reports ${spelled(reports)}`;
+    const rows = codes.filter(isRowCode);
+    const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+    const remedy =
+      settable.length === 0
+        ? "fix what the finding names instead"
+        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+    const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
+    const instead =
+      rows.length > 0
+        ? `, because ${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}${declared === "" ? "" : `; ${declared}`}`
+        : declared === ""
+          ? ""
+          : `, and ${declared}`;
     return {
       code: STALE_SUPPRESSION,
       mechanism: first.mechanism,

package/src/findings-pass.ts

@@ -20,7 +20,7 @@ import type { Provenance, Recorded } from "./suppress-file.ts";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.ts";
 
 /** The counts a report's totals carry beside its findings. */
-export interface PassTotals {
+interface PassTotals {
   readonly suppressionsInEffect: number;
   readonly reasonsRecorded: number;
   readonly staleSuppressions: number;
@@ -40,7 +40,7 @@ export interface PassResult {
   readonly edgeEvaluations: readonly EdgeEvaluation<CompletedFinding>[];
   readonly totals: PassTotals;
   /** What every suppression record did, in reading order. */
-  readonly ledger: Ledger<CompletedFinding>;
+  readonly ledger: Ledger;
 }
 
 /** The exit code of a report holding at least one pending finding. */

package/src/graph.ts

@@ -87,13 +87,13 @@ export interface Edge {
 }
 
 /** How many references one declaration carries, split by the classification of the file that made each. */
-export interface Counts {
+interface Counts {
   readonly production: number;
   readonly test: number;
 }
 
 /** One root the inventory holds, at the position of the declaration it names. */
-export interface Rooted {
+interface Rooted {
   readonly at: number;
   readonly kind: RootKind;
 }

package/src/html-entries.ts

@@ -1,6 +1,7 @@
 /**
- * The files the module scripts of the target's HTML files load. An HTML file is read as
- * text and no markup is parsed, so a `<script>` inside a comment is read as well.
+ * The files the scripts of the target's HTML files load: a module script's, and a
+ * classic script's that names its file by `src`. An HTML file is read as text and no
+ * markup is parsed, so a `<script>` inside a comment is read as well.
  */
 
 import {
@@ -14,8 +15,8 @@ import type { Host } from "./host.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
 
-/** One file a module script loads, and the value or specifier that named it. */
-export interface HTMLEntry {
+/** One file a script loads, and the value or specifier that named it. */
+interface HTMLEntry {
   readonly file: SourceFile;
   readonly source: string;
 }
@@ -35,6 +36,9 @@ const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)
 /** A value that names a resource on another origin, or by another scheme. */
 const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 
+/** The `type` values a classic script carries, compared in lowercase. */
+const CLASSIC_TYPES: ReadonlySet<string> = new Set(["text/javascript", "application/javascript"]);
+
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"] as const;
 
@@ -85,18 +89,22 @@ function specifiersOf(parse: ParseFile, fileName: string, content: string): read
 }
 
 /**
- * Every value a module script of one HTML file names a file by: a `src` attribute's
- * value, or each specifier an inline script imports or re-exports that starts with `/`,
- * `./` or `../`.
+ * Every value a script of one HTML file names a file by: the `src` attribute's value of a
+ * module script or of a classic one, or each specifier an inline module script imports or
+ * re-exports that starts with `/`, `./` or `../`.
  */
 function scriptValues(parse: ParseFile | undefined, path: string, text: string): readonly string[] {
   const values: string[] = [];
   for (const match of text.matchAll(SCRIPT_TAG)) {
     const held = attributes(match[1] ?? "");
-    if (held.get("type") !== "module") {
+    const type = held.get("type");
+    const src = held.get("src");
+    if (type !== "module") {
+      if (src !== undefined && (type === undefined || CLASSIC_TYPES.has(type.toLowerCase()))) {
+        values.push(src);
+      }
       continue;
     }
-    const src = held.get("src");
     if (src !== undefined) {
       values.push(src);
       continue;
@@ -131,11 +139,11 @@ function manifestDirectory(host: Host, root: string, dir: string): string {
 }
 
 /**
- * The own files the module scripts of every HTML file below the target root load. A value
+ * The own files the scripts of every HTML file below the target root load. A value
  * starting with a single `/` is read against the nearest manifest's directory, any other
- * against the HTML file's own, and either resolves as a configuration file's relative
- * specifier does. A value naming another origin or scheme, or no source file of the
- * program, loads nothing here.
+ * against the HTML file's own, as a configuration file's relative specifier. One naming no
+ * source file is read back through the project's emit mapping, and a `/` one also against
+ * an output directory that is the HTML file's own. Another origin or scheme loads nothing.
  */
 export function htmlEntries(
   host: Host,
@@ -157,12 +165,22 @@ export function htmlEntries(
       if (ELSEWHERE.test(value)) {
         continue;
       }
-      const reached = value.startsWith("/")
-        ? resolveRelativeSpecifier(host, manifestDirectory(host, root, dir), `.${value}`)
-        : resolveRelativeSpecifier(host, dir, value);
+      const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
+      const relative = value.startsWith("/") ? `.${value}` : value;
+      const reached = resolveRelativeSpecifier(host, base, relative);
       const file = reached === undefined ? undefined : files.byName.get(reached);
       if (file !== undefined) {
         found.push({ file, source: value });
+        continue;
+      }
+      const served = value.startsWith("/")
+        ? files.outputDirs.filter((outDir) => outDir === dir)
+        : [];
+      const emitting = [base, ...served].flatMap((against) =>
+        files.named(resolvePath(against, relative)),
+      );
+      for (const one of new Set(emitting)) {
+        found.push({ file: one, source: value });
       }
     }
   }