xo 3.0.1 → 4.0.0

package/dist/lib/handle-ts-files.d.ts

@@ -1,21 +1,14 @@
-import ts from 'typescript';
 /**
-This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
+This function checks if the files are matched by the tsconfig include/exclude, and returns the unmatched files.
 
-If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
+All unincluded files are routed through a generated tsconfig (`parserOptions.project`) so that autofix works correctly across multiple ESLint passes. The in-memory Program approach is intentionally not used here because `@typescript-eslint/typescript-estree` always returns the AST built from the original file text when using `parserOptions.programs`, ignoring the updated `code` ESLint passes on subsequent fix passes, which causes file corruption.
 
 @param options - The options for handling the tsconfig.
 @param options.files - The TypeScript files to check against the tsconfig.
 @param options.cwd - The current working directory.
-@param options.cacheLocation - The cache directory used to detect virtual/stdin files.
-@returns The unmatched files and an in-memory TypeScript Program.
+@returns The unincluded files.
 */
-export declare function handleTsconfig({ files, cwd, cacheLocation }: {
+export declare function handleTsconfig({ files, cwd }: {
     files: string[];
     cwd: string;
-    cacheLocation?: string;
-}): {
-    existingFiles: string[];
-    virtualFiles: string[];
-    program: ts.Program | undefined;
-};
+}): string[];

package/dist/lib/handle-ts-files.js

@@ -1,9 +1,7 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import ts from 'typescript';
 import { getTsconfig, createFilesMatcher } from 'get-tsconfig';
-import { tsconfigDefaults } from './constants.js';
 let hasWarnedAboutTypeScriptVersion = false;
 /**
 Warns once if the project's own TypeScript is an older major than the version XO bundles. Mixing TypeScript versions in one process can crash type-aware linting (notably under pnpm), because the TypeFlags enum was renumbered in TypeScript 6.
@@ -29,65 +27,17 @@ const warnOnOutdatedProjectTypeScript = (cwd) => {
     hasWarnedAboutTypeScriptVersion = true;
     console.warn(`XO bundles TypeScript ${ts.version}, but your project has TypeScript ${projectVersion}. Mixing TypeScript versions in one process can crash type-aware linting (notably with pnpm). Upgrade your project's \`typescript\` to ${bundledMajor} or later, or pin it (for example, a pnpm \`overrides\` entry).`);
 };
-const createInMemoryProgram = (files, cwd) => {
-    if (files.length === 0) {
-        return undefined;
-    }
-    try {
-        const compilerOptions = getFallbackCompilerOptions(cwd);
-        const program = ts.createProgram(files, { ...compilerOptions });
-        Object.defineProperty(program, 'toJSON', {
-            value: () => ({
-                __type: 'TypeScriptProgram',
-                files: files.map(file => path.relative(cwd, file)),
-            }),
-            configurable: true,
-        });
-        return program;
-    }
-    catch (error) {
-        console.warn('XO: Failed to create TypeScript Program for type-aware linting. Continuing without type information for unincluded files.', error instanceof Error ? error.message : String(error));
-        return undefined;
-    }
-};
-const fallbackCompilerOptionsCache = new Map();
-const getFallbackCompilerOptions = (cwd) => {
-    const cacheKey = path.resolve(cwd);
-    const cached = fallbackCompilerOptionsCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const compilerOptionsResult = ts.convertCompilerOptionsFromJson(tsconfigDefaults.compilerOptions ?? {}, cacheKey);
-    if (compilerOptionsResult.errors.length > 0) {
-        throw new Error('XO: Invalid default TypeScript compiler options');
-    }
-    const compilerOptions = {
-        ...compilerOptionsResult.options,
-        // Anchor module and `@types` resolution to the project directory. Without `configFilePath`, an option-only program resolves these from `process.cwd()`, which differs from `cwd` for programmatic callers. The file need not exist; only its directory is used.
-        configFilePath: path.join(cacheKey, 'tsconfig.json'),
-        esModuleInterop: true,
-        resolveJsonModule: true,
-        allowJs: true,
-        skipLibCheck: true,
-        skipDefaultLibCheck: true,
-        // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, files outside the tsconfig resolve imports to `any` and type-aware rules misfire.
-        types: ['*'],
-    };
-    fallbackCompilerOptionsCache.set(cacheKey, compilerOptions);
-    return compilerOptions;
-};
 /**
-This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
+This function checks if the files are matched by the tsconfig include/exclude, and returns the unmatched files.
 
-If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
+All unincluded files are routed through a generated tsconfig (`parserOptions.project`) so that autofix works correctly across multiple ESLint passes. The in-memory Program approach is intentionally not used here because `@typescript-eslint/typescript-estree` always returns the AST built from the original file text when using `parserOptions.programs`, ignoring the updated `code` ESLint passes on subsequent fix passes, which causes file corruption.
 
 @param options - The options for handling the tsconfig.
 @param options.files - The TypeScript files to check against the tsconfig.
 @param options.cwd - The current working directory.
-@param options.cacheLocation - The cache directory used to detect virtual/stdin files.
-@returns The unmatched files and an in-memory TypeScript Program.
+@returns The unincluded files.
 */
