knip 2.1.2 → 2.2.0

package/dist/{configuration-chief.js → ConfigurationChief.js}

@@ -1,6 +1,6 @@
 import mapWorkspaces from '@npmcli/map-workspaces';
 import micromatch from 'micromatch';
-import { ConfigurationValidator } from './configuration-validator.js';
+import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS, KNIP_CONFIG_LOCATIONS } from './constants.js';
 import * as plugins from './plugins/index.js';
 import { arrayify, compact } from './util/array.js';
@@ -88,7 +88,7 @@ export class ConfigurationChief {
         return [this.config.syncCompilers, this.config.asyncCompilers];
     }
     normalize(rawLocalConfig) {
-        const workspaces = rawLocalConfig.workspaces ?? {
+        const initialWorkspaces = rawLocalConfig.workspaces ?? {
             [ROOT_WORKSPACE_NAME]: {
                 ...rawLocalConfig,
             },
@@ -102,6 +102,42 @@ export class ConfigurationChief {
         const { syncCompilers, asyncCompilers } = rawLocalConfig;
         const extensions = [...Object.keys(syncCompilers ?? {}), ...Object.keys(asyncCompilers ?? {})];
         const defaultWorkspaceConfig = getDefaultWorkspaceConfig(extensions);
+        const workspaces = Object.entries(initialWorkspaces)
+            .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
+            .reduce((workspaces, workspace) => {
+            const [workspaceName, workspaceConfig] = workspace;
+            const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultWorkspaceConfig.entry;
+            const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultWorkspaceConfig.project;
+            const paths = workspaceConfig.paths ?? defaultWorkspaceConfig.paths;
+            workspaces[workspaceName] = {
+                entry,
+                project,
+                paths,
+                ignore: arrayify(workspaceConfig.ignore),
+                ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
+                ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
+            };
+            for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
+                const pluginName = toCamelCase(name);
+                if (PLUGIN_NAMES.includes(pluginName)) {
+                    if (pluginConfig === false) {
+                        workspaces[workspaceName][pluginName] = false;
+                    }
+                    else {
+                        const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
+                        const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
+                        const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
+                        const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
+                        workspaces[workspaceName][pluginName] = {
+                            config,
+                            entry,
+                            project,
+                        };
+                    }
+                }
+            }
+            return workspaces;
+        }, {});
         return {
             include,
             exclude,
@@ -109,42 +145,7 @@ export class ConfigurationChief {
             ignoreWorkspaces,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
-            workspaces: Object.entries(workspaces)
-                .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
-                .reduce((workspaces, workspace) => {
-                const [workspaceName, workspaceConfig] = workspace;
-                const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultWorkspaceConfig.entry;
-                const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultWorkspaceConfig.project;
-                const paths = workspaceConfig.paths ?? defaultWorkspaceConfig.paths;
-                workspaces[workspaceName] = {
-                    entry,
-                    project,
-                    paths,
-                    ignore: arrayify(workspaceConfig.ignore),
-                    ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
-                    ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
-                };
-                for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
-                    const pluginName = toCamelCase(name);
-                    if (PLUGIN_NAMES.includes(pluginName)) {
-                        if (pluginConfig === false) {
-                            workspaces[workspaceName][pluginName] = false;
-                        }
-                        else {
-                            const isObject = typeof pluginConfig !== 'string' && !Array.isArray(pluginConfig);
-                            const config = isObject ? arrayify(pluginConfig.config) : pluginConfig ? arrayify(pluginConfig) : null;
-                            const entry = isObject && 'entry' in pluginConfig ? arrayify(pluginConfig.entry) : null;
-                            const project = isObject && 'project' in pluginConfig ? arrayify(pluginConfig.project) : entry;
-                            workspaces[workspaceName][pluginName] = {
-                                config,
-                                entry,
-                                project,
-                            };
-                        }
-                    }
-                }
-                return workspaces;
-            }, {}),
+            workspaces,
         };
     }
     async setWorkspaces() {

package/dist/{dependency-deputy.d.ts → DependencyDeputy.d.ts}

@@ -1,4 +1,4 @@
-import { Workspace } from './configuration-chief.js';
+import { Workspace } from './ConfigurationChief.js';
 import type { Issue } from './types/issues.js';
 import type { WorkspaceManifests } from './types/workspace.js';
 import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
@@ -13,12 +13,13 @@ export declare class DependencyDeputy {
     peerDependencies: Map<string, PeerDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     constructor({ isStrict }: Options);
-    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, }: {
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }: {
         name: string;
         dir: string;
         manifestPath: string;
         manifest: PackageJson;
         ignoreDependencies: string[];
+        ignoreBinaries: string[];
     }): void;
     getWorkspaceManifest(workspaceName: string): {
         workspaceDir: string;
@@ -30,6 +31,7 @@ export declare class DependencyDeputy {
         devDependencies: string[];
         allDependencies: string[];
         ignoreDependencies: string[];
+        ignoreBinaries: string[];
     } | undefined;
     getProductionDependencies(workspaceName: string): string[];
     getDevDependencies(workspaceName: string): string[];

package/dist/{dependency-deputy.js → DependencyDeputy.js}

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES } from './constants.js';
+import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 export class DependencyDeputy {
     isStrict;
@@ -13,7 +13,7 @@ export class DependencyDeputy {
         this.peerDependencies = new Map();
         this.installedBinaries = new Map();
     }
-    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, }) {
+    addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries, }) {
         const scripts = Object.values(manifest.scripts ?? {});
         const dependencies = Object.keys(manifest.dependencies ?? {});
         const peerDependencies = Object.keys(manifest.peerDependencies ?? {});
@@ -24,6 +24,7 @@ export class DependencyDeputy {
             workspaceDir: dir,
             manifestPath,
             ignoreDependencies,
+            ignoreBinaries,
             scripts,
             dependencies,
             peerDependencies,
@@ -80,6 +81,10 @@ export class DependencyDeputy {
             closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
             return true;
         }
+        if (IGNORED_GLOBAL_BINARIES.includes(packageName))
+            return true;
+        if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(packageName))
+            return true;
         for (const name of workspaceNames) {
             const binaries = this.getInstalledBinaries(name);
             if (binaries?.has(packageName)) {
@@ -102,9 +107,21 @@ export class DependencyDeputy {
     settleDependencyIssues() {
         const dependencyIssues = [];
         const devDependencyIssues = [];
-        for (const [workspaceName, { manifestPath, ignoreDependencies }] of this._manifests.entries()) {
+        for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
-            const isUnreferencedDependency = (dependency) => {
+            const installedBinaries = this.getInstalledBinaries(workspaceName);
+            const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...ignoreBinaries];
+            const ignoreDeps = [...IGNORED_DEPENDENCIES, ...ignoreDependencies];
+            const isNotIgnoredDependency = (packageName) => !ignoreDeps.includes(packageName);
+            const isNotIgnoredBinary = (packageName) => {
+                if (installedBinaries?.has(packageName)) {
+                    const binaryNames = installedBinaries.get(packageName);
+                    if (binaryNames && ignoreBins.some(ignoredBinary => binaryNames.has(ignoredBinary)))
+                        return false;
+                }
+                return true;
+            };
+            const isNotReferencedDependency = (dependency) => {
                 if (referencedDependencies?.has(dependency))
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
@@ -114,23 +131,25 @@ export class DependencyDeputy {
                         return false;
                     const peerDependencies = this.getPeerDependencies(workspaceName, typedPackageName);
                     if (peerDependencies.length) {
-                        return !peerDependencies.find(peerDependency => !isUnreferencedDependency(peerDependency));
+                        return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
                     }
                     return !referencedDependencies?.has(typedPackageName);
                 }
                 if (!referencedDependencies?.has(dependency)) {
                     const peerDependencies = this.getPeerDependencies(workspaceName, dependency);
-                    return !peerDependencies.find(peerDependency => !isUnreferencedDependency(peerDependency));
+                    return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency));
                 }
                 return false;
             };
             this.getProductionDependencies(workspaceName)
-                .filter(symbol => !IGNORED_DEPENDENCIES.includes(symbol) && !ignoreDependencies.includes(symbol))
-                .filter(isUnreferencedDependency)
+                .filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
             this.getDevDependencies(workspaceName)
-                .filter(symbol => !IGNORED_DEPENDENCIES.includes(symbol) && !ignoreDependencies.includes(symbol))
-                .filter(isUnreferencedDependency)
+                .filter(isNotIgnoredDependency)
+                .filter(isNotIgnoredBinary)
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
         }
         return { dependencyIssues, devDependencyIssues };

package/dist/{principal-factory.d.ts → PrincipalFactory.d.ts}

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ProjectPrincipal } from './project-principal.js';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { Report } from './types/issues.js';
 type Paths = ts.CompilerOptions['paths'];

package/dist/{principal-factory.js → PrincipalFactory.js}

@@ -1,4 +1,4 @@
-import { ProjectPrincipal } from './project-principal.js';
+import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { join, isAbsolute } from './util/path.js';
 const mergePaths = (cwd, compilerOptions, paths = {}) => {
     const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {

package/dist/{project-principal.d.ts → ProjectPrincipal.d.ts}

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
-import type { ExportItem, ExportItemMember } from './types/ast.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
+import type { ExportItem, ExportItemMember } from './types/exports.js';
 import type { Report } from './types/issues.js';
 type ProjectPrincipalOptions = {
     compilerOptions: ts.CompilerOptions;
@@ -39,12 +39,15 @@ export declare class ProjectPrincipal {
     getUnreferencedFiles(): string[];
     analyzeSourceFile(filePath: string): {
         imports: {
-            internal: import("./types/ast.js").Imports;
+            internal: import("./types/imports.js").Imports;
             unresolved: Set<string>;
             external: Set<string>;
         };
-        exports: import("./types/ast.js").ExportItems;
-        duplicateExports: string[][];
+        exports: {
+            exported: import("./types/exports.js").ExportItems;
+            duplicate: string[][];
+        };
+        scripts: Set<string>;
     };
     private resolveModule;
     hasExternalReferences(filePath: string, exportedItem: ExportItem): boolean;

package/dist/{project-principal.js → ProjectPrincipal.js}

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 import { DEFAULT_EXTENSIONS } from './constants.js';
 import { IGNORED_FILE_EXTENSIONS } from './constants.js';
-import { getImportsAndExports } from './typescript/ast-walker.js';
 import { createHosts } from './typescript/createHosts.js';
+import { getImportsAndExports } from './typescript/getImportsAndExports.js';
 import { extname, isInNodeModules } from './util/path.js';
-import { timerify } from './util/performance.js';
+import { timerify } from './util/Performance.js';
 const baseCompilerOptions = {
     allowJs: true,
     jsx: ts.JsxEmit.Preserve,
@@ -109,7 +109,7 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipTypeOnly = !this.isReportTypes;
         const skipExports = this.skipExportsAnalysis.has(filePath);
-        const { imports, exports, duplicateExports } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();
         unresolved.forEach(specifier => {
@@ -144,7 +144,7 @@ export class ProjectPrincipal {
                 external,
             },
             exports,
-            duplicateExports,
+            scripts,
         };
     }
     resolveModule(specifier, filePath = specifier) {
@@ -159,6 +159,8 @@ export class ProjectPrincipal {
     findUnusedMembers(filePath, members) {
         return members
             .filter(member => {
+            if (this.isPublicExport(member))
+                return false;
             const referencedSymbols = this.findReferences(filePath, member.node);
             const files = referencedSymbols
                 .flatMap(refs => refs.references)

package/dist/{workspace-worker.d.ts → WorkspaceWorker.d.ts}

@@ -50,7 +50,7 @@ export declare class WorkspaceWorker {
         peerDependencies: PeerDependencies;
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("typescript" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "tailwind" | "typedoc" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
+        enabledPlugins: ("ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
     }>;
 }
 export {};

package/dist/{workspace-worker.js → WorkspaceWorker.js}

@@ -58,7 +58,6 @@ export class WorkspaceWorker {
     }
     async initReferencedDependencies() {
         const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
-            config: this.config,
             manifest: this.manifest,
             isProduction: this.isProduction,
             isStrict: this.isStrict,
@@ -218,7 +217,6 @@ export class WorkspaceWorker {
                             cwd,
                             manifest: this.manifest,
                             config: pluginConfig,
-                            workspaceConfig: this.config,
                             isProduction: this.isProduction,
                         });
                         dependencies.forEach(specifier => {

package/dist/binaries/index.d.ts

@@ -1,2 +1,2 @@
-import type { GetReferencesFromScripts } from './types.js';
-export declare const _getReferencesFromScripts: GetReferencesFromScripts;
+import type { GetDependenciesFromScripts } from './types.js';
+export declare const _getDependenciesFromScripts: GetDependenciesFromScripts;

package/dist/binaries/index.js

@@ -1,23 +1,19 @@
-import { IGNORED_GLOBAL_BINARIES } from '../constants.js';
 import { compact } from '../util/array.js';
-import { partition } from '../util/array.js';
 import { getPackageNameFromModuleSpecifier, stripBinary } from '../util/modules.js';
 import { isInternal } from '../util/path.js';
-import { timerify } from '../util/performance.js';
+import { timerify } from '../util/Performance.js';
 import { getBinariesFromScript } from './bash-parser.js';
 const defaultCwd = process.cwd();
-const getReferencesFromScripts = (npmScripts, options = {}) => {
-    const { cwd = defaultCwd, manifest = {}, ignore = [], knownGlobalsOnly = false } = options;
-    const scripts = [npmScripts].flat();
+const getDependenciesFromScripts = (npmScripts, options = {}) => {
+    const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
+    const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
     const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
-    const [entryFiles, binaries] = partition(compact(results), isInternal);
-    return {
-        entryFiles,
-        binaries: binaries
-            .map(stripBinary)
-            .map(getPackageNameFromModuleSpecifier)
-            .filter(binaryName => !binaryName.startsWith('.'))
-            .filter(binaryName => !IGNORED_GLOBAL_BINARIES.includes(binaryName) && !ignore.includes(binaryName)),
-    };
+    return compact(results.map(identifier => {
+        if (isInternal(identifier))
+            return identifier;
+        const packageName = getPackageNameFromModuleSpecifier(stripBinary(identifier));
+        if (!packageName.startsWith('.'))
+            return packageName;
+    }));
 };
-export const _getReferencesFromScripts = timerify(getReferencesFromScripts);
+export const _getDependenciesFromScripts = timerify(getDependenciesFromScripts);

package/dist/binaries/resolvers/fallback.js

@@ -1,14 +1,18 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
 import { tryResolveFilePaths } from './util.js';
+const withPositional = parsed => [parsed._[0], parsed.require].flat();
+const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {
-    'babel-node': parsed => [parsed._[0], parsed.require].flat(),
-    'ts-node': parsed => [parsed._[0], parsed.require].flat(),
+    'babel-node': withPositional,
+    nodemon: withPositional,
+    'ts-node': withPositional,
+    zx: withPositional,
     tsx: parsed => parsed._.filter(p => p !== 'watch'),
-    default: parsed => [parsed.require].flat(),
+    default: withoutPositional,
 };
 export const resolve = (binary, args, { cwd }) => {
-    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] } });
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
     const argFilter = argFilters[binary] ?? argFilters.default;
     const filteredArgs = compact(argFilter(parsed));
     return [binary, ...tryResolveFilePaths(cwd, filteredArgs)];

package/dist/binaries/resolvers/npx.js

@@ -1,5 +1,7 @@
 import parseArgs from 'minimist';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { '--': true, stopEarly: true, boolean: ['yes', 'no'], alias: { yes: 'y', no: 'n' } });
-    return [...(parsed.yes ? [] : fromArgs(parsed._)), ...(parsed['--'] ? fromArgs(parsed['--']) : [])];
+    const left = fromArgs(parsed._);
+    const right = parsed['--'] ? fromArgs(parsed['--']) : [];
+    return [...(parsed.yes ? left.slice(1) : left), ...right];
 };

package/dist/binaries/types.d.ts

@@ -2,13 +2,9 @@ import type { PackageJson } from 'type-fest';
 type Options = {
     cwd?: string;
     manifest?: PackageJson;
-    ignore?: string[];
     knownGlobalsOnly?: boolean;
 };
-export type GetReferencesFromScripts = (npmScripts: string | string[], options?: Options) => {
-    entryFiles: string[];
-    binaries: string[];
-};
+export type GetDependenciesFromScripts = (npmScripts: string | string[] | Set<string>, options?: Options) => string[];
 type FromArgs = (args: string[]) => string[];
 export type Resolver = (binary: string, args: string[], options: {
     cwd: string;

package/dist/cli.js

@@ -6,7 +6,7 @@ import parsedArgs, { helpText } from './util/cli-arguments.js';
 import { isKnownError, ConfigurationError } from './util/errors.js';
 import { _load } from './util/loader.js';
 import { cwd, resolve } from './util/path.js';
-import { Performance } from './util/performance.js';
+import { Performance } from './util/Performance.js';
 import { version } from './version.js';
 import { main } from './index.js';
 const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, performance: isObservePerf = false, production: isProduction = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgs.values;

package/dist/index.js

@@ -1,9 +1,10 @@
-import { ConfigurationChief } from './configuration-chief.js';
-import { ConsoleStreamer } from './console-streamer.js';
+import { _getDependenciesFromScripts } from './binaries/index.js';
+import { ConfigurationChief } from './ConfigurationChief.js';
+import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
-import { DependencyDeputy } from './dependency-deputy.js';
-import { IssueCollector } from './issue-collector.js';
-import { PrincipalFactory } from './principal-factory.js';
+import { DependencyDeputy } from './DependencyDeputy.js';
+import { IssueCollector } from './IssueCollector.js';
+import { PrincipalFactory } from './PrincipalFactory.js';
 import { compact } from './util/array.js';
 import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
 import { LoaderError } from './util/errors.js';
@@ -14,7 +15,7 @@ import { dirname, isInNodeModules, join, isInternal, isAbsolute } from './util/p
 import { _resolveSpecifier, _tryResolve } from './util/require.js';
 import { _require } from './util/require.js';
 import { loadTSConfig as loadCompilerOptions } from './util/tsconfig-loader.js';
-import { WorkspaceWorker } from './workspace-worker.js';
+import { WorkspaceWorker } from './WorkspaceWorker.js';
 export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress } = unresolvedConfiguration;
     debugLogObject('Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
@@ -29,17 +30,55 @@ export const main = async (unresolvedConfiguration) => {
     const workspaces = chief.getEnabledWorkspaces();
     const report = chief.getIssueTypesToReport();
     debugLogObject('Included workspaces', workspaces);
+    const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
+        if (isInternal(specifier)) {
+            const absSpecifier = isAbsolute(specifier) ? specifier : join(dirname(containingFilePath), specifier);
+            const filePath = _tryResolve(absSpecifier, containingFilePath);
+            if (filePath) {
+                principal.addEntryPath(filePath);
+            }
+            else {
+                collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+            }
+        }
+        else {
+            if (isInNodeModules(specifier)) {
+                const packageName = getPackageNameFromFilePath(specifier);
+                const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
+                if (!isHandled)
+                    collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
+            }
+            else {
+                const packageName = getPackageNameFromModuleSpecifier(specifier);
+                const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
+                if (!isHandled)
+                    collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
+                if (specifier !== packageName) {
+                    const otherWorkspace = chief.findWorkspaceByPackageName(packageName);
+                    if (otherWorkspace) {
+                        const filePath = _resolveSpecifier(otherWorkspace.dir, specifier);
+                        if (filePath) {
+                            principal.addEntryPath(filePath);
+                        }
+                        else {
+                            collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
+                        }
+                    }
+                }
+            }
+        }
+    };
     const enabledPluginsStore = new Map();
     for (const workspace of workspaces) {
         const { name, dir, config, ancestors } = workspace;
-        const { paths, ignoreDependencies } = config;
+        const { paths, ignoreDependencies, ignoreBinaries } = config;
         const isRoot = name === ROOT_WORKSPACE_NAME;
         streamer.cast(`Analyzing workspace (${name})...`);
         const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
         const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
         if (!manifestPath || !manifest)
             throw new LoaderError(`Unable to load package.json for ${name}`);
-        deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies });
+        deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const compilerOptions = await loadCompilerOptions(join(dir, tsConfigFile ?? 'tsconfig.json'));
         const principal = factory.getPrincipal({ cwd: dir, report: report, paths, compilerOptions, compilers });
         const worker = new WorkspaceWorker({
@@ -122,40 +161,7 @@ export const main = async (unresolvedConfiguration) => {
         deputy.setInstalledBinaries(name, installedBinaries);
         enabledPluginsStore.set(name, enabledPlugins);
         referencedDependencies.forEach(([containingFilePath, specifier]) => {
-            if (isInternal(specifier)) {
-                const absSpecifier = isAbsolute(specifier) ? specifier : join(dirname(containingFilePath), specifier);
-                const filePath = _tryResolve(absSpecifier, containingFilePath);
-                if (filePath) {
-                    principal.addEntryPath(filePath);
-                }
-                else {
-                    collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
-                }
-            }
-            else {
-                if (isInNodeModules(specifier)) {
-                    const packageName = getPackageNameFromFilePath(specifier);
-                    const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
-                    if (!isHandled)
-                        collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
-                }
-                else {
-                    const packageName = getPackageNameFromModuleSpecifier(specifier);
-                    const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, packageName);
-                    if (!isHandled)
-                        collector.addIssue({ type: 'unlisted', filePath: containingFilePath, symbol: specifier });
-                    const otherWorkspace = chief.findWorkspaceByPackageName(packageName);
-                    if (otherWorkspace && specifier !== packageName) {
-                        const filePath = _resolveSpecifier(otherWorkspace.dir, specifier);
-                        if (filePath) {
-                            principal.addEntryPath(filePath);
-                        }
-                        else {
-                            collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
-                        }
-                    }
-                }
-            }
+            handleReferencedDependency({ specifier, containingFilePath, principal, workspace });
         });
     }
     const principals = factory.getPrincipals();
@@ -167,10 +173,11 @@ export const main = async (unresolvedConfiguration) => {
             collector.counters.processed++;
             const workspace = chief.findWorkspaceByFilePath(filePath);
             if (workspace) {
-                const { imports, exports, duplicateExports } = principal.analyzeSourceFile(filePath);
+                const { imports, exports, scripts } = principal.analyzeSourceFile(filePath);
                 const { internal, external, unresolved } = imports;
-                if (exports.size > 0)
-                    exportedSymbols.set(filePath, exports);
+                const { exported, duplicate } = exports;
+                if (exported.size > 0)
+                    exportedSymbols.set(filePath, exported);
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
                     const importedWorkspace = chief.findWorkspaceByPackageName(packageName);
@@ -196,7 +203,7 @@ export const main = async (unresolvedConfiguration) => {
                         }
                     }
                 }
-                duplicateExports.forEach(symbols => {
+                duplicate.forEach(symbols => {
                     const symbol = symbols.join('|');
                     collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
                 });
@@ -209,6 +216,9 @@ export const main = async (unresolvedConfiguration) => {
                 unresolved.forEach(moduleSpecifier => {
                     collector.addIssue({ type: 'unresolved', filePath, symbol: moduleSpecifier });
                 });
+                _getDependenciesFromScripts(scripts, { cwd: dirname(filePath) }).forEach(specifier => {
+                    handleReferencedDependency({ specifier, containingFilePath: filePath, principal, workspace });
+                });
             }
         };
         const isExportedInEntryFile = (importedModule) => {

package/dist/manifest/index.d.ts

@@ -1,15 +1,13 @@
-import type { WorkspaceConfiguration } from '../types/config.js';
 import type { InstalledBinaries, PeerDependencies } from '../types/workspace.js';
 import type { PackageJson } from 'type-fest';
 type Options = {
-    config: WorkspaceConfiguration;
     manifest: PackageJson;
     isProduction: boolean;
     isStrict: boolean;
     dir: string;
     cwd: string;
 };
-export declare const findDependencies: ({ config, manifest, isProduction, isStrict, dir, cwd }: Options) => Promise<{
+export declare const findDependencies: ({ manifest, isProduction, isStrict, dir, cwd }: Options) => Promise<{
     dependencies: string[];
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;