knip 6.36.0 → 6.37.0

package/dist/ConfigurationChief.d.ts

@@ -988,10 +988,13 @@ export declare class ConfigurationChief {
         ignore?: string | string[] | undefined;
         ignoreFiles?: string | string[] | undefined;
         ignoreBinaries?: (string | RegExp)[] | undefined;
+        ignoreGlobalBinaries?: boolean | undefined;
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
-        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
+        ignoreExportsUsedInFile?: boolean | {
+            [x: string]: boolean | undefined;
+        } | undefined;
         ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     };
@@ -1007,7 +1010,10 @@ export declare class ConfigurationChief {
         paths: Record<string, string[]>;
         ignore: string[];
         ignoreFiles: string[];
-        ignoreExportsUsedInFile: Record<string, boolean | undefined> | import("./types/config.ts").IgnoreExportsUsedInFile;
+        ignoreGlobalBinaries: boolean;
+        ignoreExportsUsedInFile: {
+            [x: string]: boolean | undefined;
+        } | import("./types/config.ts").IgnoreExportsUsedInFile;
         isIncludeEntryExports: boolean;
         angular?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -33,6 +33,7 @@ const isPluginName = (name) => pluginNames.includes(name);
 const defaultConfig = {
     ignore: [],
     ignoreBinaries: [],
+    ignoreGlobalBinaries: true,
     ignoreDependencies: [],
     ignoreFiles: [],
     cycles: {},
@@ -100,6 +101,7 @@ export class ConfigurationChief {
         const ignore = arrayify(rawConfig.ignore ?? defaultConfig.ignore);
         const ignoreFiles = arrayify(rawConfig.ignoreFiles ?? defaultConfig.ignoreFiles);
         const ignoreBinaries = rawConfig.ignoreBinaries ?? [];
+        const ignoreGlobalBinaries = rawConfig.ignoreGlobalBinaries ?? defaultConfig.ignoreGlobalBinaries;
         const ignoreDependencies = rawConfig.ignoreDependencies ?? [];
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
         const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
@@ -119,6 +121,7 @@ export class ConfigurationChief {
             ignoreFiles,
             cycles,
             ignoreBinaries,
+            ignoreGlobalBinaries,
             ignoreDependencies,
             ignoreMembers,
             ignoreUnresolved,
@@ -341,6 +344,7 @@ export class ConfigurationChief {
         const paths = workspaceConfig.paths ?? {};
         const ignore = arrayify(workspaceConfig.ignore);
         const ignoreFiles = arrayify(workspaceConfig.ignoreFiles);
+        const ignoreGlobalBinaries = workspaceConfig.ignoreGlobalBinaries ?? this.config.ignoreGlobalBinaries;
         const ignoreExportsUsedInFile = workspaceConfig.ignoreExportsUsedInFile ?? this.config.ignoreExportsUsedInFile;
         const isIncludeEntryExports = workspaceConfig.includeEntryExports ?? this.config.isIncludeEntryExports;
         const plugins = {};
@@ -353,7 +357,17 @@ export class ConfigurationChief {
                 plugins[pluginName] = normalizePluginConfig(pluginConfig);
             }
         }
-        return { entry, project, paths, ignore, ignoreFiles, ignoreExportsUsedInFile, isIncludeEntryExports, ...plugins };
+        return {
+            entry,
+            project,
+            paths,
+            ignore,
+            ignoreFiles,
+            ignoreGlobalBinaries,
+            ignoreExportsUsedInFile,
+            isIncludeEntryExports,
+            ...plugins,
+        };
     }
     findWorkspaceByFilePath(filePath) {
         if (this.workspaceByFileCache.has(filePath))

package/dist/DependencyDeputy.d.ts

@@ -17,7 +17,6 @@ export declare class DependencyDeputy {
     _manifests: WorkspaceManifests;
     workspacePkgNames: Set<string>;
     referencedDependencies: Map<string, Set<string>>;
-    referencedBinaries: Map<string, Set<string>>;
     hostDependencies: Map<string, HostDependencies>;
     installedBinaries: Map<string, InstalledBinaries>;
     hasTypesIncluded: Map<string, Set<string>>;
@@ -57,7 +56,6 @@ export declare class DependencyDeputy {
     private dependencyCache;
     getDependencies(workspaceName: string): DependencySet;
     addReferencedDependency(workspaceName: string, packageName: string): void;
-    addReferencedBinary(workspaceName: string, binaryName: string): void;
     setHostDependencies(workspaceName: string, hostDependencies: HostDependencies): void;
     getHostDependenciesFor(workspaceName: string, dependency: string): {
         name: string;

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { DT_SCOPE, IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { PackagePeeker } from './PackagePeeker.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, getPackageNameFromModuleSpecifier, isDefinitelyTyped, } from './util/modules.js';
@@ -12,7 +12,6 @@ export class DependencyDeputy {
     _manifests = new Map();
     workspacePkgNames = new Set();
     referencedDependencies;
-    referencedBinaries;
     hostDependencies;
     installedBinaries;
     hasTypesIncluded;
@@ -21,7 +20,6 @@ export class DependencyDeputy {
         this.isStrict = isStrict;
         this.isReportDependencies = isReportDependencies;
         this.referencedDependencies = new Map();
-        this.referencedBinaries = new Map();
         this.hostDependencies = new Map();
         this.installedBinaries = new Map();
         this.hasTypesIncluded = new Map();
@@ -106,12 +104,6 @@ export class DependencyDeputy {
         }
         this.referencedDependencies.get(workspaceName)?.add(packageName);
     }
-    addReferencedBinary(workspaceName, binaryName) {
-        if (!this.referencedBinaries.has(workspaceName)) {
-            this.referencedBinaries.set(workspaceName, new Set());
-        }
-        this.referencedBinaries.get(workspaceName)?.add(binaryName);
-    }
     setHostDependencies(workspaceName, hostDependencies) {
         this.hostDependencies.set(workspaceName, hostDependencies);
     }
@@ -167,7 +159,6 @@ export class DependencyDeputy {
     maybeAddReferencedBinary(workspace, binaryName) {
         if (!this.isReportDependencies)
             return new Set();
-        this.addReferencedBinary(workspace.name, binaryName);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...workspace.ancestors.toReversed()];
         for (const name of workspaceNames) {
             const binaries = this.installedBinaries.get(name);
@@ -180,8 +171,6 @@ export class DependencyDeputy {
                 }
             }
         }
-        if (IGNORED_GLOBAL_BINARIES.has(binaryName))
-            return new Set();
         return;
     }
     isInDependencies(workspaceName, packageName, isDevOnly) {
@@ -303,11 +292,6 @@ export class DependencyDeputy {
             const issueSet = issues[type][key];
             for (const issueKey in issueSet) {
                 const issue = issueSet[issueKey];
-                if (IGNORED_GLOBAL_BINARIES.has(issue.symbol)) {
-                    delete issueSet[issueKey];
-                    counters[type]--;
-                    continue;
-                }
                 const manifest = this.getWorkspaceManifest(issue.workspace);
                 if (manifest) {
                     const ignoreItem = findMatch(manifest.ignoreBinaries, issue.symbol);

package/dist/WorkspaceWorker.js

@@ -214,10 +214,9 @@ export class WorkspaceWorker {
         const manifest = this.manifest;
         const containingFilePath = join(cwd, 'package.json');
         const isProduction = this.options.isProduction;
-        const knownBinsOnly = false;
         const rootManifest = this.rootManifest;
         const getManifest = this.getManifest;
-        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly, getManifest };
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, getManifest };
         const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);

package/dist/binaries/bash-parser.js

@@ -32,7 +32,7 @@ export const getDependenciesFromScript = (script, options) => {
             return [];
         return getDependenciesFromScript(toScript(args), {
             ...options,
-            knownBinsOnly: false,
+            isForwardedArgs: false,
             ...opts,
         });
     };

package/dist/binaries/command.js

@@ -1,10 +1,10 @@
 import { Plugins, pluginArgsMap } from '../plugins.js';
-import { toBinary, toDeferResolve } from '../util/input.js';
-import { extractBinary } from '../util/modules.js';
+import { toDeferResolve } from '../util/input.js';
+import { extractBinary, isInNodeModulesBin, isRelativeNodeModulesBin } from '../util/modules.js';
 import { resolve as fallbackResolve, spawningBinaries } from './fallback.js';
-import KnownResolvers from './resolvers/index.js';
+import KnownResolvers, { isPackageManager } from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
-import { parseNodeArgs } from './util.js';
+import { parseNodeArgs, toCommandBinary } from './util.js';
 export const getInputsFromNodeOptions = (prefix) => prefix
     .filter(a => a.name === 'NODE_OPTIONS' && a.value)
     .map(a => a.value.value)
@@ -14,12 +14,23 @@ export const getInputsFromNodeOptions = (prefix) => prefix
     .map(id => toDeferResolve(id));
 export const getDependenciesFromCommand = (node, options, fromWords = options.fromArgs) => {
     const text = node.name?.value;
-    const binary = text ? extractBinary(text) : text;
-    const { fromArgs } = options;
+    if (!text)
+        return [];
+    const binary = extractBinary(text);
     if (!binary || binary === '.' || binary === 'source' || binary === '[')
         return [];
     if (binary.startsWith('-') || binary.startsWith('..'))
         return [];
+    const isExplicitBin = isInNodeModulesBin(text) || text.startsWith('.bin/');
+    if (options.optionalBinaries && (isExplicitBin || isPackageManager(binary))) {
+        const { fromArgs } = options;
+        options = {
+            ...options,
+            optionalBinaries: !isExplicitBin,
+            fromArgs: (args, opts) => fromArgs(args, { optionalBinaries: false, ...opts }),
+        };
+    }
+    const { fromArgs } = options;
     const words = node.suffix;
     if (binary === '!' || binary === 'test')
         return fromArgs(words);
@@ -32,16 +43,16 @@ export const getDependenciesFromCommand = (node, options, fromWords = options.fr
         return [...resolverFromPlugins(binary, words, options), ...fromNodeOptions];
     }
     if (spawningBinaries.includes(binary)) {
-        return [toBinary(binary), ...fromWords(words, options), ...fromNodeOptions];
+        return [toCommandBinary(binary, options), ...fromWords(words, options), ...fromNodeOptions];
     }
     if (binary in Plugins) {
         const inputs = fallbackResolve(binary, words, options);
-        if (options.knownBinsOnly)
+        if (options.isForwardedArgs)
             for (const input of inputs)
                 input.optional = true;
         return [...inputs, ...fromNodeOptions];
     }
-    if (options.knownBinsOnly && !text?.startsWith('.'))
+    if (options.isForwardedArgs && !text.startsWith('.') && !isRelativeNodeModulesBin(text))
         return [];
     return [...fallbackResolve(binary, words, options), ...fromNodeOptions];
 };

package/dist/binaries/fallback.js

@@ -1,20 +1,21 @@
 import parseArgs from '../util/parse-args.js';
 import { compact } from '../util/array.js';
-import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
+import { toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from '../util/modules.js';
 import { isAbsolute } from '../util/path.js';
-import { argsAfter } from './util.js';
+import { argsAfter, toCommandBinary } from './util.js';
 export const spawningBinaries = ['cross-env', 'retry-cli'];
 const endOfCommandBinaries = ['dotenvx', 'env-cmd', 'op'];
 const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode', 'vite-node', 'zx']);
 const positionalBinaries = new Set(['concurrently']);
 export const isWrapper = (binary) => spawningBinaries.includes(binary) || endOfCommandBinaries.includes(binary) || positionalBinaries.has(binary);
-export const resolve = (binary, words, { fromArgs }) => {
+export const resolve = (binary, words, options) => {
+    const { fromArgs } = options;
     const parsed = parseArgs(words, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
     const bin = binary.startsWith('.') || (binary.includes('/') && !isAbsolute(binary))
         ? toEntry(binary)
         : isValidBinary(binary)
-            ? toBinary(binary)
+            ? toCommandBinary(binary, options)
             : undefined;
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
     const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--')) : [];

package/dist/binaries/plugins.js

@@ -2,10 +2,10 @@ import parseArgs from '../util/parse-args.js';
 import { pluginArgsMap } from '../plugins.js';
 import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';
-import { extractBinary } from '../util/modules.js';
+import { extractBinary, isInNodeModulesBin } from '../util/modules.js';
 import { dirname } from '../util/path.js';
 import { isWrapper as isFallbackWrapper, resolve as fallbackResolve } from './fallback.js';
-import { toWordArgs } from './util.js';
+import { toCommandBinary, toWordArgs } from './util.js';
 const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
@@ -42,7 +42,7 @@ export const resolve = (binary, words, options) => {
         if (isGlobLike(id))
             positionals.push(toEntry(id));
         else {
-            if (id.includes('node_modules/.bin/'))
+            if (isInNodeModulesBin(id))
                 positionals.push(toBinary(extractBinary(id)));
             else
                 positionals.push(toDeferResolveEntry(id, { optional: true }));
@@ -66,7 +66,7 @@ export const resolve = (binary, words, options) => {
     const configFilePaths = config.flatMap(mapToConfigPattern);
     const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd, manifest }) ?? [];
     return [
-        toBinary(binary, inputOpts),
+        toCommandBinary(binary, options, inputOpts),
         ...positionals,
         ...resolved.map(id => toDeferResolve(id)),
         ...resolvedImports.map(id => toDeferResolve(id)),

package/dist/binaries/resolvers/bun.js

@@ -2,7 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
-import { argsAfter, expandScript } from '../util.js';
+import { argsAfter, expandScript, toCommandBinary } from '../util.js';
 import { resolveX } from './bunx.js';
 const commands = new Set([
     'add',
@@ -53,7 +53,7 @@ const commands = new Set([
     'x',
 ]);
 export const resolve = (_binary, words, options) => {
-    const binary = toBinary(_binary);
+    const binary = toCommandBinary(_binary, options);
     const parsed = parseArgs(words, { string: ['cwd'] });
     const [command, script] = parsed._;
     if (command === 'x') {

package/dist/binaries/resolvers/find.js

@@ -1,7 +1,8 @@
-import { toBinary } from '../../util/input.js';
+import { toCommandBinary } from '../util.js';
 const execFlags = new Set(['-exec', '-execdir']);
 const execTerminators = new Set([';', '\\;', '+']);
-export const resolve = (binary, words, { fromArgs }) => {
+export const resolve = (binary, words, options) => {
+    const { fromArgs } = options;
     const execIdx = words.findIndex(word => execFlags.has(word.value));
     if (execIdx >= 0) {
         const cmdWords = [];
@@ -13,7 +14,7 @@ export const resolve = (binary, words, { fromArgs }) => {
                 cmdWords.push(words[i]);
         }
         if (cmdWords.length > 0)
-            return [toBinary(binary), ...fromArgs(cmdWords)];
+            return [toCommandBinary(binary, options), ...fromArgs(cmdWords)];
     }
-    return [toBinary(binary)];
+    return [toCommandBinary(binary, options)];
 };

package/dist/binaries/resolvers/index.d.ts

@@ -1,9 +1,9 @@
+export declare const isPackageManager: (binary: string) => boolean;
 declare const _default: {
     bun: import("../../types/config.ts").BinaryResolver;
     bunx: import("../../types/config.ts").BinaryResolver;
     nub: import("../../types/config.ts").BinaryResolver;
     nubx: import("../../types/config.ts").BinaryResolver;
-    find: import("../../types/config.ts").BinaryResolver;
     npm: import("../../types/config.ts").BinaryResolver;
     npx: import("../../types/config.ts").BinaryResolver;
     pnpm: import("../../types/config.ts").BinaryResolver;
@@ -11,5 +11,6 @@ declare const _default: {
     pnpx: import("../../types/config.ts").BinaryResolver;
     pnx: import("../../types/config.ts").BinaryResolver;
     yarn: import("../../types/config.ts").BinaryResolver;
+    find: import("../../types/config.ts").BinaryResolver;
 };
 export default _default;

package/dist/binaries/resolvers/index.js

@@ -7,12 +7,11 @@ import * as nub from './nub.js';
 import * as pnpm from './pnpm.js';
 import * as pnpx from './pnpx.js';
 import * as yarn from './yarn.js';
-export default {
+const packageManagerResolvers = {
     bun: bun.resolve,
     bunx: bunx.resolve,
     nub: nub.resolve,
     nubx: bunx.resolve,
-    find: find.resolve,
     npm: npm.resolve,
     npx: npx.resolve,
     pnpm: pnpm.resolve,
@@ -21,3 +20,5 @@ export default {
     pnx: pnpx.resolve,
     yarn: yarn.resolve,
 };
+export const isPackageManager = (binary) => binary in packageManagerResolvers;
+export default { ...packageManagerResolvers, find: find.resolve };

package/dist/binaries/resolvers/npm.js

@@ -1,12 +1,54 @@
 import parseArgs from '../../util/parse-args.js';
+import { isBinary, toBinary, toDependency } from '../../util/input.js';
+import { extractBinary, isValidBinary, stripVersionFromSpecifier } from '../../util/modules.js';
+import { isInternal } from '../../util/path.js';
 import { argsAfter, expandScript } from '../util.js';
 export const resolve = (_binary, words, options) => {
     const { fromArgs, manifest } = options;
-    const parsed = parseArgs(words, { '--': true });
+    const parsed = parseArgs(words, {
+        isStorePositions: true,
+        boolean: ['yes', 'no', 'parseable'],
+        string: ['package', 'call'],
+        alias: { yes: 'y', parseable: 'p', call: 'c' },
+        '--': true,
+    });
     const [command, script] = parsed._;
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
-    if (command === 'exec')
-        return _childArgs;
+    if (command === 'exec' || command === 'x') {
+        const packages = parsed.package ? [parsed.package].flat() : [];
+        const packageInputs = packages.map(specifier => toDependency(stripVersionFromSpecifier(specifier), { optional: true }));
+        const separator = words.findIndex(word => word.value === '--');
+        const args = parsed.positionalIndices.slice(1).map(index => words[index]);
+        if (separator !== -1)
+            args.push(...words.slice(separator + 1));
+        const call = Array.isArray(parsed.call) ? parsed.call.at(-1) : parsed.call;
+        if (call)
+            return packages.length ? packageInputs : fromArgs([call]);
+        const specifier = args[0]?.value;
+        if (!specifier)
+            return packageInputs;
+        const npmWords = separator === -1 ? words : words.slice(0, separator);
+        const noInstall = parsed.no || npmWords.some(word => word.value === '--yes=false' || word.value === '--no-yes');
+        const inputOptions = noInstall && packages.length === 0 ? undefined : { optional: true };
+        const isPackage = packages.length === 0 && specifier.includes('@') && !isInternal(specifier);
+        if (isPackage && specifier.startsWith('@')) {
+            return [toDependency(stripVersionFromSpecifier(specifier), inputOptions)];
+        }
+        const inputs = fromArgs([args.map(word => word.text).join(' ')]);
+        const first = inputs[0];
+        if (first && isBinary(first) && first.specifier === extractBinary(specifier)) {
+            if (isPackage)
+                inputs[0] = toDependency(stripVersionFromSpecifier(specifier), inputOptions);
+            else if (inputOptions)
+                first.optional = true;
+        }
+        else if (isPackage || (!isInternal(specifier) && !specifier.includes('/') && isValidBinary(specifier))) {
+            inputs.unshift(isPackage
+                ? toDependency(stripVersionFromSpecifier(specifier), inputOptions)
+                : toBinary(extractBinary(specifier), inputOptions));
+        }
+        return [...packageInputs, ...inputs];
+    }
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
     if (command === 'run' && manifest.scriptNames.has(script)) {
         return expandScript(script, argsAfter(words, '--'), manifest.scripts, options) ?? _childArgs;
     }

package/dist/binaries/resolvers/npx.js

@@ -3,20 +3,24 @@ import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';
 import { argsFrom } from '../util.js';
+const noInstallFlags = new Set(['--no', '--no-install', '--yes=false', '--no-yes']);
 export const resolve = (_binary, words, options) => {
     const { fromArgs } = options;
     const parsed = parseArgs(words, {
+        isStorePositions: true,
         boolean: ['yes', 'no', 'quiet'],
-        alias: { yes: 'y', no: 'no-install', package: 'p', call: 'c' },
+        alias: { yes: 'y', package: 'p', call: 'c' },
     });
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
-    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const packages = parsed.package ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
     const command = parsed.call ? fromArgs([parsed.call]) : [];
     const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier);
-    const opts = parsed.no ? undefined : { optional: true };
+    const commandIndex = parsed.positionalIndices[0] ?? words.length;
+    const noInstall = words.slice(0, commandIndex).some(word => noInstallFlags.has(word.value));
+    const opts = noInstall ? undefined : { optional: true };
     const dependency = isBinary ? toBinary(specifier, opts) : toDependency(specifier, opts);
-    const specifiers = dependency && !parsed.yes ? [dependency] : [];
+    const specifiers = dependency ? [dependency] : [];
     return [
         ...specifiers,
         ...packages.map(id => toDependency(id, { optional: true })),

package/dist/binaries/resolvers/nub.js

@@ -1,7 +1,8 @@
 import parseArgs from '../../util/parse-args.js';
-import { toBinary, toEntry } from '../../util/input.js';
+import { toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
+import { toCommandBinary } from '../util.js';
 import { resolveX } from './bunx.js';
 const runtimes = new Set(['x', 'dlx', 'exec']);
 const runners = new Set(['run', 'watch']);
@@ -24,7 +25,7 @@ const commands = new Set([
     'why',
 ]);
 export const resolve = (_binary, words, options) => {
-    const binary = toBinary(_binary);
+    const binary = toCommandBinary(_binary, options);
     const { manifest, cwd, fromArgs } = options;
     const parsed = parseArgs(words, { string: ['filter'], boolean: ['recursive'], alias: { recursive: 'r' } });
     const [command, script] = parsed._;

package/dist/binaries/resolvers/pnpm.js

@@ -1,7 +1,7 @@
 import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
-import { argsAfter, expandScript, toWordArgs } from '../util.js';
+import { argsAfter, expandScript } from '../util.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
@@ -90,11 +90,13 @@ const commands = [
 ];
 const recursiveCommands = ['recursive', 'multi', 'm'];
 export const resolve = (_binary, words, options) => {
-    const parsed = parseArgs(words, {
+    const parseOptions = {
+        isStorePositions: true,
         boolean: ['aggregate-output', 'if-present', 'parallel', 'recursive', 'reverse', 'shell-mode', 'silent', 'stream'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c', filter: 'F' },
         '--': true,
-    });
+    };
+    const parsed = parseArgs(words, parseOptions);
     const [command] = parsed._;
     if (command === 'dlx') {
         const wordsForDlx = words.filter(word => word.value !== 'dlx');
@@ -104,15 +106,20 @@ export const resolve = (_binary, words, options) => {
         return resolve(_binary, argsAfter(words, command), options);
     }
     const { manifest, fromArgs } = options;
-    if (parsed.filter && !parsed.recursive)
-        return [];
-    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
     if (command === 'exec') {
-        if (childInputs.length > 0)
-            return childInputs;
-        const rest = parsed._.slice(1);
-        return rest.length === 1 ? fromArgs(rest.map(String)) : fromArgs(toWordArgs(rest, words));
+        const commandIndex = parsed.positionalIndices[0];
+        if (commandIndex > 0) {
+            const execOptions = parseArgs(words.slice(0, commandIndex), parseOptions);
+            if (execOptions.filter && !execOptions.recursive)
+                return [];
+        }
+        const index = commandIndex + 1;
+        const rest = words.slice(words[index]?.value === '--' ? index + 1 : index);
+        return fromArgs([rest.length === 1 ? rest[0].value : rest.map(word => word.text).join(' ')]);
     }
+    if (parsed.filter && !parsed.recursive)
+        return [];
+    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
     if (command === 'run') {
         const script = parsed._[1];
         if (script && manifest.scriptNames.has(script)) {

package/dist/binaries/resolvers/yarn.js

@@ -56,7 +56,7 @@ export const resolve = (_binary, words, options) => {
     if (!command && !binary)
         return [];
     const dirManifest = (dir && getManifest(dir)) || manifest;
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { knownBinsOnly: true }) : [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
     if (command === 'run') {
         if (dirManifest.scriptNames.has(binary)) {
             const opts = dir ? { cwd: dir, manifest: dirManifest } : {};

package/dist/binaries/util.d.ts

@@ -1,6 +1,9 @@
 import type { Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions, ScriptArg } from '../types/config.ts';
-import type { Input } from '../util/input.ts';
+import { type Input } from '../util/input.ts';
+export declare const toCommandBinary: (binary: string, { optionalBinaries }: GetInputsFromScriptsOptions, inputOptions?: {
+    dir?: string;
+}) => Input;
 export declare const toScript: (args: ScriptArg[]) => string;
 export declare const argsFrom: <T extends string | Word>(args: readonly T[], from: string) => T[];
 export declare const argsAfter: <T extends string | Word>(args: readonly T[], token: string) => T[];

package/dist/binaries/util.js

@@ -1,4 +1,6 @@
 import parseArgs from '../util/parse-args.js';
+import { toBinary } from '../util/input.js';
+export const toCommandBinary = (binary, { optionalBinaries }, inputOptions = {}) => toBinary(binary, optionalBinaries ? { ...inputOptions, optional: true } : inputOptions);
 const valueOf = (arg) => (typeof arg === 'string' ? arg : arg.value);
 export const toScript = (args) => {
     const parts = [];

package/dist/manifest/index.js

@@ -17,10 +17,8 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
         if (manifest) {
             const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});
-            for (const binaryName of binaries) {
+            for (const binaryName of binaries)
                 addBinary(binaryName, packageName);
-                addBinary(packageName, binaryName);
-            }
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {

package/dist/plugins/ava/index.js

@@ -23,7 +23,7 @@ const resolveConfig = async (localConfig, options) => {
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    return files.concat(options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true }));
+    return files.concat(options.getInputsFromScripts(fakeCommand, { optionalBinaries: true }));
 };
 const plugin = {
     title,

package/dist/plugins/eslint/helpers.d.ts

@@ -1,7 +1,8 @@
 import type { PluginOptions } from '../../types/config.ts';
+import type { Manifest } from '../../util/package-json.ts';
 import { type ConfigInput, type Input } from '../../util/input.ts';
 import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
 export declare const getInputsFromSettings: (settings?: Settings) => Input[];
-export declare const resolveFormatters: (formatters: string | string[]) => Set<Input>;
+export declare const resolveFormatters: (formatters: string | string[], manifest: Manifest) => Set<Input>;