-export function handleTsconfig({ files, cwd, cacheLocation }) {
+export function handleTsconfig({ files, cwd }) {
     warnOnOutdatedProjectTypeScript(cwd);
     const unincludedFiles = [];
     const filesMatcherCache = new Map();
@@ -108,39 +58,6 @@ export function handleTsconfig({ files, cwd, cacheLocation }) {
         }
         unincludedFiles.push(filePath);
     }
-    if (unincludedFiles.length === 0) {
-        return { existingFiles: [], virtualFiles: [], program: undefined };
-    }
-    // Separate real files from virtual/cache files
-    // Virtual files include: stdin files (in cache dir), non-existent files
-    // TypeScript will surface opaque diagnostics for missing files; pre-filter so we only pay the program cost for real files.
-    const existingFiles = [];
-    const virtualFiles = [];
-    for (const file of unincludedFiles) {
-        // Files that don't exist are always virtual
-        if (!fs.existsSync(file)) {
-            virtualFiles.push(file);
-            continue;
-        }
-        // Check if file is in cache directory (like stdin files)
-        // These need tsconfig treatment even though they exist on disk
-        if (cacheLocation !== undefined) {
-            const absolutePath = path.resolve(file);
-            const cacheRoot = path.resolve(cacheLocation);
-            const relativeToCache = path.relative(cacheRoot, absolutePath);
-            // File is inside cache if relative path doesn't escape (no '..')
-            const isInCache = !relativeToCache.startsWith('..') && !path.isAbsolute(relativeToCache);
-            if (isInCache) {
-                virtualFiles.push(file);
-                continue;
-            }
-        }
-        existingFiles.push(file);
-    }
-    return {
-        existingFiles,
-        virtualFiles,
-        program: createInMemoryProgram(existingFiles, cwd),
-    };
+    return unincludedFiles;
 }
 //# sourceMappingURL=handle-ts-files.js.map

package/dist/lib/open-report.js

@@ -23,8 +23,8 @@ const resultToFile = (result) => {
         column: message?.column,
     };
 };
