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

package/dist/src/analysis.js

@@ -32,7 +32,7 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, normalizePath, 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";
@@ -41,6 +41,7 @@ import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
+import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -119,6 +120,7 @@ function readProjects(engine, host, scope, config, stage) {
         testFiles: config.ts.testFiles,
         parse: (fileName, text) => engine.parseSourceFile(fileName, text),
         publishedAPI: config.targetKind === "library",
+        publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
     };
     const notBuilt = [...discovered.notBuilt];
     const dropped = (configFile, error) => {
@@ -144,6 +146,10 @@ function readProjects(engine, host, scope, config, stage) {
             unbuildable.push(...met);
         }
     };
+    const testPatterns = config.ts.testFiles.map(globExpression);
+    const joins = discovered.derived
+        ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
+        : new Map();
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -243,9 +249,10 @@ function readProjects(engine, host, scope, config, stage) {
             heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
         }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", workspace?.programs, () => {
-        const patterns = config.ts.testFiles.map(globExpression);
-        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && patterns.some((pattern) => pattern.test(path))), options.parse);
+    }, discovered.derived ? "record" : "refuse", joins.size === 0
+        ? workspace?.programs
+        : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins), () => {
+        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), options.parse);
     });
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
@@ -638,23 +645,38 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
         : { ...run, unansweredHeld: [...new Set([...run.unansweredHeld, ...unread])] };
 }
 /**
- * The workspace members whose manifest the run reads whole enough to judge its
- * dependencies: a built project holds a file below the member's directory, and no derived
- * configuration at or below it was dropped. A file no built project holds may import any
- * dependency the member declares.
+ * The workspace members whose dependencies the run judges: `read` holds those a built
+ * project holds a file below, `unbuilt` the others whose own directory, the nearest
+ * manifest's above the configuration, holds a configuration the run could not build. A
+ * member no configuration holds a file of is in neither.
  */
-function membersWhollyRead(host, targetRoot, read) {
+function judgedMembers(host, targetRoot, read) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const held = new Set(read.matrix.union.symbols.map((symbol) => symbol.position.path));
-    const dropped = read.notBuilt.map((one) => relativePath(root, one.configFile) ?? "");
-    return read.memberDirs.filter((dir) => {
+    const owners = new Set(read.notBuilt.map((one) => nearestManifestDir(host, root, one.configFile)));
+    const judged = { read: [], unbuilt: [] };
+    for (const dir of read.memberDirs) {
         const below = relativePath(root, dir);
         if (below === undefined) {
-            return false;
+            continue;
         }
-        const inside = (path) => path.startsWith(`${below}/`);
-        return [...held].some(inside) && !dropped.some(inside);
-    });
+        if ([...held].some((path) => path.startsWith(`${below}/`))) {
+            judged.read.push(dir);
+        }
+        else if (owners.has(dir)) {
+            judged.unbuilt.push(dir);
+        }
+    }
+    return judged;
+}
+/** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
+function nearestManifestDir(host, root, file) {
+    for (let dir = dirnamePath(file); relativePath(root, dir) !== undefined; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+            return dir;
+        }
+    }
+    return root;
 }
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
@@ -664,6 +686,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
     const targetRoot = scope.target.path;
     const swept = sweptOf(read, input);
     const { projects } = read;
+    const members = judgedMembers(host, targetRoot, read);
     return {
         config,
         swept,
@@ -672,7 +695,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             accessors: one.extra.accessors,
         })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), membersWhollyRead(host, targetRoot, read)),
+        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "4.1.0",
+        corpusVersion: "5.0.0",
         result: "pass",
-        digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
+        digest: "sha256:26c486907df44fb8eaf3f749f60a6010ac94e7cfeeda70c4aa406445193ab80a",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -11,7 +11,10 @@ import { SignatureKind } 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;
 }
@@ -88,6 +92,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 +119,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 });
             }

package/dist/src/convention-rows.js

@@ -39,8 +39,38 @@ 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 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 +502,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",

package/dist/src/conventions.js

@@ -602,6 +602,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) {
@@ -680,6 +724,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);
             }

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) => {
@@ -365,8 +369,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 +491,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 +533,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 +605,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 +634,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/findings/completion.js

@@ -108,12 +108,11 @@ function findingComponents(swept, cascade) {
 }
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
- * candidate's relation, counts, configurations and component; a live one carries no
- * relation and holds where it is declared; a file or a manifest row is `certain` and
- * holds in every configuration. A subject in no dead component gets one of its own,
- * numbered past the computed ones in finding order, so no two families mint one; nothing
- * falls with it, so its deletion removes no line. `kinds` is the vocabulary each code's
- * row is read from, the shipped one unless a caller supplies its own.
+ * candidate's relation, counts, configurations and component; a live one carries no relation and
+ * holds where it is declared; a file or a manifest row carries the class its emitter states,
+ * `certain` by default, and holds in every configuration. A subject in no dead component gets one
+ * of its own, numbered past the computed ones in finding order so no two families mint one, whose
+ * deletion removes no line. `kinds` defaults to the shipped vocabulary.
  */
 export function completed(input, findings, kinds = KINDS) {
     const { swept } = input;
@@ -172,7 +171,7 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+        const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
         const generated = input.files.generated?.has(finding.position.path) === true;
         return {
             code: finding.code,

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -1,3 +1,4 @@
+import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
 const UNUSED_DEPENDENCY = "DS1601";
 const MESSAGES = {
@@ -5,38 +6,14 @@ const MESSAGES = {
     "dev-dependency": "no import in the target needs the declared development dependency",
     "peer-dependency": "no import in the target needs the declared peer dependency",
 };
-/**
- * The dependencies the target needs: every package the projects' uses name, every
- * declared dependency that ships a command, which a script, a workflow or a shell
- * runs outside anything the analysis reads, and every peer a needed package
- * requires, which the target satisfies by declaring it.
- */
-function neededBy(dependencies) {
-    const needed = new Set(dependencies.needed);
-    for (const [name, installed] of dependencies.installed) {
-        if (installed.command) {
-            needed.add(name);
-        }
-    }
-    const pending = [...needed];
-    for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
-        for (const peer of dependencies.installed.get(name)?.peers ?? []) {
-            if (!needed.has(peer)) {
-                needed.add(peer);
-                pending.push(peer);
-            }
-        }
-    }
-    return needed;
-}
 /**
  * A dependency, development dependency or peer dependency of a manifest the run reads
  * that the target does not need, at the position of its key.
  */
 function unusedDependencies(dependencies) {
-    const needed = neededBy(dependencies);
     return dependencies.declared
-        .filter((dependency) => !needed.has(dependency.name))
+        .filter((dependency) => !dependencies.needed.has(dependency.name) &&
+        !dependencies.ran.has(declarationKey(dependency)))
         .map((dependency) => ({
         code: UNUSED_DEPENDENCY,
         position: dependency.position,
@@ -52,6 +29,9 @@ function unusedDependencies(dependencies) {
         },
         message: MESSAGES[dependency.section],
         details: { dependencyClass: dependency.section },
+        ...(dependencies.unbuilt.has(dependency.position.path)
+            ? { reachabilityClass: "possible" }
+            : {}),
     }));
 }
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */