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

package/dist/src/analysis.js

@@ -5,23 +5,24 @@
  * makes: a view carries a project's identity in its type so a handle cannot cross to
  * another project's checker, which holds only for views the session hands out.
  */
+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 { consumerReferences } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
-import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
-import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
+import { moduleIdentity } from "./load/discover.js";
+import { loadRun } from "./load/load.js";
+import { generatedFiles } from "./conventions.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 { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.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";
@@ -30,27 +31,28 @@ import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
-import { packageEntries, readManifest } from "./manifest.js";
+import { readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.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 { 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 { decodedMembers, serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
-import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
+import { mergedGlobalInterfaces } from "./augmentations.js";
+import { unseenLoadsOf } from "./unseen-loads.js";
+import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
-import { diagnosticsOf, ownedAs, runSession, } from "./session.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 { bytewise } from "./text/compare.js";
+import { holdsManifest, manifestAt } from "./fs/manifest.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";
 /**
@@ -67,273 +69,77 @@ 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 options = {
             host,
-            manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-            otherPackages: [
-                ...(workspace?.entries ?? []),
-                ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
-            ],
-            patterns: config.rootPatterns,
-            entryFiles: config.ts.entryFiles,
+            manifest: packages.manifest,
+            otherPackages: packages.entries,
+            patterns: config.roots.patterns,
+            entryFiles: config.ts.entry_files,
             conventions,
-            testFiles: config.ts.testFiles,
+            testFiles: config.ts.test_files,
             parse,
-            publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
-            publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
+            publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
+            publishedMembers: packages.published,
+            runFiles,
         };
-    };
-    const notBuilt = [...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 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 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: 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: 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: 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();
+        for (const { project, consumer } of classified.consumed) {
+            const side = { id: consumer.id, root: consumer.path };
+            for (const reference of consumerReferences(project, host, targetRoot, side, config)) {
                 consumed.set(referenceKey(reference), reference);
             }
-            return undefined;
         }
-        librariesUnfound.push(...raw.unfound.map((one) => ({
-            configFile: project.configFile,
-            error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
-        })));
-        const configuration = ids.get(project.configFile) ?? project.configFile;
-        const read = () => {
-            const held = inventory(project, host, targetRoot);
-            const found = roots(project, held, targetRoot, options);
-            const kept = skippedRoots(project, held, reading.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: reading.skips.map((one) => one.record),
-                skipped: skippedUnits(reading.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
-        ? workspace?.programs
-        : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins), () => {
-        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), parse);
-    }, readManifests);
-    for (const configFile of session.unopened) {
-        if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
-            throw new DiscoveryError(`${configFile} opened no project`, []);
-        }
-        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),
-            references: [...consumed.values()],
-        },
-        notBuilt,
-        unanswered: session.unanswered,
-        componentsUnread: workspace?.componentsUnread ?? [],
-        librariesUnfound,
-        conventionsApplied: conventions.applied,
-        conventionUses: conventions.uses,
-        memberDirs,
-        nestedDirs,
-        outsideTests,
-    };
+        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()], outsideTests };
+    });
 }
 /**
  * The projects the run the scope and the configuration describe analyzes, each read
@@ -342,7 +148,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.
@@ -353,7 +163,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) {
@@ -381,13 +191,15 @@ 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,
     };
 }
@@ -403,6 +215,44 @@ export const DETECTORS = new Map([
     ["framework-lifecycle", frameworkLifecycle],
     ["serialization-contract", serializationContract],
 ]);
+/** 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"];
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(host, targetRoot, projects) {
+    const imports = new Map();
+    for (const one of projects) {
+        for (const [path, specifiers] of one.imports) {
+            imports.set(path, specifiers);
+        }
+    }
+    const manifests = new Map();
+    const manifestIn = (dir) => {
+        if (!manifests.has(dir)) {
+            manifests.set(dir, manifestAt(host, dir));
+        }
+        return manifests.get(dir);
+    };
+    const declares = (section, name) => typeof section === "object" && section !== null && Object.hasOwn(section, name);
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return {
+        imports,
+        devDependency: (path, name) => {
+            for (const dir of ancestors(dirnamePath(joinPath(root, path)), root)) {
+                const manifest = manifestIn(dir);
+                const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+                if (declares(manifest?.[DEV_SECTION], name) || other) {
+                    return !other;
+                }
+            }
+            return false;
+        },
+    };
+}
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -413,13 +263,13 @@ 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: [] }
+        ? { delimiters: config.analysis.template_delimiters, files: [] }
         : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
     const read = readProjects(engine, host, scope, config, (project, opened) => {
         const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
-            testFiles: config.ts.testFiles,
+            testFiles: config.ts.test_files,
             testFileNames: projectRead.testFileNames,
         });
         const evidence = evidenceRecords({
@@ -429,11 +279,14 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             templates,
             ts: config.ts,
             consumers,
-            ...(config.analysis.generatedFiles === "include"
+            ...(config.analysis.generated_files === "include"
                 ? {}
                 : { generated: projectRead.generated }),
         }, detectors, disabled);
         const components = project.ownSourceFiles().filter(isComponentFile);
+        const injected = project.program
+            .getSourceFileNames()
+            .some((name) => name.endsWith(`/node_modules/${GLOBALS_RUNNER}/globals.d.ts`));
         const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             projectRead,
@@ -441,45 +294,81 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
+            augmented: mergedGlobalInterfaces(project, projectRead.held, sourceFilesOf(project, targetRoot)).map((id) => ({ id, kind: "global-augmentation", source: "" })),
+            imports: new Map(project.ownSourceFiles().flatMap((file) => {
+                const path = relativePath(targetRoot, file.fileName);
+                if (path === undefined) {
+                    return [];
+                }
+                const specifiers = file.imports.filter(isStringLiteralLikeNode).map((one) => one.text);
+                // A file calling the globals a program declares is written for their runner.
+                return [
+                    [
+                        path,
+                        injected && namesTestGlobals(project, file)
+                            ? [...specifiers, GLOBALS_RUNNER]
+                            : specifiers,
+                    ],
+                ];
+            })),
             componentWarnings: components.flatMap((file) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
             }))),
+            decoded: decodedMembers(project, projectRead.held, productionFiles(project, targetRoot, resolved.testFilePaths), consumers),
             extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
         };
     });
-    const outsidePaths = read.outsideTests.map((one) => one.path);
-    const withOutside = read.answers.map((one) => ({
+    const outsidePaths = read.result.outsideTests.map((one) => one.path);
+    const withOutside = read.result.answers.map((one) => ({
         ...one,
         references: [
             ...one.references,
-            ...outsideTestReferences(read.outsideTests, one.projectRead.held, targetRoot),
+            ...outsideTestReferences(read.result.outsideTests, one.projectRead.held, targetRoot),
         ],
         testFiles: [...one.testFiles, ...outsidePaths],
     }));
     // Test-support code is code only test code imports in any configuration of the run: a
     // configuration that holds no test file says nothing about what the tests import.
-    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
-    const 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), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles), testEvidence(host, targetRoot, withOutside));
+    // A member a decode fills or a copy carries is written: a value decoded and sent again carries it on.
+    const written = new Set([
+        ...countedWrites([...withOutside.flatMap((one) => one.references), ...read.result.references], support, mode),
+        ...withOutside.flatMap((one) => [
+            ...one.decoded.filled,
+            ...one.decoded.parsed,
+            ...one.decoded.copied,
+        ]),
+    ]);
+    const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
+    const settled = settledSatisfaction(withOutside.map((one, index) => ({
+        evidence: evidence[index] ?? [],
+        held: one.projectRead.held,
+    })), [...withOutside.flatMap((one) => one.references), ...read.result.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
         const satisfied = settled[index];
-        const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
+        const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
         const exempt = detected.records;
         const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
-        const supportFiles = [...support].filter((path) => held.has(path)).sort();
+        const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
+        const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
-            roots: projectRead.rooted.liveUnderReachability,
-            testFiles: one.testFiles,
+            // The augmentations are rooted after test support is read: an outside declaration
+            // naming one calls nothing of its file.
+            roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
+            testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
+            ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
+            ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
@@ -498,15 +387,19 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                     .filter((reference) => reference.resolution === "by-name")
                     .map((reference) => reference.to),
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+                ...one.decoded.unanswered,
             ],
+            filledOutside: one.decoded.filled,
             typeErrorSkips: projectRead.typeErrorSkips,
+            unmappedEntries: projectRead.rooted.unmappedEntries,
+            heldScripts: projectRead.rooted.heldScripts,
             skipped: projectRead.skipped,
             componentFiles: one.componentFiles,
             componentWarnings: one.componentWarnings,
             extra: one.extra,
         };
     });
-    const consumed = read.consumers.references;
+    const consumed = read.result.references;
     const projects = answers.map((one) => consumed.length === 0
         ? one
         : {
@@ -526,15 +419,17 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             ]),
         ],
         projects,
-        consumers: read.consumers.loaded,
-        notBuilt: read.notBuilt,
+        consumers: read.plan.discovery.consumers,
+        notBuilt: read.classified.notBuilt,
         unanswered: read.unanswered,
-        componentsUnread: read.componentsUnread,
-        librariesUnfound: read.librariesUnfound,
-        conventionsApplied: read.conventionsApplied,
-        conventionUses: read.conventionUses,
-        memberDirs: read.memberDirs,
-        nestedDirs: read.nestedDirs,
+        componentsUnread: read.plan.workspace?.componentsUnread ?? [],
+        librariesUnfound: read.classified.librariesUnfound,
+        unresolvedSpecifiers: read.classified.unresolvedSpecifiers,
+        unread: read.plan.unread,
+        conventionsApplied: read.plan.conventions.applied,
+        conventionUses: read.plan.conventions.uses,
+        memberDirs: read.plan.packages.members,
+        nestedDirs: read.plan.packages.nested,
     };
 }
 /**
@@ -587,6 +482,13 @@ function evidenceReferences(symbols, inTestFiles) {
             ];
     });
 }
+/**
+ * The declarations a write the mode counts stores into, a write a test-support file
+ * makes being a test's.
+ */
+function countedWrites(references, support, mode) {
+    return new Set(supportReferences(references, support).flatMap((reference) => reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : []));
+}
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
  * reference counting as a read: what the write-only kind would report but for a record.
@@ -657,7 +559,7 @@ function sweptOf(read, input) {
         unanswered: read.unanswered,
         heldByUnanswered: [...held],
         skipped: read.projects.flatMap((one) => one.skipped),
-        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(compare),
+        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
     };
 }
 /**
@@ -671,6 +573,11 @@ 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;
@@ -686,8 +593,9 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         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: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
     }));
-    // Whether a declaration carries the marker decides its code, so one whose marker went
+    // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
     const unread = run.projects.flatMap((one) => one.extra.deprecation.unanswered);
     return unread.length === 0
@@ -698,7 +606,8 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(host, targetRoot, read) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -717,20 +626,23 @@ function judgedMembers(host, targetRoot, read) {
             judged.unbuilt.push(dir);
         }
     }
+    for (const dir of read.nestedDirs) {
+        const below = relativePath(root, dir);
+        if (below !== undefined &&
+            owners.has(dir) &&
+            ![...held].some((path) => path.startsWith(`${below}/`))) {
+            judged.unbuilt.push(dir);
+        }
+    }
     return judged;
 }
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
 function nearestManifestDir(host, 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;
@@ -752,6 +664,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
             generated: new Set(projects.flatMap((one) => one.extra.generated)),
             inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
+            unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
         },
         boundary: {
             consumers: {
@@ -760,6 +673,7 @@ 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)),
         },
         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])),
@@ -770,7 +684,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) {
@@ -788,7 +702,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
@@ -800,7 +714,12 @@ 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),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -816,7 +735,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))
@@ -837,9 +756,22 @@ function inputsOver(host, scope, config, provenance, mode, read, documents) {
         suppressions,
     };
 }
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(projects) {
+    const key = (entry) => `${entry.dir}\u0000${entry.member}`;
+    const [first, ...rest] = projects;
+    const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+    const found = new Map();
+    for (const entry of first?.unmappedEntries ?? []) {
+        if (others.every((one) => one.has(key(entry)))) {
+            found.set(key(entry), entry);
+        }
+    }
+    return [...found.values()];
+}
 /**
  * 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.
  */
@@ -850,12 +782,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);
     return analysis.run.projects.flatMap((project) => {
-        const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length;
+        const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +
+            analysis.run.unread.filter((one) => one.kind === "manifest" && one.configFile === project.configFile).length +
+            analysis.run.heldScripts.filter((one) => one.configFile === project.configFile).length;
         if (questions === 0) {
             return [];
         }