-const getFiles = (report, predicate) => report.results
-    .filter(result => predicate(result))
+const getFiles = (report, isMatchingResult) => report.results
+    .filter(result => isMatchingResult(result))
     .toSorted(sortResults)
     .map(result => resultToFile(result));
 const openReport = async (report) => {

package/dist/lib/xo.d.ts

@@ -23,13 +23,11 @@ export declare class Xo {
     private prepareEslintConfig;
     private discoverFiles;
     /**
-    Add virtual files to the config with a tsconfig approach.
-    */
-    private addVirtualFilesToConfig;
-    /**
-    Add existing files to the config with an in-memory TypeScript Program.
+    Add unincluded files to the config with a generated tsconfig approach. Passing an empty array removes the generated config entry.
+
+    This uses `parserOptions.project` rather than an in-memory `parserOptions.programs`. A pre-built program's AST is built once from the original file text and is never updated between ESLint's multiple `--fix` passes, so stale offsets corrupt the output. A file-based project is re-read on each pass, so autofix stays correct.
     */
-    private addExistingFilesToConfig;
+    private addUnincludedFilesToConfig;
     private processReport;
     private getReportStatistics;
     /**
@@ -40,13 +38,13 @@ export declare class Xo {
     Sets the XO config on the XO instance.
     */
     setXoConfig(): Promise<void>;
-    setEslintConfig(cliIgnores?: string[], stripDefaultIgnores?: boolean): void;
+    setEslintConfig(cliIgnores?: string[], shouldStripDefaultIgnores?: boolean): void;
     /**
     Ensures the cache directory exists. This needs to run once before both tsconfig handling and running ESLint occur.
     */
     ensureCacheDirectory(): Promise<void>;
     /**
-    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to an in-memory TypeScript Program for type aware linting.
+    Checks every TS file to ensure it is included in the tsconfig. Any that are not included are routed through a generated tsconfig (`tsconfig.generated.json`) so that autofix works correctly across multiple ESLint passes.
 
     @param files - The TypeScript files being linted.
     */
@@ -54,7 +52,7 @@ export declare class Xo {
     /**
     Initializes the ESLint instance on the XO instance.
     */
-    initEslint(files?: string[], cliIgnores?: string[], stripDefaultIgnores?: boolean): Promise<void>;
+    initEslint(files?: string[], cliIgnores?: string[], shouldStripDefaultIgnores?: boolean): Promise<void>;
     /**
     Create an ESLint flat config for editor integrations using the same XO pipeline as the CLI.
     */

package/dist/lib/xo.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import syncFs from 'node:fs';
 import fs from 'node:fs/promises';
 import process from 'node:process';
+import { createHash } from 'node:crypto';
 import { ESLint } from 'eslint';
 import findCacheDirectory from 'find-cache-directory';
 import { globby, isDynamicPattern } from 'globby';
@@ -38,17 +39,28 @@ const createIgnoredLintResult = (filePath) => ({
     usedDeprecatedRules: [],
 });
 const normalizeGlobPath = (filePath) => filePath.split(path.sep).join('/');
-const pathMatchesPattern = (filePath, pattern) => micromatch.isMatch(normalizeGlobPath(filePath), normalizeGlobPath(pattern), { dot: true });
+const isPathMatchingPattern = (filePath, pattern) => micromatch.isMatch(normalizeGlobPath(filePath), normalizeGlobPath(pattern), { dot: true });
+const isPathInside = (parentPath, childPath) => {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+};
+const getGeneratedTsconfigPath = (directory, files) => {
+    const hash = createHash('sha256')
+        .update(JSON.stringify(files.toSorted((first, second) => first.localeCompare(second))))
+        .digest('hex')
+        .slice(0, 16);
+    return path.join(directory, `tsconfig.generated.${hash}.json`);
+};
 const isIgnoredByPatterns = (filePath, patterns) => {
     let isIgnored = false;
     for (const pattern of patterns) {
         if (pattern.startsWith('!')) {
-            if (pathMatchesPattern(filePath, pattern.slice(1))) {
+            if (isPathMatchingPattern(filePath, pattern.slice(1))) {
                 isIgnored = false;
             }
             continue;
         }
-        if (pathMatchesPattern(filePath, pattern)) {
+        if (isPathMatchingPattern(filePath, pattern)) {
             isIgnored = true;
         }
     }
@@ -117,7 +129,7 @@ const stripDefaultIgnoreConfigs = (configs) => configs.map(configItem => {
     const { ignores: _ignored, ...configWithoutIgnores } = configItem;
     return configWithoutIgnores;
 });
-const defaultIgnoreOverlapsReopenedPattern = (defaultIgnore, pattern) => {
+const doesDefaultIgnoreOverlapReopenedPattern = (defaultIgnore, pattern) => {
     const { base, isGlob } = micromatch.scan(pattern, { parts: true });
     const patternDirname = path.posix.dirname(pattern);
     const reopenedBase = isGlob ? base : (patternDirname === '' ? pattern : patternDirname);
@@ -133,7 +145,7 @@ const defaultIgnoreOverlapsReopenedPattern = (defaultIgnore, pattern) => {
 const getReopenedDefaultPatterns = (patterns) => patterns
     .filter(pattern => pattern.startsWith('!'))
     .map(pattern => pattern.slice(1))
-    .filter(pattern => defaultIgnores.some(defaultIgnore => defaultIgnoreOverlapsReopenedPattern(defaultIgnore, pattern)));
+    .filter(pattern => defaultIgnores.some(defaultIgnore => doesDefaultIgnoreOverlapReopenedPattern(defaultIgnore, pattern)));
 /**
 XO only compensates for negations that reopen its built-in default ignores.
 User-provided positive ignores are still used only for pruning.
@@ -162,7 +174,7 @@ const discoverLintFiles = async ({ cwd, globs, positiveGlobalIgnores, discoveryI
     const reopenedFiles = await globby(globs, {
         ignore: [
             ...positiveGlobalIgnores,
-            ...defaultIgnores.filter(defaultIgnore => reopenedDefaultPatterns.every(pattern => !defaultIgnoreOverlapsReopenedPattern(defaultIgnore, pattern))),
+            ...defaultIgnores.filter(defaultIgnore => reopenedDefaultPatterns.every(pattern => !doesDefaultIgnoreOverlapReopenedPattern(defaultIgnore, pattern))),
         ],
         onlyFiles: true,
         gitignore: true,
@@ -233,6 +245,14 @@ export class Xo {
     */
     #cacheLocation;
     /**
+    Directory for generated tsconfigs for unincluded TypeScript files.
+    */
+    #generatedTsconfigDirectory;
+    /**
+    File path to the currently active generated tsconfig.
+    */
+    #currentGeneratedTsconfigPath;
+    /**
     XO config derived from both the base config and the resolved flat config.
     */
     #xoConfig;
@@ -258,17 +278,6 @@ export class Xo {
     We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
     */
     #tsFilesIgnoresGlob = [];
-    /**
-    Store per-file configs separately from base config to prevent unbounded array growth.
-    Key: file path, Value: config for that file.
-    This prevents memory bloat in long-running processes (e.g., language servers).
-    */
-    #fileConfigs = new Map();
-    /**
-    Track virtual/stdin files that share a single tsconfig.stdin.json.
-    These are handled differently from regular files.
-    */
-    #virtualFiles = new Set();
     constructor(_linterOptions, _baseXoConfig = {}) {
         this.#linterOptions = _linterOptions;
         this.#baseXoConfig = _baseXoConfig;
@@ -284,15 +293,18 @@ export class Xo {
         }
         const backupCacheLocation = path.join(os.tmpdir(), cacheDirName);
         this.#cacheLocation = findCacheDirectory({ name: cacheDirName, cwd: this.#linterOptions.cwd }) ?? backupCacheLocation;
+        this.#generatedTsconfigDirectory = isPathInside(this.#linterOptions.cwd, this.#cacheLocation)
+            ? this.#cacheLocation
+            : path.join(this.#linterOptions.cwd, 'node_modules', '.cache', cacheDirName);
     }
     /**
     Initializes the ESLint flat config on the XO instance.
     */
-    async prepareEslintConfig(files, cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
+    async prepareEslintConfig(files, cliIgnores = arrify(this.#baseXoConfig.ignores), shouldStripDefaultIgnores = false) {
         await this.setXoConfig();
         await this.ensureCacheDirectory();
         await this.handleUnincludedTsFiles(files);
-        this.setEslintConfig(cliIgnores, stripDefaultIgnores);
+        this.setEslintConfig(cliIgnores, shouldStripDefaultIgnores);
         if (!this.#eslintConfig) {
             throw new Error('"Xo.prepareEslintConfig" failed');
         }
@@ -320,100 +332,74 @@ export class Xo {
         };
     }
     /**
-    Add virtual files to the config with a tsconfig approach.
+    Add unincluded files to the config with a generated tsconfig approach. Passing an empty array removes the generated config entry.
+
+    This uses `parserOptions.project` rather than an in-memory `parserOptions.programs`. A pre-built program's AST is built once from the original file text and is never updated between ESLint's multiple `--fix` passes, so stale offsets corrupt the output. A file-based project is re-read on each pass, so autofix stays correct.
     */
-    async addVirtualFilesToConfig(files) {
+    async addUnincludedFilesToConfig(files) {
         if (!this.#xoConfig) {
             return;
         }
         try {
-            const nextVirtualFiles = new Set(files);
-            const tsconfigPath = path.join(this.#cacheLocation, 'tsconfig.stdin.json');
-            const configIndex = this.#xoConfig.findIndex(configItem => {
-                const { languageOptions } = configItem;
-                const parserOptions = languageOptions?.['parserOptions'];
-                return parserOptions?.project === tsconfigPath;
-            });
-            if (nextVirtualFiles.size > 0) {
-                const filesArray = [...nextVirtualFiles];
-                const relativeFiles = filesArray.map(file => path.relative(this.#linterOptions.cwd, file));
-                const tsconfigContent = {
-                    compilerOptions: {
-                        ...tsconfigDefaults.compilerOptions,
-                        module: 'ESNext',
-                        moduleResolution: 'NodeNext',
-                        esModuleInterop: true,
-                        skipLibCheck: true,
-                        // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, virtual/stdin files resolve imports to `any` and type-aware rules misfire.
-                        types: ['*'],
-                    },
-                    files: filesArray,
-                };
-                await fs.writeFile(tsconfigPath, JSON.stringify(tsconfigContent, null, 2));
-                if (configIndex === -1) {
-                    const parserOptions = {
-                        projectService: false,
-                        project: tsconfigPath,
-                        tsconfigRootDir: this.#linterOptions.cwd,
-                    };
-                    this.#xoConfig.push({
-                        files: relativeFiles,
-                        languageOptions: {
-                            parser: typescriptParser,
-                            parserOptions,
-                        },
-                    });
+            const previousTsconfigPath = this.#currentGeneratedTsconfigPath;
+            const configIndex = previousTsconfigPath === undefined
+                ? -1
+                : this.#xoConfig.findIndex(configItem => {
+                    const { languageOptions } = configItem;
+                    const parserOptions = languageOptions?.['parserOptions'];
+                    return parserOptions?.project === previousTsconfigPath;
+                });
+            if (files.length === 0) {
+                if (configIndex !== -1) {
+                    this.#xoConfig.splice(configIndex, 1);
                 }
-                else {
-                    const existingConfig = this.#xoConfig[configIndex];
-                    this.#xoConfig[configIndex] = {
-                        ...existingConfig,
-                        files: relativeFiles,
-                    };
-                }
-                this.#virtualFiles.clear();
-                for (const file of nextVirtualFiles) {
-                    this.#virtualFiles.add(file);
+                if (previousTsconfigPath !== undefined) {
+                    this.#currentGeneratedTsconfigPath = undefined;
                 }
                 return;
             }
-            if (configIndex >= 0) {
-                this.#xoConfig.splice(configIndex, 1);
+            const tsconfigPath = getGeneratedTsconfigPath(this.#generatedTsconfigDirectory, files);
+            // The generated tsconfig references files by absolute path; the ESLint config matches them by path relative to `cwd`.
+            const relativeFiles = files.map(file => path.relative(this.#linterOptions.cwd, file));
+            const tsconfigContent = {
+                compilerOptions: {
+                    ...tsconfigDefaults.compilerOptions,
+                    module: 'ESNext',
+                    moduleResolution: 'NodeNext',
+                    esModuleInterop: true,
+                    resolveJsonModule: true,
+                    skipLibCheck: true,
+                    // JS files are routed here too (type-aware rules apply to JS). Without `allowJs`, TypeScript does not load them as source files, so the parser reports "file not found in project".
+                    allowJs: true,
+                    // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, unincluded files resolve imports to `any` and type-aware rules misfire.
+                    types: ['*'],
+                },
+                files,
+            };
+            await fs.mkdir(path.dirname(tsconfigPath), { recursive: true });
+            await fs.writeFile(tsconfigPath, JSON.stringify(tsconfigContent, null, 2));
+            this.#currentGeneratedTsconfigPath = tsconfigPath;
+            const parserOptions = {
+                projectService: false,
+                project: tsconfigPath,
+                tsconfigRootDir: this.#linterOptions.cwd,
+            };
+            const generatedConfig = {
+                files: relativeFiles,
+                languageOptions: {
+                    parser: typescriptParser,
+                    parserOptions,
+                },
+            };
+            if (configIndex === -1) {
+                this.#xoConfig.push(generatedConfig);
+            }
+            else {
+                this.#xoConfig[configIndex] = generatedConfig;
             }
-            this.#virtualFiles.clear();
-            await fs.rm(tsconfigPath, { force: true });
         }
         catch (error) {
-            console.warn('XO: Failed to create tsconfig for virtual files. Type-aware linting will be disabled for these files.', error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-    Add existing files to the config with an in-memory TypeScript Program.
-    */
-    addExistingFilesToConfig(files, program) {
-        if (!this.#xoConfig || files.length === 0) {
-            return;
-        }
-        const parserOptions = {
-            project: false,
-            projectService: false,
-        };
-        if (program) {
-            parserOptions.programs = [program];
-        }
-        const config = {
-            files: files.map(file => path.relative(this.#linterOptions.cwd, file)),
-            languageOptions: {
-                parser: typescriptParser,
-                parserOptions,
-            },
-        };
-        // IMPORTANT: All files intentionally share the same config object reference for memory efficiency.
-        // This prevents unbounded memory growth in long-running processes (e.g., language servers).
-        // The config is immutable after creation, so sharing is safe.
-        // Deduplication happens in setEslintConfig() via Set to avoid duplicate configs in the final array.
-        for (const file of files) {
-            this.#fileConfigs.set(file, config);
+            console.warn('XO: Failed to create tsconfig for unincluded files. Type-aware linting will be disabled for these files.', error instanceof Error ? error.message : String(error));
         }
     }
     processReport(report, { rulesMeta = {} } = {}) {
@@ -426,17 +412,14 @@ export class Xo {
             ...this.getReportStatistics(report),
         };
         defineLazyProperty(result, 'usedDeprecatedRules', () => {
-            const seenRules = new Set();
-            const rules = [];
-            for (const { usedDeprecatedRules } of report) {
-                for (const rule of usedDeprecatedRules) {
-                    if (!seenRules.has(rule.ruleId)) {
-                        seenRules.add(rule.ruleId);
-                        rules.push(rule);
-                    }
+            const seenRuleIds = new Set();
+            return report.flatMap(({ usedDeprecatedRules }) => usedDeprecatedRules).filter(rule => {
+                if (seenRuleIds.has(rule.ruleId)) {
+                    return false;
                 }
-            }
-            return rules;
+                seenRuleIds.add(rule.ruleId);
+                return true;
+            });
         });
         return result;
     }
@@ -488,21 +471,18 @@ export class Xo {
         this.#tsFilesGlob.push(...tsGlob);
         this.#tsFilesIgnoresGlob.push(...tsFilesIgnoresGlob);
     }
-    setEslintConfig(cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
+    setEslintConfig(cliIgnores = arrify(this.#baseXoConfig.ignores), shouldStripDefaultIgnores = false) {
         if (!this.#xoConfig) {
             throw new Error('"Xo.setEslintConfig" failed');
         }
-        // Combine base config with per-file configs from Map
-        // Deduplicate configs since multiple files can share the same config object
         const [baseConfig = {}, ...resolvedConfigs] = this.#xoConfig;
         const { ignores, ...configWithoutCliIgnores } = baseConfig;
         const expandedResolvedConfigs = resolvedConfigs.map(config => expandGlobalIgnoreConfigForEslint(config));
-        const uniqueFileConfigs = [...new Set(this.#fileConfigs.values())];
         const cliIgnoreConfig = cliIgnores.length > 0 ? [{ ignores: expandIgnoreNegationsForEslint(cliIgnores) }] : [];
-        const allConfigs = [configWithoutCliIgnores, ...expandedResolvedConfigs, ...cliIgnoreConfig, ...uniqueFileConfigs];
+        const allConfigs = [configWithoutCliIgnores, ...expandedResolvedConfigs, ...cliIgnoreConfig];
         // Always regenerate to support instance reuse with new files
         this.#eslintConfig = xoToEslintConfig(allConfigs);
-        if (stripDefaultIgnores) {
+        if (shouldStripDefaultIgnores) {
             this.#eslintConfig = stripDefaultIgnoreConfigs(this.#eslintConfig);
         }
     }
@@ -527,39 +507,30 @@ export class Xo {
         }
     }
     /**
-    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to an in-memory TypeScript Program for type aware linting.
+    Checks every TS file to ensure it is included in the tsconfig. Any that are not included are routed through a generated tsconfig (`tsconfig.generated.json`) so that autofix works correctly across multiple ESLint passes.
 
     @param files - The TypeScript files being linted.
     */
     async handleUnincludedTsFiles(files) {
-        if (!this.#linterOptions.ts || !files || files.length === 0) {
+        if (!this.#linterOptions.ts) {
             return;
         }
-        // Get ALL TypeScript files being linted (both new and previously handled)
-        const allTsFiles = matchFilesForTsConfig(this.#linterOptions.cwd, files, this.#tsFilesGlob, this.#tsFilesIgnoresGlob);
-        if (allTsFiles.length === 0) {
-            this.#fileConfigs.clear();
-            if (this.#virtualFiles.size > 0) {
-                await this.addVirtualFilesToConfig([]);
-            }
+        if (!files || files.length === 0) {
+            await this.addUnincludedFilesToConfig([]);
             return;
         }
-        const { program, existingFiles, virtualFiles } = handleTsconfig({
-            files: allTsFiles,
-            cwd: this.#linterOptions.cwd,
-            cacheLocation: this.#cacheLocation,
-        });
-        this.#fileConfigs.clear();
-        if (existingFiles.length > 0) {
-            this.addExistingFilesToConfig(existingFiles, program);
-        }
-        await this.addVirtualFilesToConfig(virtualFiles);
+        // Get ALL TypeScript files being linted
+        const allTsFiles = matchFilesForTsConfig(this.#linterOptions.cwd, files, this.#tsFilesGlob, this.#tsFilesIgnoresGlob);
+        const unincludedFiles = allTsFiles.length === 0
+            ? []
+            : handleTsconfig({ files: allTsFiles, cwd: this.#linterOptions.cwd });
+        await this.addUnincludedFilesToConfig(unincludedFiles);
     }
     /**
     Initializes the ESLint instance on the XO instance.
     */
-    async initEslint(files, cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
-        await this.prepareEslintConfig(files, cliIgnores, stripDefaultIgnores);
+    async initEslint(files, cliIgnores = arrify(this.#baseXoConfig.ignores), shouldStripDefaultIgnores = false) {
+        await this.prepareEslintConfig(files, cliIgnores, shouldStripDefaultIgnores);
         if (!this.#xoConfig) {
             throw new Error('"Xo.initEslint" failed');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "3.0.1",
+	"version": "4.0.0",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",
@@ -77,30 +77,30 @@
 		"arrify": "^3.0.0",
 		"cosmiconfig": "^9.0.2",
 		"define-lazy-prop": "^3.0.0",
-		"eslint": "^10.5.0",
-		"eslint-config-xo": "^0.53.1",
+		"eslint": "^10.6.0",
+		"eslint-config-xo": "^0.57.0",
 		"eslint-formatter-pretty": "^7.1.0",
 		"find-cache-directory": "^6.0.0",
 		"get-stdin": "^10.0.0",
 		"get-tsconfig": "^4.14.0",
-		"globby": "^16.2.0",
+		"globby": "^16.2.1",
 		"jiti": "^2.7.0",
 		"meow": "^14.1.0",
 		"micromatch": "^4.0.8",
 		"open-editor": "^6.0.0",
 		"path-exists": "^5.0.0",
-		"prettier": "^3.8.4",
-		"type-fest": "^5.7.0",
+		"prettier": "^3.9.4",
+		"type-fest": "^5.8.0",
 		"typescript": "^6.0.3"
 	},
 	"devDependencies": {
 		"@types/micromatch": "^4.0.10",
-		"@types/node": "^25.9.3",
+		"@types/node": "^26.1.0",
 		"dedent": "^1.7.2",
 		"eslint-plugin-vue": "^10.9.2",
 		"execa": "^9.6.1",
 		"husky": "^9.1.7",
-		"np": "^11.2.1",
+		"np": "^11.2.2",
 		"temp-dir": "^3.0.0",
 		"xo": "file:."
 	},