knip 6.41.0 → 6.42.1

package/dist/plugins/jest/visitors/mock.js

@@ -0,0 +1,91 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+const mockMethods = new Set([
+    'mock',
+    'doMock',
+    'requireActual',
+    'requireMock',
+    'createMockFromModule',
+    'unmock',
+    'dontMock',
+    'deepUnmock',
+    'setMock',
+    'unstable_mockModule',
+    'unstable_unmockModule',
+]);
+export function createJestMockVisitor(ctx) {
+    const jestNames = new Set();
+    const virtualMocks = new Set();
+    const virtualEsmMocks = new Set();
+    const mockLookups = [];
+    return {
+        Program(node) {
+            jestNames.clear();
+            virtualMocks.clear();
+            virtualEsmMocks.clear();
+            mockLookups.length = 0;
+            jestNames.add('jest');
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== '@jest/globals')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'jest') {
+                        jestNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const callee = node.callee;
+            if (!isStringLiteral(argument) ||
+                callee.type !== 'MemberExpression' ||
+                callee.computed ||
+                callee.object.type !== 'Identifier' ||
+                !jestNames.has(callee.object.name) ||
+                isShadowed(callee.object.name, callee.object.start) ||
+                callee.property.type !== 'Identifier' ||
+                !mockMethods.has(callee.property.name))
+                return;
+            const specifier = getStringValue(argument);
+            const method = callee.property.name;
+            const options = node.arguments[2];
+            if ((method === 'mock' || method === 'doMock' || method === 'unstable_mockModule') &&
+                options?.type === 'ObjectExpression') {
+                for (const property of options.properties) {
+                    if (property.type === 'Property' &&
+                        !property.computed &&
+                        getPropertyKey(property) === 'virtual' &&
+                        property.value.type === 'Literal' &&
+                        property.value.value === true) {
+                        (method === 'unstable_mockModule' ? virtualEsmMocks : virtualMocks).add(specifier);
+                        return;
+                    }
+                }
+            }
+            if (method === 'requireActual' || method === 'createMockFromModule') {
+                const flags = method === 'requireActual' ? IMPORT_FLAGS.OPAQUE : IMPORT_FLAGS.SIDE_EFFECTS;
+                ctx.addImport(specifier, argument.start, flags);
+                return;
+            }
+            mockLookups.push({
+                specifier,
+                pos: argument.start,
+                isEsm: method === 'unstable_mockModule' || method === 'unstable_unmockModule',
+            });
+        },
+        'Program:exit'() {
+            for (const { specifier, pos, isEsm } of mockLookups) {
+                if ((isEsm ? virtualEsmMocks : virtualMocks).has(specifier))
+                    continue;
+                ctx.addImport(specifier, pos, IMPORT_FLAGS.SIDE_EFFECTS);
+            }
+        },
+    };
+}

package/dist/plugins/mise/scripts.js

@@ -1,4 +1,4 @@
-import { parse } from 'unbash';
+import { forEachChild, parse } from 'unbash';
 import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
 import { spawningBinaries } from '../../binaries/fallback.js';
 import { isWrapper } from '../../binaries/plugins.js';
