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

package/dist/src/analysis.js

@@ -8,50 +8,51 @@
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
-import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
-import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
-import { decorator } from "./decorator.js";
+import { consumerReferences } from "./consumers.js";
+import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
+import { carriersOf, NO_CARRIERS } from "./exposure.js";
 import { deprecatedDeclarations } from "./deprecation.js";
-import { discoverProjects, DiscoveryError, isGuess, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, targetRelative, withBaseUrlPaths, } from "./discover.js";
-import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
+import { moduleIdentity } from "./load/discover.js";
+import { loadRun } from "./load/load.js";
+import { readSources } from "./entries/sources.js";
+import { readWorkflows } from "./entries/workflow-steps.js";
 import { readEdgeSides } from "./edges.js";
-import { enumGroup } from "./enum-group.js";
-import { generatedFile, generatedFilesOf } from "./generated-file.js";
-import { inOperandNames } from "./in-operands.js";
+import { bindingsOf, distinctBindings } from "./bindings.js";
+import { generatedFilesOf } from "./exemptions/generated-file.js";
+import { inOperandNames } from "./findings/in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { DETECTORS, detection } from "./exemptions/detectors.js";
+import { exemptionsOf, settle } from "./exemptions/lifecycle.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
-import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
-import { frameworkLifecycle } from "./framework-lifecycle.js";
-import { implementations, mergeImplementations } from "./implementations.js";
-import { injectionContainer } from "./injection-container.js";
-import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
+import { implementations, mergeImplementations } from "./findings/implementations.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
-import { inventory } from "./inventory.js";
-import { packageEntries, readManifest } from "./manifest.js";
-import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
+import {} from "./inventory.js";
+import { inventory } from "./inventory/enumerate.js";
+import { readManifest } from "./roots/manifest.js";
+import { matrixOf, referenceKey } from "./liveness/matrix.js";
+import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
-import { LANGUAGE } from "./report.js";
-import { SetupError, setupLine } from "./setup-failure.js";
-import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
-import { reflectiveLookup } from "./reflective-lookup.js";
-import { references, testFileRulesOf } from "./references.js";
-import { roots, unmatchedEverywhere, } from "./roots.js";
-import { serializationContract } from "./serialization-contract.js";
-import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
-import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
-import { supportReferences, testSupportFiles } from "./test-support.js";
-import { diagnosticsOf, ownedAs, runSession, } from "./session.js";
+import { skippedUnits } from "./type-errors.js";
+import { references } from "./references.js";
+import { rootSet, unmatchedEverywhere, } from "./roots/root-set.js";
+import { decodedMembers } from "./exemptions/serialization-contract.js";
+import { outsideTestReferences, testFilesAt } from "./tests/outside.js";
+import { formedForNode } from "./load/synthesize.js";
+import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
+import { targetTestFile, testFilePaths, testFileRulesOf, withheldBy, } from "./tests/file-class.js";
+import { testSupportFiles } from "./tests/support.js";
 import { accessorsOf, storesOf } from "./stores.js";
 import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
-import { readTemplates, templateField } from "./template-field.js";
-import { ownErrors, workspaceRun } from "./workspace-run.js";
+import { sweep } from "./liveness/sweep.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest, manifestAt } from "./fs/manifest.js";
+import { runDirectories } from "./entries/run-directories.js";
+import { globExpression } from "./text/glob.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -68,288 +69,91 @@ function documentOf(host, provenance, setting, targetRoot) {
     const document = resolvePath(host.workingDirectory(), origin.label);
     return relativePath(resolvePath(host.workingDirectory(), targetRoot), document) ?? "";
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
- * 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, targetRoot, memberDirs, nestedDirs) {
-    const found = new Map();
-    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],
-    ]) {
-        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, targetRoot, files, known) {
-    const seen = new Set();
-    const found = [];
-    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(engine, host, scope, config, stage) {
     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])));
     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, text) => 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 = [];
