knip 5.44.1 → 5.44.2

package/dist/ConfigurationChief.js

@@ -1,8 +1,7 @@
 import picomatch from 'picomatch';
-import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { partitionCompilers } from './compilers/index.js';
 import { DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS, ROOT_WORKSPACE_NAME } from './constants.js';
-import { defaultRules } from './issues/initializers.js';
+import { knipConfigurationSchema } from './schema/configuration.js';
 import { pluginNames } from './types/PluginNames.js';
 import { arrayify, compact } from './util/array.js';
 import parsedArgValues from './util/cli-arguments.js';
@@ -11,6 +10,7 @@ import { ConfigurationError } from './util/errors.js';
 import { findFile, isDirectory, isFile, loadJSON } from './util/fs.js';
 import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
 import { _dirGlob } from './util/glob.js';
+import { defaultRules } from './util/issue-initializers.js';
 import { _load } from './util/loader.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { getKeysByValue } from './util/object.js';
@@ -96,7 +96,7 @@ export class ConfigurationChief {
         this.rawConfig = this.resolvedConfigFilePath
             ? await this.loadResolvedConfigurationFile(this.resolvedConfigFilePath)
             : manifest.knip;
-        const parsedConfig = this.rawConfig ? ConfigurationValidator.parse(partitionCompilers(this.rawConfig)) : {};
+        const parsedConfig = this.rawConfig ? knipConfigurationSchema.parse(partitionCompilers(this.rawConfig)) : {};
         this.config = this.normalize(parsedConfig);
         await this.setWorkspaces();
     }

package/dist/IssueCollector.js

@@ -1,6 +1,6 @@
 import picomatch from 'picomatch';
-import { initCounters, initIssues } from './issues/initializers.js';
 import { timerify } from './util/Performance.js';
+import { initCounters, initIssues } from './util/issue-initializers.js';
 import { relative } from './util/path.js';
 const hasConfigurationHint = (hints, hint) => Array.from(hints).some(item => item.identifier === hint.identifier && item.type === hint.type && item.workspaceName === hint.workspaceName);
 const isMatch = timerify(picomatch.isMatch, 'isMatch');

package/dist/ProjectPrincipal.d.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 import type { GetImportsAndExportsOptions } from './types/config.js';
-import type { DependencyGraph, Export, ExportMember, FileNode } from './types/dependency-graph.js';
+import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { PrincipalOptions } from './types/project.js';
 import type { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
@@ -54,5 +54,5 @@ export declare class ProjectPrincipal {
     invalidateFile(filePath: string): void;
     findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
     hasExternalReferences(filePath: string, exportedItem: Export): boolean;
-    reconcileCache(graph: DependencyGraph): void;
+    reconcileCache(graph: ModuleGraph): void;
 }

package/dist/WorkspaceWorker.js

@@ -285,7 +285,11 @@ export class WorkspaceWorker {
         do {
             for (const [pluginName, dependencies] of configFiles.entries()) {
                 configFiles.delete(pluginName);
-                await runPlugin(pluginName, Array.from(dependencies));
+                if (this.enabledPlugins.includes(pluginName))
+                    await runPlugin(pluginName, Array.from(dependencies));
+                else
+                    for (const id of dependencies)
+                        addInput(toEntry(id));
             }
         } while (remainingPlugins.size > 0 && configFiles.size > 0);
         debugLogArray(name, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));

package/dist/graph/analyze.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigurationChief } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { DependencyDeputy } from '../DependencyDeputy.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { IssueFixer } from '../IssueFixer.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { Tags } from '../types/cli.js';
+import type { Report } from '../types/issues.js';
+import type { ModuleGraph } from '../types/module-graph.js';
+interface AnalyzeOptions {
+    analyzedFiles: Set<string>;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    deputy: DependencyDeputy;
+    entryPaths: Set<string>;
+    factory: PrincipalFactory;
+    fixer: IssueFixer;
+    graph: ModuleGraph;
+    isFix: boolean;
+    isHideConfigHints: boolean;
+    isIncludeLibs: boolean;
+    isProduction: boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    tags: Tags;
+    unreferencedFiles: Set<string>;
+    workspace?: string;
+}
+export declare const analyze: (options: AnalyzeOptions) => Promise<() => Promise<void>>;
+export {};

