knip 6.27.0 → 6.28.0

package/dist/ConfigurationChief.d.ts

@@ -472,6 +472,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        openclaw?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         orval?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1052,6 +1057,7 @@ export declare class ConfigurationChief {
         nyc?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oclif?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "openapi-ts"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        openclaw?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         orval?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxfmt?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.js

@@ -125,7 +125,7 @@ export class DependencyDeputy {
     maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly, isResolved) {
         if (!this.isReportDependencies)
             return true;
-        if (isBuiltin(packageName))
+        if (packageName.startsWith('node:') || isBuiltin(packageName))
             return true;
         if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
             return true;

package/dist/WorkspaceWorker.js

@@ -505,14 +505,23 @@ export class WorkspaceWorker {
         }
         if (type === 'project' && compilerExtensions) {
             const seen = new Set();
+            const patternExtensions = new Set();
             for (const pattern of userDefinedPatterns) {
                 for (const ext of extractPatternExtensions(pattern)) {
+                    patternExtensions.add(ext);
                     if (seen.has(ext) || DEFAULT_EXTENSIONS.has(ext) || compilerExtensions.has(ext))
                         continue;
                     seen.add(ext);
                     hints.push({ type: 'project-extension-unregistered', identifier: ext, workspaceName });
                 }
             }
+            if (patternExtensions.size > 0) {
+                for (const ext of compilerExtensions) {
+                    if (patternExtensions.has(ext))
+                        continue;
+                    hints.push({ type: 'project-extension-excluded', identifier: ext, workspaceName });
+                }
+            }
         }
         return hints;
     }

package/dist/compilers/index.d.ts

@@ -418,6 +418,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    openclaw?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     orval?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1329,6 +1334,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        openclaw?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         orval?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/mdx.d.ts

@@ -1,5 +1,6 @@
+declare const compiler: (text: string) => string;
 declare const _default: {
     dependencies: string[];
-    compiler: (text: string) => string;
+    compiler: typeof compiler;
 };
 export default _default;

package/dist/constants.js

@@ -50,6 +50,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'curl',
     'cut',
     'date',
+    'defaults',
     'deno',
     'devtunnel',
     'df',
@@ -67,7 +68,9 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'factor',
     'false',
     'find',
+    'fuser',
     'gem',
+    'getconf',
     'gh',
     'git',
     'grep',
@@ -82,6 +85,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'ln',
     'logname',
     'ls',
+    'lsof',
     'md5sum',
     'mkdir',
     'mknod',
@@ -104,14 +108,17 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'powershell.exe',
     'pr',
     'printenv',
+    'ps',
     'pulumi',
     'pwd',
     'python',
     'python3',
+    'raft',
     'rm',
     'rmdir',
     'rsync',
     'scp',
+    'security',
     'sed',
     'seq',
     'set',
@@ -127,10 +134,13 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'stat',
     'stty',
     'sudo',
+    'sw_vers',
     'sync',
+    'sysctl',
     'systemctl',
     'tac',
     'tar',
+    'taskkill',
     'tee',
     'test',
     'time',
@@ -148,14 +158,18 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'uniq',
     'unzip',
     'wc',
+    'which',
     'who',
     'whoami',
     'xargs',
     'xcodebuild',
+    'xcrun',
     'xvfb-run',
     'yarn',
     'yes',
     'zip',
+    'zsh',
+    'zstd',
 ]);
 export const IGNORED_DEPENDENCIES = new Set(['knip', 'typescript']);
 export const IGNORED_RUNTIME_DEPENDENCIES = new Set(['node', 'bun', 'deno']);

package/dist/graph/analyze.js

@@ -90,13 +90,15 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             }
                             if (isIgnored)
                                 continue;
-                            if (reExportingEntryFile && !isReferenced) {
+                            if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
                                     continue;
                                 }
-                                const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
-                                if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
-                                    continue;
+                                if (!isReferenced) {
+                                    const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
+                                    if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
+                                        continue;
+                                }
                             }
                             if (isReferenced) {
                                 const isEnumMembers = options.includedIssueTypes.enumMembers && exportedItem.type === 'enum';

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

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

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

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

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/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;

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';
@@ -259,6 +260,7 @@ export const Plugins = {
     nyc,
     oclif,
     'openapi-ts': openapiTs,
+    openclaw,
     orval,
     oxfmt,
     oxlint,

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;