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

package/src/convention-rows.ts

@@ -45,6 +45,24 @@ export interface HelperReading extends MoveReading {
   readonly package: string;
 }
 
+/** One member of a configuration file whose strings name the packages its tool loads. */
+export interface PackageKey {
+  /** The member's name, matched at any depth of the objects the row reads. */
+  readonly key: string;
+  /** Globs naming the configuration files, matched in the manifest's directory alone. */
+  readonly files: readonly string[];
+}
+
+/** One configuration property whose strings name files the test runner loads beside the tests. */
+export interface TestFileReading extends MoveReading {
+  /**
+   * The properties that move the directory the strings are read against, the first one the
+   * file writes deciding, read against the manifest's directory, which stands where none is
+   * written. A value that is not one string literal leaves the file's strings unread.
+   */
+  readonly roots: readonly string[];
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -83,6 +101,13 @@ export interface ConventionRow {
    * string there names no file the tool runs or loads.
    */
   readonly selections?: readonly MoveReading[];
+  /** The properties whose strings name a file the test runner loads beside the tests, a test file. */
+  readonly testFiles?: readonly TestFileReading[];
+  /**
+   * The members whose strings name a package the tool loads: the package itself, a
+   * subpath of it, or the package followed by `:` and a name.
+   */
+  readonly packageKeys?: readonly PackageKey[];
   /** The members of a `package.json` the tool reads its configuration from. */
   readonly manifestKeys?: readonly string[];
   /** The settings that make the tool's output import a runtime helper package. */
@@ -131,8 +156,46 @@ const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 
+/**
+ * The properties Vitest takes its project root from, `test.root` before Vite's `root`; it
+ * resolves `setupFiles` against that root (https://vitest.dev/config/setupfiles).
+ */
+const VITEST_ROOTS = ["test.root", "root"] as const;
+
+/** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
+const ANGULAR_ENTRIES = [
+  "src/{main,main.server,server,polyfills,test}.ts",
+  "server.ts",
+  "projects/*/src/{main,main.server,server,polyfills,test,public-api}.ts",
+  "projects/*/server.ts",
+];
+
+/** The `angular.json` members whose strings name the packages a build loads. */
+const ANGULAR_PACKAGE_KEYS: readonly PackageKey[] = [
+  "builder",
+  "polyfills",
+  "styles",
+  "scripts",
+].map((key) => ({ key, files: ["angular.json"] }));
+
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS: readonly ConventionRow[] = [
+  {
+    name: "angular",
+    package: "@angular/build",
+    range: ">=17.0.0 <22.0.0",
+    entries: ANGULAR_ENTRIES,
+    moves: [],
+    packageKeys: ANGULAR_PACKAGE_KEYS,
+  },
+  {
+    name: "angular-devkit",
+    package: "@angular-devkit/build-angular",
+    range: ">=12.0.0 <22.0.0",
+    entries: ANGULAR_ENTRIES,
+    moves: [],
+    packageKeys: ANGULAR_PACKAGE_KEYS,
+  },
   {
     name: "astro",
     package: "astro",
@@ -564,6 +627,18 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "vitepress",
+    package: "vitepress",
+    range: ">=1.0.0 <2.0.0-0 || >=2.0.0-alpha.0 <3.0.0",
+    entries: [
+      `.vitepress/config.${ANY_MODULE}`,
+      `.vitepress/theme/index.${ANY_MODULE}`,
+      `**/*.data.${ANY_MODULE}`,
+      "**/*.vue",
+    ],
+    moves: [],
+  },
   {
     name: "vitest",
     package: "vitest",
@@ -585,5 +660,6 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       { property: "test.coverage.include", files: [VITEST_CONFIG] },
       { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
     ],
+    testFiles: [{ property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS }],
   },
 ];

package/src/conventions.ts

@@ -53,7 +53,9 @@ import {
   type HelperReading,
   type MoveReading,
   type OptionsCall,
+  type PackageKey,
   type ShortNameReading,
+  type TestFileReading,
 } from "./convention-rows.ts";
 import { documentStrings } from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
@@ -118,6 +120,8 @@ export interface Conventions {
   readonly uses: readonly string[];
   /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
   readonly selected: ReadonlyMap<string, Selected>;
+  /** The files, absolute, an applied row's test-file properties name. */
+  readonly testFiles: ReadonlySet<string>;
 }
 
 /** The strings one configuration file holds at selection keys, which root no file. */
@@ -607,6 +611,43 @@ function holdsValue(held: Node, value: true | string): boolean {
   );
 }
 
