@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/dist/src/contextual-uses.js

@@ -3,15 +3,18 @@
  * An object-literal property writes the member of its name on each constituent of the
  * literal's contextual type that declares one. A value reaching a position typed by another
  * object type reads each of its members that type declares, through array elements and
- * function parameters and results too; a class instance there is the
- * interface-satisfaction class's evidence instead.
+ * the parameters and results of functions and constructors too; a class instance there is
+ * the interface-satisfaction class's evidence instead.
  */
-import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
-import { SignatureKind } from "@typescript/native/unstable/sync";
+import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags } from "@typescript/native/unstable/sync";
 import { isAnswered } from "./query.js";
 /** The member kinds a contextual type writes and reads: data members and the members of object types. */
 const MEMBER_KINDS = new Set(["type-member", "class-member"]);
-/** The name one literal property is written under, where the name is literal text. */
+/**
+ * The name one literal property is written under: its literal text, or the computed name
+ * node whose key the checker names, a unique symbol among them.
+ */
 function propertyName(property) {
     if (!isPropertyAssignment(property) &&
         !isShorthandPropertyAssignment(property) &&
@@ -29,6 +32,7 @@ function propertyName(property) {
         if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
             return { node: name, text: key.text };
         }
+        return { node: name, text: undefined };
     }
     return undefined;
 }
@@ -41,6 +45,9 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const queries = project.queries;
     const ownPaths = project.ownPaths();
     const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    const privateNames = new Set(held.symbols
+        .filter((symbol) => symbol.visibility === "private-name")
+        .map((symbol) => symbol.id));
     let batches = 0;
     let lookups = 0;
     const batchesOf = (count) => Math.ceil(count / cap);
@@ -80,6 +87,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
                 handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
                 own: property.declarations.some((handle) => ownPaths.has(handle.path)),
+                accessor: (property.flags & SymbolFlags.Accessor) !== 0,
             });
         }
         tables.set(type.id, table);
@@ -88,6 +96,25 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const writes = [];
     batches += batchesOf(literals.length);
     const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
