@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/dist/bin/node-host.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
+import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, readSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -77,6 +77,21 @@ function writeAtomically(path, pieces) {
         throw error;
     }
 }
+/** The text of a file's first `limit` bytes, or of all of it where it holds fewer. */
+function readHead(path, limit) {
+    const bytes = Buffer.alloc(limit);
+    const fd = openSync(path, "r");
+    try {
+        let held = 0;
+        for (let got = -1; got !== 0 && held < limit; held += got) {
+            got = readSync(fd, bytes, held, limit - held, null);
+        }
+        return bytes.toString("utf8", 0, held);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /** A new directory under the platform's temporary directory. */
 function temporaryDirectory() {
     const path = mkdtempSync(join(tmpdir(), `${PRODUCT}-mapper-`));
@@ -106,7 +121,7 @@ function componentMapperCommand() {
 export function nodeHost() {
     return {
         workingDirectory: () => process.cwd(),
-        readFile: (path) => readFileSync(path, "utf8"),
+        readFile: (path, limit) => limit === undefined ? readFileSync(path, "utf8") : readHead(path, limit),
         readDirectory: (path) => readdirSync(path, { withFileTypes: true }).map((entry) => ({
             name: entry.name,
             directory: entry.isDirectory(),
@@ -116,7 +131,10 @@ export function nodeHost() {
             if (stat === undefined) {
                 return "absent";
             }
-            return stat.isDirectory() ? "directory" : "file";
+            if (stat.isDirectory()) {
+                return "directory";
+            }
+            return stat.isFile() ? "file" : "other";
         },
         realPath: (path) => realpathSync(path),
         analyzerVersion: () => {

package/dist/src/analysis.js

@@ -8,13 +8,14 @@
 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, 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 { generatedFiles } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
 import { generatedFile, generatedFilesOf } from "./generated-file.js";
@@ -30,33 +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 { ancestors, 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 { 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 { roots, unmatchedEverywhere } from "./roots.js";
 import { decodedMembers, serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
 import { mergedGlobalInterfaces } from "./augmentations.js";
 import { unseenLoadsOf } from "./unseen-loads.js";
-import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
-import { GLOBALS_RUNNER, namesTestGlobals, withTestGlobals } from "./test-globals.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, inInstalledPackages, MANIFEST, manifestAt } from "./fs/manifest.js";
+import { holdsManifest, manifestAt } from "./fs/manifest.js";
 import { globExpression } from "./text/glob.js";
-import { LANGUAGE } from "./product.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -74,281 +70,76 @@ function documentOf(host, provenance, setting, targetRoot) {
     return relativePath(resolvePath(host.workingDirectory(), targetRoot), document) ?? "";
 }
 /**
- * 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 (holdsManifest(host, targetRoot)) {
-        found.set(targetRoot, { dir: targetRoot, path: MANIFEST });
-    }
-    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 (const dir of ancestors(dirnamePath(file), targetRoot)) {
-            if (seen.has(dir) || relativePath(targetRoot, dir) === undefined) {
-                break;
-            }
-            seen.add(dir);
-            const below = relativePath(targetRoot, dir) ?? "";
-            if (!inInstalledPackages(below) && !known.has(dir) && holdsManifest(host, dir)) {
-                found.push(dir);
-            }
-        }
-    }
-    return found.sort(bytewise);
-}
-/**
- * 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)),
-            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 = withTestGlobals(engine, host, parse, discovered.configFiles, 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 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 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`, []);
         }
-        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
@@ -357,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.
@@ -368,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) {
@@ -399,12 +194,12 @@ export function runRoots(engine, host, scope, config, provenance) {
     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.rootPatterns, projects.map((answer) => answer.rooted));
+    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,
     };
 }
@@ -468,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({
@@ -484,7 +279,7 @@ 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);
@@ -525,12 +320,12 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             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],
     }));
@@ -539,7 +334,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     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.consumers.references], support, mode),
+        ...countedWrites([...withOutside.flatMap((one) => one.references), ...read.result.references], support, mode),
         ...withOutside.flatMap((one) => [
             ...one.decoded.filled,
             ...one.decoded.parsed,
@@ -550,7 +345,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     const settled = settledSatisfaction(withOutside.map((one, index) => ({
         evidence: evidence[index] ?? [],
         held: one.projectRead.held,
-    })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
+    })), [...withOutside.flatMap((one) => one.references), ...read.result.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
         const satisfied = settled[index];
@@ -603,7 +398,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             extra: one.extra,
         };
     });
-    const consumed = read.consumers.references;
+    const consumed = read.result.references;
     const projects = answers.map((one) => consumed.length === 0
         ? one
         : {
@@ -623,15 +418,15 @@ 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,
+        conventionsApplied: read.plan.conventions.applied,
+        conventionUses: read.plan.conventions.uses,
+        memberDirs: read.plan.packages.members,
+        nestedDirs: read.plan.packages.nested,
     };
 }
 /**
@@ -904,7 +699,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
@@ -934,7 +729,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))