@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/src/analysis.ts

@@ -6,131 +6,90 @@
  * another project's checker, which holds only for views the session hands out.
  */
 
-import { isStringLiteralLikeNode } from "@typescript/native/ast";
+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,
   declarationsNamed,
-} from "./configured-declarations.ts";
-import { decorator } from "./decorator.ts";
+} from "./roots/configured-declarations.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
+import { carriersOf, NO_CARRIERS, type Carriers } from "./exposure.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
-import {
-  discoverProjects,
-  DiscoveryError,
-  isGuess,
-  MISSING_GLOBAL_TYPE,
-  projectErrors,
-  renderDiagnostic,
-  targetRelative,
-  withBaseUrlPaths,
-  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 type { AppliedConvention } from "./entries/conventions.ts";
+import { readSources, type SourceFacts } from "./entries/sources.ts";
+import { readWorkflows, type Workflows } from "./entries/workflow-steps.ts";
 import { readEdgeSides } from "./edges.ts";
-import { enumGroup } from "./enum-group.ts";
-import { generatedFile, generatedFilesOf } from "./generated-file.ts";
-import { inOperandNames } from "./in-operands.ts";
+import { bindingsOf, distinctBindings, type BindingRecord } from "./bindings.ts";
+import { generatedFilesOf, type GeneratedFact } from "./exemptions/generated-file.ts";
+import { inOperandNames } from "./findings/in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
-import {
-  evidenceRecords,
-  heldRecords,
-  disabledClasses,
-  exemptionsOf,
-  holdingWhile,
-  isUnansweredRecord,
-  retainedIn,
-  type Detector,
-  type Detectors,
-} from "./exempt.ts";
-import type { TSExemptionClass } from "./exempt-classes.ts";
+import { DETECTORS, detection } from "./exemptions/detectors.ts";
+import { exemptionsOf, settle, type Detectors, type Exemption } from "./exemptions/lifecycle.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";
 import { unmatchedRootFindings, type SelfCheckFacts } from "./findings/self-check.ts";
-import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
-import { implementations, mergeImplementations } from "./implementations.ts";
-import { injectionContainer } from "./injection-container.ts";
-import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
+import { implementations, mergeImplementations } from "./findings/implementations.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
-import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { packageEntries, readManifest, type ManifestEntry } from "./manifest.ts";
-import {
-  liveFilesAt,
-  matrixOf,
-  referenceKey,
-  sweepMatrix,
-  type Configured,
-  type Matrix,
-  type SweepResult,
-} from "./matrix.ts";
+import { type Inventory, type InventorySymbol } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
+import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
+import { matrixOf, referenceKey, type Configured, type Matrix } from "./liveness/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 { reflectiveLookup } from "./reflective-lookup.ts";
-import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
+import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
+import { skippedUnits, type SkippedUnit } from "./type-errors.ts";
+import { references, type Reference } from "./references.ts";
 import {
-  roots,
+  rootSet,
   unmatchedEverywhere,
   type RootKind,
-  type RootOptions,
   type Roots,
-} from "./roots.ts";
+  type HeldScripts,
+} from "./roots/root-set.ts";
 import type { Scope } from "./scope.ts";
