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

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,31 +31,27 @@ 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";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -73,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.disabled_conventions);
-    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.disabled_conventions);
-        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),
-            ],
+            manifest: packages.manifest,
+            otherPackages: packages.entries,
             patterns: config.roots.patterns,
             entryFiles: config.ts.entry_files,
             conventions,
             testFiles: config.ts.test_files,
             parse,
             publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "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)))),
+            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.test_files.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
@@ -356,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.
@@ -367,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) {
@@ -403,7 +199,7 @@ export function runRoots(engine, host, scope, config, provenance) {
         configurations,
         roots: ordered,
         findings: unmatchedRootFindings(unmatched, documentOf(host, provenance, ROOTS_SETTING, targetRoot)),
-        notBuilt: read.notBuilt,
+        notBuilt: read.classified.notBuilt,
         unanswered: read.unanswered,
     };
 }
@@ -524,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],
     }));
@@ -538,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,
@@ -549,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];
@@ -602,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
         : {
@@ -622,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,
     };
 }
 /**

package/dist/src/configuration-files.js

@@ -11,7 +11,7 @@ import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./p
 import { bytewise } from "./text/compare.js";
 import { isRecord } from "./json-document.js";
 import { filesIn } from "./fs/tree.js";
-import { holdsManifest, inInstalledPackages, manifestAt, readJSON } from "./fs/manifest.js";
+import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "./fs/manifest.js";
 import { shellWords } from "./text/shell.js";
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS = [
@@ -24,13 +24,6 @@ const MODULE_FORMS = [
 ];
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"];
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
@@ -351,7 +344,7 @@ export function declaredIn(host, dir) {
         return [];
     }
     const names = new Set();
-    for (const member of DEPENDENCY_MEMBERS) {
+    for (const member of DEPENDENCY_SECTIONS) {
         const section = value[member];
         if (isRecord(section)) {
             Object.keys(section).forEach((name) => names.add(name));

package/dist/src/consumers.js

@@ -1,34 +1,7 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-import { consumerProjects } from "./discover.js";
-import { inventory, packageScope } from "./inventory.js";
+import { inventory } from "./inventory.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host, module) {
-    return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(engine, host, scope, targetConfigFiles) {
-    const opened = new Set(targetConfigFiles);
-    return scope.consumers.map((module) => {
-        const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-            const fresh = !opened.has(configFile);
-            opened.add(configFile);
-            return fresh;
-        });
-        return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-    });
-}
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's

package/dist/src/contract/contract.generated.js

@@ -1072,13 +1072,23 @@ export const EVIDENCE = [
         ],
     },
 ];
-export const SETUP_CLASSES = [
-    { class: "missing-module", languages: ["go", "ts"] },
-    { class: "incomplete-module-sum", languages: ["go"] },
-    { class: "missing-consumer", languages: ["go", "ts"] },
-    { class: "workspace-member-without-source", languages: ["ts"] },
-    { class: "convention-not-literal", languages: ["ts"] },
-    { class: "no-program", languages: ["go", "ts"] },
-];
-/** The text opening the line of the error stream that names one setup failure. */
-export const SETUP_FAILURE_PREFIX = "setup failure: ";
+/** Each group of failure classes, and the text opening the line that names one of its failures. */
+export const FAILURE_PREFIXES = { setup: "setup failure: ", run: "run failure: " };
+/** Each failure class the Contract names, and its group. */
+export const FAILURE_CLASSES = {
+    "missing-module": "setup",
+    "incomplete-module-sum": "setup",
+    "missing-consumer": "setup",
+    "workspace-member-without-source": "setup",
+    "convention-not-literal": "setup",
+    "no-program": "setup",
+    "unreadable-document": "setup",
+    "unwritten-output": "run",
+    "unreportable-path": "run",
+    "memory-exhausted": "run",
+    "missing-analyzer": "run",
+    "unadmitted-analyzer": "run",
+    "unresolved-edge": "run",
+    "interrupted-run": "run",
+    "product-fault": "run",
+};

package/dist/src/conventions.js

@@ -15,7 +15,7 @@ import { bytewise } from "./text/compare.js";
 import { isRecord } from "./json-document.js";
 import { unwrapped } from "./unwrap.js";
 import { filesIn } from "./fs/tree.js";
-import { INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.js";
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.js";
 import { globExpression } from "./text/glob.js";
 import { yamlDocument } from "./text/yaml.js";
 const JSON_EXTENSION = ".json";
@@ -29,11 +29,6 @@ const YAML_NAME = /\.ya?ml$/u;
 const JSON_RC = /^\.[\w-]+rc$/u;
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
-const DEPENDENCY_SECTIONS = [
-    ...REQUIRED_SECTIONS,
-    "peerDependencies",
-    "optionalDependencies",
-];
 function declares(manifest, name, sections = DEPENDENCY_SECTIONS) {
     if (!isRecord(manifest)) {
         return false;
@@ -776,7 +771,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 failures.push({
                     dir: manifest.dir,
                     failure: {
-                        setupClass: "missing-module",
+                        failureClass: "missing-module",
                         detail: `${manifest.path} declares ${row.package}, which no node_modules at or ` +
                             `above its directory holds: run the package manager's install`,
                     },
@@ -801,7 +796,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 failures.push({
                     dir: manifest.dir,
                     failure: {
-                        setupClass: "convention-not-literal",
+                        failureClass: "convention-not-literal",
                         detail: where === "." ? failed : `${where}/${failed}`,
                     },
                 });