-    let conventions = readConventions(host, parse, [], config.ts.disabledConventions);
-    let options;
-    const readManifests = (opened) => {
-        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 workflows = readWorkflows(host, targetRoot);
+        const 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,
+            manifest: packages.manifest,
+            otherPackages: packages.entries,
+            patterns: config.roots.patterns,
+            entryFiles: config.ts.entry_files,
             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 = [...discovered.notBuilt];
-    const dropped = (configFile, error) => {
-        notBuilt.push({
-            id: ids.get(configFile) ?? configFile,
-            configFile,
-            error: targetRelative(error, absoluteRoot),
-        });
-    };
-    const failures = [];
-    const unbuildable = [];
-    const setupDropped = [];
-    const librariesUnfound = [];
-    const consumed = new Map();
-    const heldFiles = new Set();
-    let outsideTests = [];
-    const setupMet = (configFile, met) => {
-        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();
-    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),
+        const heldFiles = new Set();
+        const answers = classified.analyzed.map(({ plan: planned, project, skips, referenceOnly }) => {
+            const read = () => {
+                const held = inventory(project, host, targetRoot);
+                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: planned.id,
+                    configFile: project.configFile,
+                    held,
+                    rooted,
+                    typeErrorSkips: skips.map((one) => one.record),
+                    skipped: skippedUnits(skips, absoluteRoot),
+                    referenceOnly: project
+                        .ownSourceFiles()
+                        .filter((file) => referenceOnly(file.fileName))
+                        .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
+                    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: planned.id, read });
         });
-        if (consumer !== undefined && reading.missing.length > 0) {
-            unbuildable.push(...reading.missing.map((one) => ({
-                setupClass: "missing-consumer",
-                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)) {
+        const consumed = new Map();
+        const consumerHeld = new Set();
+        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);
             }
-            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 read = () => {
-            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", source: "" })),
-                    ],
-                };
-            const own = sourceFilesOf(project, targetRoot);
-            return {
-                configuration,
-                configFile: project.configFile,
-                held,
-                rooted,
-                typeErrorSkips: skips.map((one) => one.record),
-                skipped: skippedUnits(skips, absoluteRoot),
-                referenceOnly: project
-                    .ownSourceFiles()
-                    .filter((file) => referenceOnly(file.fileName))
-                    .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-                generated: generatedFilesOf(own, generatedFiles(conventions, own)),
-                testFileNames: conventions.testFiles,
-            };
-        };
-        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`, []);
+            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 !== 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}`, []);
-    }
-    return {
-        answers,
-        consumers: {
-            loaded: loads.map((load) => load.consumer),
+        const outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), parse);
+        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 the run the scope and the configuration describe analyzes, each read
@@ -358,7 +162,11 @@ function readProjects(engine, host, scope, config, stage) {
  */
 export function runProjects(engine, host, scope, config) {
     const read = readProjects(engine, host, scope, 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,
+    };
 }
 /**
  * The root set of the run the scope and the configuration describe.
@@ -369,7 +177,7 @@ export function runProjects(engine, host, scope, config) {
 export function runRoots(engine, host, scope, config, provenance) {
     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 = [];
     const merged = new Map();
     for (const answer of projects) {
@@ -397,28 +205,25 @@ export function runRoots(engine, host, scope, config, provenance) {
             }
         }
     }
-    const ordered = [...merged.values()].sort((a, b) => byPosition(a.position, b.position) || compare(a.kind, b.kind) || compare(a.source, b.source));
-    const unmatched = unmatchedEverywhere(config.rootPatterns, projects.map((answer) => answer.rooted));
+    const ordered = [...merged.values()].sort((a, b) => byPosition(a.position, b.position) ||
+        bytewise(a.kind, b.kind) ||
+        bytewise(a.source, b.source));
+    const unmatched = unmatchedEverywhere(config.roots.patterns, projects.map((answer) => answer.rooted));
     return {
         configurations,
         roots: ordered,
         findings: unmatchedRootFindings(unmatched, documentOf(host, provenance, ROOTS_SETTING, targetRoot)),
-        notBuilt: read.notBuilt,
+        notBuilt: read.classified.notBuilt,
         unanswered: read.unanswered,
     };
 }
-/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-export const DETECTORS = new Map([
-    ["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],
-]);
+/** The production mode a configuration sets: a consumer's test reference is classed as `analysis.consumer_tests` says. */
+export function productionMode(config) {
+    return {
+        production: true,
+        consumerTestsProduction: config.analysis.consumer_tests === "production",
+    };
+}
 /** 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"];
@@ -435,18 +240,9 @@ function testEvidence(host, targetRoot, projects) {
         }
     }
     const manifests = new Map();
-    const manifestAt = (dir) => {
+    const manifestIn = (dir) => {
         if (!manifests.has(dir)) {
-            let value;
-            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
-                : undefined);
+            manifests.set(dir, manifestAt(host, dir));
         }
         return manifests.get(dir);
     };
@@ -455,16 +251,14 @@ function testEvidence(host, targetRoot, projects) {
     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;
         },
     };
 }
@@ -476,79 +270,103 @@ function testEvidence(host, targetRoot, projects) {
  */
 function readRun(engine, host, scope, config, mode, detectors, 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(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) => 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) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
                 line: lineOf(file.originalText, warning.offset),
                 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],
     }));
     // 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, 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));
