@cplieger/deadset-ts 5.1.0 → 5.2.0

package/src/findings/unused-declarations.ts

@@ -52,8 +52,6 @@ interface Judged {
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
-  /** Whether a test-support file declares it, which test code keeps live. */
-  readonly support: boolean;
   /** Whether its container is itself dead, so it falls with the container. */
   readonly containerDead: boolean;
   readonly deprecated: boolean;
@@ -64,9 +62,9 @@ interface Judged {
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration, member of a
- * dead container or enum member nothing names, nor a test-support declaration test code
- * references; then deprecation, a test reference, and the unreferenced codes, an
- * unimportable unused export being the unreachable kind's.
+ * dead container or enum member nothing names; a test-support declaration test code
+ * references as test-only use; then deprecation, a test reference, and the unreferenced
+ * codes, an unimportable unused export being the unreachable kind's.
  */
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
@@ -80,8 +78,8 @@ function codeOf(judged: Judged): string | undefined {
   if (symbol.kind === "enum-member" && !referenced) {
     return undefined;
   }
-  if (judged.support && candidate.testRefs > 0) {
-    return undefined;
+  if (candidate.heldByTests === candidate.id) {
+    return "DS1004";
   }
   if (candidate.productionRefs === 0 && judged.deprecated) {
     return "DS1006";
@@ -220,7 +218,6 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
       candidate,
       symbol,
       test: union.test[at] === true,
-      support: union.support[at] === true,
       containerDead: containerDead && !fallen,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),

package/src/findings/visibility-narrowing.ts

@@ -232,7 +232,8 @@ function unreachable(
  * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
- * outside the file and the package whose use is decided in the other language.
+ * outside the file and the package whose use is decided in the other language. A
+ * declaration of a generated file is reported only where generated files are included.
  */
 export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
@@ -242,9 +243,14 @@ export function narrowings(input: EmitterInput): readonly Finding[] {
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );
+  const generated =
+    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
 
   const findings: Finding[] = [];
   facts.graph.symbols.forEach((symbol, at) => {
+    if (generated?.has(symbol.position.path) === true) {
+      return;
+    }
     const candidate = candidates.get(symbol.id);
     const found =
       candidate === undefined

package/src/generated-file.ts

@@ -1,10 +1,84 @@
 /**
- * The generated-file class on TypeScript: every declaration in a file below a directory
- * an applied convention row names as generated is retained, because the framework owns
- * the file and a deletion there is undone at the next generation.
+ * The generated-file class on TypeScript: every declaration in a file that marks itself
+ * generated, or below a directory an applied convention row names as generated, is
+ * retained, because a generator owns the file and a deletion there is undone at the next
+ * generation.
  */
 
 import type { DetectorInput, Evidence } from "./exempt.ts";
+import type { SourceFiles } from "./source-files.ts";
+
+/** The generated-code header, matched against each line of a leading comment. */
+const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
+
+/** The documentation tag `@generated` as a word of a comment. */
+const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
+
+/** The comments before a text's first token, a leading hashbang line skipped. */
+function leadingComments(text: string): readonly string[] {
+  const comments: string[] = [];
+  let at = text.startsWith("\uFEFF") ? 1 : 0;
+  if (text.startsWith("#!", at)) {
+    const end = text.indexOf("\n", at);
+    at = end === -1 ? text.length : end + 1;
+  }
+  for (;;) {
+    while (at < text.length && /\s/u.test(text.charAt(at))) {
+      at++;
+    }
+    if (text.startsWith("//", at)) {
+      const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
+      const stop = end === -1 ? text.length : at + end;
+      comments.push(text.slice(at, stop));
+      at = stop;
+    } else if (text.startsWith("/*", at)) {
+      const end = text.indexOf("*/", at + 2);
+      if (end === -1) {
+        return comments;
+      }
+      comments.push(text.slice(at, end + 2));
+      at = end + 2;
+    } else {
+      return comments;
+    }
+  }
+}
+
+/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
+export function generatedByComment(text: string): string | undefined {
+  const comments = leadingComments(text);
+  if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
+    return "generated by the header line its leading comments hold";
+  }
+  if (comments.some((one) => GENERATED_TAG.test(one))) {
+    return "generated by the @generated tag its leading comments hold";
+  }
+  return undefined;
+}
+
+/**
+ * Every own file of one project that is generated, by its path below the target root,
+ * with the detail a retention in it names: its leading comments' mark, else the row
+ * naming its directory as generated.
+ */
+export function generatedFilesOf(
+  files: SourceFiles,
+  byRow: ReadonlyMap<string, string>,
+): ReadonlyMap<string, string> {
+  const found = new Map<string, string>();
+  for (const [path, file] of files.byPath) {
+    const row = byRow.get(path);
+    const detail =
+      generatedByComment(file.text) ??
+      (row === undefined
+        ? undefined
+        : `generated below a directory the convention row ${row} names`);
+    if (detail !== undefined) {
+      found.set(path, detail);
+    }
+  }
+  return found;
+}
 
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
@@ -13,15 +87,9 @@ export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evid
     return [];
   }
   return input.held.symbols.flatMap((symbol): Evidence[] => {
-    const row = generated.get(symbol.position.path);
-    return symbol.kind === "file" || row === undefined
+    const detail = generated.get(symbol.position.path);
+    return symbol.kind === "file" || detail === undefined
       ? []
-      : [
-          {
-            id: symbol.id,
-            detail: `generated below a directory the convention row ${row} names`,
-            site: { path: symbol.position.path, line: 1, column: 1 },
-          },
-        ];
+      : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
   });
 }

package/src/graph.ts

@@ -40,10 +40,10 @@ const SWEPT: Readonly<Record<SymbolKind, boolean>> = {
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a command and a script, the manifest names what
- * enters the package, an alias global stands for the export it names, and an entry file,
- * a configured root and a pattern assert a caller. A library's published API only supposes
- * a consumer the run may not see, so it is live under reachability alone.
+ * test file, a setup file, a worker, a page's module script, a command and a script, the
+ * manifest names what enters the package, an alias global stands for the export it names,
+ * and an entry file, a configured root and a pattern assert a caller. A library's
+ * published API only supposes an unseen consumer, so it is live under reachability alone.
  */
 const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "entry-file": true,
@@ -62,6 +62,7 @@ const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "mutation-testing": true,
   "browser-tests": true,
   worker: true,
+  "html-entry": true,
 };
 
 /** Whether the sweep judges a declaration of one kind. */
@@ -122,9 +123,9 @@ export interface Graph {
   /** Every root naming a declaration the inventory holds, in the order the root set gives them. */
   readonly rooted: readonly Rooted[];
   /**
-   * Every reference a loaded consumer makes to a declaration the inventory holds, in the
-   * order given. A consumer is a caller the analysis read, so the sweep holds what it
-   * names live under both relations and reaches on from there.
+   * Every reference a loaded consumer or an unheld file makes to a declaration the
+   * inventory holds, in the order given. Such a file is a caller the analysis read, so the
+   * sweep holds what it names live under both relations and reaches on from there.
    */
   readonly consumed: readonly Edge[];
   /** The position of the declaration one identifier names, or {@link OUTSIDE}. */
@@ -167,7 +168,7 @@ export function graphOf(
       }
     }
     const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-    if (reference.consumer !== undefined) {
+    if (reference.consumer !== undefined || reference.unheld === true) {
       consumed.push(edge);
       continue;
     }

package/src/html-entries.ts

@@ -0,0 +1,170 @@
+/**
+ * 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.
+ */
+
+import {
+  isExportDeclaration,
+  isImportDeclaration,
+  isStringLiteral,
+  type SourceFile,
+} from "@typescript/native/unstable/ast";
+import { resolveRelativeSpecifier, type ParseFile } from "./configuration-files.ts";
+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 {
+  readonly file: SourceFile;
+  readonly source: string;
+}
+
+/** The directory no HTML file is read below. */
+const SKIPPED = "node_modules";
+
+/** A `<script` start tag, its attribute text captured. */
+const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
+
+/** The end tag an inline module script's content runs to. */
+const SCRIPT_END = /<\/script\s*>/iu;
+
+/** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
+const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
+
+/** A value that names a resource on another origin, or by another scheme. */
+const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
+
+/** The prefixes an inline script's specifier names a file of the target with. */
+const FILE_PREFIXES = ["/", "./", "../"] as const;
+
+/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
+function htmlFiles(host: Host, dir: string): readonly string[] {
+  let entries;
+  try {
+    entries = host.readDirectory(dir);
+  } catch {
+    return [];
+  }
+  const found: string[] = [];
+  for (const entry of entries) {
+    const path = joinPath(dir, entry.name);
+    if (entry.directory) {
+      if (entry.name !== SKIPPED) {
+        found.push(...htmlFiles(host, path));
+      }
+    } else if (entry.name.endsWith(".html")) {
+      found.push(path);
+    }
+  }
+  return found.sort();
+}
+
+/** Each attribute of one start tag's attribute text, by its lowercase name. */
+function attributes(text: string): ReadonlyMap<string, string> {
+  const found = new Map<string, string>();
+  for (const match of text.matchAll(ATTRIBUTE)) {
+    const [, name = "", double, single, bare] = match;
+    const key = name.toLowerCase();
+    if (!found.has(key)) {
+      found.set(key, double ?? single ?? bare ?? "");
+    }
+  }
+  return found;
+}
+
+/** The specifiers of the import and re-export declarations one inline script holds. */
+function specifiersOf(parse: ParseFile, fileName: string, content: string): readonly string[] {
+  return parse(fileName, content).statements.flatMap((statement) => {
+    const specifier =
+      isImportDeclaration(statement) || isExportDeclaration(statement)
+        ? statement.moduleSpecifier
+        : undefined;
+    return specifier !== undefined && isStringLiteral(specifier) ? [specifier.text] : [];
+  });
+}
+
+/**
+ * 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 `../`.
+ */
+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") {
+      continue;
+    }
+    const src = held.get("src");
+    if (src !== undefined) {
+      values.push(src);
+      continue;
+    }
+    if (parse === undefined) {
+      continue;
+    }
+    const start = match.index + match[0].length;
+    const rest = text.slice(start);
+    const end = rest.search(SCRIPT_END);
+    const content = end === -1 ? rest : rest.slice(0, end);
+    values.push(
+      ...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) =>
+        FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix)),
+      ),
+    );
+  }
+  return values;
+}
+
+/** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
+function manifestDirectory(host: Host, root: string, dir: string): string {
+  for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
+    if (host.kindOf(joinPath(at, "package.json")) === "file") {
+      return at;
+    }
+    if (at === root) {
+      break;
+    }
+  }
+  return root;
+}
+
+/**
+ * The own files the module 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.
+ */
+export function htmlEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile | undefined,
+): readonly HTMLEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const found: HTMLEntry[] = [];
+  for (const path of htmlFiles(host, root)) {
+    let text: string;
+    try {
+      text = host.readFile(path);
+    } catch {
+      continue;
+    }
+    const dir = dirnamePath(path);
+    for (const value of scriptValues(parse, path, text)) {
+      if (ELSEWHERE.test(value)) {
+        continue;
+      }
+      const reached = value.startsWith("/")
+        ? resolveRelativeSpecifier(host, manifestDirectory(host, root, dir), `.${value}`)
+        : resolveRelativeSpecifier(host, dir, value);
+      const file = reached === undefined ? undefined : files.byName.get(reached);
+      if (file !== undefined) {
+        found.push({ file, source: value });
+      }
+    }
+  }
+  return found;
+}