+/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
+function testFileRoot(file: SourceFile, dir: string, reading: TestFileReading): string | undefined {
+  for (const property of reading.roots) {
+    const values = valuesAt(file, property, reading.call);
+    if (values.length > 0) {
+      const texts = new Set(values.map(literalText));
+      const [text] = texts;
+      return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
+    }
+  }
+  return dir;
+}
+
+/** The files an applied row's test-file properties name. */
+function testFilesNamed(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  readings: readonly TestFileReading[],
+  into: Set<string>,
+): void {
+  for (const reading of readings) {
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      const at = testFileRoot(file, dir, reading);
+      if (at === undefined) {
+        continue;
+      }
+      for (const node of stringsAt(file, reading.property, reading.call)) {
+        const text = literalText(node);
+        if (text !== undefined && text !== "") {
+          into.add(resolvePath(at, text));
+        }
+      }
+    }
+  }
+}
+
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(
   host: Host,
@@ -873,6 +914,60 @@ function helperUses(
     .map((reading) => reading.package);
 }
 
+/**
+ * The dependencies one manifest declares that an applied row's package keys use: each
+ * whose name a string under a member of a key's name equals, or begins followed by `/` or
+ * by `:` and a name. A member's own name is no such string.
+ */
+function packageKeyUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  keys: readonly PackageKey[],
+): readonly string[] {
+  const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
+    const held = isRecord(manifest) ? manifest[section] : undefined;
+    return isRecord(held) ? Object.keys(held) : [];
+  });
+  const strings: string[] = [];
+  const collect = (node: Node): void => {
+    const text = literalText(node);
+    if (text !== undefined) {
+      strings.push(text);
+    } else if (isPropertyAssignment(node)) {
+      collect(node.initializer);
+    } else {
+      node.forEachChild(collect);
+    }
+  };
+  for (const { key, files } of keys) {
+    const visit = (node: Node): void => {
+      if (isPropertyAssignment(node) && keyOf(node) === key) {
+        collect(node.initializer);
+      }
+      node.forEachChild(visit);
+    };
+    for (const { file } of readingFiles(host, parse, dir, files)) {
+      const values = declaredValues(file);
+      for (const one of defaultExports(file)) {
+        const object = objectOf(one, values, true);
+        if (object !== undefined) {
+          visit(object);
+        }
+      }
+    }
+  }
+  return declared.filter((name) =>
+    strings.some(
+      (text) =>
+        text === name ||
+        text.startsWith(`${name}/`) ||
+        (text.startsWith(`${name}:`) && text.length > name.length + 1),
+    ),
+  );
+}
+
 /** Two strings ordered bytewise. */
 function compare(a: string, b: string): number {
   if (a === b) {
@@ -898,6 +993,7 @@ export function readConventions(
   const failures: ConventionFailure[] = [];
   const uses = new Set<string>();
   const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
+  const testFiles = new Set<string>();
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
     const versions = new Map<string, string | undefined>();
@@ -959,6 +1055,10 @@ export function readConventions(
       for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
         uses.add(name);
       }
+      const keys = row.packageKeys ?? [];
+      for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
+        uses.add(name);
+      }
       for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
         uses.add(name);
       }
@@ -966,6 +1066,7 @@ export function readConventions(
         uses.add(name);
       }
       selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
+      testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -996,6 +1097,7 @@ export function readConventions(
     failures,
     uses: [...uses].sort(compare),
     selected,
+    testFiles,
   };
 }
 

package/src/dependencies.ts

