knip 5.47.0 → 5.48.0

package/dist/ConfigurationChief.d.ts

@@ -138,12 +138,15 @@ export declare class ConfigurationChief {
         sentry?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "simple-git-hooks"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "size-limit"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sst?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        starlight?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         storybook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stryker?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "tanstack-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ProjectPrincipal.d.ts

@@ -4,7 +4,7 @@ import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 import type { GetImportsAndExportsOptions } from './types/config.js';
 import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { PrincipalOptions } from './types/project.js';
-import type { SourceFileManager } from './typescript/SourceFileManager.js';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
 import type { ToSourceFilePath } from './util/to-source-path.js';
 export declare class ProjectPrincipal {
@@ -23,7 +23,7 @@ export declare class ProjectPrincipal {
     toSourceFilePath: ToSourceFilePath;
     backend: {
         fileManager: SourceFileManager;
-        compilerHost: ts.CompilerHost;
+        compilerHost?: ts.CompilerHost;
         resolveModuleNames: ResolveModuleNames;
         program?: ts.Program;
         typeChecker?: ts.TypeChecker;

package/dist/ProjectPrincipal.js

@@ -2,6 +2,7 @@ import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
 import { ANONYMOUS, DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, PUBLIC_TAG } from './constants.js';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { createHosts } from './typescript/create-hosts.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { timerify } from './util/Performance.js';
@@ -58,9 +59,12 @@ export class ProjectPrincipal {
         this.isWatch = isWatch;
         this.cache = new CacheConsultant({ name: pkgName || ANONYMOUS, isEnabled: isCache, cacheLocation });
         this.toSourceFilePath = toSourceFilePath;
+        this.backend = {
+            fileManager: new SourceFileManager({ compilers, isSkipLibs }),
+        };
     }
     init() {
-        const { fileManager, compilerHost, resolveModuleNames, languageServiceHost } = createHosts({
+        const { compilerHost, resolveModuleNames, languageServiceHost } = createHosts({
             cwd: this.cwd,
             compilerOptions: this.compilerOptions,
             entryPaths: this.entryPaths,
@@ -68,13 +72,11 @@ export class ProjectPrincipal {
             isSkipLibs: this.isSkipLibs,
             toSourceFilePath: this.toSourceFilePath,
             useResolverCache: !this.isWatch,
+            fileManager: this.backend.fileManager,
         });
-        this.backend = {
-            fileManager,
-            compilerHost,
-            resolveModuleNames,
-            languageServiceHost,
-        };
+        this.backend.compilerHost = compilerHost;
+        this.backend.resolveModuleNames = resolveModuleNames;
+        this.backend.languageServiceHost = languageServiceHost;
     }
     addPaths(paths) {
         this.compilerOptions.paths = { ...this.compilerOptions.paths, ...paths };

package/dist/WorkspaceWorker.d.ts

@@ -1,7 +1,7 @@
 import { CacheConsultant } from './CacheConsultant.js';
 import type { Workspace } from './ConfigurationChief.js';
 import type { PluginName } from './types/PluginNames.js';
-import type { Configuration, WorkspaceConfiguration } from './types/config.js';
+import type { Configuration, GetReferencedInternalFilePath, GetSourceFile, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJson } from './types/package-json.js';
 import type { DependencySet } from './types/workspace.js';
 import { type Input } from './util/input.js';
@@ -12,8 +12,9 @@ type WorkspaceManagerOptions = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
-    getReferencedInternalFilePath: (input: Input) => string | undefined;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -22,12 +23,12 @@ type WorkspaceManagerOptions = {
     isStrict: boolean;
     isCache: boolean;
     cacheLocation: string;
-    allConfigFilePaths: Set<string>;
-    allConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    configFilesMap: Map<string, Map<PluginName, Set<string>>>;
 };
 type CacheItem = {
     resolveEntryPaths?: Input[];
     resolveConfig?: Input[];
+    resolveFromAST?: Input[];
 };
 export declare class WorkspaceWorker {
     name: string;
@@ -36,8 +37,9 @@ export declare class WorkspaceWorker {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
-    getReferencedInternalFilePath: (input: Input) => string | undefined;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
     isProduction: boolean;
     isStrict: boolean;
     rootIgnore: Configuration['ignore'];
@@ -47,9 +49,8 @@ export declare class WorkspaceWorker {
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
-    allConfigFilePaths: Set<string>;
-    allConfigFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, isCache, cacheLocation, allConfigFilePaths, allConfigFilesMap, }: WorkspaceManagerOptions);
+    configFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -6,10 +6,10 @@ import { PluginEntries, Plugins } from './plugins.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
-import { isConfig, toConfig, toDebugString, toEntry } from './util/input.js';
+import { isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { getKeysByValue } from './util/object.js';
 import { basename, dirname, join } from './util/path.js';
-import { getFinalEntryPaths, loadConfigForPlugin } from './util/plugin.js';
+import { loadConfigForPlugin } from './util/plugin.js';
 const nullConfig = { config: null, entry: null, project: null };
 const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
 export class WorkspaceWorker {
@@ -21,6 +21,7 @@ export class WorkspaceWorker {
     dependencies;
     getReferencedInternalFilePath;
     findWorkspaceByFilePath;
+    getSourceFile;
     isProduction;
     isStrict;
     rootIgnore;
@@ -30,9 +31,8 @@ export class WorkspaceWorker {
     enabledPlugins = [];
     enabledPluginsInAncestors;
     cache;
-    allConfigFilePaths;
-    allConfigFilesMap;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, isCache, cacheLocation, allConfigFilePaths, allConfigFilesMap, }) {
+    configFilesMap;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }) {
         this.name = name;
         this.dir = dir;
         this.cwd = cwd;
@@ -45,10 +45,10 @@ export class WorkspaceWorker {
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
         this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
-        this.allConfigFilePaths = allConfigFilePaths;
-        this.allConfigFilesMap = allConfigFilesMap;
+        this.configFilesMap = configFilesMap;
         this.getReferencedInternalFilePath = getReferencedInternalFilePath;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
+        this.getSourceFile = getSourceFile;
         this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation });
     }
     async init() {
@@ -162,7 +162,7 @@ export class WorkspaceWorker {
         return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async runPlugins() {
-        const name = this.name;
+        const wsName = this.name;
         const cwd = this.dir;
         const rootCwd = this.cwd;
         const manifest = this.manifest;
@@ -179,19 +179,27 @@ export class WorkspaceWorker {
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
         const remainingPlugins = new Set(this.enabledPlugins);
-        const addInput = (input, containingFilePath = input.containingFilePath) => inputs.push({ ...input, containingFilePath });
+        const addInput = (input, containingFilePath = input.containingFilePath) => {
+            if (isConfig(input)) {
+                handleConfigInput(input.pluginName, { ...input, containingFilePath });
+            }
+            else {
+                inputs.push({ ...input, containingFilePath });
+            }
+        };
+        const configFilesMap = this.configFilesMap;
+        const configFiles = this.configFilesMap.get(wsName);
         const handleConfigInput = (pluginName, input) => {
             const configFilePath = this.getReferencedInternalFilePath(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
                 if (workspace) {
                     const name = this.name === ROOT_WORKSPACE_NAME ? workspace.name : this.name;
-                    const files = this.allConfigFilesMap;
-                    if (!files.has(name))
-                        files.set(name, new Map());
-                    if (!files.get(name)?.has(pluginName))
-                        files.get(name)?.set(pluginName, new Set());
-                    files.get(name)?.get(pluginName)?.add(configFilePath);
+                    if (!configFilesMap.has(name))
+                        configFilesMap.set(name, new Map());
+                    if (!configFilesMap.get(name)?.has(pluginName))
+                        configFilesMap.get(name)?.set(pluginName, new Set());
+                    configFilesMap.get(name)?.get(pluginName)?.add(configFilePath);
                 }
             }
         };
@@ -208,22 +216,11 @@ export class WorkspaceWorker {
         }
         const runPlugin = async (pluginName, patterns) => {
             const plugin = Plugins[pluginName];
-            const hasResolveEntryPaths = typeof plugin.resolveEntryPaths === 'function';
-            const hasResolveConfig = typeof plugin.resolveConfig === 'function';
-            const hasResolve = typeof plugin.resolve === 'function';
             const config = this.getConfigForPlugin(pluginName);
             if (!config)
                 return;
             const label = 'config file';
             const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
-            const remainingConfigFilePaths = configFilePaths.filter(filePath => !this.allConfigFilePaths.has(filePath));
-            for (const filePath of remainingConfigFilePaths) {
-                if (basename(filePath) !== 'package.json') {
-                    this.allConfigFilePaths.add(filePath);
-                    addInput(toEntry(filePath));
-                    addInput(toConfig(pluginName, filePath));
-                }
-            }
             const options = {
                 ...baseScriptOptions,
                 config,
@@ -232,66 +229,97 @@ export class WorkspaceWorker {
                 configFileName: '',
                 getInputsFromScripts: createGetInputsFromScripts(containingFilePath),
             };
-            const configEntryPaths = [];
-            for (const configFilePath of remainingConfigFilePaths) {
-                const opts = {
+            if (config.entry) {
+                const toInput = isProduction && plugin.production && plugin.production.length > 0 ? toProductionEntry : toEntry;
+                for (const id of config.entry)
+                    addInput(toInput(id));
+            }
+            else if ((!plugin.resolveEntryPaths && !plugin.resolveFromAST) ||
+                (configFilePaths.length === 0 &&
+                    (!this.configFilesMap.get(wsName)?.get(pluginName) ||
+                        this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
+                if (plugin.entry)
+                    for (const id of plugin.entry)
+                        addInput(toEntry(id));
+                if (plugin.production)
+                    for (const id of plugin.production)
+                        addInput(toProductionEntry(id));
+            }
+            for (const configFilePath of configFilePaths) {
+                const isManifest = basename(configFilePath) === 'package.json';
+                const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
+                if (fd?.meta?.data && !fd.changed) {
+                    const data = fd.meta.data;
+                    if (data.resolveEntryPaths)
+                        for (const id of data.resolveEntryPaths)
+                            addInput(id, configFilePath);
+                    if (data.resolveConfig)
+                        for (const id of data.resolveConfig)
+                            addInput(id, configFilePath);
+                    if (data.resolveFromAST)
+                        for (const id of data.resolveFromAST)
+                            addInput(id, configFilePath);
+                    continue;
+                }
+                const resolveOpts = {
                     ...options,
                     getInputsFromScripts: createGetInputsFromScripts(configFilePath),
                     configFilePath,
                     configFileDir: dirname(configFilePath),
                     configFileName: basename(configFilePath),
                 };
-                if (hasResolveEntryPaths || hasResolveConfig) {
-                    const isManifest = basename(configFilePath) === 'package.json';
-                    const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
-                    if (fd?.meta?.data && !fd.changed) {
-                        if (fd.meta.data.resolveEntryPaths)
-                            for (const id of fd.meta.data.resolveEntryPaths)
-                                configEntryPaths.push(id);
-                        if (fd.meta.data.resolveConfig)
-                            for (const id of fd.meta.data.resolveConfig)
-                                addInput(id, configFilePath);
+                const seen = this.configFilesMap.get(wsName)?.get(pluginName)?.has(configFilePath);
+                const cache = {};
+                let loadedConfig;
+                if (plugin.resolveEntryPaths && !seen) {
+                    if (!loadedConfig)
+                        loadedConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
+                    if (loadedConfig) {
+                        const inputs = await plugin.resolveEntryPaths(loadedConfig, resolveOpts);
+                        for (const input of inputs)
+                            addInput(input, configFilePath);
+                        cache.resolveEntryPaths = inputs;
                     }
-                    else {
-                        const config = await loadConfigForPlugin(configFilePath, plugin, opts, pluginName);
-                        const data = {};
-                        if (config) {
-                            if (hasResolveEntryPaths) {
-                                const entryPaths = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
-                                for (const entryPath of entryPaths)
-                                    configEntryPaths.push(entryPath);
-                                data.resolveEntryPaths = entryPaths;
-                            }
-                            if (hasResolveConfig) {
-                                const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
-                                for (const input of inputs) {
-                                    if (isConfig(input)) {
-                                        handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
-                                    }
-                                    else {
-                                        addInput(input, configFilePath);
-                                    }
-                                }
-                                data.resolveConfig = inputs;
-                            }
-                            if (!isManifest && fd?.changed && fd.meta)
-                                fd.meta.data = data;
-                        }
+                }
+                if (plugin.resolveConfig && !seen) {
+                    if (!loadedConfig)
+                        loadedConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
+                    if (loadedConfig) {
+                        const inputs = await plugin.resolveConfig(loadedConfig, resolveOpts);
+                        for (const input of inputs)
+                            addInput(input, configFilePath);
+                        cache.resolveConfig = inputs;
                     }
                 }
+                if (plugin.resolveFromAST) {
+                    const sourceFile = this.getSourceFile(configFilePath);
+                    const resolveASTOpts = {
+                        ...resolveOpts,
+                        getSourceFile: this.getSourceFile,
+                        getReferencedInternalFilePath: this.getReferencedInternalFilePath,
+                    };
+                    if (sourceFile) {
+                        const inputs = plugin.resolveFromAST(sourceFile, resolveASTOpts);
+                        for (const input of inputs)
+                            addInput(input, configFilePath);
+                        cache.resolveFromAST = inputs;
+                    }
+                }
+                if (basename(configFilePath) !== 'package.json') {
+                    addInput(toEntry(configFilePath));
+                    addInput(toConfig(pluginName, configFilePath));
+                }
+                if (!isManifest && fd?.changed && fd.meta)
+                    fd.meta.data = cache;
             }
-            const finalEntryPaths = getFinalEntryPaths(plugin, options, configEntryPaths);
-            for (const id of finalEntryPaths)
-                addInput(id, id.containingFilePath);
-            if (hasResolve) {
-                const dependencies = (await plugin.resolve?.(options)) ?? [];
+            if (plugin.resolve) {
+                const dependencies = (await plugin.resolve(options)) ?? [];
                 for (const id of dependencies)
                     addInput(id, containingFilePath);
             }
         };
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
-        const configFiles = this.allConfigFilesMap.get(name);
         for (const pluginName of this.enabledPlugins) {
             const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
             configFiles?.delete(pluginName);
@@ -299,7 +327,7 @@ export class WorkspaceWorker {
             remainingPlugins.delete(pluginName);
         }
         {
-            const configFiles = this.allConfigFilesMap.get(name);
+            const configFiles = this.configFilesMap.get(wsName);
             if (configFiles) {
                 do {
                     for (const [pluginName, dependencies] of configFiles.entries()) {
@@ -313,7 +341,7 @@ export class WorkspaceWorker {
                 } while (remainingPlugins.size > 0 && configFiles.size > 0);
             }
         }
-        debugLogArray(name, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));
+        debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));
         return inputs;
     }
     onDispose() {

package/dist/cli.js

@@ -2,7 +2,7 @@ import prettyMilliseconds from 'pretty-ms';
 import { main } from './index.js';
 import { perfObserver } from './util/Performance.js';
 import parsedArgValues, { helpText } from './util/cli-arguments.js';
-import { getKnownError, hasCause, isConfigurationError, isKnownError } from './util/errors.js';
+import { getKnownError, isConfigurationError, isDisplayReason, isKnownError } from './util/errors.js';
 import { logError, logWarning } from './util/log.js';
 import { cwd, join, toPosix } from './util/path.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
@@ -94,7 +94,7 @@ const run = async () => {
         if (!isDebug && error instanceof Error && isKnownError(error)) {
             const knownError = getKnownError(error);
             logError('ERROR', knownError.message);
-            if (hasCause(knownError))
+            if (isDisplayReason(knownError))
                 console.error('Reason:', knownError.cause.message);
             if (isConfigurationError(knownError))
                 console.log('\nRun `knip --help` or visit https://knip.dev for help');

package/dist/compilers/index.d.ts

@@ -339,6 +339,16 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    sst?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
+    starlight?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     storybook?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -369,6 +379,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'tanstack-router'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     travis?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -469,6 +484,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    $schema?: string | undefined;
     rules?: Partial<Record<"dependencies" | "exports" | "files" | "devDependencies" | "optionalPeerDependencies" | "unlisted" | "binaries" | "unresolved" | "types" | "nsExports" | "nsTypes" | "duplicates" | "enumMembers" | "classMembers", "error" | "warn" | "off">> | undefined;
     paths?: Record<string, string[]> | undefined;
     ignore?: string | string[] | undefined;
@@ -813,6 +829,16 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        sst?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        starlight?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         storybook?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -843,6 +869,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'tanstack-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/analyze.js

@@ -39,8 +39,6 @@ export const analyze = async (options) => {
                     }
                     const importsForExport = file.imported;
                     for (const [identifier, exportedItem] of exportItems.entries()) {
-                        if (!isFix && exportedItem.isReExport)
-                            continue;
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);

package/dist/graph/build.js

@@ -12,8 +12,7 @@ import {} from '../util/tag.js';
 import { augmentWorkspace, getToSourcePathHandler } from '../util/to-source-path.js';
 import { loadTSConfig } from '../util/tsconfig-loader.js';
 export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
-    const allConfigFilePaths = new Set();
-    const allConfigFilesMap = new Map();
+    const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
@@ -55,10 +54,10 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
+            getSourceFile: (filePath) => principal.backend.fileManager.getSourceFile(filePath),
             isCache,
             cacheLocation,
-            allConfigFilePaths,
-            allConfigFilesMap,
+            configFilesMap,
         });
         await worker.init();
         const inputs = new Set();
@@ -73,10 +72,6 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         const entryPathsFromManifest = await getEntryPathsFromManifest(manifest, { ...sharedGlobOptions, ignore });
         for (const id of entryPathsFromManifest.map(id => toProductionEntry(id)))
             inputs.add(id);
-        const inputsFromPlugins = await worker.runPlugins();
-        for (const id of inputsFromPlugins)
-            inputs.add(id);
-        enabledPluginsStore.set(name, worker.enabledPlugins);
         const principal = factory.createPrincipal({
             cwd: dir,
             paths: config.paths,
@@ -91,6 +86,10 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             isCache,
             cacheLocation,
         });
+        const inputsFromPlugins = await worker.runPlugins();
+        for (const id of inputsFromPlugins)
+            inputs.add(id);
+        enabledPluginsStore.set(name, worker.enabledPlugins);
         const entryFilePatterns = new Set();
         const productionEntryFilePatterns = new Set();
         const projectFilePatterns = new Set();

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

@@ -3,6 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
+    config: string[];
     entry: string[];
     production: string[];
     resolve: Resolve;

package/dist/plugins/astro/index.js

@@ -3,7 +3,8 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['astro.config.{js,cjs,mjs,ts}', 'src/content/config.ts', 'src/content.config.ts'];
+const config = ['astro.config.{js,cjs,mjs,ts}'];
+const entry = ['src/content/config.ts', 'src/content.config.ts'];
 const production = [
     'src/pages/**/*.{astro,mdx,js,ts}',
     'src/content/**/*.mdx',
@@ -24,6 +25,7 @@ export default {
     title,
     enablers,
     isEnabled,
+    config,
     entry,
     production,
     resolve,

package/dist/plugins/ava/index.js

@@ -19,7 +19,7 @@ const entry = [
 const resolveEntryPaths = localConfig => {
     if (typeof localConfig === 'function')
         localConfig = localConfig();
-    return (localConfig?.files ?? []).map(toEntry);
+    return (localConfig?.files ?? entry).map(toEntry);
 };
 const resolveConfig = async (localConfig, options) => {
     if (typeof localConfig === 'function')

package/dist/plugins/index.d.ts

@@ -10,6 +10,7 @@ export declare const Plugins: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
         entry: string[];
         production: string[];
         resolve: import("../types/config.js").Resolve;
@@ -322,8 +323,9 @@ export declare const Plugins: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
-        entry: string[];
+        config: string[];
         production: string[];
+        resolveFromAST: import("../types/config.js").ResolveFromAST;
     };
     node: {
         title: string;
@@ -359,7 +361,7 @@ export declare const Plugins: {
         title: string;
         enablers: string[];
         isEnabled: import("../types/config.js").IsPluginEnabled;
-        entry: string[];
+        config: string[];
         production: string[];
         resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./nuxt/types.js").NuxtConfig>;
     };
@@ -536,6 +538,20 @@ export declare const Plugins: {
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
     };
+    sst: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        resolveFromAST: import("../types/config.js").ResolveFromAST;
+    };
+    starlight: {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        resolveFromAST: import("../types/config.js").ResolveFromAST;
+    };
     storybook: {
         title: string;
         enablers: (string | RegExp)[];
@@ -579,6 +595,15 @@ export declare const Plugins: {
         isEnabled: import("../types/config.js").IsPluginEnabled;
         entry: string[];
     };
+    'tanstack-router': {
+        title: string;
+        enablers: string[];
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+        production: string[];
+        resolveEntryPaths: import("../types/config.js").ResolveEntryPaths<import("./tanstack-router/types.js").TanstackRouterConfig>;
+        resolveFromAST: import("../types/config.js").ResolveFromAST;
+    };
     travis: {
         title: string;
         enablers: string;