knip 6.37.0 → 6.39.0

package/dist/ConfigurationChief.d.ts

@@ -592,6 +592,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        railway?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         raycast?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -822,6 +827,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        turbo?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -832,6 +842,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'typescript-content-mapper'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         unbuild?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1122,6 +1137,7 @@ export declare class ConfigurationChief {
         prisma?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         quasar?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         qwik?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        railway?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         raycast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "react-cosmos"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "react-email"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1168,8 +1184,10 @@ export declare class ConfigurationChief {
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        turbo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         typedoc?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         typescript?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "typescript-content-mapper"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         unbuild?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         unocss?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "unplugin-auto-import"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/compilers/compilers.js

@@ -5,7 +5,7 @@ export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
-export const importMatcher = /(?<![.\w$#])import\b(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
+export const importMatcher = /(?<![.\w$#])import\b(?!\s*\.)(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const collectImports = text => {
     if (!text.includes('import'))
         return '';

package/dist/constants.js

@@ -115,6 +115,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'python',
     'python3',
     'raft',
+    'railway',
     'rm',
     'rmdir',
     'rsync',

package/dist/graph/analyze.js

@@ -6,7 +6,7 @@ import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { perfObserver, timerify } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
-import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, isAlwaysIgnored } from '../util/tag.js';
+import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, hasTag, isAlwaysIgnored } from '../util/tag.js';
 import { INTERNAL_TAG } from '../constants.js';
 const toCyclePathKey = (path) => {
     const length = path.length > 1 && path[0] === path[path.length - 1] ? path.length - 1 : path.length;
@@ -70,7 +70,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             return;
         const issueType = isEnumMembers ? 'enumMembers' : 'namespaceMembers';
         const unusedMembers = [];
-        const ignoredMemberIds = [];
+        const ignoredMembers = [];
         for (const member of exportedItem.members) {
             if (findMatch(workspace.ignoreMembers, member.identifier))
                 continue;
@@ -78,8 +78,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 continue;
             if (member.hasRefsInFile)
                 continue;
-            const id = `${identifier}.${member.identifier}`;
-            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+            const [isMemberReferenced] = explorer.isReferenced(filePath, `${identifier}.${member.identifier}`, {
                 traverseEntries: true,
                 treatStarAtEntryAsReferenced: true,
             });
@@ -89,10 +88,19 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     unusedMembers.push(member);
             }
             else if (isMemberIgnored) {
-                ignoredMemberIds.push(id);
+                ignoredMembers.push(member);
+            }
+        }
+        return { issueType, unusedMembers, ignoredMembers };
+    };
+    const addMemberTagHints = (members, filePath, identifier) => {
+        for (const member of members) {
+            for (const tagName of member.jsDocTags) {
+                if (options.tags[1].includes(tagName)) {
+                    collector.addTagHint({ type: 'tag', filePath, identifier: `${identifier}.${member.identifier}`, tagName });
+                }
             }
         }
-        return { issueType, unusedMembers, ignoredMemberIds };
     };
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
@@ -115,7 +123,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         const isInternalProd = options.isProduction && exportedItem.jsDocTags.has(INTERNAL_TAG);
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags) || isInternalProd;
                         if (importsForExport) {
-                            const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
+                            const [isReferenced, reExportingEntryFile, reExportedIds] = explorer.isReferenced(filePath, identifier, {
                                 traverseEntries: isIncludeEntryExports,
                             });
                             if (isIgnored) {
@@ -124,6 +132,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                     const memberIssues = isReferenced
                                         ? getMemberIssues(exportedItem, filePath, identifier, workspace, importsForExport)
                                         : undefined;
+                                    if (memberIssues)
+                                        addMemberTagHints(memberIssues.ignoredMembers, filePath, identifier);
                                     if (!memberIssues || memberIssues.unusedMembers.length === 0) {
                                         for (const tagName of exportedItem.jsDocTags) {
                                             if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
@@ -138,9 +148,18 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 if (!isIncludeEntryExports) {
                                     continue;
                                 }
-                                if (!isReferenced) {
-                                    const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
-                                    if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
+                                if (!isReferenced && reExportedIds) {
+                                    const entryExports = graph.get(reExportingEntryFile)?.exports;
+                                    let isTagged = false;
+                                    for (const id of reExportedIds) {
+                                        const reExportedItem = entryExports?.get(id);
+                                        if (reExportedItem &&
+                                            (shouldIgnore(reExportedItem.jsDocTags) || hasTag(options.tags[1], reExportedItem.jsDocTags))) {
+                                            isTagged = true;
+                                            break;
+                                        }
+                                    }
+                                    if (isTagged)
                                         continue;
                                 }
                             }
@@ -160,13 +179,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             fixes: member.fix ? [member.fix] : [],
                                         });
                                     }
-                                    for (const id of memberIssues.ignoredMemberIds) {
-                                        for (const tagName of exportedItem.jsDocTags) {
-                                            if (options.tags[1].includes(tagName)) {
-                                                collector.addTagHint({ type: 'tag', filePath, identifier: id, tagName });
-                                            }
-                                        }
-                                    }
+                                    addMemberTagHints(memberIssues.ignoredMembers, filePath, identifier);
                                 }
                                 continue;
                             }

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

@@ -3,7 +3,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     isReferenced: (filePath: string, identifier: string, options: {
         traverseEntries: boolean;
         treatStarAtEntryAsReferenced?: boolean;
-    }) => readonly [false, string | undefined];
+    }) => readonly [false, string | undefined, Set<string> | undefined];
     hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
     isEnumerated: (filePath: string, identifier: string) => boolean;
     buildExportsTree: (options: {

package/dist/graph-explorer/operations/is-referenced.d.ts

@@ -2,4 +2,4 @@ import type { Identifier, ModuleGraph } from '../../types/module-graph.ts';
 export declare const isReferenced: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, id: Identifier, options: {
     traverseEntries: boolean;
     treatStarAtEntryAsReferenced?: boolean;
-}) => readonly [false, string | undefined];
+}) => readonly [false, string | undefined, Set<string> | undefined];

