knip 6.26.0 → 6.28.0

package/dist/typescript/comments.d.ts

@@ -1,4 +1,4 @@
-import type { Comment } from 'oxc-parser';
+import { type Comment } from 'oxc-parser';
 type CommentImportAdder = (specifier: string, identifier: string | undefined, alias: string | undefined, namespace: string | undefined, pos: number, modifiers: number) => void;
 export declare const extractImportsFromComments: (comments: readonly Comment[], firstStmtStart: number, addImport: CommentImportAdder) => void;
 export {};

package/dist/typescript/comments.js

@@ -1,10 +1,12 @@
+import { parseSync } from 'oxc-parser';
 import { IMPORT_FLAGS } from '../constants.js';
 const jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)(?:\.(\w+))?/g;
-const jsDocImportTagRe = /@import\s+(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/g;
 const jsDocTypeTagRe = /@(?:type|typedef|callback|param|arg|argument|property|prop|returns?|yields?|throws?|exception|this|extends|augments|implements|enum|template|satisfies|const|constant|member|var|namespace|module)\b/;
 const jsxImportSourceRe = /@jsxImportSource\s+(\S+)/;
 const referenceRe = /\s*<reference\s+(types|path)\s*=\s*"([^"]+)"[^/]*\/>/;
 const envPragmaRe = /@(vitest|jest)-environment\s+([@\w./-]+)/g;
