knip 6.40.0 → 6.41.0

package/dist/ConfigurationChief.d.ts

@@ -237,6 +237,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'expo-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'expressive-code'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -247,6 +252,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        flue?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         fumadocs?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1076,8 +1086,10 @@ export declare class ConfigurationChief {
         eve?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "expo-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        flue?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -40,6 +40,7 @@ export declare class DependencyDeputy {
         peerDependencies: DependencySet;
         optionalPeerDependencies: DependencySet;
         requiredPeerDependencies: DependencyArray;
+        uninstalledOptionalDependencies: DependencySet;
         allDependencies: DependencySet;
         engines: Record<string, string>;
         isPrivate: boolean;

package/dist/DependencyDeputy.js

@@ -38,15 +38,25 @@ export class DependencyDeputy {
         const requiredPeerDependencies = peerDependencies.filter(dep => !optionalPeerDependencies.has(dep));
         const devDependencies = Object.keys(manifest.devDependencies ?? {});
         const allDependencies = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
-        const packageNames = [...dependencies, ...peerDependencies, ...(this.isProduction ? [] : devDependencies)];
+        const uninstalledOptionalDependencies = new Set();
+        const packageNames = [
+            ...dependencies,
+            ...peerDependencies,
+            ...optionalDependencies,
+            ...(this.isProduction ? [] : devDependencies),
+        ];
         if (this.isReportDependencies) {
-            const { hostDependencies, installedBinaries, hasTypesIncluded } = getDependencyMetaData({
+            const { hostDependencies, installedBinaries, hasTypesIncluded, uninstalledDependencies } = getDependencyMetaData({
                 packageNames,
                 dir,
             });
             this.setHostDependencies(name, hostDependencies);
             this.installedBinaries.set(name, installedBinaries);
             this.hasTypesIncluded.set(name, hasTypesIncluded);
+            for (const dependency of optionalDependencies) {
+                if (uninstalledDependencies.has(dependency))
+                    uninstalledOptionalDependencies.add(dependency);
+            }
         }
         const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
         const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
@@ -66,6 +76,7 @@ export class DependencyDeputy {
             peerDependencies: new Set(peerDependencies),
             optionalPeerDependencies,
             requiredPeerDependencies,
+            uninstalledOptionalDependencies,
             allDependencies: new Set(allDependencies),
             engines: manifest.engines ?? {},
             isPrivate: Boolean(manifest.private),
@@ -171,6 +182,21 @@ export class DependencyDeputy {
                 }
             }
         }
+        const optionalDependencies = new Set();
+        for (const name of workspaceNames) {
+            const manifest = this._manifests.get(name);
+            if (!manifest)
+                continue;
+            for (const dependency of manifest.uninstalledOptionalDependencies) {
+                const defaultBinaryName = dependency.replace(/^@[^/]+\//, '');
+                if (defaultBinaryName === binaryName) {
+                    optionalDependencies.add(dependency);
+                    this.addReferencedDependency(name, dependency);
+                }
+            }
+        }
+        if (optionalDependencies.size)
+            return optionalDependencies;
         return;
     }
     isInDependencies(workspaceName, packageName, isDevOnly) {

package/dist/IssueCollector.js

@@ -1,7 +1,6 @@
 import picomatch from 'picomatch';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { partition } from './util/array.js';
-import { prependDirToPattern } from './util/glob.js';
 import { initCounters, initIssues } from './util/issue-initializers.js';
 import { relative } from './util/path.js';
 const createMatcher = (patterns) => {
@@ -82,23 +81,22 @@ export class IssueCollector {
             return;
         const issueTypePatterns = new Map();
         for (const [pattern, issueTypes] of Object.entries(ignoreIssues)) {
-            const id = prependDirToPattern(this.cwd, pattern);
             for (const issueType of issueTypes) {
                 if (!issueTypePatterns.has(issueType)) {
                     issueTypePatterns.set(issueType, []);
                 }
-                issueTypePatterns.get(issueType)?.push(id);
+                issueTypePatterns.get(issueType)?.push(pattern);
             }
         }
         for (const [issueType, patterns] of issueTypePatterns) {
             this.issueMatchers.set(issueType, picomatch(patterns, { dot: true }));
         }
     }
-    shouldIgnoreIssue(filePath, issueType) {
+    shouldIgnoreIssue(relativePath, issueType) {
         const matcher = this.issueMatchers.get(issueType);
         if (!matcher)
             return false;
-        return matcher(filePath);
+        return matcher(relativePath);
     }
     addFileCounts({ processed, unused }) {
         this.counters.processed += processed;
@@ -110,17 +108,17 @@ export class IssueCollector {
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
-            if (this.isMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnorePatterns);
+            const symbol = relative(this.cwd, filePath);
+            if (this.isMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnorePatterns);
                 continue;
             }
-            if (this.isFileMatch(filePath)) {
-                this.markUsedPatterns(filePath, this.unusedIgnoreFilesPatterns);
+            if (this.isFileMatch(symbol)) {
+                this.markUsedPatterns(symbol, this.unusedIgnoreFilesPatterns);
                 continue;
             }
-            if (this.shouldIgnoreIssue(filePath, 'files'))
+            if (this.shouldIgnoreIssue(symbol, 'files'))
                 continue;
-            const symbol = relative(this.cwd, filePath);
             this.issues.files[symbol] = {
                 [symbol]: { type: 'files', filePath, symbol, workspace: '', severity: this.rules.files, fixes: [] },
             };
@@ -131,15 +129,15 @@ export class IssueCollector {
     addIssue(issue) {
         if (!this.workspaceFilter(issue.filePath))
             return;
-        if (this.isMatch(issue.filePath)) {
-            this.markUsedPatterns(issue.filePath, this.unusedIgnorePatterns);
+        const key = relative(this.cwd, issue.filePath);
+        if (this.isMatch(key)) {
+            this.markUsedPatterns(key, this.unusedIgnorePatterns);
             return;
         }
-        if (this.shouldIgnoreIssue(issue.filePath, issue.type))
+        if (this.shouldIgnoreIssue(key, issue.type))
             return;
         if (this.rules[issue.type] === 'off')
             return;
-        const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
         const issues = this.issues[issue.type];
         issues[key] = issues[key] ?? {};

package/dist/IssueFixer.js

@@ -21,7 +21,7 @@ export const fix = async (issues, counters, options) => {
     }
     if (options.isFormat) {
         const report = await formatly(Array.from(touchedFiles));
-        if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+        if (report.ran && report.result.runner !== 'dry-run' && report.result.code === 0) {
             debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
         }
         else {

package/dist/WorkspaceWorker.js

@@ -14,7 +14,7 @@ import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './uti
 import { isCatalog, isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { filterTransitiveDependencies } from './util/filter-transitive-dependencies.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, join, toRelative } from './util/path.js';
+import { basename, dirname, join, relative, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
 import { formatCauseMessage } from './util/errors.js';
 import { logError } from './util/log.js';
@@ -469,18 +469,24 @@ export class WorkspaceWorker {
             hints.push({ type: `${type}-empty`, identifier, workspaceName });
             return hints;
         }
+        const dir = this.dir;
+        const relativePaths = [];
+        const hasMatch = (isMatch) => {
+            for (let i = 0; i < filePaths.length; i++) {
+                if (isMatch((relativePaths[i] ??= relative(dir, filePaths[i]))))
+                    return true;
+            }
+            return false;
+        };
         for (const pattern of patterns) {
             if (pattern.startsWith('!'))
                 continue;
-            const filePathOrPattern = join(this.dir, pattern.replace(/!$/, ''));
-            if (includedPaths.has(filePathOrPattern)) {
+            const id = pattern.replace(/!$/, '');
+            if (includedPaths.has(join(dir, id))) {
                 hints.push({ type: `${type}-redundant`, identifier: pattern, workspaceName });
             }
-            else {
-                const matcher = picomatch(filePathOrPattern);
-                if (!filePaths.some(filePath => matcher(filePath))) {
-                    hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
-                }
+            else if (!hasMatch(picomatch(id))) {
+                hints.push({ type: `${type}-empty`, identifier: pattern, workspaceName });
             }
         }
         if (type === 'project' && compilerExtensions) {

package/dist/binaries/bash-parser.js

@@ -7,6 +7,11 @@ import { walkCommands } from '../util/scripts.js';
 import { getDependenciesFromCommand } from './command.js';
 import { toScript } from './util.js';
 const collectExpansionScripts = (word, out) => {
+    if (word.type === 'ArrayValue') {
+        for (const element of word.elements)
+            collectExpansionScripts(element, out);
+        return;
+    }
     if (!word.parts)
         return;
     for (const part of word.parts) {
@@ -63,11 +68,12 @@ export const getDependenciesFromScript = (script, options) => {
     const processCommand = (node, pending) => {
         if (node.name)
             collectExpansionScripts(node.name, pending);
-        for (const prefix of node.prefix)
-            if (prefix.value)
+        for (const prefix of node.prefix) {
+            if (prefix.type === 'Assignment')
                 collectExpansionScripts(prefix.value, pending);
-        for (const suffix of node.suffix)
-            collectExpansionScripts(suffix, pending);
+        }
+        for (const arg of node.args)
+            collectExpansionScripts(arg.type === 'Assignment' ? arg.value : arg, pending);
         if (definedFunctions.size && node.name && definedFunctions.has(extractBinary(node.name.value)))
             return [];
         return getDependenciesFromCommand(node, { ...options, fromArgs }, fromWords);

package/dist/binaries/command.d.ts

@@ -2,4 +2,4 @@ import type { Command, Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
 import { type Input } from '../util/input.ts';
 export declare const getInputsFromNodeOptions: (prefix: Command['prefix']) => Input[];
-export declare const getDependenciesFromCommand: (node: Command, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];
+export declare const getDependenciesFromCommand: (node: Pick<Command, 'name' | 'prefix' | 'args'>, options: BinaryResolverOptions, fromWords?: (words: Word[], options: GetInputsFromScriptsOptions) => Input[]) => Input[];

package/dist/binaries/command.js

@@ -1,17 +1,23 @@
 import { Plugins, pluginArgsMap } from '../plugins.js';
 import { toDeferResolve } from '../util/input.js';
 import { extractBinary, isInNodeModulesBin, isRelativeNodeModulesBin } from '../util/modules.js';
+import { getCommandWords } from '../util/scripts.js';
 import { resolve as fallbackResolve, spawningBinaries } from './fallback.js';
 import KnownResolvers, { isPackageManager } from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
 import { parseNodeArgs, toCommandBinary } from './util.js';
-export const getInputsFromNodeOptions = (prefix) => prefix
-    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-    .map(a => a.value.value)
-    .map(arg => parseNodeArgs(arg.split(' ')))
-    .filter(args => args.require)
-    .flatMap(arg => arg.require)
-    .map(id => toDeferResolve(id));
+export const getInputsFromNodeOptions = (prefix) => {
+    const inputs = [];
+    for (const item of prefix) {
+        if (item.type !== 'Assignment' || item.name !== 'NODE_OPTIONS' || item.value.type !== 'Word')
+            continue;
+        const args = parseNodeArgs(item.value.value.split(' '));
+        if (args.require)
+            for (const id of [args.require].flat())
+                inputs.push(toDeferResolve(id));
+    }
+    return inputs;
+};
 export const getDependenciesFromCommand = (node, options, fromWords = options.fromArgs) => {
     const text = node.name?.value;
     if (!text)
@@ -31,7 +37,7 @@ export const getDependenciesFromCommand = (node, options, fromWords = options.fr
         };
     }
     const { fromArgs } = options;
-    const words = node.suffix;
+    const words = getCommandWords(node);
     if (binary === '!' || binary === 'test')
         return fromArgs(words);
     const fromNodeOptions = getInputsFromNodeOptions(node.prefix);

package/dist/graph/build.js

@@ -51,8 +51,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         });
     }
     deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
-    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
-    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: prependDir(options.cwd, id), id })));
+    collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: id, id })));
+    collector.addIgnoreFilesPatterns(chief.config.ignoreFiles.map(id => ({ pattern: id, id })));
     if (options.configFilePath) {
         principal.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
     }
@@ -79,7 +79,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             continue;
         const dependencies = deputy.getDependencies(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
-        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath);
+        const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath, options.isUseTscFiles);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
         const worker = new WorkspaceWorker({
             name,
@@ -122,7 +122,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 inputs.add(toProductionEntry(tryRealpath(id), { containingFilePath: tsConfigFilePath }));
         }
         const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
-        const fn = (id) => ({ pattern: prependDir(options.cwd, prependDir(name, id)), id, workspaceName: name });
+        const fn = (id) => ({ pattern: prependDir(name, id), id, workspaceName: name });
         collector.addIgnorePatterns(config.ignore.map(fn));
         collector.addIgnoreFilesPatterns(config.ignoreFiles.map(fn));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
@@ -249,7 +249,10 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
         const developmentMatchers = [];
         if (options.isProduction) {
-            const toPattern = (pattern) => join(isAbsolute(pattern) ? '' : dir, removeProductionSuffix(pattern));
+            const toPattern = (pattern) => {
+                const id = removeProductionSuffix(pattern);
+                return isAbsolute(id) ? relative(options.cwd, id) : join(name, id);
+            };
             for (const map of [entryPatterns, entryPatternsSkipExports]) {
                 for (const patterns of map.values()) {
                     const [excluded, included] = partition(patterns, pattern => pattern.startsWith('!'));
@@ -260,7 +263,12 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 }
             }
         }
-        const productionPaths = (paths) => developmentMatchers.length ? paths.filter(path => !developmentMatchers.some(match => match(path))) : paths;
+        const productionPaths = (paths) => developmentMatchers.length
+            ? paths.filter(path => {
+                const relativePath = relative(options.cwd, path);
+                return !developmentMatchers.some(match => match(relativePath));
+            })
+            : paths;
         const userEntryPatterns = options.isProduction
             ? worker.getProductionEntryFilePatterns()
             : worker.getEntryFilePatterns();
@@ -313,10 +321,11 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             }
             if (extensions.length > 0) {
                 const extPart = extensions.length === 1 ? extensions[0] : `.{${extensions.map(ext => ext.slice(1)).join(',')}}`;
-                const bases = include ? new Set(include.map(p => picomatch.scan(p).base || dir)) : new Set([dir]);
+                const tsConfigDir = relative(dir, dirname(tsConfigFilePath));
+                const bases = include ? new Set(include.map(p => join(tsConfigDir, picomatch.scan(p).base))) : new Set(['']);
                 const patterns = [
-                    ...Array.from(bases, base => `${base}/**/*${extPart}`),
-                    ...(exclude?.map(p => `!${p}`) ?? []),
+                    ...Array.from(bases, base => join(base, `**/*${extPart}`)),
+                    ...(exclude?.map(p => `!${join(tsConfigDir, p)}`) ?? []),
                 ];
                 const compilerPaths = await _glob({ ...sharedGlobOptions, patterns, label: 'compiler extension paths' });
                 for (const compilerPath of compilerPaths) {

package/dist/manifest/index.d.ts

@@ -7,6 +7,7 @@ declare const getMetaDataFromPackageJson: ({ dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
+    uninstalledDependencies: Set<string>;
 };
 export declare const getDependencyMetaData: typeof getMetaDataFromPackageJson;
 export {};

package/dist/manifest/index.js

@@ -5,6 +5,7 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
     const hostDependencies = new Map();
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
+    const uninstalledDependencies = new Set();
     const addBinary = (key, value) => {
         const set = installedBinaries.get(key);
         if (set)
@@ -35,11 +36,15 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
             if (!isDefinitelyTyped(packageName) && (manifest.types || manifest.typings))
                 hasTypesIncluded.add(packageName);
         }
+        else {
+            uninstalledDependencies.add(packageName);
+        }
     }
     return {
         hostDependencies,
         installedBinaries,
         hasTypesIncluded,
+        uninstalledDependencies,
     };
 };
 export const getDependencyMetaData = timerify(getMetaDataFromPackageJson);

package/dist/plugins/expo/helpers.js

@@ -50,7 +50,7 @@ export const getDependencies = async (localConfig, options) => {
     if (platforms.includes('web')) {
         inputs.add(toProductionDependency('react-native-web'));
         inputs.add(toProductionDependency('react-dom'));
-        if (!isExpoRouter) {
+        if (!isExpoRouter && !options.enabledPlugins.includes('expo-router')) {
             inputs.add(toDependency('@expo/metro-runtime'));
         }
     }

package/dist/plugins/expo/index.js

@@ -1,37 +1,17 @@
-import { toConfig, toIgnore, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { toConfig, toIgnore } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getConfig, getDependencies } from './helpers.js';
+import { getDependencies } from './helpers.js';
 const title = 'Expo';
 const enablers = ['expo'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['app.json', 'app.config.{ts,js}'];
-const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+const config = ['app.json', 'app.config.{json,ts,js,mts,cts,mjs,cjs}'];
 const resolve = () => [toConfig('babel', 'babel.config'), toIgnore('babel-preset-expo', 'unresolved')];
-const resolveConfig = async (localConfig, options) => {
-    const { manifest } = options;
-    const config = getConfig(localConfig, options);
-    if (manifest.main === 'expo-router/entry') {
-        let patterns = [...production];
-        const normalizedPlugins = config.plugins?.map(plugin => (Array.isArray(plugin) ? plugin : [plugin])) ?? [];
-        const expoRouterPlugin = normalizedPlugins.find(([plugin]) => plugin === 'expo-router');
-        if (expoRouterPlugin) {
-            const [, options] = expoRouterPlugin;
-            if (typeof options?.root === 'string') {
-                patterns = [join(options.root, '**/*.{js,jsx,ts,tsx}')];
-            }
-        }
-        return patterns.map(entry => toProductionEntry(entry)).concat(await getDependencies(localConfig, options));
-    }
-    return production.map(entry => toProductionEntry(entry)).concat(await getDependencies(localConfig, options));
-};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
-    production,
     resolve,
-    resolveConfig,
+    resolveConfig: getDependencies,
 };
 export default plugin;

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

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

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

@@ -0,0 +1,32 @@
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import expo from '../expo/index.js';
+import { getConfig } from '../expo/helpers.js';
+const title = 'Expo Router';
+const enablers = ['expo-router'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = expo.config;
+const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+const resolveConfig = async (localConfig, options) => {
+    const config = getConfig(localConfig, options);
+    for (const plugin of config.plugins ?? []) {
+        if (!Array.isArray(plugin))
+            continue;
+        const [name, pluginOptions] = plugin;
+        const root = pluginOptions?.root;
+        if (name === 'expo-router' && typeof root === 'string') {
+            return [toProductionEntry(join(root, '**/*.{js,jsx,ts,tsx}'))];
+        }
+    }
+    return production.map(id => toProductionEntry(id));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveConfig,
+};
+export default plugin;

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

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

package/dist/plugins/flue/index.js

@@ -0,0 +1,42 @@
+import { collectFirstPropertyValue } from '../../typescript/ast-helpers.js';
+import { isDirectory } from '../../util/fs.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Flue';
+const enablers = ['@flue/runtime'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['flue.config.{ts,mts,mjs,js,cjs,cts}'];
+const extensions = '{ts,mts,js,mjs}';
+const entryNames = ['app', 'db', 'cloudflare'];
+const agentsPattern = `{agent,agents/*,agents/*/agent}.${extensions}`;
+const production = [`{.flue/,src/,}{app,db,cloudflare}.${extensions}`, `{.flue/,src/,}${agentsPattern}`];
+const getSourceRoot = (dir) => {
+    for (const name of ['.flue', 'src'])
+        if (isDirectory(dir, name))
+            return join(dir, name);
+    return dir;
+};
+const resolveFromAST = (program, { configFileDir }) => {
+    const sourceRoot = getSourceRoot(configFileDir);
+    const inputs = [];
+    for (const name of entryNames) {
+        const filePath = collectFirstPropertyValue(program, name);
+        if (filePath)
+            inputs.push(toProductionEntry(join(configFileDir, filePath)));
+        else
+            inputs.push(toProductionEntry(join(sourceRoot, `${name}.${extensions}`)));
+    }
+    const agents = collectFirstPropertyValue(program, 'agents') ?? agentsPattern;
+    inputs.push(toProductionEntry(join(sourceRoot, agents)));
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/index.d.ts

@@ -35,6 +35,7 @@ export declare const Plugins: {
     eve: import("../types/config.ts").Plugin;
     execa: import("../types/config.ts").Plugin;
     expo: import("../types/config.ts").Plugin;
+    'expo-router': import("../types/config.ts").Plugin;
     'expressive-code': {
         title: string;
         enablers: string[];
@@ -42,6 +43,7 @@ export declare const Plugins: {
         config: string[];
     };
     fast: import("../types/config.ts").Plugin;
+    flue: import("../types/config.ts").Plugin;
     fumadocs: import("../types/config.ts").Plugin;
     gatsby: import("../types/config.ts").Plugin;
     'github-action': import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -34,8 +34,10 @@ import { default as eslint } from './eslint/index.js';
 import { default as eve } from './eve/index.js';
 import { default as execa } from './execa/index.js';
 import { default as expo } from './expo/index.js';
+import { default as expoRouter } from './expo-router/index.js';
 import { default as expressiveCode } from './expressive-code/index.js';
 import { default as fast } from './fast/index.js';
+import { default as flue } from './flue/index.js';
 import { default as fumadocs } from './fumadocs/index.js';
 import { default as gatsby } from './gatsby/index.js';
 import { default as githubAction } from './github-action/index.js';
@@ -225,8 +227,10 @@ export const Plugins = {
     eve,
     execa,
     expo,
+    'expo-router': expoRouter,
     'expressive-code': expressiveCode,
     fast,
+    flue,
     fumadocs,
     gatsby,
     'github-action': githubAction,