@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/conventions.js

@@ -471,6 +471,40 @@ function manifestKeyUses(manifest, keys) {
     const strings = keys.flatMap((key) => documentStrings(manifest[key]));
     return declared.filter((name) => strings.some((text) => text === name || text.startsWith(`${name}/`)));
 }
+/** The extensions an entry a manifest entry key names without one may carry. */
+const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+/** The characters that make a manifest string a pattern rather than a directory's name. */
+const PATTERN = /[*?{}[\]]/u;
+/**
+ * The entry globs one applied row's manifest entry keys write, below the manifest's
+ * directory: a directory's every module, or a file with or without an extension. A string
+ * that leaves the directory names nothing.
+ */
+function manifestEntryGlobs(manifest, keys) {
+    const at = (value, path) => {
+        const [key, ...rest] = path;
+        if (key === undefined) {
+            return [value];
+        }
+        if (!isRecord(value)) {
+            return [];
+        }
+        const next = key === "*" ? Object.values(value) : Object.hasOwn(value, key) ? [value[key]] : [];
+        return next.flatMap((one) => at(one, rest));
+    };
+    return keys.flatMap(({ key, directory }) => at(manifest, key.split(".")).flatMap((value) => documentStrings(value).flatMap((text) => {
+        const path = normalizePath(text)
+            .replace(/^(?:\.\/)+/u, "")
+            .replace(/\/+$/u, "");
+        if (path === "" || path === ".." || path.startsWith("../") || path.startsWith("/")) {
+            return [];
+        }
+        if (!directory) {
+            return [path, `${path}.${ENTRY_EXTENSIONS}`];
+        }
+        return PATTERN.test(path) ? [] : [`${path}/**/*.${ENTRY_EXTENSIONS}`];
+    })));
+}
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
@@ -620,6 +654,57 @@ function shortNameUses(host, parse, dir, manifest, readings) {
     }
     return [...used].filter((name) => declared.has(name)).sort(compare);
 }
+/**
+ * The package one value of a prefixed-name reading names, or none: ESLint's own naming,
+ * https://github.com/eslint/eslintrc/blob/main/lib/shared/naming.js
+ */
+function prefixedPackage(value, reading) {
+    const { prefix, marker } = reading;
+    let name;
+    if (marker === undefined) {
+        if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+            return undefined;
+        }
+        const parts = value.split("/");
+        name = (value.startsWith("@") ? parts.slice(0, 2) : parts.slice(0, 1)).join("/");
+    }
+    else {
+        if (!value.startsWith(marker) || !value.includes("/", marker.length)) {
+            return undefined;
+        }
+        name = value.slice(marker.length, value.lastIndexOf("/"));
+    }
+    if (name === "") {
+        return undefined;
+    }
+    if (!name.startsWith("@")) {
+        return name.startsWith(`${prefix}-`) ? name : `${prefix}-${name}`;
+    }
+    const [scope, rest] = name.split("/");
+    if (rest === undefined || rest === "" || rest === prefix) {
+        return `${scope ?? name}/${prefix}`;
+    }
+    return rest.startsWith(`${prefix}-`) ? name : `${scope ?? name}/${prefix}-${rest}`;
+}
+/** The declared dependencies an applied row's prefixed names use. */
+function prefixedNameUses(host, parse, dir, manifest, readings) {
+    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    }));
+    const used = new Set();
+    for (const reading of readings) {
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            for (const value of readProperty(file, reading.property, reading.call, true).values) {
+                const named = prefixedPackage(value, reading);
+                if (named !== undefined && declared.has(named)) {
+                    used.add(named);
+                }
+            }
+        }
+    }
+    return [...used].sort(compare);
+}
 /** The declared dependencies an applied row's helper settings use. */
 function helperUses(host, parse, dir, manifest, readings) {
     const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
@@ -756,6 +841,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 prefixed = row.prefixedNames ?? [];
+            for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
+                uses.add(name);
+            }
             const keys = row.packageKeys ?? [];
             for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
                 uses.add(name);
@@ -774,7 +863,11 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
                 generated.push({ dir: manifest.dir, row: row.name, below });
             }