-import { serializationContract } from "./serialization-contract.ts";
-import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
-import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
-import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
+import { decodedMembers, type Decoded } from "./exemptions/serialization-contract.ts";
+import { outsideTestReferences, testFilesAt, type OutsideTest } from "./tests/outside.ts";
+import type { UnseenLoad } from "./roots/unseen-loads.ts";
+import type { UnresolvedSpecifier } from "./load/specifiers.ts";
+import { formedForNode } from "./load/synthesize.ts";
+import type { UnreadInput } from "./load/plan.ts";
+import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.ts";
 import {
-  diagnosticsOf,
-  ownedAs,
-  runSession,
-  type Engine,
-  type OpenedFiles,
-  type ProjectView,
-} from "./session.ts";
+  targetTestFile,
+  testFilePaths,
+  testFileRulesOf,
+  withheldBy,
+  type TestFileRule,
+} from "./tests/file-class.ts";
+import { testSupportFiles, type TestEvidence } from "./tests/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 { sweep, type Sweep, type SweepPolicy } from "./liveness/sweep.ts";
+import type { Mode } from "./tests/file-class.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest, manifestAt } from "./fs/manifest.ts";
+import { runDirectories } from "./entries/run-directories.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";
@@ -187,14 +146,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;
@@ -211,10 +162,14 @@ interface ProjectRead {
   readonly typeErrorSkips: readonly TypeErrorSkip[];
   /** The lines each of those skips withholds every finding on. */
   readonly skipped: readonly SkippedUnit[];
-  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
-  readonly generated: ReadonlyMap<string, string>;
-  /** The files, absolute, an applied convention row names as test files. */
-  readonly testFileNames: ReadonlySet<string>;
+  /** The project's generated files, by path below the target root, each with what decided it. */
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+  /** The binding identities its generated files publish (`bindings.6`, `bindings.7`). */
+  readonly bindings: readonly BindingRecord[];
+  /** What the project's entry sources enter and name, read once. */
+  readonly sources: SourceFacts;
+  /** Whether the run formed the program to resolve its modules as Node does (program.36). */
+  readonly formedForNode: boolean;
 }
 
 /** One target project the run analyzes, as its stage is handed it. */
@@ -224,346 +179,67 @@ 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 declarations a consumer's read rules held, each once. */
+  readonly consumerHeld: readonly string[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
+  /** The target root's workflow steps, git hooks and makefile, read once for every project. */
+  readonly workflows: Workflows;
 }
 
 /**
- * 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(
+  return loadRun(engine, host, scope, config, ({ plan, classified, runFiles }) => {
+    const { packages, conventions } = plan;
+    const workflows = readWorkflows(host, targetRoot);
+    const options = {
       host,
+      manifest: packages.manifest,
+      otherPackages: packages.entries,
+      patterns: config.roots.patterns,
+      entryFiles: config.ts.entry_files,
       parse,
-      conventionManifests(host, absoluteRoot, memberDirs, nestedDirs),
-      config.ts.disabledConventions,
-    );
-    options = {
-      host,
-      manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-      otherPackages: [
-        ...(workspace?.entries ?? []),
-        ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
-      ],
-      patterns: config.rootPatterns,
-      entryFiles: config.ts.entryFiles,
-      conventions,
-      testFiles: config.ts.testFiles,
-      parse,
-      publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
-      publishedMembers: new Set(
-        (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
-      ),
-      runFiles: new Set(
-        opened.flatMap((one) =>
-          one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)),
-        ),
-      ),
+      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 programs = withBaseUrlPaths(
-    engine,
-    host,
-    [...discovered.configFiles, ...consumerOf.keys()],
-    workspace?.programs ?? new Map(),
-  );
-  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 missingGlobal = raw.unfound.find(
-        ({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE,
-      );
-      const skips =
-        missingGlobal === undefined
-          ? reading.skips
-          : [
-              ...reading.skips,
-              ...project.ownSourceFiles().map((file) => ({
-                record: {
-                  path: relativePath(absoluteRoot, file.fileName) ?? file.fileName,
-                  line: 1,
-                  message: missingGlobal.diagnostic.text,
-                },
-                file,
-                unit: file,
-              })),
-            ];
-      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, skips);
-        const rooted =
-          kept.length === 0
-            ? found
-            : {
-                ...found,
-                liveUnderReachability: [
-                  ...found.liveUnderReachability,
-                  ...kept.map((id) => ({ id, kind: "type-error" as const, source: "" })),
-                ],
-              };
         const own = sourceFilesOf(project, targetRoot);
+        const sources = readSources({
+          host,
+          targetRoot,
+          files: own,
+          parse,
+          testFiles: config.ts.test_files,
+          conventions,
+          workflows,
+        });
+        const rooted = rootSet(project, held, targetRoot, { ...options, sources, skips });
+        const generated = generatedFilesOf(own, sources.generated);
         return {
-          configuration,
+          configuration: planned.id,
           configFile: project.configFile,
           held,
           rooted,
@@ -573,71 +249,53 @@ function readProjects<Answer>(
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
             .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-          generated: generatedFilesOf(own, generatedFiles(conventions, own)),
-          testFileNames: conventions.testFiles,
+          generated,
+          bindings: bindingsOf(
+            own.byPath,
+            generated,
+            new Map(
+              held.symbols
+                .filter((one) => one.kind === "file")
+                .map((one) => [one.position.path, one.ref]),
+            ),
+          ),
+          sources,
+          formedForNode: formedForNode(planned),
         };
       };
       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 ? programs : withJoinedTests(engine, host, programs, 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>();
+    const consumerHeld = new Set<string>();
+    for (const { project, consumer } of classified.consumed) {
+      const side = { id: consumer.id, root: consumer.path };
+      const read = consumerReferences(project, host, targetRoot, side, config, parse);
+      for (const reference of read.references) {
+        consumed.set(referenceKey(reference), reference);
+      }
+      for (const id of read.held) {
+        consumerHeld.add(id);
+      }
     }
-    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),
+    return {
+      answers,
       references: [...consumed.values()],
-    },
-    notBuilt,
-    unanswered: session.unanswered,
-    componentsUnread: workspace?.componentsUnread ?? [],
-    librariesUnfound,
-    conventionsApplied: conventions.applied,
-    conventionUses: conventions.uses,
-    memberDirs,
-    nestedDirs,
-    outsideTests,
-  };
+      consumerHeld: [...consumerHeld],
+      outsideTests,
+      workflows,
+    };
+  });
 }
 
 /** The projects one run analyzes, and what reading them left out. */
@@ -655,7 +313,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,
@@ -663,7 +326,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,
+  };
 }
 
 /**
@@ -676,12 +343,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[] }>();
@@ -712,10 +379,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 {
@@ -725,58 +394,39 @@ export function runRoots(
       unmatched,
       documentOf(host, provenance, ROOTS_SETTING, targetRoot),
     ),
-    notBuilt: read.notBuilt,
+    notBuilt: read.classified.notBuilt,
     unanswered: read.unanswered,
   };
 }
 
+/** The production mode a configuration sets: a consumer's test reference is classed as `analysis.consumer_tests` says. */
+export function productionMode(config: PartialConfig): Mode {
+  return {
+    production: true,
+    consumerTestsProduction: config.analysis.consumer_tests === "production",
+  };
+}
+
 /** The run's sweep, beside the matrix it judged. */
 export interface RunSweep {
   readonly matrix: Matrix;
-  readonly sweep: SweepResult;
-  /** The exemption records that hold under the sweep. */
-  readonly exempt: readonly Exemption[];
-  /**
-   * The exemption records that held back a declaration some configuration of the run
-   * would otherwise judge dead, in the declarations' site order.
-   */
-  readonly retained: readonly Exemption[];
+  readonly sweep: Sweep;
   /** The derived configurations the run dropped. */
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
-  /**
-   * Every declaration an unanswered question could have kept live, and every one only
-   * such a declaration keeps live. The run reports none of them.
-   */
-  readonly heldByUnanswered: readonly string[];
   /** The lines of the units type errors skipped, on which the run reports nothing. */
   readonly skipped: readonly SkippedUnit[];
-  /** The component files the run read, by path below the target root, each once. */
-  readonly componentFiles: readonly string[];
 }
 
 /** 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;
   readonly reason: string;
 }
 
-/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-export const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
-  ["interface-satisfaction", interfaceSatisfaction],
-  ["enum-group", enumGroup],
-  ["generated-file", generatedFile],
-  ["template-field", templateField],
-  ["reflective-lookup", reflectiveLookup],
-  ["decorator", decorator],
-  ["injection-container", injectionContainer],
-  ["framework-lifecycle", frameworkLifecycle],
-  ["serialization-contract", serializationContract],
-]);
-
 /** What the sweep of one run reads of each project, beside what a caller's stage adds. */
 interface SweptProject<Extra> {
   readonly configFile: string;
@@ -784,6 +434,10 @@ 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[];
+  /** What only a bundler's retry of an import Node leaves unresolved names (program.38). */
+  readonly possiblyLoaded: 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. */
@@ -791,6 +445,7 @@ interface SweptProject<Extra> {
   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;
 }
 
@@ -798,12 +453,17 @@ interface SweptProject<Extra> {
 interface ReadProject<Extra> {
   readonly projectRead: ProjectRead;
   readonly references: readonly Reference[];
+  /** The declarations its read rules held where the checker did not answer. */
+  readonly held: readonly string[];
+  readonly possiblyLoaded: readonly string[];
   readonly testFiles: readonly string[];
   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 data members its production code decodes into. */
+  readonly decoded: Decoded;
   readonly extra: Extra;
 }
 
@@ -816,6 +476,8 @@ interface ReadRun<Extra> {
   readonly projects: readonly SweptProject<Extra>[];
   /** Every declared consumer, each loaded, in the scope's order. */
   readonly consumers: readonly LoadedConsumer[];
+  /** Whether the scope declares a consumer, loaded or not. */
+  readonly declaresConsumers: boolean;
   /** The derived configurations the run dropped. */
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
@@ -824,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. */
@@ -832,6 +498,8 @@ interface ReadRun<Extra> {
   readonly memberDirs: readonly string[];
   /** The directory of every nested package, absolute. */
   readonly nestedDirs: readonly string[];
+  /** The target root's workflow steps, git hooks and makefile, read once. */
+  readonly workflows: Workflows;
 }
 
 /** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
@@ -855,20 +523,9 @@ function testEvidence(
     }
   }
   const manifests = new Map<string, Readonly<Record<string, unknown>> | undefined>();
-  const manifestAt = (dir: string): Readonly<Record<string, unknown>> | undefined => {
+  const manifestIn = (dir: string): Readonly<Record<string, unknown>> | undefined => {
     if (!manifests.has(dir)) {
-      let value: unknown;
-      try {
-        value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-      } catch {
-        value = undefined;
-      }
-      manifests.set(
-        dir,
-        typeof value === "object" && value !== null && !Array.isArray(value)
-          ? (value as Record<string, unknown>)
-          : undefined,
-      );
+      manifests.set(dir, manifestAt(host, dir));
     }
     return manifests.get(dir);
   };
@@ -878,16 +535,14 @@ function testEvidence(
   return {
     imports,
     devDependency: (path, name) => {
-      for (let dir = dirnamePath(joinPath(root, path)); ; dir = dirnamePath(dir)) {
-        const manifest = manifestAt(dir);
+      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;
         }
-        if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
-          return false;
-        }
       }
+      return false;
     },
   };
 }
@@ -902,7 +557,7 @@ function readRun<Extra>(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
   extra: <Brand>(
@@ -910,50 +565,55 @@ function readRun<Extra>(
     read: ProjectRead,
     references: readonly Reference[],
     testFiles: readonly string[],
+    unseenLoads: readonly UnseenLoad[],
   ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
-  const disabled = disabledClasses(config);
-  const templates = disabled.has("template-field")
-    ? { delimiters: config.analysis.templateDelimiters, files: [] }
-    : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
+  const detect = detection(host, targetRoot, config, consumers, detectors);
+  const directories = runDirectories(host, targetRoot, (fileName, text) =>
+    engine.parseSourceFile(fileName, text),
+  );
   const read = readProjects<ReadProject<Extra>>(engine, host, scope, config, (project, opened) => {
     const projectRead = opened.read();
+    const testFile = targetTestFile(projectRead.sources.testFiles);
     const resolved = references(project, projectRead.held, targetRoot, {
-      testFiles: config.ts.testFiles,
-      testFileNames: projectRead.testFileNames,
+      testFile,
+      directories,
+      formedForNode: projectRead.formedForNode,
     });
-    const evidence = evidenceRecords(
-      {
-        project,
-        held: projectRead.held,
-        targetRoot,
-        templates,
-        ts: config.ts,
-        consumers,
-        ...(config.analysis.generatedFiles === "include"
-          ? {}
-          : { generated: projectRead.generated }),
-      },
-      detectors,
-      disabled,
-    );
+    const testFiles = testFilePaths(project, targetRoot, testFile);
+    const evidence = detect({ project, held: projectRead.held, generated: projectRead.generated });
     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 {
       projectRead,
       references: resolved.references,
-      testFiles: resolved.testFilePaths,
+      held: resolved.held,
+      possiblyLoaded: resolved.possiblyLoaded,
+      testFiles,
       evidence,
       componentFiles: components.map(pathOf),
       imports: new Map(
         project.ownSourceFiles().flatMap((file) => {
           const path = relativePath(targetRoot, file.fileName);
-          return path === undefined
-            ? []
-            : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+          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) =>
@@ -963,15 +623,30 @@ function readRun<Extra>(
           reason: warning.reason,
         })),
       ),
-      extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
+      decoded: decodedMembers(
+        project,
+        projectRead.held,
+        productionFiles(project, targetRoot, testFiles),
+        consumers,
+      ),
+      extra: extra(
+        project,
+        projectRead,
+        resolved.references,
+        testFiles,
+        resolved.unseenLoads.map((position) => ({
+          configuration: projectRead.configuration,
+          position,
+        })),
+      ),
     };
   });
-  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],
   }));
@@ -980,30 +655,51 @@ function readRun<Extra>(
   const { support, testUsed } = testSupportFiles(
     withOutside.flatMap((one) => one.projectRead.held.symbols),
     withOutside.flatMap((one) => one.references),
-    withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
+    // An outside declaration naming a global augmentation calls nothing of its file.
+    withOutside.flatMap((one) =>
+      one.projectRead.rooted.liveUnderReachability.filter(
+        (root) => root.kind !== "global-augmentation",
+      ),
+    ),
     withOutside.flatMap((one) => one.testFiles),
     testEvidence(host, targetRoot, withOutside),
   );
-  const settled = settledSatisfaction(
-    withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })),
-    [...withOutside.flatMap((one) => one.references), ...read.consumers.references],
+  // 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 settled = settle(
+    withOutside.map((one) => ({
+      records: one.evidence,
+      held: one.projectRead.held,
+      testFiles: new Set([...one.testFiles, ...support]),
+    })),
+    {
+      references: [...withOutside.flatMap((one) => one.references), ...read.result.references],
+      written,
+      mode,
+    },
   );
   const answers = withOutside.map((one, index): SweptProject<Extra> => {
     const { projectRead } = one;
-    const satisfied = settled[index];
-    const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
-      mode,
-      testFiles: new Set([...one.testFiles, ...support]),
-    });
-    const exempt = detected.records;
-    const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
+    const exempt = settled[index]?.records ?? [];
+    const made = [...one.references, ...(settled[index]?.references ?? [])];
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
-    const supportFiles = [...support].filter((path) => held.has(path)).sort();
-    const testUsedFiles = [...testUsed].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)],
+      references: made,
       roots: projectRead.rooted.liveUnderReachability,
       testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
@@ -1023,20 +719,23 @@ function readRun<Extra>(
       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),
+        ...made.filter((reference) => reference.guessed === true).map((reference) => reference.to),
+        ...one.held,
+        ...exempt.filter((record) => record.unanswered === true).map((record) => record.id),
+        ...one.decoded.unanswered,
       ],
+      filledOutside: one.decoded.filled,
+      possiblyLoaded: one.possiblyLoaded,
       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
@@ -1054,80 +753,41 @@ function readRun<Extra>(
     unansweredHeld: [
       ...new Set([
         ...answers.flatMap((one) => one.unanswered),
-        ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
+        ...consumed.filter((one) => one.guessed === true).map((one) => one.to),
+        ...read.result.consumerHeld,
       ]),
     ],
     projects,
-    consumers: read.consumers.loaded,
-    notBuilt: read.notBuilt,
+    consumers: read.plan.discovery.consumers,
+    declaresConsumers: scope.consumers.length > 0,
+    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,
+    workflows: read.result.workflows,
   };
 }
 
 /**
- * The run swept under one set of marks with the records that hold. A record a component
- * file's markup holds counts only while the file is live, and what it holds may be what
- * keeps the file live, so each file's markup joins only once a sweep without it finds the
- * file live, until a sweep finds no further file live.
- */
-function holdingSweep<Extra>(
-  read: ReadRun<Extra>,
-  input: Pick<SweepInput, "marked" | "mode">,
-): { readonly swept: SweepInput; readonly result: SweepResult } {
-  const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
-  let live = new Set<string>();
-  for (;;) {
-    const swept: SweepInput = {
-      ...input,
-      exempt: holdingWhile(read.exempt, live),
-      unanswered: read.unansweredHeld,
-    };
-    const result = sweepMatrix(read.matrix, swept);
-    const next = new Set(liveFilesAt(read.matrix, result, paths).map((one) => one.position.path));
-    if (next.size === live.size) {
-      return { swept, result };
-    }
-    live = next;
-  }
-}
-
-/**
- * The test references exemption evidence written in a test file makes: each is a read of
- * the declaration it would retain, made by the test file at the evidence's site.
+ * The declarations a write the mode counts stores into, a write a test-support file
+ * makes being a test's.
  */
-function evidenceReferences(
-  symbols: readonly InventorySymbol[],
-  inTestFiles: readonly Exemption[],
-): readonly Reference[] {
-  if (inTestFiles.length === 0) {
-    return [];
-  }
-  const files = new Map(
-    symbols
-      .filter((symbol) => symbol.kind === "file")
-      .map((symbol) => [symbol.position.path, symbol.id]),
+function countedWrites(
+  references: readonly Reference[],
+  support: ReadonlySet<string>,
+  mode: Mode,
+): ReadonlySet<string> {
+  return new Set(
+    references.flatMap((reference) =>
+      reference.use === "write" && !withheldBy(mode, reference, support) ? [reference.to] : [],
+    ),
   );
-  return inTestFiles.flatMap((record) => {
-    const from = files.get(record.site.path);
-    return from === undefined
-      ? []
-      : [
-          {
-            from,
-            to: record.id,
-            position: record.site,
-            use: "read",
-            resolution: "syntax",
-            test: true,
-          },
-        ];
-  });
 }
 
 /**
@@ -1138,8 +798,9 @@ function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<strin
   const written = new Set<string>();
   const readSome = new Set<string>();
   for (const { configured } of read.projects) {
+    const support = new Set(configured.supportFiles ?? []);
     for (const reference of configured.references) {
-      if (mode.production && reference.test) {
+      if (withheldBy(mode, reference, support)) {
         continue;
       }
       if (reference.use === "write" && reference.consumer === undefined) {
@@ -1152,62 +813,27 @@ function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<strin
   return new Set([...written].filter((id) => !readSome.has(id)));
 }
 
-/**
- * The sweep of a run read once, under one set of marks. Where a question went unanswered,
- * the run is swept once more without what that question could have kept live and without
- * the references that stood in for its answer, and every declaration that sweep judges
- * dead and this one judges live, or dead by another rule, is held by the gap too, as is
- * every declaration that makes such a reference.
- */
+/** The sweep of a run read once, under one set of marks. */
 function sweptOf<Extra>(
   read: ReadRun<Extra>,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
 ): RunSweep {
-  const { swept, result } = holdingSweep(read, input);
-  const exempt = swept.exempt ?? [];
-  const held = new Set(read.unansweredHeld);
-  if (held.size > 0) {
-    // What a declaration reads where the checker did not answer is unknown, so a rule
-    // over what it reads, the test of dead code among them, cannot judge it.
-    for (const { configured } of read.projects) {
-      for (const reference of configured.references) {
-        if (reference.resolution === "by-name") {
-          held.add(reference.from);
-        }
-      }
-    }
-    const dead = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-    const answered = matrixOf(
-      read.projects.map(({ configured }) => ({
-        ...configured,
-        references: configured.references.filter((one) => one.resolution !== "by-name"),
-      })),
-    );
-    const bare: SweepInput = {
-      ...swept,
-      exempt: exempt.filter((record) => !isUnansweredRecord(record)),
-      unanswered: [],
-    };
-    for (const candidate of sweepMatrix(answered, bare).candidates) {
-      const kept = dead.get(candidate.id);
-      if (
-        kept?.testOfDeadCode !== candidate.testOfDeadCode ||
-        kept.relation !== candidate.relation
-      ) {
-        held.add(candidate.id);
-      }
-    }
-  }
+  const componentFiles = [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(
+    bytewise,
+  );
   return {
     matrix: read.matrix,
-    sweep: result,
-    exempt,
-    retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
+    sweep: sweep(read.matrix, {
+      ...input,
+      exempt: read.exempt,
+      unanswered: read.unansweredHeld,
+      componentFiles,
+      unseenCallers: !read.declaresConsumers,
+      writeOnly: writtenOnly(read, input.mode),
+    }),
     notBuilt: read.notBuilt,
     unanswered: read.unanswered,
-    heldByUnanswered: [...held],
     skipped: read.projects.flatMap((one) => one.skipped),
-    componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(compare),
   };
 }
 
@@ -1223,8 +849,8 @@ export function runSweep(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
-  input: Pick<SweepInput, "marked" | "mode">,
+  config: ResolvedConfig,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   detectors: Detectors = DETECTORS,
 ): RunSweep {
   return sweptOf(
@@ -1240,12 +866,27 @@ interface EmitterExtra {
   readonly needs: ReturnType<typeof projectNeeds>;
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
-  readonly generated: readonly string[];
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+  readonly bindings: readonly BindingRecord[];
   readonly inOperands: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
   readonly parts: ProjectParts;
+  readonly unseenLoads: readonly UnseenLoad[];
+  readonly carriers: Carriers;
+}
+
+/** 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. */
@@ -1253,7 +894,7 @@ export function readEmitterRun(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
 ): ReadRun<EmitterExtra> {
@@ -1265,15 +906,22 @@ export function readEmitterRun(
     config,
     mode,
     detectors,
-    (project, read, references, testFiles) => ({
+    (project, read, references, testFiles, unseenLoads) => ({
       deprecation: deprecatedDeclarations(project, read.held),
       accessors: accessorsOf(project, read.held),
-      needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) =>
-        engine.parseSourceFile(fileName, text),
+      needs: projectNeeds(
+        project,
+        read.held,
+        host,
+        targetRoot,
+        (fileName, text) => engine.parseSourceFile(fileName, text),
+        read.sources.configuration,
+        read.sources.workflows,
       ),
       implementations: implementations(project, read.held),
       heldByInclusion: heldByInclusion(project, targetRoot),
-      generated: [...read.generated.keys()],
+      generated: read.generated,
+      bindings: read.bindings,
       inOperands: inOperandNames(project, targetRoot, testFiles),
       rooted: read.rooted,
       directives: inlineDirectives(project, read.held, targetRoot).filter(
@@ -1281,9 +929,12 @@ export function readEmitterRun(
       ),
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
+      unseenLoads,
+      // Only a closed world reports an unnecessary export, which is all the carriers decide.
+      carriers: config.consumers.complete ? carriersOf(project, read.held) : NO_CARRIERS,
     }),
   );
-  // 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
@@ -1335,24 +986,19 @@ function judgedMembers(
 
 /** 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">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   selfCheck: SelfCheckFacts,
 ): EmitterInput {
   const targetRoot = scope.target.path;
@@ -1366,14 +1012,16 @@ export function emitterInputOver(
     stores: storesOf(
       projects.map((one) => ({
         references: one.configured.references,
+        support: new Set(one.configured.supportFiles ?? []),
         accessors: one.extra.accessors,
       })),
-      swept.exempt,
+      swept.sweep.exempt,
       input.mode,
     ),
     dependencies: dependenciesOf(
       host,
       targetRoot,
+      read.workflows,
       [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
       members.read,
@@ -1384,8 +1032,19 @@ export function emitterInputOver(
     files: {
       tree: sourceTree(host, targetRoot),
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
-      generated: new Set(projects.flatMap((one) => one.extra.generated)),
+      generated: new Set(projects.flatMap((one) => [...one.extra.generated.keys()])),
       inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
+      unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
+      unwrittenRuns: new Set(
+        projects.flatMap((one) =>
+          one.heldScripts
+            .filter((held) => held.unwritten)
+            .map(
+              (held) =>
+                relativePath(resolvePath(host.workingDirectory(), targetRoot), held.dir) ?? ".",
+            ),
+        ),
+      ),
     },
     boundary: {
       consumers: {
@@ -1394,12 +1053,25 @@ export function emitterInputOver(
       },
       encapsulated: readManifest(host, targetRoot).declaresExports,
       edges: readEdgeSides(host, targetRoot),
+      filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
+      possiblyLoaded: new Set(projects.flatMap((one) => one.possiblyLoaded)),
+      carriers: {
+        named: new Map(
+          [
+            ...Map.groupBy(
+              projects.flatMap((one) => [...one.extra.carriers.named]),
+              ([id]) => id,
+            ),
+          ].map(([id, entries]) => [id, [...new Set(entries.flatMap(([, named]) => named))]]),
+        ),
+        unread: new Set(projects.flatMap((one) => [...one.extra.carriers.unread])),
+      },
     },
     selfCheck,
     intraFunction: intraFunctionFacts(
       projects.map((one) => one.extra.parts),
       projects.flatMap((one) => one.configured.references),
-      new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered]),
+      new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held]),
     ),
   };
 }
@@ -1429,14 +1101,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,
@@ -1457,7 +1129,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 ?? []),
       ),
@@ -1474,8 +1146,16 @@ 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),
+      generated: new Map(read.projects.flatMap((one) => [...one.extra.generated])),
+      bindings: distinctBindings(read.projects.flatMap((one) => one.extra.bindings)),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1487,7 +1167,7 @@ function readAnalysis(
 function inputsOver(
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   read: ReadRun<EmitterExtra>,
@@ -1501,7 +1181,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),
@@ -1570,10 +1250,22 @@ 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[];
+  /** Every generated file of the run, by its path below the target root, each once. */
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+  /** Every binding record the run's generated files publish, each once. */
+  readonly bindings: readonly BindingRecord[];
 }
 
 /** One configuration whose component files a run cannot read. */
@@ -1582,13 +1274,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;
@@ -1601,7 +1286,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.
  */
@@ -1609,7 +1294,7 @@ export function runAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors = DETECTORS,
@@ -1621,14 +1306,22 @@ 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);
+  const held = new Set(analysis.swept.sweep.held);
   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 && one.files.length > 0,
+      ).length;
+
     if (questions === 0) {
       return [];
     }
@@ -1665,7 +1358,7 @@ export function runBaselineWrite(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   reason: string,