@@ -7,121 +7,79 @@ import { toScript } from '../../binaries/util.js';
 import { SCRIPT_INTERPOLATION } from '../../constants.js';
 import { isBinary } from '../../util/input.js';
 import { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
-import { walkCommands } from '../../util/scripts.js';
+import { isScriptExpansion, collectCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
     const definedFunctions = new Set();
-    const readParts = (parts) => {
+    const readCommand = (command, source) => {
         let text = '';
-        let value = '';
-        let hasExpansion = false;
-        for (const part of parts) {
-            if (part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') {
-                if (part.script)
-                    readScript(part.script);
-                text += SCRIPT_INTERPOLATION;
-                value += SCRIPT_INTERPOLATION;
-                hasExpansion = true;
+        let cursor = command.pos;
+        const visit = (node) => {
+            if (!isScriptExpansion(node)) {
+                forEachChild(node, visit);
+                return;
             }
-            else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
-                const inner = readParts(part.parts);
-                text += `${part.type === 'LocaleString' ? '$"' : '"'}${inner.text}"`;
-                value += inner.value;
-                if (inner.hasExpansion)
-                    hasExpansion = true;
+            if (node.script)
+                readScript(node.script, node.script.source ?? source);
+            if (node.pos >= cursor && node.end <= command.end) {
+                text += source.slice(cursor, node.pos) + SCRIPT_INTERPOLATION;
+                cursor = node.end;
             }
-            else {
-                text += part.text;
-                value += 'value' in part ? part.value : part.text;
-            }
-        }
-        return { text, value, hasExpansion };
-    };
-    const readWord = (word) => {
-        if (!word.parts)
-            return word;
-        const { text, value, hasExpansion } = readParts(word.parts);
-        return hasExpansion ? { type: 'Word', pos: word.pos, end: word.end, text, value } : word;
-    };
-    const readAssignment = (assignment) => {
-        const original = assignment.value;
-        const value = original.type === 'Word'
-            ? readWord(original)
-            : { type: 'ArrayValue', pos: original.pos, end: original.end, elements: original.elements.map(readWord) };
-        if (value === original)
-            return assignment;
-        const text = value.type === 'Word' ? value.text : `(${value.elements.map(word => word.text).join(' ')})`;
-        return {
-            type: 'Assignment',
-            pos: assignment.pos,
-            end: assignment.end,
-            name: assignment.name,
-            index: assignment.index,
-            append: assignment.append,
-            value,
-            text: assignment.text.slice(0, original.pos - assignment.pos) + text,
         };
+        forEachChild(command, visit);
+        return text + source.slice(cursor, command.end);
     };
-    const readScript = (parsed) => {
+    const readScript = (parsed, source) => {
         for (const statement of parsed.commands) {
             if (statement.command.type === 'Function')
                 definedFunctions.add(statement.command.name.value);
         }
-        for (const statement of parsed.commands) {
-            for (const command of walkCommands(statement.command)) {
-                const name = command.name?.value;
-                const word = command.name && readWord(command.name);
-                const prefix = command.prefix
-                    .filter((item) => item.type === 'Assignment')
-                    .map(readAssignment);
-                const words = [];
-                for (const arg of command.args) {
-                    if (arg.type === 'Word')
-                        words.push(readWord(arg));
-                    else
-                        readAssignment(arg);
-                }
-                if (!name || !word || definedFunctions.has(name))
+        for (const command of collectCommands(parsed)) {
+            const text = readCommand(command, source);
+            const name = command.name?.value;
+            if (!name || definedFunctions.has(name))
+                continue;
+            const binary = extractBinary(name);
+            const isPackageCommand = isPackageManager(binary);
+            const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
+            const hasPath = command.prefix.some(item => item.type === 'Assignment' && item.name === 'PATH');
+            const isLocal = hasLocalBinPath && !hasPath;
+            const isWrapperCommand = !isPackageCommand && isWrapper(binary);
+            if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                continue;
+            let commandInputs;
+            if (isWrapperCommand || binary === 'find') {
+                const [marked] = collectCommands(parse(text));
+                if (!marked)
                     continue;
-                const binary = extractBinary(name);
-                const isPackageCommand = isPackageManager(binary);
-                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
-                const isLocal = hasLocalBinPath && !prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
-                if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                const fromScript = (script) => {
+                    inputs.push(...getInputsFromMiseScript(script, options, isLocal));
+                    return [];
+                };
+                const fromArgs = args => fromScript(toScript(args));
+                commandInputs = getDependenciesFromCommand(marked, { ...options, fromArgs });
+                if (spawningBinaries.includes(binary))
+                    commandInputs.push(...getInputsFromNodeOptions(marked.prefix));
+            }
+            else {
+                commandInputs = options.getInputsFromScripts(text, { cwd: options.cwd, manifest: options.manifest });
+            }
+            if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                continue;
+            const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
+            if (!isExplicit && isLocal && binaryInput)
+                binaryInput.optional = true;
+            for (const input of commandInputs) {
+                if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
                     continue;
-                let commandInputs;
-                if (isWrapperCommand || binary === 'find') {
-                    const fromScript = (script) => {
-                        inputs.push(...getInputsFromMiseScript(script, options, isLocal));
-                        return [];
-                    };
-                    const fromArgs = args => fromScript(toScript(args));
-                    commandInputs = getDependenciesFromCommand({ name: word, prefix, args: words }, { ...options, fromArgs });
-                }
-                else {
-                    commandInputs = options.getInputsFromScripts([...prefix.map(assignment => assignment.text), word.text, ...words.map(word => word.text)].join(' '), { cwd: options.cwd, manifest: options.manifest });
-                }
-                if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                if (!isExplicit && !isLocal && input === binaryInput)
                     continue;
-                if (isWrapperCommand && spawningBinaries.includes(binary)) {
-                    commandInputs.push(...getInputsFromNodeOptions(prefix));
-                }
-                const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
-                if (!isExplicit && isLocal && binaryInput)
-                    binaryInput.optional = true;
-                for (const input of commandInputs) {
-                    if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
-                        continue;
-                    if (!isExplicit && !isLocal && input === binaryInput)
-                        continue;
-                    inputs.push(input);
-                }
+                inputs.push(input);
             }
         }
     };
     try {
-        readScript(parse(script));
+        readScript(parse(script), script);
     }
     catch {
         return [];

package/dist/plugins/next/index.js

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

package/dist/plugins/nx/index.js

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

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

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

package/dist/plugins/oxlint/index.js

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

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

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

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

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

package/dist/plugins/rstest/index.js

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

package/dist/plugins/semantic-release/index.js

@@ -1,4 +1,5 @@
-import { toDeferResolve } from '../../util/input.js';
+import { toConfig, toDeferResolve } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { toCosmiconfig } from '../../util/plugin-config.js';
 const title = 'Semantic Release';
@@ -13,9 +14,36 @@ const excludePackages = [
     '@semantic-release/npm',
     '@semantic-release/release-notes-generator',
 ];
-const resolveConfig = config => {
+const resolveConfig = (config, options) => {
+    const inputs = [];
+    for (const id of [config?.extends ?? []].flat()) {
+        if (isInternal(id))
+            inputs.push(toConfig('semantic-release', id, { containingFilePath: options.configFilePath }));
+        else
+            inputs.push(toDeferResolve(id));
+    }
     const plugins = (config?.plugins ?? []).map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
-    return plugins.filter(plugin => !excludePackages.includes(plugin)).map(id => toDeferResolve(id));
+    for (const id of plugins.filter(plugin => !excludePackages.includes(plugin)))
+        inputs.push(toDeferResolve(id));
+    return inputs;
+};
+const args = {
+    alias: { extends: ['e'] },
+    resolveInputs: (parsed, { cwd }) => {
+        if (parsed.extends === 'false')
+            return [];
+        const inputs = [];
+        for (const value of [parsed.extends ?? []].flat()) {
+            for (const part of String(value).split(',')) {
+                const id = part.trim();
+                if (isInternal(id))
+                    inputs.push(toConfig('semantic-release', id, { dir: cwd }));
+                else
+                    inputs.push(toDeferResolve(id));
+            }
+        }
+        return inputs;
+    },
 };
 const plugin = {
     title,
@@ -25,5 +53,6 @@ const plugin = {
     packageJsonPath,
     config,
     resolveConfig,
+    args,
 };
 export default plugin;

package/dist/plugins/semantic-release/types.d.ts

@@ -1,3 +1,4 @@
 export type SemanticReleaseConfig = {
+    extends?: string | string[];
     plugins?: (string | [string, Record<string, unknown>])[];
 };

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

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

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

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

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

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

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

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