+const jsDocImportTag = '@import';
+const jsDocParseOptions = { sourceType: 'module' };
 const resolveEnvironmentPragma = (tool, value) => {
     if (value === 'node')
         return undefined;
@@ -19,6 +21,47 @@ const resolveEnvironmentPragma = (tool, value) => {
         return '@edge-runtime/vm';
     return value;
 };
+const isWhitespace = (char) => char === 9 || char === 10 || char === 13 || char === 32;
+const isHorizontalWhitespace = (char) => char === 9 || char === 13 || char === 32;
+const isJsDocTagStart = (text, index) => {
+    let pos = text.lastIndexOf('\n', index - 1) + 1;
+    while (isWhitespace(text.charCodeAt(pos)))
+        pos++;
+    if (text.charCodeAt(pos) === 42) {
+        pos++;
+        while (isWhitespace(text.charCodeAt(pos)))
+            pos++;
+    }
+    return pos === index;
+};
+const getJsDocImportSource = (text, index) => {
+    let source = 'import type';
+    let pos = index + jsDocImportTag.length;
+    while (pos < text.length) {
+        const lineEnd = text.indexOf('\n', pos);
+        if (lineEnd === -1)
+            return source + text.slice(pos);
+        source += text.slice(pos, lineEnd);
+        let nextLine = lineEnd + 1;
+        while (isHorizontalWhitespace(text.charCodeAt(nextLine)))
+            nextLine++;
+        if (text.charCodeAt(nextLine) === 42) {
+            nextLine++;
+            while (isHorizontalWhitespace(text.charCodeAt(nextLine)))
+                nextLine++;
+        }
+        if (text.charCodeAt(nextLine) === 64)
+            return source;
+        source += '\n';
+        pos = nextLine;
+    }
+    return source;
+};
+const parseJsDocImport = (text, index) => {
+    const source = getJsDocImportSource(text, index);
+    const imported = parseSync('jsdoc.ts', source, jsDocParseOptions).module.staticImports[0];
+    return imported?.moduleRequest.value ? imported : undefined;
+};
 const isInJsDocTypeExpression = (text, index) => {
     let depth = 0;
     for (let pos = index - 1; pos >= 0; pos--) {
@@ -39,6 +82,24 @@ const isInJsDocTypeExpression = (text, index) => {
     }
     return false;
 };
+const addJsDocImport = (imported, pos, addImport) => {
+    const specifier = imported.moduleRequest.value;
+    if (imported.entries.length === 0) {
+        addImport(specifier, undefined, undefined, undefined, pos, IMPORT_FLAGS.TYPE_ONLY);
+        return;
+    }
+    for (const entry of imported.entries) {
+        if (entry.importName.kind === 'NamespaceObject') {
+            addImport(specifier, undefined, undefined, undefined, pos, IMPORT_FLAGS.TYPE_ONLY | IMPORT_FLAGS.OPAQUE);
+        }
+        else {
+            const localName = entry.localName.value;
+            const identifier = entry.importName.kind === 'Default' ? 'default' : entry.importName.name;
+            const alias = localName === identifier ? undefined : localName;
+            addImport(specifier, identifier, alias, undefined, pos, IMPORT_FLAGS.TYPE_ONLY);
+        }
+    }
+};
 export const extractImportsFromComments = (comments, firstStmtStart, addImport) => {
     for (const comment of comments) {
         const text = comment.value;
@@ -52,10 +113,15 @@ export const extractImportsFromComments = (comments, firstStmtStart, addImport)
                 const member = results[2];
                 addImport(specifier, member, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
             }
-            jsDocImportTagRe.lastIndex = 0;
-            while ((results = jsDocImportTagRe.exec(text)) !== null) {
-                const specifier = results[1];
-                addImport(specifier, undefined, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
+            let index = text.indexOf(jsDocImportTag);
+            while (index !== -1) {
+                const next = index + jsDocImportTag.length;
+                if (isJsDocTagStart(text, index) && isWhitespace(text.charCodeAt(next))) {
+                    const imported = parseJsDocImport(text, index);
+                    if (imported)
+                        addJsDocImport(imported, comment.start + index, addImport);
+                }
+                index = text.indexOf(jsDocImportTag, next);
             }
         }
         const jsxMatch = text.match(jsxImportSourceRe);

package/dist/typescript/get-imports-and-exports.d.ts

@@ -2,4 +2,6 @@ import type { ParseResult, Visitor } from 'oxc-parser';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext } from '../types/config.ts';
 import type { FileNode } from '../types/module-graph.ts';
 import { type ResolveModule } from './ast-nodes.ts';
-export declare const _getImportsAndExports: (filePath: string, sourceText: string, resolveModule: ResolveModule, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, skipExportsForFile: boolean, visitor: Visitor, pluginCtx: PluginVisitorContext | undefined, cachedParseResult?: ParseResult) => FileNode;
+declare const getImportsAndExports: (filePath: string, sourceText: string, resolveModule: ResolveModule, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, skipExportsForFile: boolean, visitor: Visitor, pluginCtx: PluginVisitorContext | undefined, cachedParseResult?: ParseResult) => FileNode;
+export declare const _getImportsAndExports: typeof getImportsAndExports;
+export {};

package/dist/typescript/get-imports-and-exports.js

@@ -1,7 +1,7 @@
 import { isBuiltin } from 'node:module';
 import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, PROTOCOL_VIRTUAL, SIDE_EFFECTS } from '../constants.js';
 import { addNsValue, addValue, createImports } from '../util/module-graph.js';
-import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier, } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
@@ -125,9 +125,12 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                 if (module.isExternalLibraryImport) {
                     if (options.skipTypeOnly && modifiers & IMPORT_FLAGS.TYPE_ONLY)
                         return;
-                    const sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(resolvedFileName) || isInNodeModules(specifier)
-                        ? getPackageNameFromFilePath(specifier)
-                        : specifier);
+                    let sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : specifier);
+                    if (module.packageName &&
+                        isStartsLikePackageName(module.packageName) &&
+                        getPackageNameFromModuleSpecifier(sanitizedSpecifier) !== module.packageName) {
+                        sanitizedSpecifier = module.packageName;
+                    }
                     if (!isStartsLikePackageName(sanitizedSpecifier))
                         return;
                     const ePos = specifierPos ?? pos;
@@ -277,7 +280,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
-    const localRefs = _walkAST(result.program, sourceText, filePath, {
+    const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {
         lineStarts,
         skipExports,
         options,
@@ -314,7 +317,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     extractImportsFromComments(result.comments, firstStmtStart, addImport);
     for (const [id, item] of exports) {
         item.referencedIn = referencedInExport.get(id);
-        if (localRefs && shouldCountRefs(ignoreExportsUsedInFile, item.type) && (localRefs.has(id) || item.isReExport)) {
+        if (localRefs && shouldCountRefs(ignoreExportsUsedInFile, item.type) && localRefs.has(id)) {
             item.hasRefsInFile = true;
         }
     }

package/dist/typescript/resolve-module-names.d.ts

@@ -1,4 +1,4 @@
-import type { ToSourceFilePath, WorkspaceManifestHandler } from '../util/to-source-path.ts';
+import type { ToSourceFilePath, WorkspacePackageTargetHandler } from '../util/to-source-path.ts';
 import type { ResolveModule } from './ast-nodes.ts';
 type ScopedPaths = Array<{
     scope: string;
@@ -14,5 +14,5 @@ export declare function createGlobAliasResolver(scopedPaths: ScopedPaths | undef
 export declare function createCustomModuleResolver(compilerOptions: {
     scopedPaths?: ScopedPaths;
     scopedRootDirs?: ScopedRootDirs;
-}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler, tsConfigFile?: string): ResolveModule;
+}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler, tsConfigFile?: string): ResolveModule;
 export {};

package/dist/typescript/resolve-module-names.js

@@ -1,7 +1,8 @@
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
-import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from '../constants.js';
-import { sanitizeSpecifier } from '../util/modules.js';
+import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS, IS_DTS } from '../constants.js';
+import { isFile } from '../util/fs.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, toPosix } from '../util/path.js';
 import { _createSyncModuleResolver, _resolveModuleSync } from '../util/resolve.js';
@@ -22,10 +23,81 @@ function pickStringTarget(value) {
             return s;
     }
 }
+const invalidSegments = /(^|\\|\/)((\.|%2e)(\.|%2e)?|node_modules)(\\|\/|$)/i;
+const expandPackageTarget = (target, patternMatch) => {
+    if (!target?.startsWith('./') || invalidSegments.test(target.slice(2)))
+        return;
+    if (!target.includes('*'))
+        return target;
+    if (patternMatch === undefined || invalidSegments.test(patternMatch))
+        return;
+    return target.replaceAll('*', patternMatch);
+};
+const toPackagePath = (dir, target) => {
+    const candidate = join(dir, target);
+    return candidate.startsWith(`${dir}/`) ? candidate : undefined;
+};
+function pickExistingPackageTarget(value, dir, patternMatch, moduleExtensions) {
+    if (typeof value === 'string') {
+        const target = expandPackageTarget(value, patternMatch);
+        if (!target || IS_DTS.test(target) || !moduleExtensions.has(extname(target)))
+            return;
+        const candidate = toPackagePath(dir, target);
+        return candidate && isFile(candidate) ? candidate : undefined;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const target = pickExistingPackageTarget(item, dir, patternMatch, moduleExtensions);
+            if (target)
+                return target;
+        }
+        return;
+    }
+    for (const [condition, child] of Object.entries(value)) {
+        if (condition === 'types')
+            continue;
+        const target = pickExistingPackageTarget(child, dir, patternMatch, moduleExtensions);
+        if (target)
+            return target;
+    }
+}
 const moduleResolutionCaches = [];
+const installedPackageRootCache = new Map();
 export function clearModuleResolutionCaches() {
     for (const cache of moduleResolutionCaches)
         cache.clear();
+    installedPackageRootCache.clear();
+}
+function getInstalledPackageRoot(candidate) {
+    if (installedPackageRootCache.has(candidate))
+        return installedPackageRootCache.get(candidate);
+    let packageRoot;
+    try {
+        packageRoot = toPosix(realpathSync(candidate));
+    }
+    catch { }
+    installedPackageRootCache.set(candidate, packageRoot);
+    return packageRoot;
+}
+function getAttributedPackageName(specifier, containingFile, resolvedFileName) {
+    const packageName = getPackageNameFromFilePath(resolvedFileName);
+    const specifierPackageName = getPackageNameFromModuleSpecifier(specifier);
+    if (!specifierPackageName || specifierPackageName === packageName)
+        return packageName;
+    let dir = dirname(containingFile);
+    while (true) {
+        const packageRoot = getInstalledPackageRoot(join(dir, 'node_modules', specifierPackageName));
+        if (packageRoot) {
+            const isResolvedInstall = resolvedFileName === packageRoot || resolvedFileName.startsWith(`${packageRoot}/`);
+            return isResolvedInstall ? specifierPackageName : packageName;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return packageName;
+        dir = parent;
+    }
 }
 function compilePathMappings(scopedPaths) {
     if (!scopedPaths)
@@ -90,8 +162,9 @@ export function createGlobAliasResolver(scopedPaths) {
         return resolved;
     };
 }
-export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspaceManifestImports, tsConfigFile) {
+export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspacePackageTarget, tsConfigFile) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
+    const moduleExtensions = new Set([...DEFAULT_EXTENSIONS, ...customCompilerExtensions, '.json', '.jsonc']);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS, '.json', '.jsonc'];
     const resolveSync = hasCustomExts || tsConfigFile ? _createSyncModuleResolver(extensions, tsConfigFile) : _resolveModuleSync;
@@ -103,11 +176,15 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         }
         return resolvedFileName;
     }