package/dist/graph-explorer/operations/is-referenced.js

@@ -17,18 +17,22 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const seen = new Set();
     let isReferenced = false;
     let reExportingEntryFile;
+    let reExportedIds;
     const hasCompleteResult = () => isReferenced && (options.traverseEntries || reExportingEntryFile !== undefined);
     const walkDown = (path, id, viaStar = false) => {
         const isEntryFile = entryPaths.has(path);
         if (isEntryFile && !reExportingEntryFile)
             reExportingEntryFile = path;
+        if (path === reExportingEntryFile)
+            (reExportedIds ??= new Set()).add(id);
         if (hasCompleteResult())
             return true;
-        if (seen.has(path))
-            return false;
-        seen.add(path);
         const restIds = id.split('.');
         const identifier = restIds.shift();
+        const key = `${path}:${identifier}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
         if (options.treatStarAtEntryAsReferenced && isEntryFile && viaStar && restIds.length > 0) {
             isReferenced = true;
             return hasCompleteResult();
@@ -117,5 +121,5 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         return false;
     };
     walkDown(filePath, id);
-    return [isReferenced, reExportingEntryFile];
+    return [isReferenced, reExportingEntryFile, reExportedIds];
 };

package/dist/plugins/_vue/auto-import.js

@@ -3,10 +3,12 @@ import { createRequire } from 'node:module';
 import { Visitor } from 'oxc-parser';
 import { scriptBodies } from '../../compilers/compilers.js';
 import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { _parseFile } from '../../typescript/ast-nodes.js';
 import { isFile } from '../../util/fs.js';
 import { _syncGlob } from '../../util/glob.js';
 import { dirname, isInNodeModules, join } from '../../util/path.js';
+import { _createSyncModuleResolver } from '../../util/resolve.js';
 const getVueSfc = (cwd) => {
     try {
         const sfc = createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
@@ -124,6 +126,7 @@ const collectVue2TemplateIdentifiers = (source) => {
 };
 const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
 const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
+const resolveModule = _createSyncModuleResolver([...DEFAULT_EXTENSIONS, '.vue']);
 export const collectLocalImportPaths = (filePath, result) => {
     const dir = dirname(filePath);
     const paths = new Set();
@@ -150,7 +153,7 @@ export function buildAutoImportMap(filePath, result, maps, isComponents) {
         const importType = importTypes.find(it => it.start >= start && it.end <= end);
         if (!importType || !isLocalSpecifier(importType.specifier))
             return;
-        const absSpecifier = join(dir, importType.specifier);
+        const absSpecifier = resolveModule(importType.specifier, filePath) ?? join(dir, importType.specifier);
         if (isComponents) {
             const components = maps.componentMap.get(name);
             if (components) {
@@ -184,7 +187,7 @@ export function buildAutoImportMap(filePath, result, maps, isComponents) {
             const specifier = node.source.value;
             if (!isLocalSpecifier(specifier))
                 return;
-            const absSpecifier = join(dir, specifier);
+            const absSpecifier = resolveModule(specifier, filePath) ?? join(dir, specifier);
             for (const s of node.specifiers) {
                 const name = s.exported.type === 'Identifier' ? s.exported.name : s.exported.value;
                 if (name)
@@ -210,14 +213,15 @@ const getVueAutoImportMaps = (cwd) => {
     }
     return maps;
 };
-const getSyntheticImports = (maps, identifiers, templateTags) => {
+const getSyntheticImports = (maps, identifiers, filePath, templateTags) => {
     const { importMap, componentMap } = maps;
     if (importMap.size === 0 && (!templateTags || componentMap.size === 0))
         return [];
     const syntheticImports = [];
     for (const [name, specifier] of importMap) {
-        if (identifiers.has(name))
+        if (identifiers.has(name) && specifier !== filePath) {
             syntheticImports.push(`import { ${name} } from '${specifier}';`);
+        }
     }
     if (templateTags) {
         for (const [name, specifiers] of componentMap) {
@@ -226,9 +230,12 @@ const getSyntheticImports = (maps, identifiers, templateTags) => {
                 templateTags.has(kebab) ||
                 templateTags.has(`Lazy${name}`) ||
                 templateTags.has(`lazy-${kebab}`)) {
-                syntheticImports.push(`import { default as ${name} } from '${specifiers[0]}';`);
-                for (let i = 1; i < specifiers.length; i++)
-                    syntheticImports.push(`import '${specifiers[i]}';`);
+                const targets = specifiers.filter(specifier => specifier !== filePath);
+                if (targets.length === 0)
+                    continue;
+                syntheticImports.push(`import { default as ${name} } from '${targets[0]}';`);
+                for (let i = 1; i < targets.length; i++)
+                    syntheticImports.push(`import '${targets[i]}';`);
             }
         }
     }
@@ -275,7 +282,7 @@ const compileVueSfc = (source, path, maps, root) => {
         for (const id of collectVue2TemplateIdentifiers(compiled.code))
             identifiers.add(id);
     }
-    scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
+    scripts.push(...getSyntheticImports(maps, identifiers, path, templateTags));
     scripts.push(...getImportedComponentImports(maps, importedComponents));
     const styles = stylePreprocessorImports(source, path);
     if (styles)
@@ -288,7 +295,7 @@ const compileTs = (source, path, maps) => {
         path.endsWith('.config.ts'))
         return source;
     const importedComponents = new Set();
-    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path, importedComponents));
+    const syntheticImports = getSyntheticImports(maps, collectIdentifiers(source, path, importedComponents), path);
     syntheticImports.push(...getImportedComponentImports(maps, importedComponents));
     return syntheticImports.length === 0 ? source : `${source}\n${syntheticImports.join('\n')}`;
 };
@@ -305,7 +312,7 @@ const compileMarkdown = (source, path, maps) => {
     for (const [, tag] of code.matchAll(tagMatcher))
         tags.add(tag);
     const identifiers = scripts ? collectIdentifiers(scripts, path) : new Set();
-    return [scripts, ...getSyntheticImports(maps, identifiers, tags)].filter(Boolean).join(';\n');
+    return [scripts, ...getSyntheticImports(maps, identifiers, path, tags)].filter(Boolean).join(';\n');
 };
 export const createVueCompiler = (maps, cwd) => (source, path) => compileVueSfc(source, path, maps, cwd);
 export const createTsCompiler = (maps) => (source, path) => compileTs(source, path, maps);

package/dist/plugins/angular/index.js

@@ -13,7 +13,7 @@ const resolveConfig = async (config, options) => {
     const inputs = new Set();
     for (const project of Object.values(config.projects)) {
         if (!project.architect)
-            return [];
+            continue;
         for (const [targetName, target] of Object.entries(project.architect)) {
             const { options: opts, configurations: configs } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];

package/dist/plugins/cucumber/index.js

@@ -5,11 +5,43 @@ const enablers = ['@cucumber/cucumber'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['cucumber.{json,yaml,yml,js,cjs,mjs}'];
 const entry = ['features/**/*.@(js|cjs|mjs)'];
-const resolveConfig = config => {
+const builtinFormatters = new Set([
+    'html',
+    'json',
+    'junit',
+    'message',
+    'pretty',
+    'progress',
+    'progress-bar',
+    'rerun',
+    'snippets',
+    'summary',
+    'usage',
+    'usage-json',
+]);
+const toFormatterName = (format) => {
+    if (Array.isArray(format))
+        return format[0];
+    const [name, quotedName] = format.match(/^"([^"]*)"|^[^:]*/) ?? [format];
+    return quotedName ?? name;
+};
+const resolveProfile = (config) => {
     const imports = (config?.import ? config.import : entry).map(id => toEntry(id));
-    const formatters = config?.format ? config.format : [];
-    const requires = config?.require ? config.require : [];
-    return imports.concat([...formatters, ...requires].map(id => toDeferResolve(id)));
+    const requires = (config?.require ? config.require : []).map(id => toEntry(id));
+    const formatters = (config?.format ? config.format : [])
+        .map(toFormatterName)
+        .filter(name => !builtinFormatters.has(name))
+        .map(id => toDeferResolve(id));
+    return [...imports, ...requires, ...formatters];
+};
+const resolveConfig = (config, options) => {
+    if (typeof config !== 'object' || config === null)
+        return resolveProfile();
+    const isProfiles = /\.(json|ya?ml)$/.test(options.configFileName) || 'default' in config;
+    if (!isProfiles)
+        return resolveProfile(config);
+    const profiles = 'default' in config ? Object.values(config) : [undefined, ...Object.values(config)];
+    return profiles.flatMap(resolveProfile);
 };
 const plugin = {
     title,

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

@@ -2,6 +2,7 @@ export type CucumberConfig = {
     publishQuiet?: boolean;
     import?: string[];
     require?: string[];
-    format?: string[];
+    format?: Format[];
     parallel?: number;
 };
+export type Format = string | [string, string?];

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

@@ -4,5 +4,7 @@ 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 type ImportSettingKind = 'resolver' | 'parsers';
+export declare const importSettingKinds: Map<string, ImportSettingKind>;
 export declare const getInputsFromSettings: (settings?: Settings) => Input[];
 export declare const resolveFormatters: (formatters: string | string[], manifest: Manifest) => Set<Input>;

package/dist/plugins/eslint/helpers.js

@@ -79,13 +79,24 @@ const getResolverNames = (value) => {
         return [value];
     if (Array.isArray(value))
         return value.flatMap(getResolverNames);
-    if (value && typeof value === 'object')
+    if (value && typeof value === 'object') {
+        if ('name' in value && 'resolver' in value)
+            return [];
         return Object.keys(value);
+    }
     return [];
 };
+export const importSettingKinds = new Map([
+    ['import/resolver', 'resolver'],
+    ['import-x/resolver', 'resolver'],
+    ['import-x/resolver-legacy', 'resolver'],
+    ['import/parsers', 'parsers'],
+    ['import-x/parsers', 'parsers'],
+]);
 const getDependenciesFromSettings = (settings = {}) => {
     return Object.entries(settings).flatMap(([settingKey, settings]) => {
-        if (settingKey === 'import/resolver') {
+        const kind = importSettingKinds.get(settingKey);
+        if (kind === 'resolver') {
             return getResolverNames(settings)
                 .filter(key => key !== 'node')
                 .map(key => {
@@ -96,7 +107,7 @@ const getDependenciesFromSettings = (settings = {}) => {
                 return `eslint-import-resolver-${key}`;
             });
         }
-        if (settingKey === 'import/parsers') {
+        if (kind === 'parsers') {
             return (typeof settings === 'string' ? [settings] : Object.keys(settings)).map(key => {
                 if (isAbsolute(key))
                     return getPackageNameFromFilePath(key);

package/dist/plugins/eslint/resolveFromAST.js

@@ -3,27 +3,30 @@ import { toDeferResolve } from '../../util/input.js';
 import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
+import { importSettingKinds } from './helpers.js';
 export const getInputsFromSettingsAST = (program) => {
     const inputs = [];
-    const addResolver = (key, resolver) => {
+    const addResolver = (kind, resolver) => {
         if (!resolver || resolver === 'node' || isInternal(resolver))
             return;
-        const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
+        const dep = kind === 'resolver' ? `eslint-import-resolver-${resolver}` : resolver;
         inputs.push(toDeferResolve(dep, { optional: true }));
     };
-    const addResolvers = (key, node) => {
+    const addResolvers = (kind, node) => {
         if (node?.type === 'ArrayExpression') {
             for (const element of node.elements)
-                addResolvers(key, element);
+                addResolvers(kind, element);
         }
         else if (node?.type === 'ObjectExpression') {
+            if (kind === 'resolver' && findProperty(node, 'name') && findProperty(node, 'resolver'))
+                return;
             for (const prop of node.properties) {
                 if (prop.type === 'Property')
-                    addResolver(key, getPropertyKey(prop));
+                    addResolver(kind, getPropertyKey(prop));
             }
         }
         else {
-            addResolver(key, getStringValue(node));
+            addResolver(kind, getStringValue(node));
         }
     };
     const visitor = new Visitor({
@@ -35,8 +38,9 @@ export const getInputsFromSettingsAST = (program) => {
                 if (prop.type !== 'Property')
                     continue;
                 const key = getPropertyKey(prop);
-                if (key === 'import/resolver' || key === 'import/parsers')
-                    addResolvers(key, prop.value);
+                const kind = key && importSettingKinds.get(key);
+                if (kind)
+                    addResolvers(kind, prop.value);
             }
         },
     });

package/dist/plugins/eve/index.js

@@ -3,20 +3,38 @@ const title = 'eve';
 const enablers = ['eve'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const extensions = '{js,jsx,ts,tsx,mjs,cjs,mts,cts}';
-const rootAgentFileNames = '{agent,instructions,instrumentation,sandbox}';
-const subagentFileNames = '{agent,instructions,sandbox}';
+const agentRoots = '{,agent/,agents/*/,agents/*/agent/}';
+const subagentRoots = `${agentRoots}+(subagents/*/|extensions/*/subagents/*/)`;
+const extensionMounts = `{${agentRoots},${subagentRoots}}extensions/*`;
+const rootAgentFileNames = '{agent,instructions,instrumentation,memory,sandbox}';
+const rootAgentDirectories = '{channels,connections,hooks,skills,tools,schedules}';
+const subagentFileNames = '{agent,instructions,memory,sandbox}';
+const subagentDirectories = '{connections,hooks,skills,tools}';
+const entry = ['{evals,agents/*/evals}/evals.config.ts', '{evals,agents/*/evals}/**/*.eval.ts'];
 const production = [
-    `{,agent/}${rootAgentFileNames}.${extensions}`,
-    `{,agent/}sandbox/sandbox.${extensions}`,
-    `{,agent/}{channels,connections,hooks,skills,tools,schedules}/**/*.${extensions}`,
-    `{,agent/}subagents/**/${subagentFileNames}.${extensions}`,
-    `{,agent/}subagents/**/sandbox/sandbox.${extensions}`,
-    `{,agent/}subagents/**/{connections,hooks,skills,tools}/**/*.${extensions}`,
+    `${agentRoots}${rootAgentFileNames}.${extensions}`,
+    `${agentRoots}{instructions,instrumentation,memory}/*.${extensions}`,
+    `${agentRoots}sandbox/sandbox.${extensions}`,
+    `${agentRoots}sandbox/workspace/**/*.${extensions}`,
+    `${agentRoots}${rootAgentDirectories}/**/*.${extensions}`,
+    `${agentRoots}subagents/*.${extensions}`,
+    `${subagentRoots}subagents/*.${extensions}`,
+    `${subagentRoots}${subagentFileNames}.${extensions}`,
+    `${subagentRoots}{instructions,memory}/*.${extensions}`,
+    `${subagentRoots}sandbox/sandbox.${extensions}`,
+    `${subagentRoots}sandbox/workspace/**/*.${extensions}`,
+    `${subagentRoots}${subagentDirectories}/**/*.${extensions}`,
+    `${extensionMounts}.${extensions}`,
+    `${extensionMounts}/{extension,instructions}.${extensions}`,
+    `${extensionMounts}/instructions/*.${extensions}`,
+    `${extensionMounts}/${rootAgentDirectories}/**/*.${extensions}`,
+    `${extensionMounts}/subagents/*.${extensions}`,
 ];
 const plugin = {
     title,
     enablers,
     isEnabled,
+    entry,
     production,
 };
 export default plugin;

package/dist/plugins/index.d.ts

@@ -111,6 +111,7 @@ export declare const Plugins: {
     prisma: import("../types/config.ts").Plugin;
     quasar: import("../types/config.ts").Plugin;
     qwik: import("../types/config.ts").Plugin;
+    railway: import("../types/config.ts").Plugin;
     raycast: import("../types/config.ts").Plugin;
     'react-cosmos': import("../types/config.ts").Plugin;
     'react-email': import("../types/config.ts").Plugin;
@@ -157,8 +158,10 @@ export declare const Plugins: {
     tsdown: import("../types/config.ts").Plugin;
     tsup: import("../types/config.ts").Plugin;
     tsx: import("../types/config.ts").Plugin;
+    turbo: import("../types/config.ts").Plugin;
     typedoc: import("../types/config.ts").Plugin;
     typescript: import("../types/config.ts").Plugin;
+    'typescript-content-mapper': import("../types/config.ts").Plugin;
     unbuild: import("../types/config.ts").Plugin;
     unocss: import("../types/config.ts").Plugin;
     'unplugin-auto-import': import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -105,6 +105,7 @@ import { default as prettier } from './prettier/index.js';
 import { default as prisma } from './prisma/index.js';
 import { default as quasar } from './quasar/index.js';
 import { default as qwik } from './qwik/index.js';
+import { default as railway } from './railway/index.js';
 import { default as raycast } from './raycast/index.js';
 import { default as reactCosmos } from './react-cosmos/index.js';
 import { default as reactEmail } from './react-email/index.js';
@@ -151,8 +152,10 @@ import { default as tsd } from './tsd/index.js';
 import { default as tsdown } from './tsdown/index.js';
 import { default as tsup } from './tsup/index.js';
 import { default as tsx } from './tsx/index.js';
+import { default as turbo } from './turbo/index.js';
 import { default as typedoc } from './typedoc/index.js';
 import { default as typescript } from './typescript/index.js';
+import { default as typescriptContentMapper } from './typescript-content-mapper/index.js';
 import { default as unbuild } from './unbuild/index.js';
 import { default as unocss } from './unocss/index.js';
 import { default as unpluginAutoImport } from './unplugin-auto-import/index.js';
@@ -291,6 +294,7 @@ export const Plugins = {
     prisma,
     quasar,
     qwik,
+    railway,
     raycast,
     'react-cosmos': reactCosmos,
     'react-email': reactEmail,
@@ -337,8 +341,10 @@ export const Plugins = {
     tsdown,
     tsup,
     tsx,
+    turbo,
     typedoc,
     typescript,
+    'typescript-content-mapper': typescriptContentMapper,
     unbuild,
     unocss,
     'unplugin-auto-import': unpluginAutoImport,

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

@@ -1,3 +1,6 @@
 import type { Plugin } from '../../types/config.ts';
+import { type Input } from '../../util/input.ts';
+export declare const contentMappers: string[];
+export declare const resolveContentMapperOptions: (options: Record<string, unknown>) => Input[];
 declare const plugin: Plugin;
 export default plugin;