knip 6.26.0 → 6.28.0

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

@@ -15,90 +15,104 @@ const hasOnlyNsRefs = (file) => {
 };
 export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const seen = new Set();
+    let isReferenced = false;
+    let reExportingEntryFile;
+    const hasCompleteResult = () => isReferenced && (options.traverseEntries || reExportingEntryFile !== undefined);
     const walkDown = (path, id, viaStar = false) => {
         const isEntryFile = entryPaths.has(path);
-        let reExportingEntryFile = isEntryFile ? path : undefined;
+        if (isEntryFile && !reExportingEntryFile)
+            reExportingEntryFile = path;
+        if (hasCompleteResult())
+            return true;
         if (seen.has(path))
-            return [false, reExportingEntryFile];
+            return false;
         seen.add(path);
         const restIds = id.split('.');
         const identifier = restIds.shift();
         if (options.treatStarAtEntryAsReferenced && isEntryFile && viaStar && restIds.length > 0) {
-            return [true, reExportingEntryFile];
+            isReferenced = true;
+            return hasCompleteResult();
         }
         const file = graph.get(path)?.importedBy;
         if (!identifier || !file) {
-            return [false, reExportingEntryFile];
+            return false;
         }
         const follow = (sources, nextId, nextViaStar = viaStar) => {
             for (const byFilePath of sources) {
-                if (seen.has(byFilePath))
-                    continue;
-                const result = walkDown(byFilePath, nextId, nextViaStar);
-                if (result[1])
-                    reExportingEntryFile = result[1];
-                if (result[0])
+                if (walkDown(byFilePath, nextId, nextViaStar))
                     return true;
             }
             return false;
         };
-        if ((file.import.get(OPAQUE) && !hasOnlyNsRefs(file)) ||
-            ((identifier === id || (identifier !== id && file.refs.has(id))) &&
-                (file.import.has(identifier) || file.importAs.has(identifier)))) {
-            return [true, reExportingEntryFile];
+        if (!isReferenced) {
+            const hasDirectReference = (file.import.get(OPAQUE) && !hasOnlyNsRefs(file)) ||
+                ((identifier === id || (identifier !== id && file.refs.has(id))) &&
+                    (file.import.has(identifier) || file.importAs.has(identifier)));
+            if (hasDirectReference) {
+                isReferenced = true;
+                if (hasCompleteResult())
+                    return true;
+            }
         }
-        for (const [exportId, aliases] of file.importAs) {
-            if (identifier === exportId) {
-                for (const alias of aliases.keys()) {
-                    const aliasedRef = [alias, ...restIds].join('.');
-                    if (file.refs.has(aliasedRef)) {
-                        return [true, reExportingEntryFile];
+        if (!isReferenced) {
+            aliasImports: for (const [exportId, aliases] of file.importAs) {
+                if (identifier === exportId) {
+                    for (const alias of aliases.keys()) {
+                        const aliasedRef = [alias, ...restIds].join('.');
+                        if (file.refs.has(aliasedRef)) {
+                            isReferenced = true;
+                            break aliasImports;
+                        }
                     }
                 }
             }
+            if (hasCompleteResult())
+                return true;
         }
         for (const namespace of file.importNs.keys()) {
-            if (file.refs.has(`${namespace}.${id}`)) {
-                return [true, reExportingEntryFile];
+            if (!isReferenced && file.refs.has(`${namespace}.${id}`)) {
+                isReferenced = true;
+                if (hasCompleteResult())
+                    return true;
             }
             const nsAliasMap = getAliasReExportMap(file, namespace);
             if (nsAliasMap) {
                 for (const [alias, sources] of nsAliasMap) {
                     if (follow(sources, `${alias}.${id}`))
-                        return [true, reExportingEntryFile];
+                        return true;
                 }
             }
             const nsReExportSources = getNamespaceReExportSources(file, namespace);
             if (nsReExportSources) {
                 if (follow(nsReExportSources, `${namespace}.${id}`))
-                    return [true, reExportingEntryFile];
+                    return true;
             }
         }
         if (isEntryFile && !options.traverseEntries)
-            return [false, reExportingEntryFile];
+            return false;
         const aliasMap = getAliasReExportMap(file, identifier);
         if (aliasMap) {
             for (const [alias, sources] of aliasMap) {
                 if (follow(sources, [alias, ...restIds].join('.')))
-                    return [true, reExportingEntryFile];
+                    return true;
             }
         }
         const directSources = getPassThroughReExportSources(file, identifier);
         const starSources = getStarReExportSources(file);
         if (directSources) {
             if (follow(directSources, id))
-                return [true, reExportingEntryFile];
+                return true;
         }
         else if (starSources) {
             if (follow(starSources, id, true))
-                return [true, reExportingEntryFile];
+                return true;
         }
         for (const [namespace, sources] of file.reExportNs) {
-            if (follow(sources, `${namespace}.${id}`, true)) {
-                return [true, reExportingEntryFile];
-            }
+            if (follow(sources, `${namespace}.${id}`, true))
+                return true;
         }
-        return [false, reExportingEntryFile];
+        return false;
     };
-    return walkDown(filePath, id);
+    walkDown(filePath, id);
+    return [isReferenced, reExportingEntryFile];
 };

package/dist/manifest/index.d.ts

@@ -4,9 +4,10 @@ type Options = {
     dir: string;
     cwd: string;
 };
-export declare const getDependencyMetaData: ({ cwd, dir, packageNames }: Options) => {
+declare const getMetaDataFromPackageJson: ({ cwd, dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
 };
+export declare const getDependencyMetaData: typeof getMetaDataFromPackageJson;
 export {};

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

@@ -9,7 +9,26 @@ import { _syncGlob } from '../../util/glob.js';
 import { dirname, isInNodeModules, join } from '../../util/path.js';
 const getVueSfc = (cwd) => {
     try {
-        return createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+        const sfc = createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+        if (typeof sfc.parseComponent === 'function') {
+            return {
+                parse: (source, path) => ({
+                    descriptor: sfc.parse({ source, filename: path, sourceMap: false }),
+                }),
+                compileTemplate: (source, path, isTS, preprocessLang) => sfc.compileTemplate({
+                    source,
+                    filename: path,
+                    sourceMap: false,
+                    isProduction: true,
+                    prettify: false,
+                    isTS,
+                    preprocessLang,
+                }),
+            };
+        }
+        return {
+            parse: (source, path) => sfc.parse(source, { filename: path, sourceMap: false }),
+        };
     }
     catch { }
     return {
@@ -40,11 +59,15 @@ const collectIdentifiers = (source, fileName) => {
 const collectTemplateInfo = (tree) => {
     const tags = new Set();
     const identifiers = new Set();
+    const visited = new Set();
     const addExprIdentifiers = (expr) => {
         for (const id of collectIdentifiers(expr, 'expr.ts'))
             identifiers.add(id);
     };
     const visit = (node) => {
+        if (visited.has(node))
+            return;
+        visited.add(node);
         if (node.tag)
             tags.add(node.tag);
         if (node.type === 5 && node.content && !node.content.isStatic)
@@ -62,10 +85,34 @@ const collectTemplateInfo = (tree) => {
         if (node.children)
             for (const child of node.children)
                 visit(child);
+        if (node.ifConditions)
+            for (const condition of node.ifConditions)
+                visit(condition.block);
+        if (node.scopedSlots)
+            for (const name in node.scopedSlots)
+                visit(node.scopedSlots[name]);
     };
     visit(tree);
     return { tags, identifiers };
 };
+const collectVue2TemplateIdentifiers = (source) => {
+    const identifiers = new Set();
+    const visitor = new Visitor({
+        MemberExpression(node) {
+            if (!node.computed &&
+                node.object.type === 'Identifier' &&
+                node.object.name === '_vm' &&
+                node.property.type === 'Identifier') {
+                const name = node.property.name;
+                if (name !== '_self' && name !== '$set' && name !== '$delete' && !(name.length === 2 && name[0] === '_')) {
+                    identifiers.add(name);
+                }
+            }
+        },
+    });
+    visitor.visit(_parseFile('template.js', source).program);
+    return identifiers;
+};
 const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
 const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
 export const collectLocalImportPaths = (filePath, result) => {
@@ -182,20 +229,33 @@ const compileVueSfc = (source, path, maps, root) => {
     if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
         return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
     }
-    const { descriptor } = sfcForRoot(root).parse(source, path);
+    const sfc = sfcForRoot(root);
+    const { descriptor } = sfc.parse(source, path);
     const scripts = [];
     if (descriptor.script?.content)
         scripts.push(descriptor.script.content);
     if (descriptor.scriptSetup?.content)
         scripts.push(descriptor.scriptSetup.content);
     const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path);
+    const template = descriptor.template;
+    const compiled = template && !template.ast && sfc.compileTemplate
+        ? sfc.compileTemplate(template.content, path, descriptor.script?.lang === 'ts' ||
+            descriptor.script?.lang === 'tsx' ||
+            descriptor.scriptSetup?.lang === 'ts' ||
+            descriptor.scriptSetup?.lang === 'tsx', template.lang)
+        : undefined;
     let templateTags;
-    if (descriptor.template?.ast) {
-        const info = collectTemplateInfo(descriptor.template.ast);
+    const templateAst = template?.ast ?? compiled?.ast;
+    if (templateAst) {
+        const info = collectTemplateInfo(templateAst);
         templateTags = info.tags;
         for (const id of info.identifiers)
             identifiers.add(id);
     }
+    if (compiled?.code) {
+        for (const id of collectVue2TemplateIdentifiers(compiled.code))
+            identifiers.add(id);
+    }
     scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
     const styles = stylePreprocessorImports(source, path);
     if (styles)

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

@@ -13,24 +13,31 @@ export interface TemplateAstNode {
     props?: TemplateAstProp[];
     content?: TemplateExpressionNode;
     children?: TemplateAstNode[];
+    ifConditions?: {
+        block: TemplateAstNode;
+    }[];
+    scopedSlots?: Record<string, TemplateAstNode>;
+}
+interface DescriptorBlock {
+    content: string;
+    lang?: string;
 }
 interface Descriptor {
-    script: {
-        content: string;
-    } | null;
-    scriptSetup: {
-        content: string;
-    } | null;
-    template: {
-        content: string;
+    script: DescriptorBlock | null;
+    scriptSetup: DescriptorBlock | null;
+    template: (DescriptorBlock & {
         ast?: TemplateAstNode;
-    } | null;
+    }) | null;
 }
-export type VueSfc = {
+export interface VueSfc {
     parse: (source: string, path: string) => {
         descriptor: Descriptor;
     };
-};
+    compileTemplate?: (source: string, path: string, isTS: boolean, preprocessLang?: string) => {
+        ast?: TemplateAstNode;
+        code: string;
+    };
+}
 export interface AutoImportMaps {
     importMap: Map<string, string>;
     componentMap: Map<string, string[]>;

package/dist/plugins/angular/index.js

@@ -84,6 +84,9 @@ const entriesByOption = (opts) => new Map(Object.entries({
     scripts: 'scripts' in opts && opts.scripts && Array.isArray(opts.scripts)
         ? opts.scripts.map(scriptStringOrObject => typeof scriptStringOrObject === 'string' ? scriptStringOrObject : scriptStringOrObject.input)
         : [],
+    styles: 'styles' in opts && opts.styles && Array.isArray(opts.styles)
+        ? opts.styles.map(styleStringOrObject => typeof styleStringOrObject === 'string' ? styleStringOrObject : styleStringOrObject.input)
+        : [],
     polyfills: 'polyfills' in opts && opts.polyfills
         ? Array.isArray(opts.polyfills)
             ? opts.polyfills

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

@@ -1,14 +1,16 @@
 export declare const resolveName: (identifier: string, namespace: 'preset' | 'plugin') => string;
+declare const cacheFn: {
+    (): undefined;
+    forever: () => any;
+    never: () => any;
+    using: () => any;
+    invalidate: () => any;
+};
 export declare const api: {
     assertVersion: () => boolean;
-    cache: {
-        (): undefined;
-        forever: () => any;
-        never: () => any;
-        using: () => any;
-        invalidate: () => any;
-    };
+    cache: typeof cacheFn;
     caller: () => boolean;
     env: (env?: string) => "development" | true;
     version: string;
 };
+export {};

package/dist/plugins/convex/index.js

@@ -1,12 +1,21 @@
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Convex';
 const enablers = ['convex'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['convex/*.config.@(js|ts)', 'convex/**/_generated/*.@(js|ts)'];
+const config = ['convex.json'];
+const production = ['convex/**/*.@(js|ts)'];
+const resolveConfig = localConfig => {
+    const functionsDir = typeof localConfig.functions === 'string' ? localConfig.functions : 'convex';
+    return [toProductionEntry(join(functionsDir, '**/*.@(js|ts)'))];
+};
 const plugin = {
     title,
     enablers,
     isEnabled,
-    entry,
+    config,
+    production,
+    resolveConfig,
 };
 export default plugin;

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

@@ -0,0 +1,3 @@
+export interface ConvexConfig {
+    functions?: string;
+}

package/dist/plugins/convex/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/github-actions/index.js

@@ -17,8 +17,9 @@ export const getActionDependencies = (config, options) => {
     const scripts = [runs.pre, runs.main, runs.post].filter(isString);
     return scripts.map(script => join(configFileDir, script));
 };
+const ACTION_PATH_VAR = /\$\{\{\s*github\.action_path\s*\}\}|\$\{GITHUB_ACTION_PATH\}|\$GITHUB_ACTION_PATH/g;
 const resolveConfig = async (config, options) => {
-    const { rootCwd, getInputsFromScripts, isProduction, getManifest } = options;
+    const { rootCwd, getInputsFromScripts, isProduction, getManifest, configFileDir } = options;
     const inputs = new Set();
     const jobs = findByKeyDeep(config, 'steps');
     for (const steps of jobs) {
@@ -31,7 +32,9 @@ const resolveConfig = async (config, options) => {
             const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
             if (step.run) {
                 const manifest = getManifest(dir) ?? options.manifest;
-                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true, manifest })) {
+                const actionPath = relative(dir, configFileDir);
+                const run = step.run.replace(ACTION_PATH_VAR, actionPath ? `./${actionPath}` : '.');
+                for (const input of getInputsFromScripts([run], { knownBinsOnly: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

package/dist/plugins/index.d.ts

@@ -87,6 +87,7 @@ export declare const Plugins: {
     nyc: import("../types/config.ts").Plugin;
     oclif: import("../types/config.ts").Plugin;
     'openapi-ts': import("../types/config.ts").Plugin;
+    openclaw: import("../types/config.ts").Plugin;
     orval: import("../types/config.ts").Plugin;
     oxfmt: import("../types/config.ts").Plugin;
     oxlint: import("../types/config.ts").Plugin;
@@ -144,6 +145,7 @@ export declare const Plugins: {
     'tanstack-router': import("../types/config.ts").Plugin;
     taskfile: import("../types/config.ts").Plugin;
     tauri: import("../types/config.ts").Plugin;
+    temporal: import("../types/config.ts").Plugin;
     travis: import("../types/config.ts").Plugin;
     'ts-node': import("../types/config.ts").Plugin;
     tsdown: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -81,6 +81,7 @@ import { default as nx } from './nx/index.js';
 import { default as nyc } from './nyc/index.js';
 import { default as oclif } from './oclif/index.js';
 import { default as openapiTs } from './openapi-ts/index.js';
+import { default as openclaw } from './openclaw/index.js';
 import { default as orval } from './orval/index.js';
 import { default as oxfmt } from './oxfmt/index.js';
 import { default as oxlint } from './oxlint/index.js';
@@ -138,6 +139,7 @@ import { default as tailwind } from './tailwind/index.js';
 import { default as tanstackRouter } from './tanstack-router/index.js';
 import { default as taskfile } from './taskfile/index.js';
 import { default as tauri } from './tauri/index.js';
+import { default as temporal } from './temporal/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsdown } from './tsdown/index.js';
@@ -258,6 +260,7 @@ export const Plugins = {
     nyc,
     oclif,
     'openapi-ts': openapiTs,
+    openclaw,
     orval,
     oxfmt,
     oxlint,
@@ -315,6 +318,7 @@ export const Plugins = {
     'tanstack-router': tanstackRouter,
     taskfile,
     tauri,
+    temporal,
     travis,
     'ts-node': tsNode,
     tsdown,

package/dist/plugins/markdownlint/index.js

@@ -2,19 +2,40 @@ import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getArgumentValues } from './helpers.js';
 const title = 'markdownlint';
-const enablers = ['markdownlint-cli'];
+const enablers = ['markdownlint-cli', 'markdownlint-cli2'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.markdownlint.{json,jsonc}', '.markdownlint.{yml,yaml}'];
+const isBundled = (specifier) => specifier.startsWith('markdownlint/style/') || specifier === 'markdownlint-cli2-formatter-default';
+const config = ['.markdownlint-cli2.{jsonc,yaml,cjs,mjs}', '.markdownlint.{json,jsonc,yaml,yml,cjs,mjs}'];
 const resolveConfig = (config, options) => {
     const { manifest } = options;
-    const extend = config?.extends ? [config.extends] : [];
+    const dependencies = [];
+    for (const extend of [config?.extends, config?.config?.extends]) {
+        if (extend)
+            dependencies.push(extend);
+    }
+    for (const customRule of config?.customRules ?? []) {
+        if (typeof customRule === 'string')
+            dependencies.push(customRule);
+        else if (Array.isArray(customRule)) {
+            for (const rule of customRule) {
+                if (typeof rule === 'string')
+                    dependencies.push(rule);
+            }
+        }
+    }
+    for (const modules of [config?.markdownItPlugins, config?.outputFormatters]) {
+        for (const module of modules ?? []) {
+            if (Array.isArray(module) && typeof module[0] === 'string')
+                dependencies.push(module[0]);
+        }
+    }
     const scripts = manifest?.scripts
         ? Object.values(manifest.scripts).filter((script) => typeof script === 'string')
         : [];
     const uses = scripts
-        .filter(script => script.includes('markdownlint '))
+        .filter(script => script.includes('markdownlint ') || script.includes('markdownlint-cli2 '))
         .flatMap(script => getArgumentValues(script, / (--rules|-r)[ =]([^ ]+)/g));
-    return [...extend, ...uses].map(id => toDependency(id));
+    return [...dependencies, ...uses].filter(id => !isBundled(id)).map(id => toDependency(id));
 };
 const plugin = {
     title,

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

@@ -1,3 +1,9 @@
 export type MarkdownlintConfig = {
+    config?: {
+        extends?: string;
+    };
+    customRules?: unknown[];
     extends?: string;
+    markdownItPlugins?: unknown[];
+    outputFormatters?: unknown[];
 };

package/dist/plugins/nitro/index.js

@@ -1,4 +1,4 @@
-import { toDependency, toProductionEntry } from '../../util/input.js';
+import { toDependency, toIgnore, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Nitro';
@@ -22,6 +22,7 @@ const setup = async () => {
         });
     }
 };
+const resolve = () => [toIgnore('^#nitro-internal-', 'unresolved')];
 const resolveConfig = async (localConfig) => {
     const srcDir = localConfig.srcDir ?? '.';
     const patterns = [
@@ -53,6 +54,7 @@ const plugin = {
     config,
     production,
     setup,
+    resolve,
     resolveConfig,
 };
 export default plugin;

package/dist/plugins/nuxt/index.js

@@ -1,8 +1,8 @@
 import { isDirectory } from '../../util/fs.js';
 import { _syncGlob } from '../../util/glob.js';
-import { toAlias, toConfig, toDeferResolveProductionEntry, toDependency, toEntry, toIgnore, toProductionEntry, } from '../../util/input.js';
+import { toAlias, toConfig, toDeferResolveProductionEntry, toDependency, toEntry, toIgnore, toProductionDependency, toProductionEntry, } from '../../util/input.js';
 import { loadTSConfig } from '../../util/load-tsconfig.js';
-import { join } from '../../util/path.js';
+import { isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { buildAutoImportMap, collectLocalImportPaths, createAutoImportMaps, createTsCompiler, createVueCompiler, readAndParseFile, } from '../_vue/auto-import.js';
 const title = 'Nuxt';
@@ -35,6 +35,13 @@ const setup = async () => {
         });
     }
 };
+const resolve = () => [
+    toIgnore('^#build/', 'unresolved'),
+    toIgnore('#components', 'unresolved'),
+    toIgnore('#imports', 'unresolved'),
+    toIgnore('^#internal/', 'unresolved'),
+    toIgnore('#spa-template', 'unresolved'),
+];
 const resolveAlias = (specifier, srcDir, rootDir) => {
     if (specifier.startsWith('~~/') || specifier.startsWith('@@/'))
         return join(rootDir, specifier.slice(3));
@@ -80,14 +87,18 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir: cwd } = options;
     const hasAppDir = isDirectory(cwd, 'app');
-    const srcDir = localConfig.srcDir ?? (hasAppDir ? join(cwd, 'app') : cwd);
+    const srcDir = toAbsolute(localConfig.srcDir ?? (hasAppDir ? join(cwd, 'app') : cwd), cwd);
     const serverDir = localConfig.serverDir ?? 'server';
     const inputs = [];
+    const addModule = (id) => {
+        const specifier = resolveAlias(id, srcDir, cwd);
+        inputs.push(isInternal(specifier) ? toDeferResolveProductionEntry(specifier) : toProductionDependency(specifier));
+    };
     for (const id of localConfig.modules ?? []) {
         if (Array.isArray(id) && typeof id[0] === 'string')
-            inputs.push(toDependency(id[0]));
+            addModule(id[0]);
         if (typeof id === 'string')
-            inputs.push(toDependency(id));
+            addModule(id);
     }
     addAppEntries(inputs, srcDir, serverDir, localConfig, cwd);
     const aliases = localConfig.alias;
@@ -101,7 +112,8 @@ const resolveConfig = async (localConfig, options) => {
         }
     }
     for (const ext of localConfig.extends ?? []) {
-        const resolved = resolveAlias(ext, srcDir, cwd);
+        const target = resolveAlias(ext, srcDir, cwd);
+        const resolved = isInternal(target) ? toAbsolute(target, cwd) : target;
         const configs = _syncGlob({ cwd: resolved, patterns: config });
         if (configs.length > 0)
             for (const cfg of configs)
@@ -129,8 +141,6 @@ const resolveConfig = async (localConfig, options) => {
             inputs.push(toAlias(key, paths[key], { dir }));
         }
     }
-    inputs.push(toIgnore('#imports', 'unresolved'));
-    inputs.push(toIgnore('#components', 'unresolved'));
     return inputs;
 };
 const plugin = {
@@ -141,6 +151,7 @@ const plugin = {
     entry,
     production,
     setup,
+    resolve,
     resolveConfig,
     registerCompilers,
 };

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

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