knip 6.40.0 → 6.42.0

package/dist/plugins/next/index.js

@@ -42,6 +42,28 @@ const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
     const pageExtensions = new Set();
     const loaders = new Set();
+    const aliasTargets = new Set();
+    const collectAliasTargets = (node) => {
+        const target = getStringValue(node);
+        if (target)
+            aliasTargets.add(target);
+        else if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                collectAliasTargets(element);
+        }
+        else if (node?.type === 'ObjectExpression') {
+            collectAliasTargets(findProperty(node, 'browser'));
+        }
+    };
+    const collectTurbopackAliases = (node) => {
+        const aliases = findProperty(node, 'resolveAlias');
+        if (aliases?.type !== 'ObjectExpression')
+            return;
+        for (const alias of aliases.properties) {
+            if (alias.type === 'Property')
+                collectAliasTargets(alias.value);
+        }
+    };
     const collectLoaders = (node) => {
         if (node?.type === 'ArrayExpression') {
             for (const element of node.elements)
@@ -60,7 +82,15 @@ const resolveFromAST = (program, { configFileDir }) => {
         ObjectExpression(node) {
             for (const extension of getPropertyValues(node, 'pageExtensions'))
                 pageExtensions.add(extension);
-            const rules = findProperty(findProperty(node, 'turbopack'), 'rules');
+            const turbopack = findProperty(node, 'turbopack');
+            if (turbopack?.type === 'ConditionalExpression') {
+                collectTurbopackAliases(turbopack.consequent);
+                collectTurbopackAliases(turbopack.alternate);
+            }
+            else {
+                collectTurbopackAliases(turbopack);
+            }
+            const rules = findProperty(turbopack, 'rules');
             if (rules?.type !== 'ObjectExpression')
                 return;
             for (const rule of rules.properties) {
@@ -75,6 +105,8 @@ const resolveFromAST = (program, { configFileDir }) => {
     const inputs = patterns.map(id => toProductionEntry(join(configFileDir, id)));
     for (const loader of loaders)
         inputs.push(toDeferResolve(loader));
+    for (const target of aliasTargets)
+        inputs.push({ ...toDeferResolve(target, { dir: configFileDir }), production: true });
     return inputs;
 };
 const commands = new Set(['dev', 'build', 'start']);

package/dist/plugins/nx/index.js

@@ -1,6 +1,8 @@
 import { compact } from '../../util/array.js';
-import { toConfig, toDependency } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { isFile, loadJSON } from '../../util/fs.js';
+import { toConfig, toDeferResolveEntry, toDependency } from '../../util/input.js';
+import { get } from '../../util/object.js';
+import { dirname, join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { substringBefore } from '../../util/string.js';
 const title = 'Nx';
@@ -53,32 +55,71 @@ const resolveConfig = async (localConfig, options) => {
             commands = [target.options.command];
         else if (target.options?.commands)
             commands = target.options.commands.map(commandConfig => typeof commandConfig === 'string' ? commandConfig : commandConfig.command);
-        return options.getInputsFromScripts(commands.map(expand), { cwd: resolveTargetCwd(target.options?.cwd) });
+        const cwd = resolveTargetCwd(target.options?.cwd);
+        const expandRelative = (command) => command
+            .replaceAll('{projectRoot}', relative(cwd, options.configFileDir))
+            .replaceAll('{workspaceRoot}', relative(cwd, options.rootCwd));
+        const scriptInputs = options.getInputsFromScripts(commands.map(expandRelative), { cwd });
+        for (const input of scriptInputs)
+            input.dir ??= cwd;
+        return scriptInputs;
     });
+    const toTargetConfig = (pluginName, specifier) => toConfig(pluginName, expand(specifier), { dir: options.rootCwd });
     const configInputs = targets.flatMap(target => {
         const opts = target.options;
         if (!opts)
             return [];
         const configs = [];
         if ('eslintConfig' in opts && typeof opts.eslintConfig === 'string') {
-            configs.push(toConfig('eslint', opts.eslintConfig));
+            configs.push(toTargetConfig('eslint', opts.eslintConfig));
         }
         if ('jestConfig' in opts && typeof opts.jestConfig === 'string') {
-            configs.push(toConfig('jest', opts.jestConfig));
+            configs.push(toTargetConfig('jest', opts.jestConfig));
+        }
+        if ('karmaConfig' in opts && typeof opts.karmaConfig === 'string') {
+            configs.push(toTargetConfig('karma', opts.karmaConfig));
         }
         if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
-            configs.push(toConfig('typescript', opts.tsConfig));
+            configs.push(toTargetConfig('typescript', opts.tsConfig));
         }
         if ('vitestConfig' in opts && typeof opts.vitestConfig === 'string') {
-            configs.push(toConfig('vitest', opts.vitestConfig));
+            configs.push(toTargetConfig('vitest', opts.vitestConfig));
         }
         if ('webpackConfig' in opts && typeof opts.webpackConfig === 'string') {
-            configs.push(toConfig('webpack', opts.webpackConfig));
+            configs.push(toTargetConfig('webpack', opts.webpackConfig));
         }
         return configs;
     });
     return compact([...executors, ...inputs, ...configInputs]).map(id => typeof id === 'string' ? toDependency(id) : id);
 };
+const collections = [
+    ['generators', 'schematics'],
+    ['executors', 'builders'],
+];
+const resolve = async (options) => {
+    const inputs = [];
+    for (const [key, alias] of collections) {
+        const file = get(options.manifest, key) ?? get(options.manifest, alias);
+        if (typeof file !== 'string')
+            continue;
+        const filePath = join(options.cwd, file);
+        if (!isFile(filePath))
+            continue;
+        const collection = await loadJSON(filePath);
+        for (const entries of [collection[key], collection[alias]]) {
+            for (const entry of Object.values(entries ?? {})) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                for (const id of [entry.implementation || entry.factory, entry.batchImplementation]) {
+                    if (typeof id === 'string' && id.length > 0) {
+                        inputs.push(toDeferResolveEntry(join(dirname(filePath), substringBefore(id, '#'))));
+                    }
+                }
+            }
+        }
+    }
+    return inputs;
+};
 const args = {
     fromArgs: (parsed) => (parsed._[0] === 'exec' ? [...parsed._.slice(1), ...(parsed['--'] ?? [])] : []),
 };
@@ -91,6 +132,7 @@ const plugin = {
     isEnabled,
     config,
     resolveConfig,
+    resolve,
     args,
 };
 export default plugin;

package/dist/plugins/nx/types.d.ts

@@ -11,6 +11,7 @@ export interface NxProjectConfiguration {
                 cwd?: string;
                 eslintConfig?: string;
                 jestConfig?: string;
+                karmaConfig?: string;
                 tsConfig?: string;
                 vitestConfig?: string;
                 webpackConfig?: string;
@@ -18,6 +19,12 @@ export interface NxProjectConfiguration {
         };
     };
 }
+type NxCollectionEntry = string | {
+    factory?: string;
+    implementation?: string;
+    batchImplementation?: string;
+};
+export type NxCollection = Record<string, Record<string, NxCollectionEntry> | undefined>;
 export interface NxConfigRoot {
     plugins?: Array<string | {
         plugin: string;
@@ -25,3 +32,4 @@ export interface NxConfigRoot {
     generators?: Record<string, unknown>;
     targetDefaults?: Record<string, unknown>;
 }
+export {};

package/dist/plugins/oxlint/index.js

@@ -26,7 +26,7 @@ export const resolveExtendedConfig = (config, configFilePath) => {
     for (const entry of config.extends ?? []) {
         if (typeof entry === 'string') {
             const filePath = toAbsolute(entry, dirname(configFilePath));
-            inputs.push(toConfig('oxlint', filePath, { containingFilePath: configFilePath }));
+            inputs.push(toConfig('oxlint', filePath));
         }
         else {
             for (const input of resolveExtendedConfig(entry, configFilePath))

package/dist/plugins/react-native/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'React Native';
 const enablers = ['react-native'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['react-native.config.js'];
+const config = ['react-native.config.{js,cjs,mjs,ts}'];
 const RN_CLI_PACKAGES = [
     '@react-native-community/cli',
     '@react-native-community/cli-platform-android',

package/dist/plugins/react-router/index.d.ts

@@ -1,3 +1,6 @@
 import type { Plugin } from '../../types/config.ts';
+export declare const docs: {
+    note: string;
+};
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/react-router/index.js

@@ -43,6 +43,9 @@ const resolveConfig = async (localConfig, options) => {
     }
     return resolved;
 };
+const note = `Route modules import their types from \`./+types/<route>\`, which \`react-router typegen\` generates.
+Run \`react-router typegen\` before Knip (e.g. in CI or a fresh checkout), or these imports are reported as unresolved.`;
+export const docs = { note };
 const plugin = {
     title,
     enablers,

package/dist/plugins/rsbuild/index.js

@@ -5,7 +5,19 @@ const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = async (config, options) => {
+const configParams = [
+    { env: 'development', command: 'dev', envMode: 'development' },
+    { env: 'production', command: 'build', envMode: 'production' },
+];
+const getConfigs = async (configOrFn) => {
+    if (typeof configOrFn !== 'function')
+        return [configOrFn];
+    const configs = [];
+    for (const params of configParams)
+        configs.push(await configOrFn(params));
+    return configs;
+};
+const resolveConfig = async (configOrFn, options) => {
     const entries = new Set();
     const inputs = [];
     const checkSource = (source) => {
@@ -34,7 +46,7 @@ const resolveConfig = async (config, options) => {
                     entries.add(e);
         }
     };
-    const checkConfig = async (localConfig) => {
+    const checkConfig = async (localConfig, config) => {
         checkSource(localConfig.source);
         if (!localConfig.tools?.rspack)
             return;
@@ -68,10 +80,12 @@ const resolveConfig = async (config, options) => {
             }
         }
     };
-    await checkConfig(config);
-    if (config.environments) {
-        for (const environment of Object.values(config.environments)) {
-            await checkConfig(environment);
+    for (const config of await getConfigs(configOrFn)) {
+        await checkConfig(config, config);
+        if (config.environments) {
+            for (const environment of Object.values(config.environments)) {
+                await checkConfig(environment, config);
+            }
         }
     }
     for (const entry of entries)

package/dist/plugins/rsbuild/types.d.ts

@@ -29,4 +29,10 @@ export type RsbuildConfig = {
         [k: string]: Omit<RsbuildConfig, 'environments'>;
     };
 };
+export type ConfigParams = {
+    env: string;
+    command: string;
+    envMode: string;
+};
+export type RsbuildConfigOrFn = RsbuildConfig | ((params: ConfigParams) => RsbuildConfig | Promise<RsbuildConfig>);
 export {};

package/dist/plugins/rstest/index.js

@@ -91,7 +91,7 @@ const resolveConfig = async (localConfig, options) => {
                     .catch(() => undefined)
                 : undefined;
             if (!project) {
-                inputs.push(toConfig('rstest', filePath, { containingFilePath: configFilePath }));
+                inputs.push(toConfig('rstest', filePath));
                 continue;
             }
             inputs.push(toEntry(filePath));

package/dist/plugins/rstest/types.d.ts

@@ -1,3 +1,4 @@
+import type { ConfigParams } from '../rsbuild/types.ts';
 type TestEnvironment = 'node' | 'jsdom' | 'happy-dom';
 export type RstestProjectConfig = {
     root?: string;
@@ -23,10 +24,5 @@ type RstestConfig = RstestProjectConfig & {
         provider?: 'istanbul' | 'v8';
     };
 };
-type ConfigParams = {
-    env: string;
-    command: string;
-    envMode: string;
-};
 export type RstestConfigOrFn = RstestConfig | ((params: ConfigParams) => RstestConfig | Promise<RstestConfig>);
 export {};

package/dist/plugins/solidjs-vite-plugin/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../types/config.ts';
+export declare const docs: {
+    note: string;
+};
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/solidjs-vite-plugin/index.js

@@ -0,0 +1,17 @@
+import { hasDependency } from '../../util/plugin.js';
+import { config } from '../vite/index.js';
+import { production, resolveFromAST } from './resolveFromAST.js';
+const title = '@solidjs/vite-plugin';
+const enablers = ['@solidjs/vite-plugin'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const note = `Without a Vite config, the default entry patterns are used. With a config, start entries are only added when \`start\` is enabled. Paths like \`start.app\` replace the matching default, and the \`ssr\` option decides which files Solid loads. \`serverFunctions.configure\` is added with or without \`start\`.`;
+export const docs = { note };
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/solidjs-vite-plugin/resolveFromAST.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveFromAST } from '../../types/config.ts';
+export declare const production: string[];
+export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/solidjs-vite-plugin/resolveFromAST.js

@@ -0,0 +1,76 @@
+import { findImportedCalls, findProperty } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { isFile } from '../../util/fs.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join, toAbsolute } from '../../util/path.js';
+import { getViteRoot } from '../vite/helpers.js';
+const entryExtensions = ['tsx', 'jsx', 'ts', 'js', 'mjs', 'tsrx'];
+const entryStems = {
+    entryServer: 'src/entry-server',
+    entryClient: 'src/entry-client',
+};
+const conventions = {
+    entryServer: `src/entry-server.{${entryExtensions.join(',')}}`,
+    entryClient: `src/entry-client.{${entryExtensions.join(',')}}`,
+    app: 'src/{App,app}.{tsx,jsx,ts,js,tsrx}',
+    document: 'src/Document.{tsx,jsx,tsrx}',
+    env: 'env.{ts,js}',
+};
+export const production = Object.values(conventions);
+const startOptions = ['app', 'document', 'entryServer', 'entryClient', 'middleware', 'instrument', 'setup', 'env'];
+const isBoolean = (node, value) => node?.type === 'Literal' && node.value === value;
+const hasEntryFile = (root, stem) => {
+    for (const extension of entryExtensions)
+        if (isFile(root, `${stem}.${extension}`))
+            return true;
+    return false;
+};
+export const resolveFromAST = (program, options) => {
+    const root = getViteRoot(program, options.cwd);
+    const patterns = new Set();
+    const paths = new Set();
+    for (const call of findImportedCalls(program, '@solidjs/vite-plugin')) {
+        const arg = call.arguments[0];
+        if (arg?.type !== 'ObjectExpression')
+            continue;
+        const configure = getStringValue(findProperty(findProperty(arg, 'serverFunctions'), 'configure'));
+        if (configure)
+            paths.add(configure);
+        const start = findProperty(arg, 'start');
+        if (!start || isBoolean(start, false))
+            continue;
+        const values = {};
+        for (const name of startOptions) {
+            values[name] = start.type === 'ObjectExpression' ? findProperty(start, name) : undefined;
+        }
+        const isAuthored = (name) => Boolean(getStringValue(values[name])) || hasEntryFile(root, entryStems[name]);
+        const ssr = findProperty(arg, 'ssr');
+        const skip = new Set();
+        if (!ssr || isBoolean(ssr, false)) {
+            skip.add('entryServer');
+            skip.add('setup');
+            if (isAuthored('entryClient'))
+                skip.add('app');
+        }
+        else if (isBoolean(ssr, true) && isAuthored('entryServer') && isAuthored('entryClient')) {
+            skip.add('app');
+            skip.add('document');
+        }
+        for (const name of startOptions) {
+            if (skip.has(name))
+                continue;
+            const value = values[name];
+            const path = getStringValue(value);
+            if (path)
+                paths.add(path);
+            else if (name in conventions && !(name === 'env' && isBoolean(value, false)))
+                patterns.add(conventions[name]);
+        }
+    }
+    const inputs = [];
+    for (const pattern of patterns)
+        inputs.push(toProductionEntry(join(root, pattern)));
+    for (const id of paths)
+        inputs.push(toProductionEntry(toAbsolute(id, root)));
+    return inputs;
+};

package/dist/plugins/sst/resolveFromAST.js

@@ -44,5 +44,5 @@ export const resolveFromAST = (program, options) => {
         visitor.visit(program);
     }
     catch { }
-    return Array.from(entries).map(specifier => toDeferResolveProductionEntry(specifier, { containingFilePath: options.configFilePath }));
+    return Array.from(entries).map(specifier => toDeferResolveProductionEntry(specifier));
 };

package/dist/plugins/stencil/index.js

@@ -1,8 +1,6 @@
 import scss from '../../compilers/scss.js';
-import { IMPORT_FLAGS } from '../../constants.js';
-import { getPropertyValues } from '../../typescript/ast-helpers.js';
-import { dirname, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { createComponentStyleUrlsVisitor } from '../_component-style-urls/component-style-urls-visitor.js';
 import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
 import { entry, resolveFromAST } from './resolveFromAST.js';
 const title = 'Stencil';
@@ -18,42 +16,7 @@ const registerCompilers = ({ hasDependency, registerCompiler }) => {
 };
 const registerVisitors = ({ ctx, registerVisitor }) => {
     registerVisitor(createCustomElementVisitor(ctx, isStencilSpecifier, { decoratorName: 'Component' }));
-    const componentNames = new Set();
-    registerVisitor({
-        Program() {
-            componentNames.clear();
-        },
-        ImportDeclaration(node) {
-            if (!isStencilSpecifier(node.source?.value))
-                return;
-            for (const spec of node.specifiers ?? []) {
-                if (spec.type === 'ImportSpecifier' &&
-                    spec.imported.type === 'Identifier' &&
-                    spec.imported.name === 'Component')
-                    componentNames.add(spec.local.name);
-            }
-        },
-        ClassDeclaration(node) {
-            resolveStyleUrls(node);
-        },
-    });
-    function resolveStyleUrls(node) {
-        const dir = dirname(ctx.filePath);
-        for (const decorator of node.decorators ?? []) {
-            const expr = decorator.expression;
-            if (expr?.type !== 'CallExpression')
-                continue;
-            if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
-                continue;
-            const arg = expr.arguments?.[0];
-            if (arg?.type !== 'ObjectExpression')
-                continue;
-            for (const url of getPropertyValues(arg, 'styleUrl'))
-                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
-            for (const url of getPropertyValues(arg, 'styleUrls'))
-                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
-        }
-    }
+    registerVisitor(createComponentStyleUrlsVisitor(ctx, isStencilSpecifier));
 };
 const plugin = {
     title,

package/dist/plugins/storybook/index.js

@@ -12,7 +12,7 @@ const restEntry = ['.{storybook,rnstorybook}/{manager,preview,index,vitest.setup
 const entry = [...restEntry, ...stories];
 const project = ['.{storybook,rnstorybook}/**/*.{js,jsx,ts,tsx,mts}'];
 const resolveConfig = async (localConfig, options) => {
-    const { cwd, configFileDir, configFilePath } = options;
+    const { cwd, configFileDir } = options;
     const strs = typeof localConfig?.stories === 'function' ? await localConfig.stories(stories) : localConfig?.stories;
     const relativePatterns = strs?.map(pattern => {
         if (typeof pattern === 'string')
@@ -37,9 +37,7 @@ const resolveConfig = async (localConfig, options) => {
     const viteConfigPath = typeof framework === 'object' &&
         framework?.name === '@storybook/react-vite' &&
         framework?.options?.builder?.viteConfigPath;
-    const configs = viteConfigPath
-        ? [toConfig('vite', viteConfigPath, { dir: cwd, containingFilePath: configFilePath })]
-        : [];
+    const configs = viteConfigPath ? [toConfig('vite', viteConfigPath, { dir: cwd })] : [];
     const hasVitestAddon = addons.some(addon => addon === '@storybook/addon-vitest');
     const coverageDeps = hasVitestAddon
         ? [

package/dist/plugins/sveltejs-package/helpers.js

@@ -1,5 +1,6 @@
 import parseArgs from '../../util/parse-args.js';
 import { parse } from 'unbash';
+import { getCommandWords, collectCommands } from '../../util/scripts.js';
 const BIN = 'svelte-package';
 export const DEFAULT_INPUT = 'src/lib';
 export const DEFAULT_OUTPUT = 'dist';
@@ -7,48 +8,6 @@ const parseCommandIO = (args) => {
     const parsed = parseArgs(args, { string: ['i', 'o', 'input', 'output'], alias: { input: ['i'], output: ['o'] } });
     return { input: parsed.input ?? DEFAULT_INPUT, output: parsed.output ?? DEFAULT_OUTPUT };
 };
-const collectFromCommands = (statements, out) => {
-    for (const stmt of statements)
-        visit(stmt.command, out);
-};
-const visit = (node, out) => {
-    switch (node.type) {
-        case 'Command':
-            if (node.name?.value === BIN)
-                out.push(parseCommandIO(node.suffix.map(w => w.value)));
-            return;
-        case 'AndOr':
-        case 'Pipeline':
-            for (const n of node.commands)
-                visit(n, out);
-            return;
-        case 'If':
-            collectFromCommands(node.clause.commands, out);
-            collectFromCommands(node.then.commands, out);
-            if (node.else)
-                visit(node.else, out);
-            return;
-        case 'While':
-            collectFromCommands(node.clause.commands, out);
-            collectFromCommands(node.body.commands, out);
-            return;
-        case 'For':
-        case 'Select':
-        case 'Subshell':
-        case 'BraceGroup':
-            collectFromCommands(node.body.commands, out);
-            return;
-        case 'CompoundList':
-            collectFromCommands(node.commands, out);
-            return;
-        case 'Function':
-        case 'Coproc':
-            visit(node.body, out);
-            return;
-        case 'Statement':
-            visit(node.command, out);
-    }
-};
 export const parseScripts = (scripts) => {
     const out = [];
     for (const script of Object.values(scripts ?? {})) {
@@ -56,8 +15,12 @@ export const parseScripts = (scripts) => {
             continue;
         try {
             const parsed = parse(script);
-            if (parsed.commands)
-                collectFromCommands(parsed.commands, out);
+            for (const statement of parsed.commands) {
+                for (const node of collectCommands(statement.command)) {
+                    if (node.name?.value === BIN)
+                        out.push(parseCommandIO(getCommandWords(node).map(word => word.value)));
+                }
+            }
         }
         catch { }
     }

package/dist/plugins/taskfile/index.js

@@ -78,7 +78,7 @@ const extractScriptsFromTask = (task) => {
 const resolveConfig = async (localConfig, options) => {
     if (!localConfig || !options.configFilePath)
         return [];
-    const { configFilePath, getInputsFromScripts, isProduction, configFileDir } = options;
+    const { getInputsFromScripts, isProduction, configFileDir } = options;
     const inputs = [];
     if (localConfig.includes && typeof localConfig.includes === 'object') {
         for (const includeValue of Object.values(localConfig.includes)) {
@@ -89,17 +89,14 @@ const resolveConfig = async (localConfig, options) => {
                     : undefined;
             if (includePath) {
                 const resolvedPath = join(configFileDir, includePath);
-                inputs.push(toConfig('taskfile', relative(configFileDir, resolvedPath), { containingFilePath: configFilePath }));
+                inputs.push(toConfig('taskfile', relative(configFileDir, resolvedPath)));
             }
         }
     }
     if (localConfig.tasks && typeof localConfig.tasks === 'object') {
         for (const task of Object.values(localConfig.tasks)) {
             for (const script of extractScriptsFromTask(task)) {
-                for (const input of getInputsFromScripts([script], {
-                    optionalBinaries: true,
-                    containingFilePath: configFilePath,
-                })) {
+                for (const input of getInputsFromScripts([script], { optionalBinaries: true })) {
                     if (isProduction)
                         Object.assign(input, { optional: true });
                     inputs.push({ ...input, dir: configFileDir });

package/dist/plugins/tsrs/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/tsrs/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '../../util/plugin.js';
+import { args as typescriptArgs, config, resolveConfig } from '../typescript/index.js';
+const title = 'tsrs';
+const enablers = ['tsrs'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const args = { ...typescriptArgs, binaries: ['tsrs'] };
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+    args,
+};
+export default plugin;

package/dist/plugins/typescript/index.d.ts

@@ -1,4 +1,15 @@
-import type { Plugin } from '../../types/config.ts';
+import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { TsConfigJson } from '../../types/tsconfig-json.ts';
+export declare const config: string[];
+export declare const resolveConfig: ResolveConfig<TsConfigJson>;
+export declare const args: {
+    binaries: string[];
+    string: string[];
+    alias: {
+        project: string[];
+    };
+    config: [string, (p: string) => string][];
+};
 export declare const docs: {
     note: string;
 };