package/dist/graph/analyze.js

@@ -0,0 +1,232 @@
+import { getType, hasStrictlyEnumReferences, hasStrictlyNsReferences } from '../util/has-strictly-ns-references.js';
+import { getIsIdentifierReferencedHandler } from '../util/is-identifier-referenced.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';
+export const analyze = async (options) => {
+    const { analyzedFiles, chief, collector, deputy, entryPaths, factory, fixer, graph, isFix, isHideConfigHints, isIncludeLibs, isProduction, report, streamer, tags, unreferencedFiles, workspace, } = options;
+    const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;
+    const isReportValues = report.exports || report.nsExports || report.classMembers;
+    const isReportTypes = report.types || report.nsTypes || report.enumMembers;
+    const isReportClassMembers = report.classMembers;
+    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
+    const isShowConfigHints = !workspace && !isProduction && !isHideConfigHints;
+    const shouldIgnore = getShouldIgnoreHandler(isProduction);
+    const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
+    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths);
+    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
+    const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
+        (exportedItem.refs[0] > 0 &&
+            (typeof ignoreExportsUsedInFile === 'object'
+                ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
+                : ignoreExportsUsedInFile));
+    const analyzeGraph = async () => {
+        if (isReportValues || isReportTypes) {
+            streamer.cast('Connecting the dots...');
+            for (const [filePath, file] of graph.entries()) {
+                const exportItems = file.exports;
+                if (!exportItems || exportItems.size === 0)
+                    continue;
+                const workspace = chief.findWorkspaceByFilePath(filePath);
+                if (workspace) {
+                    const { isIncludeEntryExports } = workspace.config;
+                    const principal = factory.getPrincipalByPackageName(workspace.pkgName);
+                    const isEntry = entryPaths.has(filePath);
+                    if (!isIncludeEntryExports && isEntry) {
+                        createAndPrintTrace(filePath, { isEntry });
+                        continue;
+                    }
+                    const importsForExport = file.imported;
+                    for (const [identifier, exportedItem] of exportItems.entries()) {
+                        if (!isFix && exportedItem.isReExport)
+                            continue;
+                        if (shouldIgnore(exportedItem.jsDocTags))
+                            continue;
+                        const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
+                        if (importsForExport) {
+                            const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                                for (const tagName of exportedItem.jsDocTags) {
+                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                    }
+                                }
+                            }
+                            if (isIgnored)
+                                continue;
+                            if (reExportingEntryFile) {
+                                if (!isIncludeEntryExports) {
+                                    createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
+                                    continue;
+                                }
+                                const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
+                                if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
+                                    continue;
+                            }
+                            if (traceNode)
+                                printTrace(traceNode, filePath, identifier);
+                            if (isReferenced) {
+                                if (report.enumMembers && exportedItem.type === 'enum') {
+                                    if (!report.nsTypes && importsForExport.refs.has(identifier))
+                                        continue;
+                                    if (hasStrictlyEnumReferences(importsForExport, identifier))
+                                        continue;
+                                    for (const member of exportedItem.members) {
+                                        if (findMatch(workspace.ignoreMembers, member.identifier))
+                                            continue;
+                                        if (shouldIgnore(member.jsDocTags))
+                                            continue;
+                                        if (member.refs[0] === 0) {
+                                            const id = `${identifier}.${member.identifier}`;
+                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const isIgnored = shouldIgnoreTags(member.jsDocTags);
+                                            if (!isReferenced) {
+                                                if (isIgnored)
+                                                    continue;
+                                                const isIssueAdded = collector.addIssue({
+                                                    type: 'enumMembers',
+                                                    filePath,
+                                                    workspace: workspace.name,
+                                                    symbol: member.identifier,
+                                                    parentSymbol: identifier,
+                                                    pos: member.pos,
+                                                    line: member.line,
+                                                    col: member.col,
+                                                });
+                                                if (isFix && isIssueAdded && member.fix)
+                                                    fixer.addUnusedTypeNode(filePath, [member.fix]);
+                                            }
+                                            else if (isIgnored) {
+                                                for (const tagName of exportedItem.jsDocTags) {
+                                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                                        collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                if (principal && isReportClassMembers && exportedItem.type === 'class') {
+                                    const members = exportedItem.members.filter(member => !(findMatch(workspace.ignoreMembers, member.identifier) || shouldIgnore(member.jsDocTags)));
+                                    for (const member of principal.findUnusedMembers(filePath, members)) {
+                                        if (shouldIgnoreTags(member.jsDocTags)) {
+                                            const identifier = `${exportedItem.identifier}.${member.identifier}`;
+                                            for (const tagName of exportedItem.jsDocTags) {
+                                                if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                                    collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                                }
+                                            }
+                                            continue;
+                                        }
+                                        const isIssueAdded = collector.addIssue({
+                                            type: 'classMembers',
+                                            filePath,
+                                            workspace: workspace.name,
+                                            symbol: member.identifier,
+                                            parentSymbol: exportedItem.identifier,
+                                            pos: member.pos,
+                                            line: member.line,
+                                            col: member.col,
+                                        });
+                                        if (isFix && isIssueAdded && member.fix)
+                                            fixer.addUnusedTypeNode(filePath, [member.fix]);
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                        const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
+                        const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
+                        if (hasStrictlyNsRefs && ((!report.nsTypes && isType) || !(report.nsExports || isType)))
+                            continue;
+                        if (!isExportedItemReferenced(exportedItem)) {
+                            if (isIgnored)
+                                continue;
+                            if (!isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
+                                continue;
+                            const type = getType(hasStrictlyNsRefs, isType);
+                            const isIssueAdded = collector.addIssue({
+                                type,
+                                filePath,
+                                workspace: workspace.name,
+                                symbol: identifier,
+                                symbolType: exportedItem.type,
+                                parentSymbol: namespace,
+                                pos: exportedItem.pos,
+                                line: exportedItem.line,
+                                col: exportedItem.col,
+                            });
+                            if (isFix && isIssueAdded) {
+                                if (isType)
+                                    fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
+                                else
+                                    fixer.addUnusedExportNode(filePath, exportedItem.fixes);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (const [filePath, file] of graph.entries()) {
+            const ws = chief.findWorkspaceByFilePath(filePath);
+            if (ws) {
+                if (file.duplicates) {
+                    for (const symbols of file.duplicates) {
+                        if (symbols.length > 1) {
+                            const symbol = symbols.map(s => s.symbol).join('|');
+                            collector.addIssue({ type: 'duplicates', filePath, workspace: ws.name, symbol, symbols });
+                        }
+                    }
+                }
+                if (file.imports?.external) {
+                    for (const specifier of file.imports.external) {
+                        const packageName = getPackageNameFromModuleSpecifier(specifier);
+                        const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(ws, packageName);
+                        if (!isHandled)
+                            collector.addIssue({
+                                type: 'unlisted',
+                                filePath,
+                                workspace: ws.name,
+                                symbol: packageName ?? specifier,
+                                specifier,
+                            });
+                    }
+                }
+                if (file.imports?.unresolved) {
+                    for (const unresolvedImport of file.imports.unresolved) {
+                        const { specifier, pos, line, col } = unresolvedImport;
+                        collector.addIssue({ type: 'unresolved', filePath, workspace: ws.name, symbol: specifier, pos, line, col });
+                    }
+                }
+            }
+        }
+        const unusedFiles = [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath));
+        collector.addFilesIssues(unusedFiles);
+        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
+        if (isReportDependencies) {
+            const { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues } = deputy.settleDependencyIssues();
+            for (const issue of dependencyIssues)
+                collector.addIssue(issue);
+            if (!isProduction)
+                for (const issue of devDependencyIssues)
+                    collector.addIssue(issue);
+            for (const issue of optionalPeerDependencyIssues)
+                collector.addIssue(issue);
+            deputy.removeIgnoredIssues(collector.getIssues());
+            if (isShowConfigHints) {
+                const configurationHints = deputy.getConfigurationHints();
+                for (const hint of configurationHints)
+                    collector.addConfigurationHint(hint);
+            }
+        }
+        if (isShowConfigHints) {
+            const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();
+            for (const identifier of unusedIgnoredWorkspaces) {
+                collector.addConfigurationHint({ type: 'ignoreWorkspaces', identifier });
+            }
+        }
+    };
+    await analyzeGraph();
+    return analyzeGraph;
+};

package/dist/graph/build.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
+import type { ConsoleStreamer } from '../ConsoleStreamer.js';
+import type { DependencyDeputy } from '../DependencyDeputy.js';
+import type { IssueCollector } from '../IssueCollector.js';
+import type { PrincipalFactory } from '../PrincipalFactory.js';
+import type { ProjectPrincipal } from '../ProjectPrincipal.js';
+import type { Tags } from '../types/cli.js';
+import type { Report } from '../types/issues.js';
+import type { ModuleGraph } from '../types/module-graph.js';
+interface BuildOptions {
+    cacheLocation: string;
+    chief: ConfigurationChief;
+    collector: IssueCollector;
+    cwd: string;
+    deputy: DependencyDeputy;
+    factory: PrincipalFactory;
+    gitignore: boolean;
+    isCache: boolean;
+    isFixExports: boolean;
+    isFixTypes: boolean;
+    isGitIgnored: (path: string) => boolean;
+    isIsolateWorkspaces: boolean;
+    isProduction: boolean;
+    isSkipLibs: boolean;
+    isStrict: boolean;
+    isWatch: boolean;
+    report: Report;
+    streamer: ConsoleStreamer;
+    tags: Tags;
+    tsConfigFile?: string;
+    workspaces: Workspace[];
+}
+export declare function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }: BuildOptions): Promise<{
+    graph: ModuleGraph;
+    entryPaths: Set<string>;
+    analyzedFiles: Set<string>;
+    unreferencedFiles: Set<string>;
+    analyzeSourceFile: (filePath: string, principal: ProjectPrincipal) => void;
+}>;
+export {};

package/dist/graph/build.js

@@ -0,0 +1,268 @@
+import { WorkspaceWorker } from '../WorkspaceWorker.js';
+import { _getInputsFromScripts } from '../binaries/index.js';
+import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
+import { debugLog, debugLogArray } from '../util/debug.js';
+import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
+import { _glob, negate } from '../util/glob.js';
+import { isConfigPattern, isEntry, isProductionEntry, toProductionEntry } from '../util/input.js';
+import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
+import { getEntryPathsFromManifest } from '../util/package-json.js';
+import { dirname, isAbsolute, join, relative } from '../util/path.js';
+import {} from '../util/tag.js';
+import { augmentWorkspace, getToSourcePathHandler } from '../util/to-source-path.js';
+import { loadTSConfig } from '../util/tsconfig-loader.js';
+export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
+    const allConfigFilePaths = new Set();
+    const enabledPluginsStore = new Map();
+    const toSourceFilePath = getToSourcePathHandler(chief);
+    const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
+    const isReportClassMembers = report.classMembers;
+    for (const workspace of workspaces) {
+        const { name, dir, manifestPath, manifestStr } = workspace;
+        const manifest = chief.getManifestForWorkspace(name);
+        if (!manifest)
+            continue;
+        deputy.addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ...chief.getIgnores(name) });
+    }
+    for (const workspace of workspaces) {
+        const { name, dir, ancestors, pkgName } = workspace;
+        streamer.cast(`Analyzing workspace ${name}...`);
+        const manifest = chief.getManifestForWorkspace(name);
+        if (!manifest) {
+            continue;
+        }
+        const dependencies = deputy.getDependencies(name);
+        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
+        const extensions = getCompilerExtensions(compilers);
+        const config = chief.getConfigForWorkspace(name, extensions);
+        const tsConfigFilePath = join(dir, tsConfigFile ?? 'tsconfig.json');
+        const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(tsConfigFilePath);
+        if (isFile)
+            augmentWorkspace(workspace, dir, compilerOptions);
+        const worker = new WorkspaceWorker({
+            name,
+            dir,
+            cwd,
+            config,
+            manifest,
+            dependencies,
+            getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
+            isProduction,
+            isStrict,
+            rootIgnore: chief.config.ignore,
+            negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
+            ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
+            enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
+            isCache,
+            cacheLocation,
+            allConfigFilePaths,
+        });
+        await worker.init();
+        const deps = new Set();
+        if (definitionPaths.length > 0) {
+            debugLogArray(name, 'Definition paths', definitionPaths);
+            for (const id of definitionPaths)
+                deps.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
+        }
+        const ignore = worker.getIgnorePatterns();
+        const sharedGlobOptions = { cwd, dir, gitignore };
+        collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
+        const entryPathsFromManifest = await getEntryPathsFromManifest(manifest, { ...sharedGlobOptions, ignore });
+        for (const id of entryPathsFromManifest.map(id => toProductionEntry(id)))
+            deps.add(id);
+        const dependenciesFromPlugins = await worker.findDependenciesByPlugins();
+        for (const id of dependenciesFromPlugins)
+            deps.add(id);
+        enabledPluginsStore.set(name, worker.enabledPlugins);
+        const principal = factory.createPrincipal({
+            cwd: dir,
+            paths: config.paths,
+            isFile,
+            compilerOptions,
+            compilers,
+            pkgName,
+            isIsolateWorkspaces,
+            isSkipLibs,
+            isWatch,
+            toSourceFilePath,
+            isCache,
+            cacheLocation,
+        });
+        const entryFilePatterns = new Set();
+        const productionEntryFilePatterns = new Set();
+        for (const dependency of deps) {
+            const s = dependency.specifier;
+            if (isEntry(dependency)) {
+                entryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+            }
+            else if (isProductionEntry(dependency)) {
+                productionEntryFilePatterns.add(isAbsolute(s) ? relative(dir, s) : s);
+            }
+            else if (!isConfigPattern(dependency)) {
+                const ws = (dependency.containingFilePath && chief.findWorkspaceByFilePath(dependency.containingFilePath)) || workspace;
+                const specifierFilePath = getReferencedInternalFilePath(dependency, ws);
+                if (specifierFilePath)
+                    principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
+            }
+        }
+        if (isProduction) {
+            const negatedEntryPatterns = Array.from(entryFilePatterns).map(negate);
+            {
+                const label = 'entry';
+                const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
+                principal.addEntryPaths(workspaceEntryPaths);
+            }
+            {
+                const label = 'production plugin entry';
+                const patterns = Array.from(productionEntryFilePatterns);
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+            }
+            {
+                const label = 'project';
+                const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                for (const projectPath of workspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
+            }
+        }
+        else {
+            {
+                const label = 'entry';
+                const patterns = worker.getEntryFilePatterns();
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, gitignore: false, label });
+                principal.addEntryPaths(workspaceEntryPaths);
+            }
+            {
+                const label = 'project';
+                const patterns = worker.getProjectFilePatterns([...productionEntryFilePatterns]);
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                for (const projectPath of workspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
+            }
+            {
+                const label = 'plugin entry';
+                const patterns = worker.getPluginEntryFilePatterns([...entryFilePatterns, ...productionEntryFilePatterns]);
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
+            }
+            {
+                const label = 'plugin project';
+                const patterns = worker.getPluginProjectFilePatterns();
+                const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                for (const projectPath of pluginWorkspaceProjectPaths)
+                    principal.addProjectPath(projectPath);
+            }
+            {
+                const label = 'plugin configuration';
+                const patterns = worker.getPluginConfigPatterns();
+                const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns, label });
+                principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
+            }
+        }
+        if (chief.resolvedConfigFilePath) {
+            principal.addEntryPath(chief.resolvedConfigFilePath, { skipExportsAnalysis: true });
+        }
+        worker.onDispose();
+    }
+    const principals = factory.getPrincipals();
+    debugLog('*', `Created ${principals.length} programs for ${workspaces.length} workspaces`);
+    const graph = new Map();
+    const analyzedFiles = new Set();
+    const unreferencedFiles = new Set();
+    const entryPaths = new Set();
+    const isPackageNameInternalWorkspace = (packageName) => chief.availableWorkspacePkgNames.has(packageName);
+    const getPrincipalByFilePath = (filePath) => {
+        const workspace = chief.findWorkspaceByFilePath(filePath);
+        if (workspace)
+            return factory.getPrincipalByPackageName(workspace.pkgName);
+    };
+    const analyzeSourceFile = (filePath, principal) => {
+        if (!isWatch && analyzedFiles.has(filePath))
+            return;
+        analyzedFiles.add(filePath);
+        const workspace = chief.findWorkspaceByFilePath(filePath);
+        if (workspace) {
+            const { imports, exports, duplicates, scripts, traceRefs } = principal.analyzeSourceFile(filePath, {
+                skipTypeOnly: isStrict,
+                isFixExports,
+                isFixTypes,
+                ignoreExportsUsedInFile: chief.config.ignoreExportsUsedInFile,
+                isReportClassMembers,
+                tags,
+            }, isGitIgnored, isPackageNameInternalWorkspace, getPrincipalByFilePath);
+            const node = getOrCreateFileNode(graph, filePath);
+            node.imports = imports;
+            node.exports = exports;
+            node.duplicates = duplicates;
+            node.scripts = scripts;
+            node.traceRefs = traceRefs;
+            updateImportMap(node, imports.internal, graph);
+            node.internalImportCache = imports.internal;
+            graph.set(filePath, node);
+            if (scripts && scripts.size > 0) {
+                const dependencies = deputy.getDependencies(workspace.name);
+                const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
+                const dir = dirname(filePath);
+                const options = {
+                    cwd: dir,
+                    rootCwd: cwd,
+                    containingFilePath: filePath,
+                    dependencies,
+                    manifestScriptNames,
+                };
+                const inputs = _getInputsFromScripts(scripts, options);
+                for (const input of inputs) {
+                    input.containingFilePath ??= filePath;
+                    input.dir ??= dir;
+                    const specifierFilePath = getReferencedInternalFilePath(input, workspace);
+                    if (specifierFilePath)
+                        analyzeSourceFile(specifierFilePath, principal);
+                }
+            }
+        }
+    };
+    for (let i = 0; i < principals.length; ++i) {
+        const principal = principals[i];
+        if (!principal)
+            continue;
+        principal.init();
+        streamer.cast('Running async compilers...');
+        await principal.runAsyncCompilers();
+        streamer.cast('Analyzing source files...');
+        let size = principal.entryPaths.size;
+        let round = 0;
+        do {
+            size = principal.entryPaths.size;
+            const resolvedFiles = principal.getUsedResolvedFiles();
+            const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
+            debugLogArray('*', `Analyzing used resolved files [P${i + 1}/${++round}]`, files);
+            for (const filePath of files)
+                analyzeSourceFile(filePath, principal);
+        } while (size !== principal.entryPaths.size);
+        for (const filePath of principal.getUnreferencedFiles())
+            unreferencedFiles.add(filePath);
+        for (const filePath of principal.entryPaths)
+            entryPaths.add(filePath);
+        principal.reconcileCache(graph);
+        if (!isIsolateWorkspaces && isSkipLibs && !isWatch) {
+            factory.deletePrincipal(principal);
+            principals[i] = undefined;
+        }
+    }
+    if (isIsolateWorkspaces) {
+        for (const principal of principals) {
+            if (principal)
+                factory.deletePrincipal(principal);
+        }
+        principals.length = 0;
+    }
+    return {
+        graph,
+        entryPaths,
+        analyzedFiles,
+        unreferencedFiles,
+        analyzeSourceFile,
+    };
+}