@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/analysis.ts

@@ -6,14 +6,10 @@
  * another project's checker, which holds only for views the session hands out.
  */
 
+import { isStringLiteralLikeNode, type SourceFile } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.ts";
-import { kindOf, type Config, type Provenance } from "./config.ts";
-import {
-  consumerLoads,
-  consumerReferences,
-  moduleIdentity,
-  type LoadedConsumer,
-} from "./consumers.ts";
+import { kindOf, type PartialConfig, type Provenance, type ResolvedConfig } from "./config.ts";
+import { consumerReferences } from "./consumers.ts";
 import {
   configuredDeclarations,
   configuredRef,
@@ -22,24 +18,10 @@ import {
 import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
-import {
-  discoverProjects,
-  DiscoveryError,
-  isGuess,
-  projectErrors,
-  renderDiagnostic,
-  targetRelative,
-  type LocatedDiagnostic,
-  type NotBuilt,
-} from "./discover.ts";
-import {
-  conventionFailuresFor,
-  generatedFiles,
-  readConventions,
-  type AppliedConvention,
-  type ConventionManifest,
-  type Conventions,
-} from "./conventions.ts";
+import { moduleIdentity, type LoadedConsumer, type NotBuilt } from "./load/discover.ts";
+import type { LibraryUnfound } from "./load/classify.ts";
+import { loadRun, type LoadedRun } from "./load/load.ts";
+import { generatedFiles, type AppliedConvention } from "./conventions.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
 import { generatedFile, generatedFilesOf } from "./generated-file.ts";
@@ -53,12 +35,12 @@ import {
   holdingWhile,
   isUnansweredRecord,
   retainedIn,
+  writtenRecords,
   type Detector,
   type Detectors,
 } from "./exempt.ts";
 import type { TSExemptionClass } from "./exempt-classes.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";
@@ -70,7 +52,7 @@ import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { packageEntries, readManifest } from "./manifest.ts";
+import { readManifest, type ManifestEntry } from "./manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -81,53 +63,46 @@ import {
   type SweepResult,
 } from "./matrix.ts";
 import {
+  ancestors,
   dirnamePath,
   extensionOf,
   joinPath,
-  normalizePath,
   relativePath,
   resolvePath,
 } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
-import { LANGUAGE, type TypeErrorSkip, type UnansweredCount } from "./report.ts";
-import { SetupError, setupLine, type SetupFailure } from "./setup-failure.ts";
-import {
-  pathsOf,
-  readErrors,
-  skippedRoots,
-  skippedUnits,
-  type SkippedUnit,
-} from "./type-errors.ts";
+import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
+import { skippedRoots, skippedUnits, type SkippedUnit } from "./type-errors.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
 import {
   roots,
   unmatchedEverywhere,
+  type Root,
   type RootKind,
-  type RootOptions,
   type Roots,
+  type HeldScripts,
 } from "./roots.ts";
 import type { Scope } from "./scope.ts";
-import { serializationContract } from "./serialization-contract.ts";
+import { decodedMembers, serializationContract, type Decoded } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
-import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
-import { supportReferences, testSupportFiles } from "./test-support.ts";
-import {
-  diagnosticsOf,
-  ownedAs,
-  runSession,
-  type Engine,
-  type OpenedFiles,
-  type ProjectView,
-} from "./session.ts";
+import { mergedGlobalInterfaces } from "./augmentations.ts";
+import { unseenLoadsOf, type UnseenLoad } from "./unseen-loads.ts";
+import type { UnresolvedSpecifier } from "./load/specifiers.ts";
+import type { UnreadInput } from "./load/plan.ts";
+import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.ts";
+import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
+import type { Engine, ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
 import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } from "./suppress.ts";
 import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
 import { inlineDirectives, inlineSuppressions, type InlineDirective } from "./suppress-inline.ts";
 import type { Exemption, Mode, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
-import { ownErrors, workspaceRun } from "./workspace-run.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest, manifestAt } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -184,14 +159,6 @@ function documentOf(
   return relativePath(resolvePath(host.workingDirectory(), targetRoot), document) ?? "";
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** What every stage after the root set reads of one project. */
 interface ProjectRead {
   readonly configuration: string;
@@ -221,304 +188,52 @@ interface OpenedProject {
   readonly read: () => ProjectRead;
 }
 
-/** What a run read of the consumers its scope declares. */
-interface ConsumerReads {
-  /** Every declared consumer, each loaded, in the scope's order. */
-  readonly loaded: readonly LoadedConsumer[];
+/** What reading a loaded run's projects answered. */
+interface ProjectsRead<Answer> {
+  readonly answers: readonly Answer[];
   /** Every reference a consumer makes to a declaration of the target, each once. */
   readonly references: readonly Reference[];
-}
-
-/** What a run read of its projects: each target project's answer, and its consumers. */
-interface ReadProjects<Answer> {
-  readonly answers: readonly Answer[];
-  readonly consumers: ConsumerReads;
-  /** The derived configurations the run dropped, in the order it met them. */
-  readonly notBuilt: readonly NotBuilt[];
-  /** Every question the checker could not answer, each once. */
-  readonly unanswered: readonly UnansweredQuestion[];
-  /** Per configuration whose component files the run cannot read, the reason. */
-  readonly componentsUnread: readonly ComponentsUnread[];
-  /** Per analyzed configuration, each library it names that the compiler cannot find. */
-  readonly librariesUnfound: readonly LibraryUnfound[];
-  /** The convention rows the run applied. */
-  readonly conventionsApplied: readonly AppliedConvention[];
-  /** The dependencies the applied rows' short names use. */
-  readonly conventionUses: readonly string[];
-  /** The directory of every workspace member, absolute. */
-  readonly memberDirs: readonly string[];
-  /** The directory of every nested package, absolute. */
-  readonly nestedDirs: readonly string[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
 }
 
 /**
- * The manifests the analysis reads, each once: the target's own, then every workspace
- * member's and every nested package's below the target root.
- */
-function conventionManifests(
-  host: Host,
-  targetRoot: string,
-  memberDirs: readonly string[],
-  nestedDirs: readonly string[],
-): readonly ConventionManifest[] {
-  const found = new Map<string, ConventionManifest>();
-  if (host.kindOf(joinPath(targetRoot, "package.json")) === "file") {
-    found.set(targetRoot, { dir: targetRoot, path: "package.json" });
-  }
-  for (const [dirs, nested] of [
-    [memberDirs, false],
-    [nestedDirs, true],
-  ] as const) {
-    for (const dir of dirs) {
-      const below = relativePath(targetRoot, dir);
-      if (below !== undefined && !found.has(dir)) {
-        found.set(dir, { dir, path: `${below}/package.json`, nested });
-      }
-    }
-  }
-  return [...found.values()];
-}
-
-/**
- * The nested packages of a run: each directory below the target root, in no `node_modules`
- * directory and none of `known`, that holds a `package.json` and lies at or above one of
- * `files`, the program's source files and the compiler configuration files, in path order.
- */
-function nestedPackageDirs(
-  host: Host,
-  targetRoot: string,
-  files: Iterable<string>,
-  known: ReadonlySet<string>,
-): readonly string[] {
-  const seen = new Set<string>();
-  const found: string[] = [];
-  for (const file of files) {
-    for (
-      let dir = dirnamePath(file);
-      dir !== targetRoot && !seen.has(dir) && relativePath(targetRoot, dir) !== undefined;
-      dir = dirnamePath(dir)
-    ) {
-      seen.add(dir);
-      const below = relativePath(targetRoot, dir) ?? "";
-      if (
-        !below.split("/").includes("node_modules") &&
-        !known.has(dir) &&
-        host.kindOf(joinPath(dir, "package.json")) === "file"
-      ) {
-        found.push(dir);
-      }
-    }
-  }
-  return found.sort(compare);
-}
-
-/**
- * Reads every project the scope discovers, and each declared consumer's, in one snapshot,
- * each checked for errors first. `stage` is handed a target project and enumerates and roots
- * it if it reads it; a consumer project is read for its references to the target. A type error
- * in an own file skips the unit holding it. A guess that does not load or meets a setup failure
- * is dropped into `notBuilt` (see {@link isGuess}); any other such project fails the run, as
- * does a run whose every guess was dropped.
+ * Reads every project the load phase analyzes through `stage`, which enumerates and roots one
+ * if it reads it, and each declared consumer's project for its references to the target,
+ * in the same snapshot. A type error in an own file skips the unit holding it.
  */
 function readProjects<Answer>(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: PartialConfig,
   stage: <Brand>(project: ProjectView<Brand>, opened: OpenedProject) => Answer,
-): ReadProjects<Answer> {
+): LoadedRun<ProjectsRead<Answer>> {
   const targetRoot = scope.target.path;
-  const discovered = discoverProjects(engine, host, scope, config.analysis.configurations);
-  if (discovered.configFiles.length === 0 && discovered.notBuilt.length === 0) {
-    throw new DiscoveryError(
-      `${targetRoot} holds no compiler configuration, so the run holds no program`,
-      [],
-    );
-  }
-  const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
-  const loads = consumerLoads(engine, host, scope, discovered.configFiles);
-  const consumerOf = new Map(
-    loads.flatMap((load) =>
-      load.configFiles.map((configFile) => [configFile, load.consumer] as const),
-    ),
-  );
   const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
-  const workspace = workspaceRun(
-    engine,
-    host,
-    absoluteRoot,
-    discovered.configFiles,
-    readManifest(host, targetRoot),
-  );
+  const testPatterns = config.ts.test_files.map(globExpression);
   const parse = (fileName: string, text: string) => engine.parseSourceFile(fileName, text);
-  const memberDirs = workspace?.memberDirs ?? [];
-  // The nested packages are known only once every program is open, and every visit reads
-  // the conventions and options they decide, so both are set in the session's first step.
-  let nestedDirs: readonly string[] = [];
-  let conventions = readConventions(host, parse, [], config.ts.disabledConventions);
-  let options: RootOptions & { readonly parse: typeof parse; readonly conventions: Conventions };
-  const readManifests = (opened: readonly OpenedFiles[]): void => {
-    nestedDirs = nestedPackageDirs(
-      host,
-      normalizePath(absoluteRoot),
-      opened
-        .filter((one) => !consumerOf.has(one.configFile))
-        .flatMap((one) => [one.configFile, ...one.fileNames()]),
-      new Set(memberDirs),
-    );
-    conventions = readConventions(
-      host,
-      parse,
-      conventionManifests(host, absoluteRoot, memberDirs, nestedDirs),
-      config.ts.disabledConventions,
-    );
-    options = {
+  return loadRun(engine, host, scope, config, ({ plan, classified, runFiles }) => {
+    const { packages, conventions } = plan;
+    const options = {
       host,
-      manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-      otherPackages: [
-        ...(workspace?.entries ?? []),
-        ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
-      ],
-      patterns: config.rootPatterns,
-      entryFiles: config.ts.entryFiles,
+      manifest: packages.manifest,
+      otherPackages: packages.entries,
+      patterns: config.roots.patterns,
+      entryFiles: config.ts.entry_files,
       conventions,
-      testFiles: config.ts.testFiles,
+      testFiles: config.ts.test_files,
       parse,
-      publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
-      publishedMembers: new Set(
-        (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
-      ),
+      publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
+      publishedMembers: packages.published,
+      runFiles,
     };
-  };
-  const notBuilt: NotBuilt[] = [...discovered.notBuilt];
-  const dropped = (configFile: string, error: string): void => {
-    notBuilt.push({
-      id: ids.get(configFile) ?? configFile,
-      configFile,
-      error: targetRelative(error, absoluteRoot),
-    });
-  };
-  const failures: LocatedDiagnostic[] = [];
-  const unbuildable: SetupFailure[] = [];
-  const setupDropped: SetupFailure[] = [];
-  const librariesUnfound: LibraryUnfound[] = [];
-  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)) {
-      dropped(configFile, setupLine(first));
-      setupDropped.push(...met);
-    } else {
-      unbuildable.push(...met);
-    }
-  };
-  const testPatterns = config.ts.testFiles.map(globExpression);
-  const joins = discovered.derived
-    ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
-    : new Map<string, readonly string[]>();
-  const session = runSession(
-    engine,
-    [...discovered.configFiles, ...consumerOf.keys()],
-    (opened) => {
-      const consumer = consumerOf.get(opened.configFile);
-      const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
-      if (setup !== undefined) {
-        setupMet(opened.configFile, [
-          { setupClass: "workspace-member-without-source", detail: setup },
-        ]);
-        return undefined;
-      }
-      const referenceOnly =
-        workspace === undefined || consumer !== undefined
-          ? () => false
-          : workspace.referenceOnly(opened.configFile, opened.rootFiles);
-      const project =
-        workspace === undefined || consumer !== undefined
-          ? opened
-          : ownedAs(opened, (file, fromExternalLibrary) =>
-              workspace.ownFile(file, fromExternalLibrary),
-            );
-      const raw = projectErrors(diagnosticsOf(project));
-      const errors = { load: raw.load, check: ownErrors(raw.check, referenceOnly) };
-      const [unloaded] = errors.load;
-      if (
-        unloaded !== undefined &&
-        consumer === undefined &&
-        isGuess(discovered, project.configFile)
-      ) {
-        dropped(
-          project.configFile,
-          renderDiagnostic(unloaded, (path) => relativePath(absoluteRoot, path) ?? path),
-        );
-        return undefined;
-      }
-      if (errors.load.length > 0) {
-        failures.push(...errors.load);
-        return undefined;
-      }
-      const reading = readErrors(project, errors.check, {
-        host,
-        targetRoot:
-          consumer === undefined
-            ? absoluteRoot
-            : resolvePath(host.workingDirectory(), consumer.path),
-        paths: pathsOf(engine, project.configFile),
-      });
-      if (consumer !== undefined && reading.missing.length > 0) {
-        unbuildable.push(
-          ...reading.missing.map((one) => ({
-            setupClass: "missing-consumer" as const,
-            detail: `the consumer ${consumer.path} does not build, its dependencies not installed: ${one.detail}`,
-          })),
-        );
-        return undefined;
-      }
-      if (reading.missing.length > 0) {
-        setupMet(project.configFile, reading.missing);
-        return undefined;
-      }
-      const unconventional =
-        consumer === undefined
-          ? conventionFailuresFor(
-              conventions,
-              project.configFile,
-              project.ownSourceFiles().map((file) => file.fileName),
-            )
-          : [];
-      if (unconventional.length > 0) {
-        setupMet(project.configFile, unconventional);
-        return undefined;
-      }
-      if (consumer !== undefined) {
-        for (const reference of consumerReferences(
-          project,
-          host,
-          targetRoot,
-          {
-            id: consumer.id,
-            root: consumer.path,
-          },
-          config,
-        )) {
-          consumed.set(referenceKey(reference), reference);
-        }
-        return undefined;
-      }
-      librariesUnfound.push(
-        ...raw.unfound.map((one) => ({
-          configFile: project.configFile,
-          error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
-        })),
-      );
-      const configuration = ids.get(project.configFile) ?? project.configFile;
+    const heldFiles = new Set<string>();
+    const answers = classified.analyzed.map(({ plan: planned, project, skips, referenceOnly }) => {
       const read = (): ProjectRead => {
         const held = inventory(project, host, targetRoot);
         const found = roots(project, held, targetRoot, options);
-        const kept = skippedRoots(project, held, reading.skips);
+        const kept = skippedRoots(project, held, skips);
         const rooted =
           kept.length === 0
             ? found
@@ -531,12 +246,12 @@ function readProjects<Answer>(
               };
         const own = sourceFilesOf(project, targetRoot);
         return {
-          configuration,
+          configuration: planned.id,
           configFile: project.configFile,
           held,
           rooted,
-          typeErrorSkips: reading.skips.map((one) => one.record),
-          skipped: skippedUnits(reading.skips, absoluteRoot),
+          typeErrorSkips: skips.map((one) => one.record),
+          skipped: skippedUnits(skips, absoluteRoot),
           referenceOnly: project
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
@@ -548,66 +263,25 @@ function readProjects<Answer>(
       for (const file of project.ownSourceFiles()) {
         heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
       }
-      return stage(project, { configuration, read });
-    },
-    discovered.derived ? "record" : "refuse",
-    joins.size === 0
-      ? workspace?.programs
-      : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins),
-    () => {
-      outsideTests = testFilesAt(
-        host,
-        targetRoot,
-        sourcePaths(host, targetRoot).filter(
-          (path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path)),
-        ),
-        parse,
-      );
-    },
-    readManifests,
-  );
-  for (const configFile of session.unopened) {
-    if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
-      throw new DiscoveryError(`${configFile} opened no project`, []);
+      return stage(project, { configuration: planned.id, read });
+    });
+    const consumed = new Map<string, Reference>();
+    for (const { project, consumer } of classified.consumed) {
+      const side = { id: consumer.id, root: consumer.path };
+      for (const reference of consumerReferences(project, host, targetRoot, side, config)) {
+        consumed.set(referenceKey(reference), reference);
+      }
     }
-    dropped(configFile, "the compiler opened no project for the configuration");
-  }
-  if (unbuildable.length > 0) {
-    throw new SetupError(unbuildable);
-  }
-  if (failures.length > 0) {
-    throw new DiscoveryError(
-      `${String(failures.length)} error(s), so no answer was produced`,
-      failures,
-    );
-  }
-  const answers = session.projects.filter((answer): answer is Answer => answer !== undefined);
-  const [first] = notBuilt;
-  if (answers.length === 0 && setupDropped.length > 0) {
-    throw new SetupError(setupDropped);
-  }
-  if (answers.length === 0 && first !== undefined) {
-    throw new DiscoveryError(
-      `no configuration discovery derived could be built; ${first.id}: ${first.error}`,
-      [],
+    const outsideTests = testFilesAt(
+      host,
+      targetRoot,
+      sourcePaths(host, targetRoot).filter(
+        (path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path)),
+      ),
+      parse,
     );
-  }
-  return {
-    answers,
-    consumers: {
-      loaded: loads.map((load) => load.consumer),
-      references: [...consumed.values()],
-    },
-    notBuilt,
-    unanswered: session.unanswered,
-    componentsUnread: workspace?.componentsUnread ?? [],
-    librariesUnfound,
-    conventionsApplied: conventions.applied,
-    conventionUses: conventions.uses,
-    memberDirs,
-    nestedDirs,
-    outsideTests,
-  };
+    return { answers, references: [...consumed.values()], outsideTests };
+  });
 }
 
 /** The projects one run analyzes, and what reading them left out. */
@@ -625,7 +299,12 @@ interface RunProjects {
  * for the errors and setup failures that decide whether it is analyzed, dropped or
  * fails the run, exactly as the analysis reads them.
  */
-export function runProjects(engine: Engine, host: Host, scope: Scope, config: Config): RunProjects {
+export function runProjects(
+  engine: Engine,
+  host: Host,
+  scope: Scope,
+  config: PartialConfig,
+): RunProjects {
   const read = readProjects(
     engine,
     host,
@@ -633,7 +312,11 @@ export function runProjects(engine: Engine, host: Host, scope: Scope, config: Co
     config,
     (_project, opened) => opened.configuration,
   );
-  return { configurations: read.answers, notBuilt: read.notBuilt, unanswered: read.unanswered };
+  return {
+    configurations: read.result.answers,
+    notBuilt: read.classified.notBuilt,
+    unanswered: read.unanswered,
+  };
 }
 
 /**
@@ -646,12 +329,12 @@ export function runRoots(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
 ): RunRoots {
   const targetRoot = scope.target.path;
   const read = readProjects(engine, host, scope, config, (_project, opened) => opened.read());
-  const projects = read.answers;
+  const projects = read.result.answers;
 
   const configurations: string[] = [];
   const merged = new Map<string, Omit<RunRoot, "configurations"> & { configurations: string[] }>();
@@ -682,10 +365,12 @@ export function runRoots(
 
   const ordered = [...merged.values()].sort(
     (a, b) =>
-      byPosition(a.position, b.position) || compare(a.kind, b.kind) || compare(a.source, b.source),
+      byPosition(a.position, b.position) ||
+      bytewise(a.kind, b.kind) ||
+      bytewise(a.source, b.source),
   );
   const unmatched = unmatchedEverywhere(
-    config.rootPatterns,
+    config.roots.patterns,
     projects.map((answer) => answer.rooted),
   );
   return {
@@ -695,7 +380,7 @@ export function runRoots(
       unmatched,
       documentOf(host, provenance, ROOTS_SETTING, targetRoot),
     ),
-    notBuilt: read.notBuilt,
+    notBuilt: read.classified.notBuilt,
     unanswered: read.unanswered,
   };
 }
@@ -727,7 +412,7 @@ export interface RunSweep {
 }
 
 /** One `<script` start tag of a component file the run read no block for. */
-export interface ComponentWarning {
+interface ComponentWarning {
   /** The file, below the target root. */
   readonly path: string;
   readonly line: number;
@@ -754,11 +439,16 @@ interface SweptProject<Extra> {
   readonly exempt: readonly Exemption[];
   /** The declarations of the project an unanswered question could have kept live. */
   readonly unanswered: readonly string[];
+  /** The data members a generic declared outside the analysis fills, which it may read. */
+  readonly filledOutside: readonly string[];
   readonly typeErrorSkips: readonly TypeErrorSkip[];
   readonly skipped: readonly SkippedUnit[];
   /** The component files the project holds of its own, by path below the target root. */
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** The manifest entries the project reads back to no file of its own. */
+  readonly unmappedEntries: readonly ManifestEntry[];
+  readonly heldScripts: readonly HeldScripts[];
   readonly extra: Extra;
 }
 
@@ -770,6 +460,12 @@ interface ReadProject<Extra> {
   readonly evidence: readonly Exemption[];
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** Per own file below the target root, the module specifiers its imports write. */
+  readonly imports: ReadonlyMap<string, readonly string[]>;
+  /** The global augmentations a declaration outside the project names. */
+  readonly augmented: readonly Root[];
+  /** The data members its production code decodes into. */
+  readonly decoded: Decoded;
   readonly extra: Extra;
 }
 
@@ -790,6 +486,10 @@ interface ReadRun<Extra> {
   readonly componentsUnread: readonly ComponentsUnread[];
   /** Per analyzed configuration, each library it names that the compiler cannot find. */
   readonly librariesUnfound: readonly LibraryUnfound[];
+  /** The relative specifiers of the run's unchecked JavaScript files that resolve to no file. */
+  readonly unresolvedSpecifiers: readonly UnresolvedSpecifier[];
+  /** The inputs the run could not read. */
+  readonly unread: readonly UnreadInput[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
@@ -800,6 +500,51 @@ interface ReadRun<Extra> {
   readonly nestedDirs: readonly string[];
 }
 
+/** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
+const DEV_SECTION = "devDependencies";
+const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"] as const;
+
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(
+  host: Host,
+  targetRoot: string,
+  projects: readonly { readonly imports: ReadonlyMap<string, readonly string[]> }[],
+): TestEvidence {
+  const imports = new Map<string, readonly string[]>();
+  for (const one of projects) {
+    for (const [path, specifiers] of one.imports) {
+      imports.set(path, specifiers);
+    }
+  }
+  const manifests = new Map<string, Readonly<Record<string, unknown>> | undefined>();
+  const manifestIn = (dir: string): Readonly<Record<string, unknown>> | undefined => {
+    if (!manifests.has(dir)) {
+      manifests.set(dir, manifestAt(host, dir));
+    }
+    return manifests.get(dir);
+  };
+  const declares = (section: unknown, name: string): boolean =>
+    typeof section === "object" && section !== null && Object.hasOwn(section, name);
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return {
+    imports,
+    devDependency: (path, name) => {
+      for (const dir of ancestors(dirnamePath(joinPath(root, path)), root)) {
+        const manifest = manifestIn(dir);
+        const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+        if (declares(manifest?.[DEV_SECTION], name) || other) {
+          return !other;
+        }
+      }
+      return false;
+    },
+  };
+}
+
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -810,7 +555,7 @@ function readRun<Extra>(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
   extra: <Brand>(
@@ -823,13 +568,13 @@ function readRun<Extra>(
   const targetRoot = scope.target.path;
   const disabled = disabledClasses(config);
   const templates = disabled.has("template-field")
-    ? { delimiters: config.analysis.templateDelimiters, files: [] }
+    ? { delimiters: config.analysis.template_delimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
   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,
+      testFiles: config.ts.test_files,
       testFileNames: projectRead.testFileNames,
     });
     const evidence = evidenceRecords(
@@ -840,7 +585,7 @@ function readRun<Extra>(
         templates,
         ts: config.ts,
         consumers,
-        ...(config.analysis.generatedFiles === "include"
+        ...(config.analysis.generated_files === "include"
           ? {}
           : { generated: projectRead.generated }),
       },
@@ -848,6 +593,9 @@ function readRun<Extra>(
       disabled,
     );
     const components = project.ownSourceFiles().filter(isComponentFile);
+    const injected = project.program
+      .getSourceFileNames()
+      .some((name) => name.endsWith(`/node_modules/${GLOBALS_RUNNER}/globals.d.ts`));
     const pathOf = (file: (typeof components)[number]): string =>
       relativePath(targetRoot, file.fileName) ?? file.fileName;
     return {
@@ -856,6 +604,29 @@ function readRun<Extra>(
       testFiles: resolved.testFilePaths,
       evidence,
       componentFiles: components.map(pathOf),
+      augmented: mergedGlobalInterfaces(
+        project,
+        projectRead.held,
+        sourceFilesOf(project, targetRoot),
+      ).map((id): Root => ({ id, kind: "global-augmentation", source: "" })),
+      imports: new Map(
+        project.ownSourceFiles().flatMap((file) => {
+          const path = relativePath(targetRoot, file.fileName);
+          if (path === undefined) {
+            return [];
+          }
+          const specifiers = file.imports.filter(isStringLiteralLikeNode).map((one) => one.text);
+          // A file calling the globals a program declares is written for their runner.
+          return [
+            [
+              path,
+              injected && namesTestGlobals(project, file)
+                ? [...specifiers, GLOBALS_RUNNER]
+                : specifiers,
+            ],
+          ];
+        }),
+      ),
       componentWarnings: components.flatMap((file) =>
         readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
           path: pathOf(file),
@@ -863,48 +634,77 @@ function readRun<Extra>(
           reason: warning.reason,
         })),
       ),
+      decoded: decodedMembers(
+        project,
+        projectRead.held,
+        productionFiles(project, targetRoot, resolved.testFilePaths),
+        consumers,
+      ),
       extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
     };
   });
-  const outsidePaths = read.outsideTests.map((one) => one.path);
-  const withOutside = read.answers.map((one) => ({
+  const outsidePaths = read.result.outsideTests.map((one) => one.path);
+  const withOutside = read.result.answers.map((one) => ({
     ...one,
     references: [
       ...one.references,
-      ...outsideTestReferences(read.outsideTests, one.projectRead.held, targetRoot),
+      ...outsideTestReferences(read.result.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(
+  const { support, testUsed } = 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),
+    testEvidence(host, targetRoot, withOutside),
   );
+  // A member a decode fills or a copy carries is written: a value decoded and sent again carries it on.
+  const written = new Set([
+    ...countedWrites(
+      [...withOutside.flatMap((one) => one.references), ...read.result.references],
+      support,
+      mode,
+    ),
+    ...withOutside.flatMap((one) => [
+      ...one.decoded.filled,
+      ...one.decoded.parsed,
+      ...one.decoded.copied,
+    ]),
+  ]);
+  const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
   const settled = settledSatisfaction(
-    withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })),
-    [...withOutside.flatMap((one) => one.references), ...read.consumers.references],
+    withOutside.map((one, index) => ({
+      evidence: evidence[index] ?? [],
+      held: one.projectRead.held,
+    })),
+    [...withOutside.flatMap((one) => one.references), ...read.result.references],
   );
   const answers = withOutside.map((one, index): SweptProject<Extra> => {
     const { projectRead } = one;
     const satisfied = settled[index];
-    const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
+    const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
       mode,
       testFiles: new Set([...one.testFiles, ...support]),
     });
     const exempt = detected.records;
     const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
-    const supportFiles = [...support].filter((path) => held.has(path)).sort();
+    const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
+    const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
     const configured: Configured = {
       configuration: projectRead.configuration,
       symbols: projectRead.held.symbols,
       references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
-      roots: projectRead.rooted.liveUnderReachability,
-      testFiles: one.testFiles,
+      // The augmentations are rooted after test support is read: an outside declaration
+      // naming one calls nothing of its file.
+      roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
+      testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
+      ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
+      ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
       ...(projectRead.referenceOnly.length === 0
         ? {}
         : { referenceOnly: projectRead.referenceOnly }),
@@ -923,15 +723,19 @@ function readRun<Extra>(
           .filter((reference) => reference.resolution === "by-name")
           .map((reference) => reference.to),
         ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+        ...one.decoded.unanswered,
       ],
+      filledOutside: one.decoded.filled,
       typeErrorSkips: projectRead.typeErrorSkips,
+      unmappedEntries: projectRead.rooted.unmappedEntries,
+      heldScripts: projectRead.rooted.heldScripts,
       skipped: projectRead.skipped,
       componentFiles: one.componentFiles,
       componentWarnings: one.componentWarnings,
       extra: one.extra,
     };
   });
-  const consumed = read.consumers.references;
+  const consumed = read.result.references;
   const projects = answers.map((one) =>
     consumed.length === 0
       ? one
@@ -953,15 +757,17 @@ function readRun<Extra>(
       ]),
     ],
     projects,
-    consumers: read.consumers.loaded,
-    notBuilt: read.notBuilt,
+    consumers: read.plan.discovery.consumers,
+    notBuilt: read.classified.notBuilt,
     unanswered: read.unanswered,
-    componentsUnread: read.componentsUnread,
-    librariesUnfound: read.librariesUnfound,
-    conventionsApplied: read.conventionsApplied,
-    conventionUses: read.conventionUses,
-    memberDirs: read.memberDirs,
-    nestedDirs: read.nestedDirs,
+    componentsUnread: read.plan.workspace?.componentsUnread ?? [],
+    librariesUnfound: read.classified.librariesUnfound,
+    unresolvedSpecifiers: read.classified.unresolvedSpecifiers,
+    unread: read.plan.unread,
+    conventionsApplied: read.plan.conventions.applied,
+    conventionUses: read.plan.conventions.uses,
+    memberDirs: read.plan.packages.members,
+    nestedDirs: read.plan.packages.nested,
   };
 }
 
@@ -1025,6 +831,22 @@ function evidenceReferences(
   });
 }
 
+/**
+ * The declarations a write the mode counts stores into, a write a test-support file
+ * makes being a test's.
+ */
+function countedWrites(
+  references: readonly Reference[],
+  support: ReadonlySet<string>,
+  mode: Mode,
+): ReadonlySet<string> {
+  return new Set(
+    supportReferences(references, support).flatMap((reference) =>
+      reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : [],
+    ),
+  );
+}
+
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
  * reference counting as a read: what the write-only kind would report but for a record.
@@ -1102,7 +924,7 @@ function sweptOf<Extra>(
     unanswered: read.unanswered,
     heldByUnanswered: [...held],
     skipped: read.projects.flatMap((one) => one.skipped),
-    componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(compare),
+    componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
   };
 }
 
@@ -1118,7 +940,7 @@ export function runSweep(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   input: Pick<SweepInput, "marked" | "mode">,
   detectors: Detectors = DETECTORS,
 ): RunSweep {
@@ -1141,6 +963,19 @@ interface EmitterExtra {
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
   readonly parts: ProjectParts;
+  readonly unseenLoads: readonly UnseenLoad[];
+}
+
+/** The project's own files below the target root that are no test file. */
+function productionFiles<Brand>(
+  project: ProjectView<Brand>,
+  targetRoot: string,
+  testFiles: readonly string[],
+): readonly SourceFile[] {
+  const tests = new Set(testFiles);
+  return [...sourceFilesOf(project, targetRoot).byPath].flatMap(([path, file]) =>
+    tests.has(path) ? [] : [file],
+  );
 }
 
 /** Reads a run's projects with every per-project fact an emitter reads. */
@@ -1148,7 +983,7 @@ export function readEmitterRun(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
 ): ReadRun<EmitterExtra> {
@@ -1176,9 +1011,10 @@ export function readEmitterRun(
       ),
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
+      unseenLoads: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
     }),
   );
-  // Whether a declaration carries the marker decides its code, so one whose marker went
+  // Whether a declaration carries the marker decides its code, so one whose answer went
   // unread is reported by nothing.
   const unread = run.projects.flatMap((one) => one.extra.deprecation.unanswered);
   return unread.length === 0
@@ -1190,7 +1026,8 @@ export function readEmitterRun(
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(
   host: Host,
@@ -1214,27 +1051,32 @@ function judgedMembers(
       judged.unbuilt.push(dir);
     }
   }
+  for (const dir of read.nestedDirs) {
+    const below = relativePath(root, dir);
+    if (
+      below !== undefined &&
+      owners.has(dir) &&
+      ![...held].some((path) => path.startsWith(`${below}/`))
+    ) {
+      judged.unbuilt.push(dir);
+    }
+  }
   return judged;
 }
 
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
 function nearestManifestDir(host: Host, root: string, file: string): string {
-  for (let dir = dirnamePath(file); relativePath(root, dir) !== undefined; dir = dirnamePath(dir)) {
-    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
-      return dir;
-    }
-  }
-  return root;
+  return ancestors(dirnamePath(file), root).find((dir) => holdsManifest(host, dir)) ?? root;
 }
 
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
- * each kind family reads, every per-project one read in the same session as the sweep.
+ * each emitter reads, every per-project one read in the same session as the sweep.
  */
 export function emitterInputOver(
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   read: ReadRun<EmitterExtra>,
   input: Pick<SweepInput, "marked" | "mode">,
   selfCheck: SelfCheckFacts,
@@ -1270,6 +1112,7 @@ export function emitterInputOver(
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
       generated: new Set(projects.flatMap((one) => one.extra.generated)),
       inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
+      unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
     },
     boundary: {
       consumers: {
@@ -1278,6 +1121,7 @@ export function emitterInputOver(
       },
       encapsulated: readManifest(host, targetRoot).declaresExports,
       edges: readEdgeSides(host, targetRoot),
+      filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
     },
     selfCheck,
     intraFunction: intraFunctionFacts(
@@ -1313,14 +1157,14 @@ interface AnalysisReader {
  * directives, the ignore file's entries and the baseline's rows are bound before any
  * sweep, and the run is swept once under every bound record's mark and once under none,
  * so a record is decided against the finding its code would have produced. The
- * self-check family reports the refused suppressions and the roots that named nothing.
+ * configuration family reports the refused suppressions and the roots that named nothing.
  * Beside the inputs it answers the projects and test-file rules a report names.
  */
 function readAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors,
@@ -1341,7 +1185,7 @@ function readAnalysis(
         configFile: one.configFile,
       })),
       testFileRules: testFileRulesOf(
-        config.ts.testFiles,
+        config.ts.test_files,
         read.projects.flatMap((one) => one.configured.testFiles),
         read.projects.flatMap((one) => one.configured.supportFiles ?? []),
       ),
@@ -1358,7 +1202,14 @@ function readAnalysis(
       unanswered: read.unanswered,
       componentsUnread: read.componentsUnread,
       librariesUnfound: read.librariesUnfound,
+      unresolvedSpecifiers: read.unresolvedSpecifiers,
+      unread: read.unread,
       conventionsApplied: read.conventionsApplied,
+      unmappedEntries: unmappedEverywhere(read.projects),
+      heldScripts: read.projects.flatMap((one) =>
+        one.heldScripts.map((held) => ({ ...held, configFile: one.configFile })),
+      ),
+      unseenLoads: read.projects.flatMap((one) => one.extra.unseenLoads),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1370,7 +1221,7 @@ function readAnalysis(
 function inputsOver(
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   read: ReadRun<EmitterExtra>,
@@ -1384,7 +1235,7 @@ function inputsOver(
   const facts: SelfCheckFacts = {
     refusals: suppressions.refusals,
     unmatchedRoots: unmatchedEverywhere(
-      config.rootPatterns,
+      config.roots.patterns,
       read.projects.map((one) => one.extra.rooted),
     ),
     rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
@@ -1410,6 +1261,22 @@ function inputsOver(
   };
 }
 
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(
+  projects: readonly { readonly unmappedEntries: readonly ManifestEntry[] }[],
+): readonly ManifestEntry[] {
+  const key = (entry: ManifestEntry): string => `${entry.dir}\u0000${entry.member}`;
+  const [first, ...rest] = projects;
+  const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+  const found = new Map<string, ManifestEntry>();
+  for (const entry of first?.unmappedEntries ?? []) {
+    if (others.every((one) => one.has(key(entry)))) {
+      found.set(key(entry), entry);
+    }
+  }
+  return [...found.values()];
+}
+
 /** One project of a run: the name the run gives it and the file it was opened from. */
 export interface RunProject {
   readonly id: string;
@@ -1437,8 +1304,18 @@ interface RunFacts {
   readonly componentsUnread: readonly ComponentsUnread[];
   /** Per analyzed configuration, each library it names that the compiler cannot find. */
   readonly librariesUnfound: readonly LibraryUnfound[];
+  /** The relative specifiers of the run's unchecked JavaScript files that resolve to no file. */
+  readonly unresolvedSpecifiers: readonly UnresolvedSpecifier[];
+  /** The inputs the run could not read. */
+  readonly unread: readonly UnreadInput[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The manifest entries no project of the run reads back to a file, each once. */
+  readonly unmappedEntries: readonly ManifestEntry[];
+  /** Per project, by its compiler configuration file, each package whose command strings name files it holds. */
+  readonly heldScripts: readonly (HeldScripts & { readonly configFile: string })[];
+  /** The loads of production files whose target the run cannot resolve, per configuration. */
+  readonly unseenLoads: readonly UnseenLoad[];
 }
 
 /** One configuration whose component files a run cannot read. */
@@ -1447,13 +1324,6 @@ interface ComponentsUnread {
   readonly reason: string;
 }
 
-/** One library an analyzed configuration names that the compiler cannot find. */
-interface LibraryUnfound {
-  readonly configFile: string;
-  /** The compiler's error, rendered as a dropped configuration's is. */
-  readonly error: string;
-}
-
 /** The findings of one run, beside what a report states about the run itself. */
 export interface RunAnalysis {
   readonly result: PassResult;
@@ -1466,7 +1336,7 @@ export interface RunAnalysis {
 
 /**
  * The analysis of the run the scope and the configuration describe: the run read with its
- * suppressions bound, every family's findings with the suppressions applied and the
+ * suppressions bound, every emitter's findings with the suppressions applied and the
  * declared edges evaluated, the projects and test-file rules the report names, and the sweep
  * an explanation reads.
  */
@@ -1474,7 +1344,7 @@ export function runAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors = DETECTORS,
@@ -1486,14 +1356,20 @@ export function runAnalysis(
 
 /**
  * One count per configuration of the run in which the checker left a question unanswered:
- * the questions asked in its project, and the declarations of its own the run holds for them.
+ * the questions asked in its project, a formed program's manifest that does not parse or cannot
+ * be read and a package whose command strings name files the project holds each counted as one, and the
+ * declarations of its own the run holds for them.
  */
 export function unansweredCounts(analysis: RunAnalysis): readonly UnansweredCount[] {
   const held = new Set(analysis.swept.heldByUnanswered);
   return analysis.run.projects.flatMap((project) => {
-    const questions = analysis.run.unanswered.filter(
-      (one) => one.configFile === project.configFile,
-    ).length;
+    const questions =
+      analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +
+      analysis.run.unread.filter(
+        (one) => one.kind === "manifest" && one.configFile === project.configFile,
+      ).length +
+      analysis.run.heldScripts.filter((one) => one.configFile === project.configFile).length;
+
     if (questions === 0) {
       return [];
     }
@@ -1530,7 +1406,7 @@ export function runBaselineWrite(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   reason: string,