@@ -1,19 +1,22 @@
 /**
- * The dependencies the target's manifest and its workspace members' manifests declare, and
- * what the projects' own files need from outside the target. A file needs a package it
- * imports, re-exports from, augments or references the types of, by name or through the
- * file the specifier resolves to; a compiler configuration needs one it names, and a
- * configuration file a tool loads needs each dependency its strings spell. A package one
- * dependency pulls in for itself is that dependency's need, not the target's.
+ * The dependencies the target's manifest and its workspace members' manifests declare, and what the
+ * projects' own files need from outside the target. A file needs a package it imports, re-exports
+ * from, augments, references the types of or asks the runtime to resolve, by name or through the
+ * file the specifier resolves to; a compiler configuration needs one it names, and a configuration
+ * file a tool loads needs each dependency its strings spell. A package one dependency pulls in for
+ * itself is that dependency's need, not the target's.
  */
 
 import {
+  isCallExpression,
   isExportDeclaration,
   isExternalModuleReference,
   isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
+  isMetaProperty,
   isNamespaceExport,
+  isPropertyAccessExpression,
   isShorthandPropertyAssignment,
   isStringLiteral,
   isNoSubstitutionTemplateLiteral,
@@ -32,11 +35,13 @@ import {
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
+import { scriptTokens } from "./manifest.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
+import { workflowTokens } from "./workflow-steps.ts";
 
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
@@ -54,7 +59,7 @@ const SECTIONS: readonly (readonly [string, DependencySection])[] = [
 const PROJECT_OWNER = "";
 
 /** One dependency a manifest the run reads declares. */
-export interface DeclaredDependency {
+interface DeclaredDependency {
   readonly name: string;
   readonly section: DependencySection;
   /** Where the manifest writes the dependency's key, below the target root. */
@@ -68,16 +73,14 @@ export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
   return {
     packages: new Set(packages),
     uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
-    unanswered: false,
+    unanswered: [],
   };
 }
 
 /** What the installed copy of one declared dependency states about itself. */
-export interface InstalledDependency {
-  /** Whether its manifest declares a command. */
-  readonly command: boolean;
-  /** The peer dependencies its manifest requires: every peer not marked optional. */
-  readonly peers: readonly string[];
+interface InstalledDependency {
+  /** The commands its manifest's `bin` declares, by name. */
+  readonly commands: readonly string[];
 }
 
 /** What one project's own files and configuration need from outside the target. */
@@ -91,20 +94,29 @@ export interface ProjectNeeds {
    */
   readonly uses: ReadonlyMap<string, ReadonlySet<string>>;
   /**
-   * Whether the checker left a module specifier unanswered, so the project may use any
-   * dependency the manifest declares.
+   * The files writing a module specifier the checker left unanswered, each of which may
+   * use any dependency a manifest at or above it declares.
    */
-  readonly unanswered: boolean;
+  readonly unanswered: readonly string[];
 }
 
 /** The run's dependency evidence. */
 export interface Dependencies {
   /** Every declared dependency, manifest by manifest, in the order each writes them. */
   readonly declared: readonly DeclaredDependency[];
-  /** The installed copy of each declared dependency the run found, by name. */
-  readonly installed: ReadonlyMap<string, InstalledDependency>;
   /** Every package some project needs. */
   readonly needed: ReadonlySet<string>;
+  /**
+   * The declared dependencies whose command a script entry of the manifest declaring them,
+   * or a workflow step for the target's manifest, runs, each by {@link declarationKey}.
+   */
+  readonly ran: ReadonlySet<string>;
+  /**
+   * The manifests, by their path below the target root, whose directory holds source only
+   * in configurations the run could not build, so a dependency they declare that nothing
+   * needs is reported at `possible`.
+   */
+  readonly unbuilt: ReadonlySet<string>;
   /**
    * Per deletion candidate, the declared dependencies whose last use in the target is
    * written inside it, sorted bytewise; a candidate holding no last use has no entry.
@@ -325,9 +337,11 @@ export function projectNeeds<Brand>(
   };
   use([PROJECT_OWNER], packages);
 
-  let unanswered = false;
+  const unanswered: string[] = [];
   for (const file of project.ownSourceFiles()) {
-    unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
+    if (fileNeeds(project, held, file, programPackages, use)) {
+      unanswered.push(file.fileName);
+    }
   }
 
   const beside = new Map<string, readonly string[]>();
@@ -352,16 +366,20 @@ export function projectNeeds<Brand>(
       use(ownersOf(file, held, node), dependenciesNamed(text, names));
     }
   }
-  for (const document of configuration.documents) {
-    const names = declaredAt(document.path);
-    for (const text of document.strings) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  for (const { strings, manifestDirs } of configuration.documents) {
+    for (const manifestDir of manifestDirs) {
+      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      for (const text of strings) {
+        use([PROJECT_OWNER], dependenciesNamed(text, names));
+      }
     }
   }
-  for (const { file, manifestDir } of configuration.outside) {
-    const names = declaredAt(joinPath(manifestDir, "package.json"));
-    for (const { text } of moduleStrings(file)) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  for (const { file, manifestDirs } of configuration.outside) {
+    for (const manifestDir of manifestDirs) {
+      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      for (const { text } of moduleStrings(file)) {
+        use([PROJECT_OWNER], dependenciesNamed(text, names));
+      }
     }
   }
   return { packages, uses, unanswered };
@@ -491,9 +509,43 @@ function fileNeeds<Brand>(
   for (const reference of file.typeReferenceDirectives) {
     use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
   }
+  for (const specifier of resolvedSpecifiers(file)) {
+    const named = packageOfSpecifier(specifier.text);
+    if (named !== undefined) {
+      use(ownersOf(file, held, specifier), [named]);
+    }
+  }
   return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 
+/**
+ * The literal specifiers one file asks the runtime to resolve, through `import.meta.resolve`
+ * or `require.resolve`, each of which needs the package it names installed.
+ */
+function resolvedSpecifiers(file: SourceFile): readonly Texted[] {
+  const found: Texted[] = [];
+  if (!file.text.includes(".resolve(")) {
+    return found;
+  }
+  const visit = (node: Node): void => {
+    if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
+      const callee = node.expression;
+      const [argument] = node.arguments;
+      const receiver = callee.expression;
+      const resolving =
+        callee.name.text === "resolve" &&
+        ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
+          (isIdentifier(receiver) && receiver.text === "require"));
+      if (resolving && argument !== undefined && isLiteralText(argument)) {
+        found.push(argument);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  visit(file);
+  return found;
+}
+
 /** The offset just past the JSON value that starts at `at` in text the parser has accepted. */
 function valueEnd(text: string, at: number): number {
   const first = text.charAt(at);
@@ -585,21 +637,17 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
   for (let dir = root; ; dir = dirnamePath(dir)) {
     const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
     if (read !== undefined && isRecord(read.value)) {
-      const manifest = read.value;
-      const bin = manifest["bin"];
-      const peers = manifest["peerDependencies"];
-      const meta = isRecord(manifest["peerDependenciesMeta"])
-        ? manifest["peerDependenciesMeta"]
-        : {};
+      const bin = read.value["bin"];
+      // A string `bin` names one command, the package's name without its scope.
       return {
-        command:
-          (typeof bin === "string" && bin !== "") || (isRecord(bin) && Object.keys(bin).length > 0),
-        peers: isRecord(peers)
-          ? Object.keys(peers).filter((peer) => {
-              const about = meta[peer];
-              return !(isRecord(about) && about["optional"] === true);
-            })
-          : [],
+        commands:
+          typeof bin === "string"
+            ? bin === ""
+              ? []
+              : [name.slice(name.indexOf("/") + 1)]
+            : isRecord(bin)
+              ? Object.keys(bin)
+              : [],
       };
     }
     if (dirnamePath(dir) === dir) {
@@ -639,12 +687,37 @@ function declaredIn(
   return declared.sort((a, b) => a.at - b.at).map(({ dependency }) => dependency);
 }
 
+/** The key one declared dependency is known by: its manifest's path and its name. */
+export function declarationKey(dependency: DeclaredDependency): string {
+  return `${dependency.position.path}\u0000${dependency.name}`;
+}
+
+/** Every token of every value of one manifest's `scripts` member. */
+function scriptTokensOf(manifest: Record<string, unknown>): ReadonlySet<string> {
+  const scripts = manifest["scripts"];
+  const found = new Set<string>();
+  if (isRecord(scripts)) {
+    for (const command of Object.values(scripts)) {
+      if (typeof command === "string") {
+        scriptTokens(command).forEach((token) => found.add(token));
+      }
+    }
+  }
+  return found;
+}
+
+/** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
+function isInside(path: string, dir: string): boolean {
+  return dir === "" || path.startsWith(`${dir}/`);
+}
+
 /**
  * The run's dependency evidence: the target's manifest and each workspace member's in
  * `members` below the target root, read with the position of every dependency each
- * declares, the installed copy of each found from its manifest's directory, what the
- * projects need, and the last uses each deletion candidate holds. A manifest the
- * program cannot read declares nothing.
+ * declares, what the projects and the commands its scripts and workflow steps run need,
+ * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
+ * in configurations the run could not build. A manifest the program cannot read declares
+ * nothing.
  */
 export function dependenciesOf(
   host: Host,
@@ -652,30 +725,43 @@ export function dependenciesOf(
   perProject: readonly ProjectNeeds[],
   candidates: readonly string[],
   members: readonly string[] = [],
+  unbuiltMembers: readonly string[] = [],
 ): Dependencies {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const scopeOf = packageScope(host, targetRoot);
   const manifests = new Map<string, string>([[root, MANIFEST]]);
-  for (const dir of members) {
+  const unbuilt = new Set<string>();
+  for (const dir of [...members, ...unbuiltMembers]) {
     const below = relativePath(root, dir);
     if (below !== undefined && !manifests.has(dir)) {
       manifests.set(dir, `${below}/${MANIFEST}`);
     }
   }
+  for (const dir of unbuiltMembers) {
+    const path = manifests.get(dir);
+    if (path !== undefined && dir !== root) {
+      unbuilt.add(path);
+    }
+  }
+  const workflow = new Set(workflowTokens(host, targetRoot));
   const declared: DeclaredDependency[] = [];
-  const installed = new Map<string, InstalledDependency>();
+  const ran = new Set<string>();
   for (const [dir, path] of manifests) {
     const read = readJSON(host, joinPath(dir, MANIFEST));
     if (read === undefined || !isRecord(read.value)) {
       continue;
     }
+    const tokens = scriptTokensOf(read.value);
     for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
       declared.push(dependency);
-      if (!installed.has(dependency.name)) {
-        const found = installedOf(host, dir, dependency.name);
-        if (found !== undefined) {
-          installed.set(dependency.name, found);
-        }
+      const found = installedOf(host, dir, dependency.name);
+      if (found === undefined) {
+        continue;
+      }
+      const runs = (command: string): boolean =>
+        tokens.has(command) || (dir === root && workflow.has(command));
+      if (found.commands.some(runs)) {
+        ran.add(declarationKey(dependency));
       }
     }
   }
@@ -685,9 +771,15 @@ export function dependenciesOf(
   const needed = new Set<string>();
   const uses = new Map<string, Set<string>>();
   for (const project of perProject) {
-    // A specifier the checker left unanswered may resolve to any declared dependency,
-    // and what the configuration needs is never deleted, so it is needed there.
-    const unknown = project.unanswered ? declared.map((dependency) => dependency.name) : [];
+    // A specifier the checker left unanswered may resolve to any dependency a manifest at
+    // or above its file declares, and what the configuration needs is never deleted.
+    const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
+    const unknown = declared
+      .filter((dependency) => {
+        const dir = dirnamePath(dependency.position.path);
+        return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
+      })
+      .map((dependency) => dependency.name);
     const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)] as const];
     for (const [id, used] of [...project.uses, ...held]) {
       const merged = uses.get(id) ?? new Set<string>();
@@ -711,5 +803,5 @@ export function dependenciesOf(
       );
     }
   }
-  return { declared, installed, needed, lastUses };
+  return { declared, needed, ran, unbuilt, lastUses };
 }

package/src/discover.ts

@@ -34,7 +34,7 @@ export class DiscoveryError extends Error {
 const ERROR_CATEGORY: number = DiagnosticCategory.Error;
 
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic: Diagnostic): boolean {
+function isError(diagnostic: Diagnostic): boolean {
   return diagnostic.category === ERROR_CATEGORY;
 }
 
@@ -113,7 +113,7 @@ export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
 }
 
 /** One project a run analyzes. */
-export interface DiscoveredProject {
+interface DiscoveredProject {
   /**
    * The name a run gives the project: the identifier the build matrix declares for
    * it, or, for a project discovery derived, its configuration file's path below the
@@ -162,7 +162,7 @@ export function isGuess(discovery: Discovery, configFile: string): boolean {
 }
 
 /** Every project discovery found, and where each came from. */
-export interface Discovery {
+interface Discovery {
   /** The projects, in discovery order, each once. */
   readonly projects: readonly DiscoveredProject[];
   /**

package/src/edges.ts

@@ -39,7 +39,7 @@ const REFERENCE_WANT =
   "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
   constructor(at: string, text: string, want: string) {
     super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
     this.name = "EdgesError";
@@ -174,7 +174,7 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
 }
 
 /** One side's verdict, as an evaluation names it. */
-export type EdgeState = "live" | "dead" | "absent";
+type EdgeState = "live" | "dead" | "absent";
 
 /** One edge evaluation: one side of this language, its state, and the finding it holds. */
 export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
@@ -184,7 +184,7 @@ export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
 }
 
 /** The findings a report publishes, and one evaluation per declared side of this language. */
-export interface Evaluated<F extends Finding> {
+interface Evaluated<F extends Finding> {
   readonly findings: readonly F[];
   /** Ordered by edge, then by side, each compared bytewise. */
   readonly evaluations: readonly EdgeEvaluation<F>[];

package/src/entry-points.ts

@@ -64,7 +64,7 @@ export type EntryRule =
   | "workflow-step";
 
 /** One file a rule enters. */
-export interface EntryPoint {
+interface EntryPoint {
   readonly file: SourceFile;
   readonly rule: EntryRule;
   /**