package/src/inventory.ts

@@ -470,7 +470,20 @@ function nameNodeOf(node: Node): Node | undefined {
  * needs the declaration this enumeration made for it.
  */
 export function nodeKey(file: SourceFile, node: Node): string {
-  return `${file.fileName}:${String(node.pos)}:${String(node.end)}`;
+  return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
+}
+
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node: Node): number {
+  const start = node.getStart();
+  const prefix = DEFAULT_EXPORT.exec(node.getText());
+  return prefix === null ? start : start + prefix[0].length;
 }
 
 /** The kind a class element takes: a method, or a property or accessor. */
@@ -565,12 +578,11 @@ export function inventory<Brand>(
     name: Node | undefined,
     named: { readonly component: Component; readonly localName: string | undefined },
   ): Building {
-    const at = name ?? node;
     const record = keep({
       file: owner.file,
       node,
       module: owner.module,
-      position: renderPosition(owner.file, targetRoot, at.getStart()),
+      position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
       endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
       kind,
       parentChain: owner.kind === "file" ? [] : chainOf(owner),

package/src/kinds.ts

@@ -71,7 +71,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1004",
     name: "test-only-use",
     languages: ["go", "ts"],
-    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only test code imports, is a test reference, and a declaration of test-support code is never reported under this code.",
+    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach, is a test reference. A declaration of test-support code that test code references is reported under this code at the reachability class possible, as grammar/analysis.md states. Such a declaration that is an interface is reported under DS1201 instead.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -179,7 +179,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1301",
     name: "write-only-symbol",
     languages: ["go", "ts"],
-    rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, or an import binding the writes alone use. The finding's message names each such declaration.",
+    rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",

package/src/manifest.ts

@@ -1,13 +1,12 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts.
- *
- * One call reads one manifest, the one in the directory it is given.
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
 
 import type { Host } from "./host.ts";
-import { isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 
 /** The manifest's own name. */
 const MANIFEST = "package.json";
@@ -41,6 +40,8 @@ export interface ManifestEntry {
    * `exports` is the surface a library's published API is read from.
    */
   readonly published: boolean;
+  /** The directory of the manifest that names it, which `path` was resolved against. */
+  readonly dir: string;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -89,7 +90,7 @@ function below(member: string, key: string): string {
  * any depth; a `null` blocks a subpath. Every level is walked, because each
  * condition names its own entry file, and a key's meaning is never read.
  */
-function exportTargets(value: unknown, member: string, found: ManifestEntry[]): void {
+function exportTargets(value: unknown, member: string, found: Omit<ManifestEntry, "dir">[]): void {
   if (typeof value === "string") {
     if (isTarget(value, true)) {
       found.push({ member, path: value, role: "import", published: true });
@@ -162,7 +163,7 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     return { entries: [], declaresExports: false };
   }
 
-  const found: ManifestEntry[] = [];
+  const found: Omit<ManifestEntry, "dir">[] = [];
   for (const member of LEGACY_MEMBERS) {
     const value = manifest[member];
     if (typeof value === "string" && isTarget(value, false)) {
@@ -201,7 +202,48 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
   }
 
   return {
-    entries: found.map((entry) => ({ ...entry, path: resolvePath(targetRoot, entry.path) })),
+    entries: found.map((entry) => ({
+      ...entry,
+      path: resolvePath(targetRoot, entry.path),
+      dir: targetRoot,
+    })),
     declaresExports: manifest["exports"] !== undefined,
   };
 }
+
+/**
+ * The entry points every package manifest between the target root and each compiler
+ * configuration names: each directory holding a `package.json` that a configuration sits
+ * in or below, the target root and `known` excluded, whose manifests the run reads
+ * otherwise. Each entry is spelled under its manifest's path below the target root, and
+ * is published by its own manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(
+  host: Host,
+  targetRoot: string,
+  configFiles: readonly string[],
+  known: ReadonlySet<string>,
+): readonly ManifestEntry[] {
+  const dirs = new Set<string>();
+  for (const configFile of configFiles) {
+    for (
+      let dir = dirnamePath(resolvePath(targetRoot, configFile));
+      dir !== targetRoot && relativePath(targetRoot, dir) !== undefined;
+      dir = dirnamePath(dir)
+    ) {
+      if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+        dirs.add(dir);
+      }
+    }
+  }
+  return [...dirs].sort().flatMap((dir) => {
+    const manifest = readManifest(host, dir);
+    const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+    return manifest.entries.map((entry) => ({
+      ...entry,
+      member: `${where} ${entry.member}`,
+      published:
+        entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+    }));
+  });
+}

package/src/matrix.ts

@@ -5,7 +5,7 @@
  */
 
 import { componentsOf, type Component } from "./components.ts";
-import { graphOf, type Graph } from "./graph.ts";
+import { graphOf, OUTSIDE, type Graph } from "./graph.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { byPosition } from "./position.ts";
 import type { Reference } from "./references.ts";
@@ -55,6 +55,13 @@ export interface Matrix {
 export interface MatrixCandidate extends Candidate {
   /** The configurations the declaration is dead in, which are every one that holds it. */
   readonly configurations: readonly string[];
+  /**
+   * The declaration of test-support code that test code references, outside the
+   * test-of-dead-code rule, that is or contains this one, the outermost where two do.
+   * Such a declaration is not dead while test code references it, so neither it nor a
+   * declaration it contains is a member of a dead component.
+   */
+  readonly heldByTests: string | undefined;
 }
 
 /** One run's sweep. */
@@ -178,6 +185,7 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   const union = matrix.union;
   const dead = union.symbols.map(() => false);
   const testOfDeadCode = union.symbols.map(() => false);
+  const heldBy: (string | undefined)[] = union.symbols.map(() => undefined);
   const candidates: MatrixCandidate[] = [];
   union.symbols.forEach((symbol, at) => {
     const held = matrix.heldIn[at] ?? [];
@@ -187,24 +195,34 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
     }
     const all = found.filter((candidate): candidate is Candidate => candidate !== undefined);
     const admitted = all.every((candidate) => candidate.testOfDeadCode);
+    const testRefs = union.made[at]?.test ?? 0;
+    const heldByTests =
+      heldBy[union.parent[at] ?? OUTSIDE] ??
+      (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
     dead[at] = true;
     testOfDeadCode[at] = admitted;
+    heldBy[at] = heldByTests;
     candidates.push({
       id: symbol.id,
       productionRefs: union.made[at]?.production ?? 0,
-      testRefs: union.made[at]?.test ?? 0,
+      testRefs,
       relation: all.every((candidate) => candidate.relation === "reference-counting")
         ? "reference-counting"
         : "reachability",
       testOfDeadCode: admitted,
       configurations: held,
+      heldByTests,
     });
   });
 
   return {
     liveUnder: liveAnywhere(union.symbols, per),
     candidates,
-    components: componentsOf(union, dead, testOfDeadCode),
+    components: componentsOf(
+      union,
+      dead.map((one, at) => one && heldBy[at] === undefined),
+      testOfDeadCode,
+    ),
   };
 }