knip 5.70.1 → 5.71.0

package/dist/DependencyDeputy.js

@@ -174,7 +174,7 @@ export class DependencyDeputy {
         const dependencyIssues = [];
         const devDependencyIssues = [];
         const optionalPeerDependencyIssues = [];
-        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests.entries()) {
+        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
             const peeker = new PackagePeeker(manifestStr);
@@ -342,7 +342,7 @@ export class DependencyDeputy {
     }
     getConfigurationHints() {
         const configurationHints = new Set();
-        for (const [workspaceName, manifest] of this._manifests.entries()) {
+        for (const [workspaceName, manifest] of this._manifests) {
             for (const identifier of manifest.unusedIgnoreDependencies) {
                 configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' });
             }

package/dist/ProjectPrincipal.js

@@ -217,7 +217,7 @@ export class ProjectPrincipal {
         return externalRefs.length > 0;
     }
     reconcileCache(graph) {
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const fd = this.cache.getFileDescriptor(filePath);
             if (!fd?.meta)
                 continue;

package/dist/WorkspaceWorker.js

@@ -89,15 +89,7 @@ export class WorkspaceWorker {
         if (project.length === 0)
             return [];
         const excludeProductionNegations = project.filter(pattern => !(pattern.startsWith('!') && pattern.endsWith('!')));
-        const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
-        return [
-            excludeProductionNegations,
-            negatedPluginConfigPatterns,
-            negatedPluginProjectFilePatterns,
-            projectFilePatterns,
-            this.negatedWorkspacePatterns,
-        ].flat();
+        return [excludeProductionNegations, projectFilePatterns, this.negatedWorkspacePatterns].flat();
     }
     getPluginProjectFilePatterns(patterns = []) {
         for (const [pluginName, plugin] of PluginEntries) {
@@ -175,18 +167,10 @@ export class WorkspaceWorker {
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
         const remainingPlugins = new Set(this.enabledPlugins);
-        const addInput = (input, containingFilePath = input.containingFilePath) => {
-            if (isConfig(input)) {
-                handleConfigInput(input.pluginName, { ...input, containingFilePath });
-            }
-            else {
-                inputs.push({ ...input, containingFilePath });
-            }
-        };
         const configFilesMap = this.configFilesMap;
         const configFiles = this.configFilesMap.get(wsName);
         const seen = new Map();
-        const handleConfigInput = (pluginName, input) => {
+        const storeConfigFilePath = (pluginName, input) => {
             const configFilePath = this.getReferencedInternalFilePath(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
@@ -202,20 +186,26 @@ export class WorkspaceWorker {
         };
         for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
             if (isConfig(input)) {
-                handleConfigInput(input.pluginName, { ...input, containingFilePath });
+                storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
             }
-            else {
-                if (!isProduction)
-                    addInput(input, containingFilePath);
-                else if (isProduction && (input.production || hasProductionInput(input)))
-                    addInput(input, containingFilePath);
+            else if (!isProduction || (isProduction && (input.production || hasProductionInput(input)))) {
+                inputs.push({ ...input, containingFilePath });
             }
         }
         const runPlugin = async (pluginName, patterns) => {
             const plugin = Plugins[pluginName];
             const config = this.getConfigForPlugin(pluginName);
             if (!config)
-                return;
+                return [];
+            const inputs = [];
+            const addInput = (input, containingFilePath = input.containingFilePath) => {
+                if (isConfig(input)) {
+                    storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
+                }
+                else {
+                    inputs.push(Object.assign(input, { containingFilePath }));
+                }
+            };
             const label = 'config file';
             const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
             const options = {
@@ -229,7 +219,7 @@ export class WorkspaceWorker {
             if (config.entry) {
                 const toInput = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntry : toEntry;
                 for (const id of config.entry)
-                    addInput(toInput(id));
+                    inputs.push(toInput(id));
             }
             else if ((!plugin.resolveConfig && !plugin.resolveFromAST) ||
                 (configFilePaths.filter(path => basename(path) !== 'package.json').length === 0 &&
@@ -237,10 +227,10 @@ export class WorkspaceWorker {
                         this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
                 if (plugin.entry)
                     for (const id of plugin.entry)
-                        addInput(toEntry(id));
+                        inputs.push(toEntry(id));
                 if (plugin.production)
                     for (const id of plugin.production)
-                        addInput(toProductionEntry(id));
+                        inputs.push(toProductionEntry(id));
             }
             for (const configFilePath of configFilePaths) {
                 const isManifest = basename(configFilePath) === 'package.json';
@@ -295,8 +285,8 @@ export class WorkspaceWorker {
                     }
                 }
                 if (!isManifest) {
-                    addInput(toEntry(configFilePath));
-                    addInput(toConfig(pluginName, configFilePath));
+                    inputs.push(toEntry(configFilePath));
+                    storeConfigFilePath(pluginName, toConfig(pluginName, configFilePath));
                     cache.configFile = toEntry(configFilePath);
                     if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
                         fd.meta.data = cache;
@@ -311,26 +301,33 @@ export class WorkspaceWorker {
                 for (const id of dependencies)
                     addInput(id, containingFilePath);
             }
+            if (inputs.some(input => input.specifier.startsWith('!')))
+                for (const input of inputs)
+                    input.group = pluginName;
+            return inputs;
         };
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
         for (const pluginName of this.enabledPlugins) {
             const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
             configFiles?.delete(pluginName);
-            await runPlugin(pluginName, compact(patterns));
+            for (const input of await runPlugin(pluginName, compact(patterns)))
+                inputs.push(input);
             remainingPlugins.delete(pluginName);
         }
         {
             const configFiles = this.configFilesMap.get(wsName);
             if (configFiles) {
                 do {
-                    for (const [pluginName, dependencies] of configFiles.entries()) {
+                    for (const [pluginName, dependencies] of configFiles) {
                         configFiles.delete(pluginName);
-                        if (this.enabledPlugins.includes(pluginName))
-                            await runPlugin(pluginName, Array.from(dependencies));
+                        if (this.enabledPlugins.includes(pluginName)) {
+                            for (const input of await runPlugin(pluginName, Array.from(dependencies)))
+                                inputs.push(input);
+                        }
                         else
                             for (const id of dependencies)
-                                addInput(toEntry(id));
+                                inputs.push(toEntry(id));
                     }
                 } while (remainingPlugins.size > 0 && configFiles.size > 0);
             }

package/dist/binaries/bash-parser.js

@@ -25,6 +25,12 @@ export const getDependenciesFromScript = (script, options) => {
             knownBinsOnly: false,
         });
     };
+    const definedFunctions = new Set();
+    const collectFunctionNames = (nodes) => {
+        for (const node of nodes)
+            if (node.type === 'Function')
+                definedFunctions.add(node.name.text);
+    };
     const getDependenciesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
@@ -41,6 +47,8 @@ export const getDependenciesFromScript = (script, options) => {
                     return [];
                 if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
                     return [];
+                if (definedFunctions.has(binary))
+                    return [];
                 const args = node.suffix?.map(arg => arg.text) ?? [];
                 if (['!', 'test'].includes(binary))
                     return fromArgs(args);
@@ -82,13 +90,18 @@ export const getDependenciesFromScript = (script, options) => {
                 return getDependenciesFromNodes(node.commands);
             case 'Function':
                 return getDependenciesFromNodes(node.body.commands);
+            case 'Subshell':
+                return getDependenciesFromNodes(node.list.commands);
             default:
                 return [];
         }
     });
     try {
         const parsed = parse(script);
-        return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
+        if (!parsed?.commands)
+            return [];
+        collectFunctionNames(parsed.commands);
+        return getDependenciesFromNodes(parsed.commands);
     }
     catch (error) {
         const msg = `Warning: failed to parse and ignoring script in ${relative(options.cwd, options.containingFilePath)} (${truncate(script, 30)})`;

package/dist/compilers/index.js

@@ -38,7 +38,7 @@ const compilers = new Map([
 ]);
 export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
     const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers.entries()) {
+    for (const [extension, { condition, compiler }] of compilers) {
         if (extension === '.mdx' && AstroMDX.condition(hasDependency)) {
             syncCompilers.set(extension, AstroMDX.compiler);
         }

package/dist/constants.js

@@ -89,6 +89,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'rmdir',
     'rsync',
     'scp',
+    'sed',
     'seq',
     'set',
     'sh',

package/dist/graph/analyze.js

@@ -1,13 +1,13 @@
-import { getType, hasStrictlyEnumReferences, hasStrictlyNsReferences } from '../util/has-strictly-ns-references.js';
-import { getIsIdentifierReferencedHandler } from '../util/is-identifier-referenced.js';
+import { createGraphExplorer } from '../graph-explorer/explorer.js';
+import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
-import { createAndPrintTrace, printTrace } from '../util/trace.js';
+import { printTraceNode } from '../util/trace.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
+    const explorer = createGraphExplorer(graph, entryPaths);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
     const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
         (exportedItem.refs[0] > 0 &&
@@ -17,7 +17,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
-            for (const [filePath, file] of graph.entries()) {
+            for (const [filePath, file] of graph) {
                 const exportItems = file.exports;
                 if (!exportItems || exportItems.size === 0)
                     continue;
@@ -27,16 +27,17 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
-                        createAndPrintTrace(filePath, options, { isEntry });
                         continue;
                     }
                     const importsForExport = file.imported;
-                    for (const [identifier, exportedItem] of exportItems.entries()) {
+                    for (const [identifier, exportedItem] of exportItems) {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
                         if (importsForExport) {
-                            const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
+                                includeEntryExports: isIncludeEntryExports,
+                            });
                             if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
@@ -48,15 +49,12 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
-                                    createAndPrintTrace(filePath, options, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
                                 const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
                                 if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
                                     continue;
                             }
-                            if (traceNode)
-                                printTrace(traceNode, filePath, options, identifier);
                             if (isReferenced) {
                                 if (options.includedIssueTypes.enumMembers && exportedItem.type === 'enum') {
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
@@ -70,9 +68,11 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             continue;
                                         if (member.refs[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+                                                includeEntryExports: true,
+                                            });
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
-                                            if (!isReferenced) {
+                                            if (!isMemberReferenced) {
                                                 if (isIgnored)
                                                     continue;
                                                 collector.addIssue({
@@ -125,7 +125,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             }
                         }
-                        const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
+                        const [hasStrictlyNsRefs, namespace] = explorer.hasStrictlyNsReferences(filePath, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
                         if (hasStrictlyNsRefs &&
                             ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
@@ -135,7 +135,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
-                            const type = getType(hasStrictlyNsRefs, isType);
+                            const type = getIssueType(hasStrictlyNsRefs, isType);
                             collector.addIssue({
                                 type,
                                 filePath,
@@ -153,7 +153,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const ws = chief.findWorkspaceByFilePath(filePath);
             if (ws) {
                 if (file.duplicates && options.includedIssueTypes.duplicates) {
@@ -227,5 +227,10 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
+    if (options.isTrace) {
+        const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
+        for (const node of nodes)
+            printTraceNode(node, options);
+    }
     return analyzeGraph;
 };

package/dist/graph/build.js

@@ -106,33 +106,34 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));
         enabledPluginsStore.set(name, worker.enabledPlugins);
-        const entryPatterns = new Set();
-        const entryPatternsSkipExports = new Set();
-        const productionPatterns = new Set();
-        const productionPatternsSkipExports = new Set();
+        const DEFAULT_GROUP = 'default';
+        const createPatternMap = () => new Map([[DEFAULT_GROUP, new Set()]]);
+        const groups = new Set([DEFAULT_GROUP]);
+        const entryPatterns = createPatternMap();
+        const entryPatternsSkipExports = createPatternMap();
+        const productionPatterns = createPatternMap();
+        const productionPatternsSkipExports = createPatternMap();
         const projectFilePatterns = new Set();
+        const addPattern = (map, input, pattern) => {
+            if (input.group && !map.has(input.group))
+                map.set(input.group, new Set());
+            map.get(input.group ?? DEFAULT_GROUP).add(pattern);
+        };
+        const toWorkspaceRelative = (path) => (isAbsolute(path) ? relative(dir, path) : path);
         for (const input of inputs) {
+            if (input.group)
+                groups.add(input.group);
             const specifier = input.specifier;
             if (isEntry(input)) {
-                const relativePath = isAbsolute(specifier) ? relative(dir, specifier) : specifier;
-                if (!input.skipExportsAnalysis) {
-                    entryPatterns.add(relativePath);
-                }
-                else {
-                    entryPatternsSkipExports.add(relativePath);
-                }
+                const targetMap = input.skipExportsAnalysis ? entryPatternsSkipExports : entryPatterns;
+                addPattern(targetMap, input, toWorkspaceRelative(specifier));
             }
             else if (isProductionEntry(input)) {
-                const relativePath = isAbsolute(specifier) ? relative(dir, specifier) : specifier;
-                if (!input.skipExportsAnalysis) {
-                    productionPatterns.add(relativePath);
-                }
-                else {
-                    productionPatternsSkipExports.add(relativePath);
-                }
+                const targetMap = input.skipExportsAnalysis ? productionPatternsSkipExports : productionPatterns;
+                addPattern(targetMap, input, toWorkspaceRelative(specifier));
             }
             else if (isProject(input)) {
-                projectFilePatterns.add(isAbsolute(specifier) ? relative(dir, specifier) : specifier);
+                projectFilePatterns.add(toWorkspaceRelative(specifier));
             }
             else if (isAlias(input)) {
                 principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir);
@@ -150,11 +151,11 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
                 if (resolvedFilePath) {
                     if (isDeferResolveProductionEntry(input)) {
-                        productionPatternsSkipExports.add(resolvedFilePath);
+                        addPattern(productionPatternsSkipExports, input, resolvedFilePath);
                     }
                     else if (isDeferResolveEntry(input)) {
                         if (!options.isProduction || !input.optional)
-                            entryPatternsSkipExports.add(resolvedFilePath);
+                            addPattern(entryPatternsSkipExports, input, resolvedFilePath);
                     }
                     else {
                         principal.addEntryPath(resolvedFilePath, { skipExportsAnalysis: true });
@@ -162,82 +163,63 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 }
             }
         }
+        const negatedEntryPatterns = [];
         if (options.isProduction) {
-            const negatedEntryPatterns = [...entryPatterns, ...entryPatternsSkipExports].map(negate);
-            {
-                const label = 'entry paths';
-                const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
-                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
-                principal.addEntryPaths(workspaceEntryPaths);
+            for (const map of [entryPatterns, entryPatternsSkipExports]) {
+                for (const patterns of map.values())
+                    for (const pattern of patterns)
+                        negatedEntryPatterns.push(negate(pattern));
             }
-            {
-                const label = 'production entry paths from plugins (ignore exports)';
-                const patterns = Array.from(productionPatternsSkipExports);
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+        }
+        {
+            const patterns = options.isProduction
+                ? worker.getProductionEntryFilePatterns(negatedEntryPatterns)
+                : worker.getEntryFilePatterns();
+            const entryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label: 'entry paths' });
+            if (!options.isProduction) {
+                const hints = worker.getConfigurationHints('entry', patterns, entryPaths, principal.entryPaths);
+                for (const hint of hints)
+                    collector.addConfigurationHint(hint);
             }
+            principal.addEntryPaths(entryPaths);
+        }
+        for (const group of groups) {
             {
-                const label = 'production entry paths from plugins';
-                const patterns = Array.from(productionPatterns);
+                const patterns = worker.getPluginEntryFilePatterns([
+                    ...((!options.isProduction && entryPatterns.get(group)) || []),
+                    ...((!options.isProduction && group === DEFAULT_GROUP && worker.getPluginConfigPatterns()) || []),
+                    ...(productionPatterns.get(group) ?? []),
+                ]);
+                const label = `entry paths from plugins${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(pluginWorkspaceEntryPaths);
             }
             {
-                const label = 'project paths';
-                const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
-                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                for (const projectPath of workspaceProjectPaths)
-                    principal.addProjectPath(projectPath);
-            }
-        }
-        else {
-            {
-                const label = 'entry paths from plugins (ignore exports)';
                 const patterns = worker.getPluginEntryFilePatterns([
-                    ...entryPatternsSkipExports,
-                    ...productionPatternsSkipExports,
+                    ...((!options.isProduction && entryPatternsSkipExports.get(group)) || []),
+                    ...(productionPatternsSkipExports.get(group) ?? []),
                 ]);
+                const label = `entry paths from plugins (ignore exports)${group !== DEFAULT_GROUP ? ` - ${group}` : ''}`;
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
-            {
-                const label = 'entry paths from plugins';
-                const patterns = worker.getPluginEntryFilePatterns([...entryPatterns, ...productionPatterns]);
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(pluginWorkspaceEntryPaths);
-            }
-            {
-                const label = 'entry paths';
-                const patterns = worker.getEntryFilePatterns();
-                const entryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
-                const hints = worker.getConfigurationHints('entry', patterns, entryPaths, principal.entryPaths);
-                for (const hint of hints)
-                    collector.addConfigurationHint(hint);
-                principal.addEntryPaths(entryPaths);
-            }
-            {
-                const label = 'project paths from plugins';
-                const patterns = worker.getPluginProjectFilePatterns();
-                const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                for (const projectPath of pluginWorkspaceProjectPaths)
-                    principal.addProjectPath(projectPath);
-            }
-            {
-                const label = 'plugin configuration paths (ignore exports)';
-                const patterns = worker.getPluginConfigPatterns();
-                const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
-                principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
-            }
-            {
-                const label = 'project paths';
-                const patterns = worker.getProjectFilePatterns([...productionPatternsSkipExports, ...projectFilePatterns]);
-                const projectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+        }
+        {
+            const patterns = options.isProduction
+                ? worker.getProductionProjectFilePatterns(negatedEntryPatterns)
+                : worker.getProjectFilePatterns([
+                    ...(productionPatternsSkipExports.get(DEFAULT_GROUP) ?? []),
+                    ...projectFilePatterns,
+                    ...worker.getPluginProjectFilePatterns(),
+                ]);
+            const projectPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'project paths' });
+            if (!options.isProduction) {
                 const hints = worker.getConfigurationHints('project', config.project, projectPaths, principal.projectPaths);
                 for (const hint of hints)
                     collector.addConfigurationHint(hint);
-                for (const projectPath of projectPaths)
-                    principal.addProjectPath(projectPath);
             }
+            for (const projectPath of projectPaths)
+                principal.addProjectPath(projectPath);
         }
         if (options.configFilePath) {
             factory.getPrincipals().at(0)?.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
@@ -294,13 +276,15 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 if (!isIgnored)
                     principal.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
-            for (const [_import, specifierFilePath] of file.imports.imports) {
-                const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
-                if (packageName && isInternalWorkspace(packageName)) {
-                    file.imports.external.add({ ..._import, specifier: packageName });
-                    const principal = getPrincipalByFilePath(specifierFilePath);
-                    if (principal && !isGitIgnored(specifierFilePath)) {
-                        principal.addNonEntryPath(specifierFilePath);
+            for (const _import of file.imports.imports) {
+                if (_import.filePath) {
+                    const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
+                    if (packageName && isInternalWorkspace(packageName)) {
+                        file.imports.external.add({ ..._import, specifier: packageName });
+                        const principal = getPrincipalByFilePath(_import.filePath);
+                        if (principal && !isGitIgnored(_import.filePath)) {
+                            principal.addNonEntryPath(_import.filePath);
+                        }
                     }
                 }
             }

package/dist/graph-explorer/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CONTINUE = "continue";
+export declare const STOP = "stop";

package/dist/graph-explorer/constants.js

@@ -0,0 +1,2 @@
+export const CONTINUE = 'continue';
+export const STOP = 'stop';

package/dist/graph-explorer/explorer.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>) => {
+    isReferenced: (filePath: string, identifier: string, options: {
+        includeEntryExports: boolean;
+    }) => [boolean, string | undefined];
+    hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
+    buildExportsTree: (options: {
+        filePath?: string;
+        identifier?: string;
+    }) => import("./operations/build-trace-tree.js").TreeNode[];
+};

package/dist/graph-explorer/explorer.js

@@ -0,0 +1,10 @@
+import { buildExportsTree } from './operations/build-trace-tree.js';
+import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
+import { isReferenced } from './operations/is-referenced.js';
+export const createGraphExplorer = (graph, entryPaths) => {
+    return {
+        isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
+        hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, graph.get(filePath)?.imported, identifier),
+        buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+    };
+};

package/dist/graph-explorer/operations/build-trace-tree.d.ts

@@ -0,0 +1,12 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+export interface TreeNode {
+    filePath: string;
+    identifier: string;
+    hasRef: boolean;
+    isEntry: boolean;
+    children: TreeNode[];
+}
+export declare const buildExportsTree: (graph: ModuleGraph, entryPaths: Set<string>, options: {
+    filePath?: string;
+    identifier?: Identifier;
+}) => TreeNode[];