-            for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+            const written = [
+                ...row.entries.flatMap((entry) => expand(entry, resolved)),
+                ...manifestEntryGlobs(declared, row.manifestEntries ?? []),
+            ];
+            for (const glob of new Set(written)) {
                 globs.push({
                     dir: manifest.dir,
                     row: row.name,
@@ -819,10 +912,13 @@ export function conventionEntries(conventions, files) {
     const found = new Map();
     for (const glob of conventions.globs) {
         for (const file of files.byName.values()) {
-            const path = relativePath(glob.dir, file.fileName);
-            if (path !== undefined &&
-                glob.expression.test(path) &&
-                !glob.excludes.some((one) => one.test(path))) {
+            const matched = [file.fileName, ...files.writtenAs(file)].some((name) => {
+                const path = relativePath(glob.dir, name);
+                return (path !== undefined &&
+                    glob.expression.test(path) &&
+                    !glob.excludes.some((one) => one.test(path)));
+            });
+            if (matched) {
                 found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
             }
         }

package/dist/src/decorator.js

@@ -1,14 +1,10 @@
 /**
- * The decorator class: a member a decorator expression is attached to, and every
- * member of a class a decorator expression is attached to, is held back, because the
- * decorator receives the member or the class when the class is defined and may reach
- * the member by its name.
- *
- * The rule is read from the tree alone: a decorator is attached where it is written.
- * The use the decorator itself makes of what it decorates is the reference pass's,
- * which records it as a `decorator` reference; this class records only that the
- * declaration is held back, and the member set of a decorated class is every member
- * the inventory holds for the class, static members included.
+ * The decorator class: a member a decorator expression is attached to, and every member
+ * of a class one is attached to but the member a parameter property declares, is held
+ * back, because the decorator may reach the member by its name. The rule is read from
+ * the tree alone. The decorator's own use of what it decorates is the reference pass's
+ * `decorator` reference; this class records only that the declaration is held back,
+ * static members of a decorated class included.
  */
 import { decoratorsOf, spelledDecorator } from "./calls.js";
 import { isParameterProperty, nodeKey, } from "./inventory.js";
@@ -34,25 +30,32 @@ export function decorator(input) {
             }
         }
     }
-    const found = [];
+    const decorated = [];
+    // A decorated class's container passes each constructor argument, which keeps the
+    // parameter, not the member a parameter property stores it in.
+    const parameterMembers = new Set();
     for (const file of project.ownSourceFiles()) {
         const visit = (node) => {
             const id = held.declarations.get(nodeKey(file, node));
             const symbol = id === undefined ? undefined : byId.get(id);
+            if (id !== undefined && isParameterProperty(node)) {
+                parameterMembers.add(id);
+            }
             // A parameter property's decorator is attached to its parameter, and to no member.
             if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
                 for (const attached of decoratorsOf(node)) {
-                    const detail = `decorated by ${spelledDecorator(attached)}`;
-                    const site = renderPosition(file, targetRoot, attached.getStart());
-                    const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
-                    for (const member of reached) {
-                        found.push({ id: member.id, detail, site });
-                    }
+                    decorated.push({
+                        symbol,
+                        detail: `decorated by ${spelledDecorator(attached)}`,
+                        site: renderPosition(file, targetRoot, attached.getStart()),
+                    });
                 }
             }
             node.forEachChild(visit);
         };
         file.forEachChild(visit);
     }
-    return found;
+    return decorated.flatMap(({ symbol, detail, site }) => (symbol.kind === "class"
+        ? (membersOf.get(symbol.id) ?? []).filter((member) => !parameterMembers.has(member.id))
+        : [symbol]).map((member) => ({ id: member.id, detail, site })));
 }

package/dist/src/dependencies.js

@@ -6,8 +6,9 @@
  * 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 { isCallExpression, isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
+import { isArrayLiteralExpression, isCallExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { automaticTypes } from "./automatic-types.js";
+import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
 import { scriptTokens } from "./manifest.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
@@ -18,6 +19,8 @@ const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
 const TYPES_SCOPE = "@types/";
+/** A script token naming a JavaScript file by a path no expansion changes. */
+const SCRIPT_FILE = /^[^$`{*?[~]+\.(?:js|mjs|cjs)$/u;
 /** The manifest sections a dependency is declared in, each by the selector its reference spells. */
 const SECTIONS = [
     ["dependencies", "dependency"],
@@ -30,7 +33,7 @@ const PROJECT_OWNER = "";
 export function configurationNeeds(packages) {
     return {
         uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
-        at: new Map([[ANYWHERE, new Set(packages)]]),
+        at: new Map([[ANYWHERE, new Map(packages.map((one) => [one, new Set([PROJECT_OWNER])]))]]),
         unanswered: [],
     };
 }
@@ -99,12 +102,35 @@ function typePackages(name, programPackages) {
     }
     return [typed, named];
 }
+/**
+ * The strings the `extends` member of one compiler configuration file holds, read as the
+ * compiler reads the file, comments and trailing commas allowed; none where it cannot be read.
+ */
+function extendsOf(host, path, parse) {
+    let text;
+    try {
+        text = host.readFile(path);
+    }
+    catch {
+        return [];
+    }
+    const [statement] = parse(path, text).statements;
+    const document = statement !== undefined && isExpressionStatement(statement) ? statement.expression : undefined;
+    if (document === undefined || !isObjectLiteralExpression(document)) {
+        return [];
+    }
+    const value = document.properties
+        .filter(isPropertyAssignment)
+        .findLast((property) => isLiteralText(property.name) && property.name.text === "extends")?.initializer;
+    const entries = value !== undefined && isArrayLiteralExpression(value) ? value.elements : [value];
+    return entries.flatMap((entry) => entry !== undefined && isLiteralText(entry) ? [entry.text] : []);
+}
 /**
  * The packages the compiler configuration of one project names: its type packages,
  * its JSX import source, the helper library it imports, its plugins, and every
  * package a configuration file it extends through is read from.
  */
-function configurationPackages(host, configFile, options, programPackages) {
+function configurationPackages(host, configFile, options, programPackages, parse) {
     const found = new Set();
     const add = (name) => {
         const named = typeof name === "string" ? packageOfSpecifier(name) : undefined;
@@ -139,12 +165,7 @@ function configurationPackages(host, configFile, options, programPackages) {
             continue;
         }
         seen.add(file);
-        const read = readJSON(host, file);
-        const extended = isRecord(read?.value) ? read.value["extends"] : undefined;
-        for (const entry of Array.isArray(extended) ? extended : [extended]) {
-            if (typeof entry !== "string") {
-                continue;
-            }
+        for (const entry of extendsOf(host, file, parse)) {
             if (entry.startsWith(".") || isAbsolutePath(entry)) {
                 const local = resolvePath(dirnamePath(file), entry);
                 pending.push(local.endsWith(".json") ? local : `${local}.json`);
@@ -207,13 +228,19 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             programPackages.add(named);
         }
     }
-    const packages = configurationPackages(host, project.configFile, project.program.getCompilerOptions(), programPackages);
+    const options = project.program.getCompilerOptions();
+    const packages = configurationPackages(host, project.configFile, options, programPackages, parse);
+    const automatic = automaticTypes(host, project.configFile, options, parse);
     const uses = new Map();
     const at = new Map();
     const use = (owners, named, path) => {
         for (const one of named) {
-            at.set(path, (at.get(path) ?? new Set()).add(one));
+            const inFile = at.get(path) ?? new Map();
+            at.set(path, inFile);
+            const holders = inFile.get(one) ?? new Set();
+            inFile.set(one, holders);
             for (const owner of owners) {
+                holders.add(owner);
                 let set = uses.get(owner);
                 if (set === undefined) {
                     set = new Set();
@@ -229,7 +256,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         const inFile = (owners, named) => {
             use(owners, named, file.fileName);
         };
-        if (fileNeeds(project, held, file, programPackages, inFile)) {
+        if (fileNeeds(project, held, file, { programPackages, automatic }, inFile)) {
             unanswered.push(file.fileName);
         }
     }
@@ -243,9 +270,10 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         }
         return names;
     };
-    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
-    for (const { file } of configuration.modules) {
-        const names = declaredAt(file.fileName);
+    const files = sourceFilesOf(project, targetRoot);
+    const configuration = configurationFiles(host, targetRoot, files, parse);
+    for (const { file, manifestDir } of configuration.modules) {
+        const names = declaredAt(joinPath(manifestDir, MANIFEST));
         for (const { node, text } of moduleStrings(file)) {
             use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
         }
@@ -258,7 +286,8 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     }
-    for (const { file, manifestDirs } of configuration.outside) {
+    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files));
+    for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, "package.json"));
             for (const { text } of moduleStrings(file)) {
@@ -268,6 +297,48 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     }
     return { uses, at, unanswered };
 }
+/**
+ * The JavaScript files no program holds that a script of a manifest at or above one of the
+ * project's files runs, each with the directory of that manifest, and those a workflow
+ * step or git hook runs, with the target root's: a token naming such a file below the
+ * target root and in no `node_modules`, read against the manifest's directory.
+ */
+function scriptRunFiles(host, targetRoot, files) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const dirs = new Set([root]);
+    for (const name of files.byName.keys()) {
+        for (let dir = dirnamePath(name); !dirs.has(dir); dir = dirnamePath(dir)) {
+            if (relativePath(root, dir) === undefined) {
+                break;
+            }
+            dirs.add(dir);
+        }
+    }
+    const tokens = new Map([
+        [root, new Set(workflowTokens(host, root))],
+    ]);
+    for (const dir of dirs) {
+        const read = readJSON(host, joinPath(dir, MANIFEST));
+        if (read !== undefined && isRecord(read.value)) {
+            const own = scriptTokensOf(read.value);
+            tokens.set(dir, dir === root ? new Set([...own, ...(tokens.get(root) ?? [])]) : own);
+        }
+    }
+    const found = [];
+    for (const [manifestDir, held] of tokens) {
+        for (const token of held) {
+            const path = SCRIPT_FILE.test(token) ? resolvePath(manifestDir, token) : undefined;
+            const below = path === undefined ? undefined : relativePath(root, path);
+            if (path !== undefined &&
+                below?.split("/").includes(MODULES_DIR) === false &&
+                !files.byName.has(path) &&
+                host.kindOf(path) === "file") {
+                found.push({ path, manifestDir });
+            }
+        }
+    }
+    return found;
+}
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
     const parent = node.parent;
@@ -291,8 +362,27 @@ function ownersOf(file, held, node) {
     }
     return [PROJECT_OWNER];
 }
-/** Records the needs of one file, and answers whether a specifier of it went unanswered. */
-function fileNeeds(project, held, file, programPackages, use) {
+/**
+ * Whether one identifier stands for a value or type of the scope it is written in, rather
+ * than naming a member, a property or a label.
+ */
+function isScopeName(node) {
+    const parent = node.parent;
+    if (parent === undefined || isShorthandPropertyAssignment(parent)) {
+        return true;
+    }
+    const named = parent;
+    return (named.name !== node &&
+        (parent.kind !== SyntaxKind.QualifiedName || named.right !== node) &&
+        named.propertyName !== node &&
+        named.label !== node);
+}
+/**
+ * Records the needs of one file, and answers whether a specifier of it went unanswered. A
+ * module specifier or a name of the file's scope that resolves to nothing, and that an
+ * automatically included type package declares, uses that package.
+ */
+function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     const specifiers = [...file.imports, ...file.moduleAugmentations].filter(isLiteralText);
     const bindings = [];
     const bound = new Set();
@@ -309,16 +399,22 @@ function fileNeeds(project, held, file, programPackages, use) {
     }
     const names = new Set(bindings.map(({ node }) => node.text));
     const candidates = [];
+    const globals = [];
     const visit = (node) => {
-        if (isIdentifier(node) && names.has(node.text) && !bound.has(node)) {
-            candidates.push(node);
+        if (isIdentifier(node) && !bound.has(node)) {
+            if (names.has(node.text)) {
+                candidates.push(node);
+            }
+            else if (automatic.globals.has(node.text) && isScopeName(node)) {
+                globals.push(node);
+            }
         }
         node.forEachChild(visit);
     };
-    if (names.size > 0) {
+    if (names.size > 0 || automatic.globals.size > 0) {
         visit(file);
     }
-    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates];
+    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates, ...globals];
     const handles = asked.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
@@ -329,6 +425,9 @@ function fileNeeds(project, held, file, programPackages, use) {
             named.add(byName);
         }
         const symbol = resolved[index];
+        if (symbol === undefined) {
+            automatic.modules.get(specifier.text)?.forEach((one) => named.add(one));
+        }
         for (const declaration of typeof symbol === "object" ? symbol.declarations : []) {
             const byPath = packageOfPath(declaration.path);
             if (byPath !== undefined) {
@@ -364,7 +463,7 @@ function fileNeeds(project, held, file, programPackages, use) {
         let symbol = resolved[offset + index];
         const parent = node.parent;
         if (parent !== undefined && isShorthandPropertyAssignment(parent) && parent.name === node) {
-            symbol = project.shorthandValueAt(project.handle(node));
+            symbol = project.shorthandValueAt(project.handle(parent));
         }
         const named = symbol === UNANSWERED || (unresolvedNames.has(node.text) && symbol === undefined)
             ? byName.get(node.text)
@@ -376,6 +475,13 @@ function fileNeeds(project, held, file, programPackages, use) {
             use(ownersOf(file, held, node), named);
         }
     });
+    const unresolvedAt = offset + candidates.length;
+    globals.forEach((node, index) => {
+        const symbol = resolved[unresolvedAt + index];
+        if (symbol === undefined || symbol === UNANSWERED) {
+            use(ownersOf(file, held, node), automatic.globals.get(node.text) ?? []);
+        }
+    });
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
@@ -567,6 +673,18 @@ function manifestDir(dependency) {
     const dir = dirnamePath(dependency.position.path);
     return dir === "." ? "" : dir;
 }
+/**
+ * The declarations of one name a use written at `below` needs: those of the nearest
+ * manifest at or above it that declares the name, or every one for a use no file holds.
+ */
+function nearestDeclaring(declarations, below) {
+    if (below === undefined) {
+        return declarations;
+    }
+    const enclosing = declarations.filter((dependency) => isInside(below, manifestDir(dependency)));
+    const nearest = Math.max(-1, ...enclosing.map((dependency) => manifestDir(dependency).length));
+    return enclosing.filter((dependency) => manifestDir(dependency).length === nearest);
+}
 /**
  * Adds to `needed` each declared dependency that the installed manifest of a needed or
  * run declared dependency names as a peer, until no further one joins: the declaration of
@@ -646,6 +764,8 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     // A declaration several projects compile is one user, and a use any project makes is
     // a use, so the uses are merged by declaration before anything is counted.
     const needed = new Set();
+    const live = new Set();
+    const holders = new Map();
     const byName = new Map();
     for (const dependency of declared) {
         byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
@@ -656,7 +776,10 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         // or above its file declares, and what the configuration needs is never deleted.
         const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
         const unknownDeclared = declared.filter((dependency) => unanswered.some((file) => isInside(file, manifestDir(dependency))));
-        unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+        for (const dependency of unknownDeclared) {
+            needed.add(declarationKey(dependency));
+            live.add(declarationKey(dependency));
+        }
         const unknown = unknownDeclared.map((dependency) => dependency.name);
         const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
         for (const [id, used] of [...project.uses, ...held]) {
@@ -666,16 +789,32 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
         for (const [path, named] of project.at) {
             const below = path === ANYWHERE ? undefined : relativePath(root, path);
-            for (const one of named) {
-                for (const dependency of byName.get(one) ?? []) {
-                    if (below === undefined || isInside(below, manifestDir(dependency))) {
-                        needed.add(declarationKey(dependency));
+            for (const [one, owners] of named) {
+                // An import none of whose bindings is used is no evidence about the code using it.
+                const unheld = owners.size === 0;
+                for (const dependency of nearestDeclaring(byName.get(one) ?? [], below)) {
+                    const key = declarationKey(dependency);
+                    needed.add(key);
+                    if (unheld) {
+                        live.add(key);
+                    }
+                    else {
+                        const held = holders.get(key) ?? new Set();
+                        owners.forEach((owner) => held.add(owner));
+                        holders.set(key, held);
                     }
                 }
             }
         }
     }
     addNeededPeers(declared, peers, needed, ran);
+    addNeededPeers(declared, peers, live, ran);
+    const heldBy = new Map();
+    for (const [key, held] of holders) {
+        if (!live.has(key) && !ran.has(key)) {
+            heldBy.set(key, [...held].sort((a, b) => (a < b ? -1 : 1)));
+        }
+    }
     const users = new Map();
     for (const used of uses.values()) {
         used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));
@@ -688,5 +827,21 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             lastUses.set(id, sole.sort((a, b) => (a < b ? -1 : 1)));
         }
     }
-    return { declared, needed, ran, unbuilt, lastUses };
+    const owners = new Map();
+    for (const [owner, used] of uses) {
+        for (const one of used) {
+            if (names.has(one)) {
+                owners.set(one, (owners.get(one) ?? new Set()).add(owner));
+            }
+        }
+    }
+    const fileLastUses = new Map();
+    for (const [one, held] of [...owners].sort(([a], [b]) => (a < b ? -1 : 1))) {
+        const paths = new Set([...held].map((owner) => owner.replace(/:\d+:\d+$/u, "")));
+        const [path] = paths;
+        if (paths.size === 1 && path !== undefined && path !== PROJECT_OWNER) {
+            fileLastUses.set(path, [...(fileLastUses.get(path) ?? []), one]);
+        }
+    }
+    return { declared, needed, ran, unbuilt, lastUses, fileLastUses, heldBy };
 }