+    // A computed name that is not literal text names the property the literal declares
+    // under the checker's own key, which is how a type declares a member a unique symbol
+    // keys: asked once, for the literals that have a contextual type.
+    const computed = literals.flatMap(({ literal }, index) => contexts[index] === undefined || !isAnswered(contexts[index])
+        ? []
+        : literal.properties.flatMap((property) => {
+            const name = propertyName(property);
+            return name !== undefined && name.text === undefined ? [name.node] : [];
+        }));
+    batches += batchesOf(computed.length);
+    const keys = new Map();
+    (computed.length === 0
+        ? []
+        : project.symbolsAt(computed.map((node) => project.handle(node)), cap)).forEach((symbol, index) => {
+        const node = computed[index];
+        if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+            keys.set(node, symbol.name);
+        }
+    });
     literals.forEach(({ literal, from }, index) => {
         const context = contexts[index];
         if (context === undefined || !isAnswered(context)) {
@@ -96,10 +123,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const tablesOf = partsOf(context).map(membersOf);
         for (const property of literal.properties) {
             const name = propertyName(property);
-            if (name === undefined) {
+            const text = name?.text ?? (name === undefined ? undefined : keys.get(name.node));
+            if (name === undefined || text === undefined) {
                 continue;
             }
-            const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+            const ids = [...new Set(tablesOf.flatMap((table) => table.get(text)?.ids ?? []))];
             if (ids.length > 0) {
                 writes.push({ at: name.node, from, ids });
             }
@@ -134,13 +162,22 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return element;
     };
     const calls = new Map();
-    /** The parameter and return types of a type's one call signature, read once per type. */
+    /**
+     * The parameter and return types of a type's one call signature, or of its one construct
+     * signature where it has no call signature, read once per type.
+     */
     const callOf = (type) => {
         if (calls.has(type.id)) {
             return calls.get(type.id);
         }
         lookups += 1;
-        const signatures = queries.signaturesOf(type, SignatureKind.Call);
+        let kind = SignatureKind.Call;
+        let signatures = queries.signaturesOf(type, kind);
+        if (isAnswered(signatures) && signatures.length === 0) {
+            lookups += 1;
+            kind = SignatureKind.Construct;
+            signatures = queries.signaturesOf(type, kind);
+        }
         let called;
         const [signature, ...more] = isAnswered(signatures) ? signatures : [];
         if (signature !== undefined && more.length === 0) {
@@ -148,6 +185,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const result = queries.returnTypeOf(signature);
             lookups += parameters.length + 1;
             called = {
+                kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
                 result: isAnswered(result) ? result : undefined,
             };
@@ -188,7 +226,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     continue;
                 }
                 const other = called === undefined ? undefined : callOf(part);
-                if (called === undefined || other === undefined) {
+                if (called === undefined || other?.kind !== called.kind) {
                     continue;
                 }
                 other.parameters.forEach((parameter, index) => {
@@ -264,5 +302,25 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
         }
     });
+    const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
+    batches += batchesOf(spreads.length);
+    const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
+    spreads.forEach(({ value, from }, index) => {
+        const type = spreadTypes[index];
+        if (type === undefined || !isAnswered(type)) {
+            return;
+        }
+        // A spread gets every own enumerable property, an overwritten key's getter included.
+        // So it reads each data member but a class's accessor, which sits on the prototype with
+        // the class's methods (never data members), and a private name, which is no property
+        // (https://tc39.es/ecma262/#sec-copydataproperties).
+        const own = (member, id) => !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-member");
+        const ids = [
+            ...new Set(partsOf(type).flatMap((part) => [...membersOf(part).values()].flatMap((member) => member.ids.filter((id) => own(member, id))))),
+        ];
+        if (ids.length > 0) {
+            reads.push({ at: value, from, ids });
+        }
+    });
     return { writes, reads, batches, lookups };
 }

package/dist/src/convention-rows.js

@@ -39,8 +39,43 @@ const BABEL_CONFIG = [
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
+/**
+ * The properties Vitest takes its project root from, `test.root` before Vite's `root`; it
+ * resolves `setupFiles` against that root (https://vitest.dev/config/setupfiles).
+ */
+const VITEST_ROOTS = ["test.root", "root"];
+/** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
+const ANGULAR_ENTRIES = [
+    "src/{main,main.server,server,polyfills,test}.ts",
+    "server.ts",
+    "projects/*/src/{main,main.server,server,polyfills,test,public-api}.ts",
+    "projects/*/server.ts",
+];
+/** The `angular.json` members whose strings name the packages a build loads. */
+const ANGULAR_PACKAGE_KEYS = [
+    "builder",
+    "polyfills",
+    "styles",
+    "scripts",
+].map((key) => ({ key, files: ["angular.json"] }));
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS = [
+    {
+        name: "angular",
+        package: "@angular/build",
+        range: ">=17.0.0 <22.0.0",
+        entries: ANGULAR_ENTRIES,
+        moves: [],
+        packageKeys: ANGULAR_PACKAGE_KEYS,
+    },
+    {
+        name: "angular-devkit",
+        package: "@angular-devkit/build-angular",
+        range: ">=12.0.0 <22.0.0",
+        entries: ANGULAR_ENTRIES,
+        moves: [],
+        packageKeys: ANGULAR_PACKAGE_KEYS,
+    },
     {
         name: "astro",
         package: "astro",
@@ -472,6 +507,18 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "vitepress",
+        package: "vitepress",
+        range: ">=1.0.0 <2.0.0-0 || >=2.0.0-alpha.0 <3.0.0",
+        entries: [
+            `.vitepress/config.${ANY_MODULE}`,
+            `.vitepress/theme/index.${ANY_MODULE}`,
+            `**/*.data.${ANY_MODULE}`,
+            "**/*.vue",
+        ],
+        moves: [],
+    },
     {
         name: "vitest",
         package: "vitest",
@@ -493,5 +540,6 @@ export const CONVENTION_ROWS = [
             { property: "test.coverage.include", files: [VITEST_CONFIG] },
             { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
         ],
+        testFiles: [{ property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS }],
     },
 ];

package/dist/src/conventions.js

@@ -413,6 +413,35 @@ function holdsValue(held, value) {
             return first !== undefined && literalText(first) === value;
         }));
 }
+/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
+function testFileRoot(file, dir, reading) {
+    for (const property of reading.roots) {
+        const values = valuesAt(file, property, reading.call);
+        if (values.length > 0) {
+            const texts = new Set(values.map(literalText));
+            const [text] = texts;
+            return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
+        }
+    }
+    return dir;
+}
+/** The files an applied row's test-file properties name. */
+function testFilesNamed(host, parse, dir, readings, into) {
+    for (const reading of readings) {
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            const at = testFileRoot(file, dir, reading);
+            if (at === undefined) {
+                continue;
+            }
+            for (const node of stringsAt(file, reading.property, reading.call)) {
+                const text = literalText(node);
+                if (text !== undefined && text !== "") {
+                    into.add(resolvePath(at, text));
+                }
+            }
+        }
+    }
+}
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(host, parse, dir, readings, into) {
     for (const reading of readings) {
@@ -602,6 +631,50 @@ function helperUses(host, parse, dir, manifest, readings) {
         readingFiles(host, parse, dir, reading.files).some(({ file }) => valuesAt(file, reading.property, reading.call).some((held) => holdsValue(held, reading.value))))
         .map((reading) => reading.package);
 }
+/**
+ * The dependencies one manifest declares that an applied row's package keys use: each
+ * whose name a string under a member of a key's name equals, or begins followed by `/` or
+ * by `:` and a name. A member's own name is no such string.
+ */
+function packageKeyUses(host, parse, dir, manifest, keys) {
+    const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    });
+    const strings = [];
+    const collect = (node) => {
+        const text = literalText(node);
+        if (text !== undefined) {
+            strings.push(text);
+        }
+        else if (isPropertyAssignment(node)) {
+            collect(node.initializer);
+        }
+        else {
+            node.forEachChild(collect);
+        }
+    };
+    for (const { key, files } of keys) {
+        const visit = (node) => {
+            if (isPropertyAssignment(node) && keyOf(node) === key) {
+                collect(node.initializer);
+            }
+            node.forEachChild(visit);
+        };
+        for (const { file } of readingFiles(host, parse, dir, files)) {
+            const values = declaredValues(file);
+            for (const one of defaultExports(file)) {
+                const object = objectOf(one, values, true);
+                if (object !== undefined) {
+                    visit(object);
+                }
+            }
+        }
+    }
+    return declared.filter((name) => strings.some((text) => text === name ||
+        text.startsWith(`${name}/`) ||
+        (text.startsWith(`${name}:`) && text.length > name.length + 1)));
+}
 /** Two strings ordered bytewise. */
 function compare(a, b) {
     if (a === b) {
@@ -620,6 +693,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const failures = [];
     const uses = new Set();
     const selected = new Map();
+    const testFiles = new Set();
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
         const versions = new Map();
@@ -680,6 +754,10 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
                 uses.add(name);
             }
+            const keys = row.packageKeys ?? [];
+            for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
+                uses.add(name);
+            }
             for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
                 uses.add(name);
             }
@@ -687,6 +765,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 uses.add(name);
             }
             selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
+            testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
@@ -714,6 +793,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
         failures,
         uses: [...uses].sort(compare),
         selected,
+        testFiles,
     };
 }
 /**

package/dist/src/dependencies.js

@@ -1,17 +1,19 @@
 /**
- * The dependencies the target's manifest and its workspace members' manifests declare, and
- * what the projects' own files need from outside the target. A file needs a package it
- * imports, re-exports from, augments or references the types of, by name or through the
- * file the specifier resolves to; a compiler configuration needs one it names, and a
- * configuration file a tool loads needs each dependency its strings spell. A package one
- * dependency pulls in for itself is that dependency's need, not the target's.
+ * The dependencies the target's manifest and its workspace members' manifests declare, and what the
+ * projects' own files need from outside the target. A file needs a package it imports, re-exports
+ * from, augments, references the types of or asks the runtime to resolve, by name or through the
+ * file the specifier resolves to; a compiler configuration needs one it names, and a configuration
+ * file a tool loads needs each dependency its strings spell. A package one dependency pulls in for
+ * itself is that dependency's need, not the target's.
  */
-import { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
+import { scriptTokens } from "./manifest.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
+import { workflowTokens } from "./workflow-steps.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -29,7 +31,7 @@ export function configurationNeeds(packages) {
     return {
         packages: new Set(packages),
         uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
-        unanswered: false,
+        unanswered: [],
     };
 }
 function isRecord(value) {
@@ -219,9 +221,11 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         }
     };
     use([PROJECT_OWNER], packages);
-    let unanswered = false;
+    const unanswered = [];
     for (const file of project.ownSourceFiles()) {
-        unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
+        if (fileNeeds(project, held, file, programPackages, use)) {
+            unanswered.push(file.fileName);
+        }
     }
     const beside = new Map();
     const declaredAt = (path) => {
@@ -240,16 +244,20 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             use(ownersOf(file, held, node), dependenciesNamed(text, names));
         }
     }
-    for (const document of configuration.documents) {
-        const names = declaredAt(document.path);
-        for (const text of document.strings) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { strings, manifestDirs } of configuration.documents) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const text of strings) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names));
+            }
         }
     }
-    for (const { file, manifestDir } of configuration.outside) {
-        const names = declaredAt(joinPath(manifestDir, "package.json"));
-        for (const { text } of moduleStrings(file)) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { file, manifestDirs } of configuration.outside) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const { text } of moduleStrings(file)) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names));
+            }
         }
     }
     return { packages, uses, unanswered };
@@ -365,8 +373,40 @@ function fileNeeds(project, held, file, programPackages, use) {
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
+    for (const specifier of resolvedSpecifiers(file)) {
+        const named = packageOfSpecifier(specifier.text);
+        if (named !== undefined) {
+            use(ownersOf(file, held, specifier), [named]);
+        }
+    }
     return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
+/**
+ * The literal specifiers one file asks the runtime to resolve, through `import.meta.resolve`
+ * or `require.resolve`, each of which needs the package it names installed.
+ */
+function resolvedSpecifiers(file) {
+    const found = [];
+    if (!file.text.includes(".resolve(")) {
+        return found;
+    }
+    const visit = (node) => {
+        if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
+            const callee = node.expression;
+            const [argument] = node.arguments;
+            const receiver = callee.expression;
+            const resolving = callee.name.text === "resolve" &&
+                ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
+                    (isIdentifier(receiver) && receiver.text === "require"));
+            if (resolving && argument !== undefined && isLiteralText(argument)) {
+                found.push(argument);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(file);
+    return found;
+}
 /** The offset just past the JSON value that starts at `at` in text the parser has accepted. */
 function valueEnd(text, at) {
     const first = text.charAt(at);
@@ -455,20 +495,16 @@ function installedOf(host, root, name) {
     for (let dir = root;; dir = dirnamePath(dir)) {
         const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
         if (read !== undefined && isRecord(read.value)) {
-            const manifest = read.value;
-            const bin = manifest["bin"];
-            const peers = manifest["peerDependencies"];
-            const meta = isRecord(manifest["peerDependenciesMeta"])
-                ? manifest["peerDependenciesMeta"]
-                : {};
+            const bin = read.value["bin"];
+            // A string `bin` names one command, the package's name without its scope.
             return {
-                command: (typeof bin === "string" && bin !== "") || (isRecord(bin) && Object.keys(bin).length > 0),
-                peers: isRecord(peers)
-                    ? Object.keys(peers).filter((peer) => {
-                        const about = meta[peer];
-                        return !(isRecord(about) && about["optional"] === true);
-                    })
-                    : [],
+                commands: typeof bin === "string"
+                    ? bin === ""
+                        ? []
+                        : [name.slice(name.indexOf("/") + 1)]
+                    : isRecord(bin)
+                        ? Object.keys(bin)
+                        : [],
             };
         }
         if (dirnamePath(dir) === dir) {
@@ -501,37 +537,70 @@ function declaredIn(text, manifest, path, scope) {
     }
     return declared.sort((a, b) => a.at - b.at).map(({ dependency }) => dependency);
 }
+/** The key one declared dependency is known by: its manifest's path and its name. */
+export function declarationKey(dependency) {
+    return `${dependency.position.path}\u0000${dependency.name}`;
+}
+/** Every token of every value of one manifest's `scripts` member. */
+function scriptTokensOf(manifest) {
+    const scripts = manifest["scripts"];
+    const found = new Set();
+    if (isRecord(scripts)) {
+        for (const command of Object.values(scripts)) {
+            if (typeof command === "string") {
+                scriptTokens(command).forEach((token) => found.add(token));
+            }
+        }
+    }
+    return found;
+}
+/** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
+function isInside(path, dir) {
+    return dir === "" || path.startsWith(`${dir}/`);
+}
 /**
  * The run's dependency evidence: the target's manifest and each workspace member's in
  * `members` below the target root, read with the position of every dependency each
- * declares, the installed copy of each found from its manifest's directory, what the
- * projects need, and the last uses each deletion candidate holds. A manifest the
- * program cannot read declares nothing.
+ * declares, what the projects and the commands its scripts and workflow steps run need,
+ * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
+ * in configurations the run could not build. A manifest the program cannot read declares
+ * nothing.
  */
-export function dependenciesOf(host, targetRoot, perProject, candidates, members = []) {
+export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const scopeOf = packageScope(host, targetRoot);
     const manifests = new Map([[root, MANIFEST]]);
-    for (const dir of members) {
+    const unbuilt = new Set();
+    for (const dir of [...members, ...unbuiltMembers]) {
         const below = relativePath(root, dir);
         if (below !== undefined && !manifests.has(dir)) {
             manifests.set(dir, `${below}/${MANIFEST}`);
         }
     }
+    for (const dir of unbuiltMembers) {
+        const path = manifests.get(dir);
+        if (path !== undefined && dir !== root) {
+            unbuilt.add(path);
+        }
+    }
+    const workflow = new Set(workflowTokens(host, targetRoot));
     const declared = [];
-    const installed = new Map();
+    const ran = new Set();
     for (const [dir, path] of manifests) {
         const read = readJSON(host, joinPath(dir, MANIFEST));
         if (read === undefined || !isRecord(read.value)) {
             continue;
         }
+        const tokens = scriptTokensOf(read.value);
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
             declared.push(dependency);
-            if (!installed.has(dependency.name)) {
-                const found = installedOf(host, dir, dependency.name);
-                if (found !== undefined) {
-                    installed.set(dependency.name, found);
-                }
+            const found = installedOf(host, dir, dependency.name);
+            if (found === undefined) {
+                continue;
+            }
+            const runs = (command) => tokens.has(command) || (dir === root && workflow.has(command));
+            if (found.commands.some(runs)) {
+                ran.add(declarationKey(dependency));
             }
         }
     }
@@ -540,9 +609,15 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     const needed = new Set();
     const uses = new Map();
     for (const project of perProject) {
-        // A specifier the checker left unanswered may resolve to any declared dependency,
-        // and what the configuration needs is never deleted, so it is needed there.
-        const unknown = project.unanswered ? declared.map((dependency) => dependency.name) : [];
+        // A specifier the checker left unanswered may resolve to any dependency a manifest at
+        // or above its file declares, and what the configuration needs is never deleted.
+        const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
+        const unknown = declared
+            .filter((dependency) => {
+            const dir = dirnamePath(dependency.position.path);
+            return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
+        })
+            .map((dependency) => dependency.name);
         const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
         for (const [id, used] of [...project.uses, ...held]) {
             const merged = uses.get(id) ?? new Set();
@@ -563,5 +638,5 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             lastUses.set(id, sole.sort((a, b) => (a < b ? -1 : 1)));
         }
     }
-    return { declared, installed, needed, lastUses };
+    return { declared, needed, ran, unbuilt, lastUses };
 }

package/dist/src/discover.js

@@ -23,7 +23,7 @@ export class DiscoveryError extends Error {
 /** The category an error diagnostic carries, which the protocol sends as a number. */
 const ERROR_CATEGORY = DiagnosticCategory.Error;
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic) {
+function isError(diagnostic) {
     return diagnostic.category === ERROR_CATEGORY;
 }
 /**

package/dist/src/edges.js

@@ -25,7 +25,7 @@ const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and a
 const ID_WANT = "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
 const REFERENCE_WANT = "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
     constructor(at, text, want) {
         super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
         this.name = "EdgesError";