@cplieger/deadset-ts 5.1.0 → 5.1.1

package/src/analysis.ts

@@ -46,7 +46,8 @@ import { enumGroup } from "./enum-group.ts";
 import { generatedFile } 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";
@@ -219,6 +222,8 @@ interface ReadProjects<Answer> {
   readonly componentsUnread: readonly ComponentsUnread[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The test files below the target root no project the run reads holds, parsed. */
+  readonly outsideTests: readonly OutsideTest[];
 }
 
 /**
@@ -284,7 +289,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 +317,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)) {
@@ -434,10 +449,24 @@ function readProjects<Answer>(
           generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
         };
       };
+      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 +504,7 @@ function readProjects<Answer>(
     unanswered: session.unanswered,
     componentsUnread: workspace?.componentsUnread ?? [],
     conventionsApplied: conventions.applied,
+    outsideTests,
   };
 }
 
@@ -630,6 +660,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;
@@ -674,18 +715,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 +733,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 +829,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),
       ]),
     ],

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",

package/src/contextual-uses.ts

@@ -99,9 +99,6 @@ interface Checked {
   readonly targets: readonly Type[];
 }
 
-/** 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[];
@@ -254,12 +251,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 +264,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);
@@ -281,7 +278,7 @@ export function contextualUses<Brand>(
       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 +286,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) => {
+  /**
+   * 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)) {
         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,7 +330,7 @@ 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) {
       const tables = targets.map(membersOf);

package/src/exempt.ts

@@ -187,12 +187,23 @@ export function detectExemptions<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.
+ */
+export function evidenceRecords<Brand>(
+  input: DetectorInput<Brand>,
+  detectors: Detectors,
+  disabled: ReadonlySet<ExemptionClass>,
+): readonly Exemption[] {
   const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
   const found: Exemption[] = [];
-  const inTestFiles: Exemption[] = [];
   for (const exemptionClass of TS_EXEMPTION_CLASSES) {
     const detect = detectors.get(exemptionClass);
-    if (detect === undefined || holding.disabled.has(exemptionClass)) {
+    if (detect === undefined || disabled.has(exemptionClass)) {
       continue;
     }
     const allowed = typescriptVisibilityOf(exemptionClass);
@@ -200,17 +211,26 @@ export function detectExemptions<Brand>(
       if (!retainable(allowed, visibility.get(evidence.id))) {
         continue;
       }
-      const record = {
+      found.push({
         id: evidence.id,
         class: exemptionClass,
         detail: evidence.detail,
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
-      };
-      if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-        inTestFiles.push(record);
-        continue;
-      }
+      });
+    }
+  }
+  return found;
+}
+
+/** The records that hold under one mode, beside the evidence a production mode found in a test file. */
+export function heldRecords(records: readonly Exemption[], holding: Holding): Detected {
+  const found: Exemption[] = [];
+  const inTestFiles: Exemption[] = [];
+  for (const record of records) {
+    if (holding.mode.production && holding.testFiles.has(record.site.path)) {
+      inTestFiles.push(record);
+    } else {
       found.push(record);
     }
   }

package/src/file-facts.ts

@@ -65,13 +65,11 @@ function lastLine(text: string): number {
 }
 
 /**
- * Every source file below the target root, in path order. A directory that cannot be
- * read is skipped, as discovery skips it, and a file that cannot be read is skipped
- * with it: a tree the analysis may not enter holds no file it can report.
+ * The path below the target root of every source file there, in path order. A directory
+ * that cannot be read is skipped, as discovery skips it.
  */
-export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[] {
-  const scopeOf = packageScope(host, targetRoot);
-  const found: TreeFile[] = [];
+export function sourcePaths(host: Host, targetRoot: string): readonly string[] {
+  const found: string[] = [];
   const pending = [""];
   for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
     let entries: readonly { readonly name: string; readonly directory: boolean }[];
@@ -88,23 +86,29 @@ export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[]
         }
         continue;
       }
-      if (!SOURCE_FILE.test(entry.name) || DECLARATION_FILE.test(entry.name)) {
-        continue;
+      if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
+        found.push(path);
       }
-      let text: string;
-      try {
-        text = host.readFile(joinPath(targetRoot, path));
-      } catch {
-        continue;
-      }
-      found.push({
-        path,
-        ref: renderRef(scopeOf(path), { of: "module" }),
-        endLine: lastLine(text),
-      });
     }
   }
-  return found.sort((a, b) => (a.path < b.path ? -1 : 1));
+  return found.sort((a, b) => (a < b ? -1 : 1));
+}
+
+/**
+ * Every source file below the target root, in path order. A file that cannot be read is
+ * skipped: a tree the analysis may not enter holds no file it can report.
+ */
+export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[] {
+  const scopeOf = packageScope(host, targetRoot);
+  return sourcePaths(host, targetRoot).flatMap((path) => {
+    let text: string;
+    try {
+      text = host.readFile(joinPath(targetRoot, path));
+    } catch {
+      return [];
+    }
+    return [{ path, ref: renderRef(scopeOf(path), { of: "module" }), endLine: lastLine(text) }];
+  });
 }
 
 /** Whether one file changes what the program sees by being included in it. */

package/src/graph.ts

@@ -122,9 +122,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 +167,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/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/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";
@@ -205,3 +204,40 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     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")),
+    }));
+  });
+}