-    function toResult(resolvedFileName) {
+    function toResult(specifier, containingFile, resolvedFileName) {
         const mapped = toSourcePath(resolvedFileName);
+        const isExternalLibraryImport = mapped === resolvedFileName && isInNodeModules(resolvedFileName);
         return {
             resolvedFileName: mapped,
-            isExternalLibraryImport: mapped === resolvedFileName && isInNodeModules(resolvedFileName),
+            isExternalLibraryImport,
+            packageName: isExternalLibraryImport
+                ? getAttributedPackageName(specifier, containingFile, resolvedFileName)
+                : undefined,
         };
     }
     const cache = new Map();
@@ -133,7 +210,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             return undefined;
         const resolvedFileName = resolveSync(specifier, containingFile);
         if (resolvedFileName)
-            return toResult(resolvedFileName);
+            return toResult(specifier, containingFile, resolvedFileName);
         if (pathMappings) {
             const dir = dirname(containingFile);
             for (const { prefix, wildcard, values, scope } of pathMappings) {
@@ -146,7 +223,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                         const mapped = starIdx >= 0 ? value.slice(0, starIdx) + captured + value.slice(starIdx + 1) : value;
                         const resolved = resolveSync(mapped, containingFile);
                         if (resolved)
-                            return toResult(resolved);
+                            return toResult(specifier, containingFile, resolved);
                     }
                 }
             }