-    const settled = settledSatisfaction(withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
+    const { support, testUsed } = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), 
+    // 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));
+    // 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) => {
         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 = {
             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 }),
@@ -568,20 +386,23 @@ function readRun(engine, host, scope, config, mode, detectors, 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
         : {
@@ -597,70 +418,32 @@ function readRun(engine, host, scope, config, mode, detectors, 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(read, input) {
-    const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
-    let live = new Set();
-    for (;;) {
-        const swept = {
-            ...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, inTestFiles) {
-    if (inTestFiles.length === 0) {
-        return [];
-    }
-    const files = new Map(symbols
-        .filter((symbol) => symbol.kind === "file")
-        .map((symbol) => [symbol.position.path, symbol.id]));
-    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,
-                },
-            ];
-    });
+function countedWrites(references, support, mode) {
+    return new Set(references.flatMap((reference) => reference.use === "write" && !withheldBy(mode, reference, support) ? [reference.to] : []));
 }
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
@@ -670,8 +453,9 @@ function writtenOnly(read, mode) {
     const written = new Set();
     const readSome = new Set();
     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) {
@@ -684,55 +468,22 @@ function writtenOnly(read, mode) {
     }
     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(read, input) {
-    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 = {
-            ...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),
     };
 }
 /**
@@ -746,23 +497,32 @@ function sweptOf(read, input) {
 export function runSweep(engine, host, scope, config, input, detectors = DETECTORS) {
     return sweptOf(readRun(engine, host, scope, config, input.mode, detectors, () => undefined), input);
 }
+/** The project's own files below the target root that are no test file. */
+function productionFiles(project, targetRoot, testFiles) {
+    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. */
 export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
-    const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references, testFiles) => ({
+    const run = readRun(engine, host, scope, config, mode, detectors, (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((directive) => !read.referenceOnly.includes(directive.site.path)),
         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
@@ -805,16 +565,11 @@ function judgedMembers(host, targetRoot, read) {
 }
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
 function nearestManifestDir(host, root, file) {
-    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, scope, config, read, input, selfCheck) {
     const targetRoot = scope.target.path;
@@ -827,15 +582,20 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
         deprecated: new Set(projects.flatMap((one) => one.extra.deprecation.deprecated)),
         stores: storesOf(projects.map((one) => ({
             references: one.configured.references,
+            support: new Set(one.configured.supportFiles ?? []),
             accessors: one.extra.accessors,
-        })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt, read.nestedDirs),
+        })), 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, members.unbuilt, read.nestedDirs),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         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: {
@@ -844,9 +604,17 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             },
             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])),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held])),
     };
 }
 /**
@@ -854,7 +622,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
  * 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, host, scope, config, provenance, mode, detectors) {
@@ -872,7 +640,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
                 id: one.configured.configuration,
                 configFile: one.configFile,
             })),
-            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
+            testFileRules: testFileRulesOf(config.ts.test_files, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
             typeErrorSkips: read.projects.flatMap((one) => one.typeErrorSkips),
             componentWarnings: [
                 ...new Map(read.projects
@@ -884,8 +652,14 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             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,
@@ -901,7 +675,7 @@ function inputsOver(host, scope, config, provenance, mode, read, documents) {
     };
     const facts = {
         refusals: suppressions.refusals,
-        unmatchedRoots: unmatchedEverywhere(config.rootPatterns, read.projects.map((one) => one.extra.rooted)),
+        unmatchedRoots: unmatchedEverywhere(config.roots.patterns, read.projects.map((one) => one.extra.rooted)),
         rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
         unmatchedDeclarations: configuredDeclarations(config)
             .filter((_, at) => !read.projects.some((one) => one.extra.declarationsNamed[at] === true))
@@ -937,7 +711,7 @@ function unmappedEverywhere(projects) {
 }
 /**
  * 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.
  */
@@ -948,12 +722,16 @@ export function runAnalysis(engine, host, scope, config, provenance, mode, detec
 }
 /**
  * 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) {
-    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 [];
         }