knip 6.26.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;
@@ -757,6 +762,11 @@ export declare class ConfigurationChief {
             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;
@@ -1047,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;
@@ -1104,6 +1115,7 @@ export declare class ConfigurationChief {
         "tanstack-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         taskfile?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tauri?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        temporal?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -58,7 +58,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean, isResolved?: boolean): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {

package/dist/DependencyDeputy.js

@@ -122,10 +122,10 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly) {
+    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;
@@ -150,7 +150,7 @@ export class DependencyDeputy {
             this.addReferencedDependency(workspace.name, packageName);
             return true;
         }
-        if (!this.isStrict) {
+        if (!this.isStrict && isResolved !== false) {
             for (const name of workspaceNames) {
                 const hosts = this.getHostDependenciesFor(name, packageName);
                 if (hosts.length === 0)

package/dist/ProjectPrincipal.d.ts

@@ -7,7 +7,7 @@ import type { Paths } from './types/project.ts';
 import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
-import type { ToSourceFilePath, WorkspaceManifestHandler } from './util/to-source-path.ts';
+import type { ToSourceFilePath, WorkspacePackageTargetHandler } from './util/to-source-path.ts';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
@@ -25,14 +25,14 @@ export declare class ProjectPrincipal {
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
-    private findWorkspaceManifestImports;
+    private findWorkspacePackageTarget;
     fileManager: SourceFileManager;
     private resolveModule;
     resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;
-    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;

package/dist/ProjectPrincipal.js

@@ -35,17 +35,17 @@ export class ProjectPrincipal {
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
-    findWorkspaceManifestImports;
+    findWorkspacePackageTarget;
     fileManager;
     resolveModule = () => undefined;
     resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
-    constructor(options, toSourceFilePath, findWorkspaceManifestImports) {
+    constructor(options, toSourceFilePath, findWorkspacePackageTarget) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
-        this.findWorkspaceManifestImports = findWorkspaceManifestImports;
+        this.findWorkspacePackageTarget = findWorkspacePackageTarget;
         this.tsConfigFile = options.tsConfigFile ? toAbsolute(options.tsConfigFile, options.cwd) : undefined;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
@@ -91,7 +91,7 @@ export class ProjectPrincipal {
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
-        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports, this.tsConfigFile);
+        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspacePackageTarget, this.tsConfigFile);
         this.resolveGlobPattern = createGlobAliasResolver(scopedPaths);
     }
     readFile(filePath) {

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/binaries/fallback.js

@@ -7,7 +7,11 @@ const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode',
 const positionalBinaries = new Set(['concurrently']);
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
-    const bin = binary.startsWith('.') ? toEntry(binary) : isValidBinary(binary) ? toBinary(binary) : undefined;
+    const bin = binary.startsWith('.') || binary.includes('/')
+        ? toEntry(binary)
+        : isValidBinary(binary)
+            ? toBinary(binary)
+            : undefined;
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
     const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
     const commands = positionalBinaries.has(binary) ? parsed._.flatMap(cmd => fromArgs([cmd])) : [];

package/dist/binaries/resolvers/bun.js

@@ -2,6 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
+import { argsAfter, expandScript } from '../util.js';
 import { resolveX } from './bunx.js';
 const commands = new Set([
     'add',
@@ -59,10 +60,12 @@ export const resolve = (_binary, args, options) => {
         return [binary, ...resolveX(argsForX, options)];
     }
     const { manifest, cwd, fromArgs } = options;
-    if (command === 'run' && manifest.scriptNames.has(script))
-        return [binary];
-    if (manifest.scriptNames.has(command))
-        return [binary];
+    if (command === 'run' && manifest.scriptNames.has(script)) {
+        return [binary, ...(expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? [])];
+    }
+    if (manifest.scriptNames.has(command)) {
+        return [binary, ...(expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? [])];
+    }
     if (command !== 'run' && commands.has(command))
         return [binary];
     const filePath = command === 'run' ? script : command;
@@ -74,5 +77,10 @@ export const resolve = (_binary, args, options) => {
         return [binary, toEntry(resolved)];
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
-    return command === 'run' ? [binary] : [binary, ...fromArgs(args, opts)];
+    if (command !== 'run')
+        return [binary, ...fromArgs(args, opts)];
+    const input = toBinary(filePath, { optional: true });
+    if (dir)
+        input.dir = dir;
+    return [binary, input];
 };

package/dist/binaries/resolvers/npm.js

@@ -1,4 +1,5 @@
 import parseArgs from '../../util/parse-args.js';
+import { expandScript } from '../util.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs, manifest } = options;
     const parsed = parseArgs(args, { '--': true });
@@ -6,7 +7,8 @@ export const resolve = (_binary, args, options) => {
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec')
         return _childArgs;
-    if (command === 'run' && manifest.scriptNames.has(script))
-        return _childArgs;
+    if (command === 'run' && manifest.scriptNames.has(script)) {
+        return expandScript(script, parsed['--'] ?? [], manifest.scripts, options) ?? _childArgs;
+    }
     return [];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -1,6 +1,7 @@
 import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
+import { argsAfter, expandScript } from '../util.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
@@ -98,8 +99,17 @@ export const resolve = (_binary, args, options) => {
     if (command === 'exec') {
         return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
     }
+    if (command === 'run') {
+        const script = parsed._[1];
+        if (script && manifest.scriptNames.has(script)) {
+            return expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? childInputs;
+        }
+        return childInputs;
+    }
     const isScript = manifest.scriptNames.has(command);
-    if (isScript || commands.includes(command))
+    if (isScript)
+        return expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? childInputs;
+    if (commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];
 };

package/dist/binaries/resolvers/yarn.js

@@ -2,7 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
-import { argsFrom } from '../util.js';
+import { argsAfter, argsFrom, expandScript } from '../util.js';
 const commands = [
     'add',
     'bin',
@@ -58,8 +58,10 @@ export const resolve = (_binary, args, options) => {
     const dirManifest = (dir && getManifest(dir)) || manifest;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (dirManifest.scriptNames.has(binary))
-            return _childArgs;
+        if (dirManifest.scriptNames.has(binary)) {
+            const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
+            return expandScript(binary, argsAfter(args, binary), dirManifest.scripts, options, opts) ?? _childArgs;
+        }
         const bin = toBinary(binary, { optional: true });
         if (dir)
             Object.assign(bin, { dir });
@@ -71,7 +73,11 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if (dirManifest.scriptNames.has(command) || commands.includes(command))
+    if (dirManifest.scriptNames.has(command)) {
+        const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
+        return expandScript(command, argsAfter(args, command), dirManifest.scripts, options, opts) ?? _childArgs;
+    }
+    if (commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/binaries/util.d.ts

@@ -1,2 +1,6 @@
+import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
+import type { Input } from '../util/input.ts';
 export declare const argsFrom: (args: string[], from: string) => string[];
+export declare const argsAfter: (args: string[], token: string) => string[];
+export declare const expandScript: (name: string, forwardedArgs: string[], scripts: Record<string, string> | undefined, options: BinaryResolverOptions, opts?: Partial<GetInputsFromScriptsOptions>) => Input[] | undefined;
 export declare const parseNodeArgs: (args: string[]) => import("../util/parse-args.ts").ParsedArgs;

package/dist/binaries/util.js

@@ -1,5 +1,19 @@
 import parseArgs from '../util/parse-args.js';
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));
+export const argsAfter = (args, token) => {
+    const index = args.indexOf(token);
+    return index === -1 ? [] : args.slice(index + 1).filter(arg => arg !== '--');
+};
+export const expandScript = (name, forwardedArgs, scripts, options, opts = {}) => {
+    const source = scripts?.[name];
+    if (!source || forwardedArgs.length === 0)
+        return;
+    const expandedScripts = options.expandedScripts ?? new Set();
+    if (expandedScripts.has(name))
+        return;
+    expandedScripts.add(name);
+    return options.fromArgs([source, ...forwardedArgs], { ...opts, expandedScripts });
+};
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],
     alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },

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;
@@ -703,6 +708,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         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;
@@ -1324,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;
@@ -1609,6 +1624,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             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/compilers/less.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['less'];
-const importMatcher = /@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
 const isExternalUrl = (s) => s.startsWith('//') || s.startsWith('http://') || s.startsWith('https://');
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);

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/compilers/scss.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
-const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');

package/dist/compilers/stylus.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['stylus'];
-const importMatcher = /@(?:import|require)\s+['"]([^'"]+)['"]/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:import|require)\s+['"]([^'"]+)['"]/g;
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     if (name.endsWith('.styl') || name.endsWith('.stylus') || name.endsWith('.css'))

package/dist/constants.js

@@ -36,6 +36,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'chmod',
     'chown',
     'cksum',
+    'claude',
     'clear',
     'cmd',
     'cmd.exe',
@@ -49,6 +50,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'curl',
     'cut',
     'date',
+    'defaults',
     'deno',
     'devtunnel',
     'df',
@@ -66,7 +68,9 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'factor',
     'false',
     'find',
+    'fuser',
     'gem',
+    'getconf',
     'gh',
     'git',
     'grep',
@@ -77,9 +81,11 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'id',
     'join',
     'kill',
+    'launchctl',
     'ln',
     'logname',
     'ls',
+    'lsof',
     'md5sum',
     'mkdir',
     'mknod',
@@ -102,13 +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',
@@ -124,13 +134,19 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'stat',
     'stty',
     'sudo',
+    'sw_vers',
     'sync',
+    'sysctl',
+    'systemctl',
     'tac',
     'tar',
+    'taskkill',
     'tee',
     'test',
     'time',
     'timeout',
+    'tmux',
+    'tmuxinator',
     'touch',
     'trap',
     'tr',
@@ -142,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';
@@ -193,7 +195,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName &&
-                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly);
+                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly, extImport.filePath !== undefined);
                         if (!isHandled)
                             collector.addIssue({
                                 type: 'unlisted',

package/dist/graph/build.js

@@ -18,6 +18,7 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '../util/path.js';
+import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }) {
@@ -331,10 +332,21 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     file.imports.external.add({ ...unresolvedImport, specifier: sanitizedSpecifier });
                 }
                 else {
-                    if (!isGitIgnored(join(dirname(filePath), sanitizedSpecifier))) {
-                        const ext = extname(sanitizedSpecifier);
-                        if (!ext || (ext !== '.json' && !FOREIGN_FILE_EXTENSIONS.has(ext)))
-                            unresolvedImports.add(unresolvedImport);
+                    const candidate = join(dirname(filePath), sanitizedSpecifier);
+                    const ext = extname(sanitizedSpecifier);
+                    const aliases = extensionAlias[ext];
+                    let isIgnored = isGitIgnored(candidate);
+                    if (!isIgnored && aliases) {
+                        const basePath = candidate.slice(0, -ext.length);
+                        for (const alias of aliases) {
+                            if (alias !== ext && isGitIgnored(basePath + alias)) {
+                                isIgnored = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!isIgnored && (!ext || (ext !== '.json' && !FOREIGN_FILE_EXTENSIONS.has(ext)))) {
+                        unresolvedImports.add(unresolvedImport);
                     }
                 }
             }

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