@@ -165,21 +242,23 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                             continue;
                         const resolved = resolveSync(join(targetRoot, relPath, specifier), containingFile);
                         if (resolved)
-                            return toResult(resolved);
+                            return toResult(specifier, containingFile, resolved);
                     }
                 }
             }
         }
-        if (specifier.startsWith('#') && findWorkspaceManifestImports) {
-            const ws = findWorkspaceManifestImports(containingFile);
-            if (ws) {
-                const target = pickStringTarget(ws.imports[specifier]);
-                if (target?.startsWith('.')) {
-                    const sourcePath = toSourceFilePath(join(ws.dir, target));
-                    if (sourcePath)
-                        return toResult(sourcePath);
-                }
+        const workspaceTarget = findWorkspacePackageTarget?.(specifier, containingFile);
+        if (workspaceTarget) {
+            const target = expandPackageTarget(pickStringTarget(workspaceTarget.target), workspaceTarget.patternMatch);
+            if (target) {
+                const targetPath = toPackagePath(workspaceTarget.dir, target);
+                const sourcePath = targetPath && toSourceFilePath(targetPath);
+                if (sourcePath)
+                    return toResult(specifier, containingFile, sourcePath);
             }
+            const existingTarget = pickExistingPackageTarget(workspaceTarget.target, workspaceTarget.dir, workspaceTarget.patternMatch, moduleExtensions);
+            if (existingTarget)
+                return toResult(specifier, containingFile, existingTarget);
         }
         const candidate = isAbsolute(specifier) ? specifier : join(dirname(containingFile), specifier);
         if (existsSync(candidate)) {

package/dist/typescript/visitors/walk.d.ts

@@ -50,6 +50,7 @@ export interface WalkState extends WalkContext {
     filePath: string;
     sourceText: string;
     isJS: boolean;
+    isModuleFile: boolean;
     handledImportExpressions: Set<number>;
     bareExprRefs: Set<string>;
     accessedAliases: Set<string>;
@@ -59,6 +60,7 @@ export interface WalkState extends WalkContext {
     currentVarDeclStart: number;
     nsRanges: [number, number][];
     memberRefsInFile: string[];
+    importedRefs: Set<string> | undefined;
     scopeDepth: number;
     scopeStarts: number[];
     scopeEnds: number[];
@@ -88,6 +90,6 @@ export interface WalkState extends WalkContext {
 }
 export declare const isShadowed: (name: string, pos: number) => boolean;
 export declare function buildVisitor(pluginVisitorObjects: PluginVisitorObject[], includeLocalRefs?: boolean): Visitor;
-declare function walkAST(program: Program, sourceText: string, filePath: string, ctx: WalkContext): Set<string> | undefined;
+declare function walkAST(program: Program, sourceText: string, filePath: string, hasModuleSyntax: boolean, ctx: WalkContext): Set<string> | undefined;
 export declare const _walkAST: typeof walkAST;
 export {};

package/dist/typescript/visitors/walk.js

@@ -155,7 +155,11 @@ export const isShadowed = (name, pos) => {
     return false;
 };
 const _addLocalRef = (name, pos) => {
-    if (!state.localImportMap.has(name) && !isShadowed(name, pos))
+    if (isShadowed(name, pos))
+        return;
+    if (state.localImportMap.has(name))
+        (state.importedRefs ??= new Set()).add(name);
+    else
         state.localRefs.add(name);
 };
 const _addShadowRange = (name, range) => {
@@ -211,7 +215,7 @@ const coreVisitorObject = {
     },
     TSModuleDeclaration(node) {
         state.nsRanges.push([node.start, node.end]);
-        if (node.kind !== 'global' && isStringLiteral(node.id)) {
+        if (node.kind !== 'global' && state.isModuleFile && isStringLiteral(node.id)) {
             const specifier = getStringValue(node.id);
             for (const name of collectAugmentationRefs(node))
                 state.addImport(specifier, name, undefined, undefined, node.id.start, IMPORT_FLAGS.TYPE_ONLY | IMPORT_FLAGS.AUGMENT);
@@ -704,13 +708,24 @@ export function buildVisitor(pluginVisitorObjects, includeLocalRefs) {
     }
     return new Visitor(merged);
 }
-function walkAST(program, sourceText, filePath, ctx) {
+const isExternalModule = (program, hasModuleSyntax) => {
+    if (hasModuleSyntax)
+        return true;
+    for (const node of program.body) {
+        if (node.type === 'TSImportEqualsDeclaration' && node.moduleReference.type === 'TSExternalModuleReference') {
+            return true;
+        }
+    }
+    return false;
+};
+function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
     const isJS = filePath.endsWith('.js') || filePath.endsWith('.mjs') || filePath.endsWith('.cjs') || filePath.endsWith('.jsx');
     state = {
         ...ctx,
         filePath,
         sourceText,
         isJS,
+        isModuleFile: isExternalModule(program, hasModuleSyntax),
         handledImportExpressions: new Set(),
         bareExprRefs: new Set(),
         accessedAliases: new Set(),
@@ -720,6 +735,7 @@ function walkAST(program, sourceText, filePath, ctx) {
         currentVarDeclStart: -1,
         nsRanges: [],
         memberRefsInFile: [],
+        importedRefs: undefined,
         scopeDepth: 0,
         scopeStarts: [],
         scopeEnds: [],
@@ -824,6 +840,14 @@ function walkAST(program, sourceText, filePath, ctx) {
             }
         }
     }
+    if (state.localRefs && state.importedRefs) {
+        for (const name of state.importedRefs) {
+            const exportNames = state.localToExports.get(name);
+            if (exportNames)
+                for (const exportName of exportNames)
+                    state.localRefs.add(exportName);
+        }
+    }
     const localRefs = state.localRefs;
     state = undefined;
     return localRefs;

package/dist/util/codeowners.js

@@ -9,7 +9,7 @@ export function parseCodeowners(content) {
         .map(rule => {
         const [path, ...owners] = rule.split(/\s+/);
         const { pattern } = convertGitignoreToPicomatchIgnorePatterns(path);
-        return { owners, match: picomatch(expandIgnorePatterns([pattern])) };
+        return { owners, match: picomatch(expandIgnorePatterns([pattern], true)) };
     });
     return (filePath) => {
         for (const matcher of [...matchers].reverse()) {

package/dist/util/create-input-handler.js

@@ -55,7 +55,14 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
-            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input), input.isTypeOnly);
+            let isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input), input.isTypeOnly);
+            if (input.isTypeOnly && input.containingFilePath) {
+                const owningWorkspace = chief.findWorkspaceByFilePath(input.containingFilePath);
+                if (owningWorkspace && owningWorkspace !== inputWorkspace) {
+                    const isOwnerHandled = deputy.maybeAddReferencedExternalDependency(owningWorkspace, packageName, isConfig(input), input.isTypeOnly);
+                    isHandled = isHandled || isOwnerHandled;
+                }
+            }
             if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }

package/dist/util/create-options.d.ts

@@ -460,6 +460,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             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;
@@ -745,6 +750,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        temporal?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1368,6 +1378,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 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;
@@ -1653,6 +1668,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            temporal?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             travis?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/glob-cache.d.ts

@@ -1,3 +1,4 @@
+import type { FSLike } from 'fdir';
 export declare const initGlobCache: (cacheLocation: string) => void;
 export declare const isGlobCacheEnabled: () => boolean;
 export declare const flushGlobCache: () => void;
@@ -7,6 +8,11 @@ export declare const computeGlobCacheKey: (input: {
     cwd: string;
     dir: string;
     gitignore: boolean;
+    gitignoreFingerprint: string;
 }) => string;
 export declare const getCachedGlob: (key: string) => string[] | undefined;
-export declare const setCachedGlob: (key: string, paths: string[], baseDir: string) => void;
+export declare const createDirTracker: () => {
+    dirs: Set<string>;
+    fs: Partial<FSLike>;
+};
+export declare const setCachedGlob: (key: string, paths: string[], baseDir: string, dirs?: Iterable<string>) => void;

package/dist/util/glob-cache.js

@@ -1,12 +1,18 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
-import { createDiskCache, mtimeMatches } from './disk-cache.js';
-import { dirname } from './path.js';
+import { createDiskCache } from './disk-cache.js';
 const store = createDiskCache('glob');
-export const initGlobCache = store.init;
+const dirMtimeCache = new Map();
+export const initGlobCache = (cacheLocation) => {
+    dirMtimeCache.clear();
+    store.init(cacheLocation);
+};
 export const isGlobCacheEnabled = store.isEnabled;
 export const flushGlobCache = store.flush;
-export const clearGlobCache = store.clear;
+export const clearGlobCache = () => {
+    dirMtimeCache.clear();
+    store.clear();
+};
 export const computeGlobCacheKey = (input) => {
     const h = createHash('sha1');
     h.update(input.cwd);
@@ -15,15 +21,31 @@ export const computeGlobCacheKey = (input) => {
     h.update('\0');
     h.update(input.gitignore ? '1' : '0');
     h.update('\0');
+    h.update(input.gitignoreFingerprint);
+    h.update('\0');
     for (const p of input.patterns) {
         h.update(p);
         h.update('\0');
     }
     return h.digest('base64url');
 };
+const statDirMtime = (dir) => {
+    let mtime = dirMtimeCache.get(dir);
+    if (mtime === undefined) {
+        try {
+            const stat = fs.statSync(dir);
+            mtime = stat.isDirectory() ? stat.mtimeMs : Number.NaN;
+        }
+        catch {
+            mtime = Number.NaN;
+        }
+        dirMtimeCache.set(dir, mtime);
+    }
+    return mtime;
+};
 const validateEntry = (entry) => {
     for (const dir in entry.dirMtimes) {
-        if (!mtimeMatches(dir, entry.dirMtimes[dir]))
+        if (statDirMtime(dir) !== entry.dirMtimes[dir])
             return false;
     }
     return true;
@@ -38,33 +60,34 @@ export const getCachedGlob = (key) => {
     }
     return entry.paths;
 };
-const captureDirMtimes = (paths, baseDir) => {
+const trackReads = (native, dirs) => {
+    const tracked = function (path, ...rest) {
+        if (typeof path === 'string')
+            dirs.add(path);
+        return native.call(this, path, ...rest);
+    };
+    return tracked;
+};
+export const createDirTracker = () => {
     const dirs = new Set();
-    dirs.add(baseDir);
-    for (const p of paths) {
-        let d = dirname(p);
-        while (d.length >= baseDir.length) {
-            if (dirs.has(d))
-                break;
-            dirs.add(d);
-            const parent = dirname(d);
-            if (parent === d)
-                break;
-            d = parent;
-        }
-    }
+    return { dirs, fs: { readdir: trackReads(fs.readdir, dirs), readdirSync: trackReads(fs.readdirSync, dirs) } };
+};
+const stripTrailingSlash = (dir) => (dir.length > 1 && dir.endsWith('/') ? dir.slice(0, -1) : dir);
+const captureDirMtimes = (dirs, baseDir) => {
     const result = {};
-    for (const d of dirs) {
-        try {
-            const stat = fs.statSync(d);
-            if (stat.isDirectory())
-                result[d] = stat.mtimeMs;
-        }
-        catch {
-        }
+    const baseMtime = statDirMtime(baseDir);
+    if (!Number.isNaN(baseMtime))
+        result[baseDir] = baseMtime;
+    for (const dir of dirs) {
+        const d = stripTrailingSlash(dir);
+        if (d in result)
+            continue;
+        const mtime = statDirMtime(d);
+        if (!Number.isNaN(mtime))
+            result[d] = mtime;
     }
     return result;
 };
-export const setCachedGlob = (key, paths, baseDir) => {
-    store.set(key, { paths, dirMtimes: captureDirMtimes(paths, baseDir) });
+export const setCachedGlob = (key, paths, baseDir, dirs = []) => {
+    store.set(key, { paths, dirMtimes: captureDirMtimes(dirs, baseDir) });
 };