biome-to-oxc 3.6.1 → 3.7.0

package/README.md

@@ -32,7 +32,14 @@ Current capabilities:
 ✅ **Preserves Representable Setup**
 
 - Ignore patterns, override file globs, and override exclusions
-- Negated `includes` exceptions (`!pattern`), translated into `ignorePatterns` for both tools
+- Negated `includes` exceptions (`!pattern`), translated into `ignorePatterns` for both tools, and
+  patterns that re-include files after an exception, carried over as `!` entries (or, in an
+  override, as a second override for the re-included files)
+- Root anchoring of `includes` patterns: Biome matches `!dist` and `*.gen.ts` at the config root
+  only, so they are written as `/dist` in `ignorePatterns` and `./*.gen.ts` in an override, where
+  Oxlint and Oxfmt would otherwise match them at any depth
+- `includes` patterns Biome matches against no path — ending in `/`, starting with `/`, or an
+  exception starting with `./` — are left out with a warning instead of excluding the path
 - `.biomeignore` patterns migrated into the Oxlint **and** Oxfmt `ignorePatterns`. Biome 2.x does
   not read `.biomeignore` itself, so this deliberately narrows scope; the migration says so
 - Linter configuration overrides
@@ -435,8 +442,8 @@ npx oxlint --type-aware --type-check
 - Overlapping `overrides` are migrated as-is. Biome and Oxfmt both merge matching overrides field
   by field with later entries winning, so the two agree; a conformance test pins this
 - Type-aware linting is stable as of `oxlint-tsgolint` v7 and requires TypeScript 7; 60 of the 62
-  targeted typescript-eslint rules are currently implemented, and Oxlint 1.85 does not yet expose
-  `no-generated-empty-object-type`, so 59 can be enabled
+  targeted typescript-eslint rules are currently implemented (`naming-convention` and
+  `prefer-destructuring` are not), and Oxlint 1.86 and later can enable all 60
 - CSS, JSON and GraphQL formatter overrides are mapped but may need manual review
 - Prettier plugin support is not available in Oxfmt
 - Assist actions are migrated only when the Biome config names them explicitly; actions enabled

package/dist/bin/biome-to-oxc.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as readJsonFile, n as DefaultReporter, r as findClosestPackageJson, t as migrate } from "../src-FuMDOlMz.mjs";
+import { i as readJsonFile, n as DefaultReporter, r as findClosestPackageJson, t as migrate } from "../src-JKoQYJ0f.mjs";
 import { realpath } from "node:fs/promises";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/src/index.d.mts

@@ -18,7 +18,10 @@ export interface BiomeConfig {
 export interface BiomeFilesConfig {
   include?: string[];
   includes?: string[];
-  /** Negated `includes` entries (`!pattern`), split out during normalization. */
+  /**
+   * Exclusions split out of `includes` during normalization, in source order: an exception
+   * (`!pattern`) as `pattern`, and a pattern re-included after one as `!pattern`.
+   */
   exclude?: string[];
   ignore?: string[];
   ignoreUnknown?: boolean;
@@ -35,7 +38,10 @@ export interface BiomeLinterConfig {
   enabled?: boolean;
   include?: string[];
   includes?: string[];
-  /** Negated `includes` entries (`!pattern`), split out during normalization. */
+  /**
+   * Exclusions split out of `includes` during normalization, in source order: an exception
+   * (`!pattern`) as `pattern`, and a pattern re-included after one as `!pattern`.
+   */
   exclude?: string[];
   ignore?: string[];
   rules?: BiomeLinterRules;
@@ -84,7 +90,10 @@ export interface BiomeFormatterConfig {
   enabled?: boolean;
   include?: string[];
   includes?: string[];
-  /** Negated `includes` entries (`!pattern`), split out during normalization. */
+  /**
+   * Exclusions split out of `includes` during normalization, in source order: an exception
+   * (`!pattern`) as `pattern`, and a pattern re-included after one as `!pattern`.
+   */
   exclude?: string[];
   ignore?: string[];
   formatWithErrors?: boolean;

package/dist/src/index.mjs

@@ -1,2 +1,2 @@
-import { t as migrate } from "../src-FuMDOlMz.mjs";
+import { t as migrate } from "../src-JKoQYJ0f.mjs";
 export { migrate };

package/dist/{src-FuMDOlMz.mjs → src-JKoQYJ0f.mjs}

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { access, copyFile, mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
+import { basename, dirname, join, posix, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import pc from "picocolors";
 import { z } from "zod";
@@ -215,13 +215,32 @@ async function loadBiomeIgnorePatterns(projectDir, reporter) {
 //#endregion
 //#region src/schema-normalizer.ts
 /**
+* Biome 2 anchors every `includes` pattern at the config root, so `dist` and `*.gen.ts` only
+* match there. Oxlint and Oxfmt match a pattern without a `/` at any depth, and anchor one
+* with a leading `/` in `ignorePatterns` but with `./` in an override's `files` and
+* `excludeFiles`, where a leading `/` matches nothing.
+*/
+function anchorAtRoot(pattern, target) {
+	if (pattern.includes("/") || pattern === "**") return pattern;
+	return `${target === "ignorePatterns" ? "/" : "./"}${pattern}`;
+}
+/** Why Biome 2 matches `pattern` against no path, if it does. */
+function findUnmatchableReason(pattern) {
+	const body = pattern.replace(/^!{1,2}/u, "");
+	if (body.endsWith("/")) return "ends with \"/\"";
+	if (body.startsWith("/")) return "starts with \"/\"";
+	return body !== pattern && body.startsWith("./") ? "starts with \"./\"" : void 0;
+}
+/**
 * Splits a Biome selection into positive selectors and negated exceptions.
 *
 * Biome 2.x `includes` mixes both: a bare pattern selects files, `!pattern` excludes
-* them again, and `!!pattern` force-ignores a path at the scanner level. The legacy
-* `include` field carries positive selectors only.
+* them again, and `!!pattern` force-ignores a path at the scanner level. The patterns
+* apply in order, so a bare pattern after an exception re-includes what it matches, and a
+* pattern ending in `/` matches nothing. The legacy `include` field carries positive
+* selectors only.
 */
-function normalizeIncludeFields(obj, fieldName, reporter) {
+function normalizeIncludeFields(obj, fieldName, reporter, target = "ignorePatterns") {
 	if (obj.include && obj.includes) {
 		reporter.warn(`Both 'include' and 'includes' found in ${fieldName}. Using 'include' and ignoring 'includes'.`);
 		return {
@@ -229,26 +248,46 @@ function normalizeIncludeFields(obj, fieldName, reporter) {
 			exclude: void 0
 		};
 	}
-	if (obj.includes) return splitIncludes(obj.includes, fieldName, reporter);
+	if (obj.includes) return splitIncludes(obj.includes, fieldName, reporter, target);
 	return {
 		include: obj.include,
 		exclude: void 0
 	};
 }
-function splitIncludes(includes, fieldName, reporter) {
+function splitIncludes(includes, fieldName, reporter, target) {
 	const include = [];
 	const exclude = [];
 	for (const pattern of includes) {
+		const unmatchable = findUnmatchableReason(pattern);
+		if (unmatchable && pattern.startsWith("!")) {
+			const body = pattern.replace(/^!{1,2}/u, "");
+			const intended = anchorAtRoot(`${body.replace(/^\.?\//u, "")}${body.endsWith("/") ? "**" : ""}`, target);
+			const destination = target === "ignorePatterns" ? "the Oxlint and Oxfmt ignorePatterns" : "the excludeFiles of the migrated override";
+			reporter.warn(`Biome exception "${pattern}" in ${fieldName} ${unmatchable} and matches no file in Biome, so it excludes nothing and nothing was migrated for it. If the path was meant to be excluded, add "${intended}" to ${destination}.`);
+			continue;
+		}
+		if (unmatchable) reporter.warn(`Biome pattern "${pattern}" in ${fieldName} ${unmatchable} and matches no file in Biome, so it selects nothing.`);
 		if (pattern.startsWith("!!")) {
-			exclude.push(pattern.slice(2));
+			exclude.push(anchorAtRoot(pattern.slice(2), target));
 			reporter.loss(`Biome force-ignore pattern "${pattern}" in ${fieldName} was migrated as a plain ignore; Oxc has no scanner-level force-ignore, so files reachable through other tooling paths may still be processed.`);
 			continue;
 		}
 		if (pattern.startsWith("!")) {
-			exclude.push(pattern.slice(1));
+			exclude.push(anchorAtRoot(pattern.slice(1), target));
 			continue;
 		}
-		include.push(pattern);
+		const anchored = unmatchable ? pattern : anchorAtRoot(pattern.replace(/^\.\//u, ""), target);
+		if (exclude.length === 0) {
+			include.push(target === "override" ? anchored : pattern);
+			continue;
+		}
+		if (unmatchable) continue;
+		const blockedBy = target === "ignorePatterns" ? findExcludedAncestor(anchored, exclude) : null;
+		if (blockedBy) {
+			reporter.warn(`Biome pattern "${pattern}" in ${fieldName} re-includes nothing: an earlier exception still excludes the directory "${blockedBy}", and Biome does not look inside an excluded directory, so nothing was migrated for it. Re-include "${blockedBy}" first if its files were meant to be processed.`);
+			continue;
+		}
+		exclude.push(`!${anchored}`);
 	}
 	return {
 		include: include.length > 0 ? include : void 0,
@@ -268,6 +307,91 @@ function withoutMatchAllSelection(selection) {
 		include: void 0
 	} : selection;
 }
+function isReinclude(pattern) {
+	return pattern.startsWith("!");
+}
+const GLOB_SEGMENT = /[*?[{]/u;
+/** Whether a glob can match files at more than one directory depth or in several directories. */
+function hasDirectoryGlob(pattern) {
+	return pattern.replace(/^!/u, "").split("/").slice(0, -1).some((segment) => GLOB_SEGMENT.test(segment));
+}
+/** A pattern as a project-relative glob, without the `!` or the root anchor it was given. */
+function globBody(pattern) {
+	return pattern.replace(/^!/u, "").replace(/^\.?\//u, "");
+}
+/**
+* The directory that stops Biome from reaching anything `pattern` names, if there is one.
+*
+* Biome walks the project and skips a directory whose last matching `includes` pattern is
+* an exception, so a re-include of a file below one has no effect. Only the directories in
+* the pattern's literal prefix are checked: those the pattern itself needs to be walked.
+*/
+function findExcludedAncestor(pattern, ordered) {
+	const segments = globBody(pattern).split("/").slice(0, -1);
+	const literalDepth = segments.findIndex((segment) => GLOB_SEGMENT.test(segment));
+	const directories = segments.slice(0, literalDepth === -1 ? segments.length : literalDepth).map((_, index, literal) => literal.slice(0, index + 1).join("/"));
+	for (const directory of directories) {
+		const lastMatch = ordered.findLast((entry) => posix.matchesGlob(directory, globBody(entry)));
+		if (lastMatch !== void 0 && !isReinclude(lastMatch)) return directory;
+	}
+	return null;
+}
+/**
+* Joins the `files` exclusions with a tool's own for one `ignorePatterns` list. A `!` entry
+* lifts every earlier pattern it matches, so the list carrying one goes first and cannot lift
+* the other list's exclusions. `normalizeBiomeConfig` leaves at most one of the two with any.
+*/
+function joinExclusions(filesExclude = [], toolExclude = []) {
+	return toolExclude.some(isReinclude) ? [...toolExclude, ...filesExclude] : [...filesExclude, ...toolExclude];
+}
+/**
+* `files.includes` bounds what a tool's own `includes` can select, but both end up in one
+* `ignorePatterns` list, where a re-include from either would lift the other's exclusions.
+* When both carry re-includes only those of `files` are kept.
+*/
+function withoutToolReincludes(exclude, fieldName, filesExclude, reporter) {
+	const reincludes = exclude?.filter(isReinclude) ?? [];
+	if (!exclude || reincludes.length === 0 || !filesExclude?.some(isReinclude)) return exclude;
+	reporter.loss(`Biome ${fieldName}.includes re-includes ${reincludes.map((pattern) => pattern.slice(1)).join(", ")} after a negated pattern, and files.includes re-includes files too; one ignorePatterns list cannot keep the two sets of exceptions apart, so the files ${fieldName}.includes re-includes stay excluded.`);
+	return exclude.filter((pattern) => !isReinclude(pattern));
+}
+/**
+* Splits an override selection that re-includes files into selections that need no
+* re-include. An override's `excludeFiles` cannot carry an exception to an exclusion, but
+* Biome selects a file when the last pattern matching it is a positive one, which is the
+* union of every positive pattern less the exceptions listed after it. So the patterns
+* ahead of the first exception keep every exception, and each run of re-includes keeps
+* only the exceptions that follow it.
+*/
+function splitReincludes(selection) {
+	const ordered = selection.exclude ?? [];
+	if (!ordered.some(isReinclude)) return [selection];
+	const exceptionsFrom = (index) => {
+		const exceptions = ordered.slice(index).filter((pattern) => !isReinclude(pattern));
+		return exceptions.length > 0 ? exceptions : void 0;
+	};
+	const leading = selection.include ?? [];
+	const selections = leading.length > 0 ? [{
+		include: leading,
+		exclude: exceptionsFrom(0)
+	}] : [];
+	let run;
+	for (const [index, pattern] of ordered.entries()) {
+		if (!isReinclude(pattern)) {
+			run = void 0;
+			continue;
+		}
+		if (!run) {
+			run = [];
+			selections.push({
+				include: run,
+				exclude: exceptionsFrom(index)
+			});
+		}
+		run.push(pattern.slice(1));
+	}
+	return selections;
+}
 function normalizeBiomeConfig(config, reporter) {
 	const normalized = { ...config };
 	if (normalized.files) {
@@ -284,7 +408,7 @@ function normalizeBiomeConfig(config, reporter) {
 		normalized.linter = {
 			...normalized.linter,
 			include,
-			exclude,
+			exclude: withoutToolReincludes(exclude, "linter", normalized.files?.exclude, reporter),
 			includes: void 0
 		};
 	}
@@ -293,19 +417,23 @@ function normalizeBiomeConfig(config, reporter) {
 		normalized.formatter = {
 			...normalized.formatter,
 			include,
-			exclude,
+			exclude: withoutToolReincludes(exclude, "formatter", normalized.files?.exclude, reporter),
 			includes: void 0
 		};
 	}
-	if (normalized.overrides) normalized.overrides = normalized.overrides.map((override, index) => {
-		const { include, exclude } = normalizeIncludeFields(override, `overrides[${index}]`, reporter);
-		return {
-			...override,
-			include,
-			exclude,
-			includes: void 0
-		};
-	});
+	if (normalized.overrides) {
+		const overrides = [];
+		for (const [index, override] of normalized.overrides.entries()) {
+			const selection = normalizeIncludeFields(override, `overrides[${index}]`, reporter, "override");
+			for (const { include, exclude } of splitReincludes(selection)) overrides.push({
+				...override,
+				include,
+				exclude,
+				includes: void 0
+			});
+		}
+		normalized.overrides = overrides;
+	}
 	return normalized;
 }
 //#endregion
@@ -1241,12 +1369,11 @@ function mapOrganizeImportsOptions(value, reporter) {
 }
 function mapIgnorePatterns$1(biomeConfig, oxfmtConfig, additionalIgnorePatterns) {
 	const ignorePatterns = [
+		...joinExclusions(biomeConfig.files?.exclude, biomeConfig.formatter?.exclude),
 		...oxfmtConfig.ignorePatterns ?? [],
 		...additionalIgnorePatterns,
 		...biomeConfig.files?.ignore ?? [],
-		...biomeConfig.formatter?.ignore ?? [],
-		...biomeConfig.files?.exclude ?? [],
-		...biomeConfig.formatter?.exclude ?? []
+		...biomeConfig.formatter?.ignore ?? []
 	];
 	if (ignorePatterns.length > 0) oxfmtConfig.ignorePatterns = [...new Set(ignorePatterns)];
 }
@@ -1320,7 +1447,7 @@ function validatePatternGroups(configName, groups) {
 function findPatternProblem(pattern) {
 	const body = pattern.startsWith("!") ? pattern.slice(1) : pattern;
 	if (body.split("/").includes("..")) return "escapes the config directory with \"..\", which Oxlint and Oxfmt reject";
-	if (body.startsWith("/") || /^[A-Za-z]:[/\\]/u.test(body)) return "is an absolute path, but patterns are resolved within the config directory";
+	if (/^[A-Za-z]:[/\\]/u.test(body)) return "is an absolute path, but patterns are resolved within the config directory";
 }
 //#endregion
 //#region src/js-plugin-scaffolder.ts
@@ -1342,6 +1469,14 @@ const RESERVED_JS_PLUGIN_NAMES = /* @__PURE__ */ new Set([
 	"eslint"
 ]);
 const UNSUPPORTED_BIOME_RULE_GUIDANCE = {
+	noDeprecatedImports: {
+		nativeAlternatives: ["typescript/no-deprecated"],
+		notes: "Not a drop-in replacement: typescript/no-deprecated is type-aware and reports each use of a deprecated symbol, wherever it was declared, rather than the import statement, so an imported but unused deprecated symbol is not reported."
+	},
+	noForIn: {
+		nativeAlternatives: ["guard-for-in", "typescript/no-for-in-array"],
+		notes: "Neither forbids every for-in loop: guard-for-in reports the ones whose body is not wrapped in an own-property check, and the type-aware typescript/no-for-in-array reports only loops over arrays."
+	},
 	noReExportAll: {
 		nativeAlternatives: ["import/no-cycle", "import/no-self-import"],
 		jsPluginSpecifiers: ["eslint-plugin-import"],
@@ -1558,7 +1693,10 @@ const PARTIAL_RULE_MAPPING_NOTES = {
 	noComponentHookFactories: "Biome rule noComponentHookFactories was mapped to react/no-unstable-nested-components, which reports nested component definitions but not nested custom hook definitions.",
 	noBarrelFile: "Biome rule noBarrelFile was mapped to oxc/no-barrel-file, which only counts `export *` re-exports and reports a file once it re-exports more modules than its threshold (100 by default); Biome reports any file that re-exports, including through named `export { ... } from`.",
 	noExcessiveCognitiveComplexity: "Biome rule noExcessiveCognitiveComplexity was mapped to complexity, which scores cyclomatic complexity rather than cognitive complexity; the threshold carries over, but the two scores differ, so a different set of functions is reported.",
+	noMeaninglessVoidOperator: "Biome rule noMeaninglessVoidOperator was mapped to typescript/no-meaningless-void-operator, which reports `void` applied to a value whose type is `void` or `undefined` but not `void` applied to any other non-call operand, such as `void 1` or `void value`.",
 	noInlineStyles: "Biome rule noInlineStyles was mapped to react/forbid-dom-props, which reports the `style` prop on JSX DOM elements but not `style` passed through React.createElement() or written in HTML, Vue, Svelte or Astro templates.",
+	noSelfImport: "Biome rule noSelfImport was mapped to import/no-self-import, which reports static `import` and `export ... from` statements that resolve to their own file but not `require()` calls or dynamic `import()` expressions that do.",
+	noReactObjectTypeAsDefaultProp: "Biome rule noReactObjectTypeAsDefaultProp was mapped to react/no-object-type-as-default-prop, which reports array, object, function, class, regex, `new` and JSX default prop values but not a `Symbol()` default.",
 	noReactPropAssignments: "Biome rule noReactPropAssignments was mapped to the React Compiler rule react/immutability, which reports prop mutation alongside other mutations of values React treats as immutable.",
 	noUnresolvedImports: "Biome rule noUnresolvedImports was mapped to import/named, which reports named imports a JavaScript module does not export but skips TypeScript files entirely and does not report import paths that cannot be resolved.",
 	noUnsafeIframeSandbox: "Biome rule noUnsafeIframeSandbox was mapped to react/iframe-missing-sandbox, which reports `allow-scripts` combined with `allow-same-origin` only when the sandbox value is a plain string attribute, not a `{\"...\"}` or template-literal expression; it also reports iframes with no or an invalid sandbox attribute, which Biome leaves to useIframeSandbox.",
@@ -1775,6 +1913,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noLabelVar: "no-label-var",
 	noLoopFunc: "no-loop-func",
 	noMagicNumbers: "no-magic-numbers",
+	noMeaninglessVoidOperator: "typescript/no-meaningless-void-operator",
 	noMisleadingCharacterClass: "no-misleading-character-class",
 	noMisleadingInstantiator: "typescript/no-misused-new",
 	noMisrefactoredShorthandAssign: "oxc/misrefactored-assign-op",
@@ -1807,6 +1946,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noProto: "no-proto",
 	noPrototypeBuiltins: "no-prototype-builtins",
 	noRedeclare: "no-redeclare",
+	noReactObjectTypeAsDefaultProp: "react/no-object-type-as-default-prop",
 	noReactPropAssignments: "react/immutability",
 	noRedundantAlt: "jsx-a11y/img-redundant-alt",
 	noRedundantRoles: "jsx-a11y/no-redundant-roles",
@@ -1827,6 +1967,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noScriptUrl: "no-script-url",
 	noSelfCompare: "no-self-compare",
 	noSelfAssign: "no-self-assign",
+	noSelfImport: "import/no-self-import",
 	noSetterReturn: "no-setter-return",
 	noShadow: "no-shadow",
 	noShadowRestrictedNames: "no-shadow-restricted-names",
@@ -1996,6 +2137,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	useObjectSpread: "prefer-object-spread",
 	useOptionalChain: "typescript/prefer-optional-chain",
 	useParseIntRadix: "radix",
+	usePromiseRejectErrors: "prefer-promise-reject-errors",
 	useReadonlyClassProperties: "typescript/prefer-readonly",
 	useReactFunctionComponentDefinition: "react/function-component-definition",
 	useReactCompiler: REACT_COMPILER_RULES,
@@ -2012,6 +2154,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	useSpread: "prefer-spread",
 	useSpreadOverApply: "prefer-spread",
 	useStaticResponseMethods: "unicorn/prefer-response-static-json",
+	useStrictBooleanExpressions: "typescript/strict-boolean-expressions",
 	useStringStartsEndsWith: "typescript/prefer-string-starts-ends-with",
 	useSymbolDescription: "symbol-description",
 	useTemplate: "prefer-template",
@@ -2573,6 +2716,8 @@ function mapTypeAwareOptions(oxlintConfig, typeAware, typeCheck) {
 function warnAboutUnrepresentableIncludes(biomeConfig, reporter) {
 	const positiveSelectors = [...biomeConfig.files?.include ?? [], ...biomeConfig.linter?.include ?? []];
 	if (positiveSelectors.length > 0) reporter.loss(`Biome files/linter positive include selection (${positiveSelectors.join(", ")}) cannot be represented in an Oxlint config; Oxlint will lint every file not covered by ignorePatterns, which is a wider set. Pass equivalent paths to the Oxlint CLI before replacing Biome.`);
+	const reincludes = joinExclusions(biomeConfig.files?.exclude, biomeConfig.linter?.exclude).filter((pattern) => pattern.startsWith("!") && hasDirectoryGlob(pattern)).map((pattern) => pattern.slice(1));
+	if (reincludes.length > 0) reporter.warn(`Biome re-includes ${reincludes.join(", ")} after a negated pattern, which was migrated as "!" entries in the Oxlint ignorePatterns. Oxlint lifts the exclusion for every file such an entry matches, while Biome does not look inside a directory an earlier exception excluded, so Oxlint may lint files below one that Biome skipped.`);
 }
 function addImportGraphRecipe(oxlintConfig, maxDepth) {
 	oxlintConfig.rules ??= {};
@@ -2618,11 +2763,10 @@ function sortPlugins(plugins) {
 }
 function mapIgnorePatterns(biomeConfig, oxlintConfig, additionalIgnorePatterns) {
 	const ignorePatterns = [
+		...joinExclusions(biomeConfig.files?.exclude, biomeConfig.linter?.exclude),
 		...additionalIgnorePatterns,
 		...biomeConfig.files?.ignore ?? [],
-		...biomeConfig.linter?.ignore ?? [],
-		...biomeConfig.files?.exclude ?? [],
-		...biomeConfig.linter?.exclude ?? []
+		...biomeConfig.linter?.ignore ?? []
 	];
 	if (ignorePatterns.length > 0) oxlintConfig.ignorePatterns = [...new Set(ignorePatterns)];
 }
@@ -3579,7 +3723,7 @@ async function buildSuggestions({ biomeIgnorePatterns, detectedIntegrations, opt
 		suggestions.push("  pnpm add -D oxlint-tsgolint@latest");
 		suggestions.push(`  ${typeAwareCommand}`);
 		suggestions.push("Type-aware mode uses the tsgolint backend.");
-		suggestions.push("Type-aware linting is stable as of tsgolint v7; it implements 60 of typescript-eslint’s 62 type-aware rules, and Oxlint does not yet expose no-generated-empty-object-type, so check those three if you relied on them.");
+		suggestions.push("Type-aware linting is stable as of tsgolint v7; it implements 60 of typescript-eslint’s 62 type-aware rules, so check naming-convention and prefer-destructuring if you relied on them.");
 		suggestions.push("TypeScript compatibility caveat: migrate deprecated tsconfig options if needed (typescript-go / TS7+ behavior).");
 		suggestions.push(`Resolved type-aware profile: ${typeAwareProfile}`);
 	}
@@ -3770,10 +3914,7 @@ function countRebasablePatterns(oxlintConfig, oxfmtConfig) {
 		oxfmtConfig.ignorePatterns,
 		...(oxlintConfig.overrides ?? []).flatMap((override) => [override.files, override.excludeFiles]),
 		...(oxfmtConfig.overrides ?? []).flatMap((override) => [override.files, override.excludeFiles])
-	].reduce((total, patterns) => total + (patterns ?? []).filter((pattern) => !isAbsolute(stripNegation(pattern))).length, 0);
-}
-function stripNegation(pattern) {
-	return pattern.startsWith("!") ? pattern.slice(1) : pattern;
+	].reduce((total, patterns) => total + (patterns ?? []).length, 0);
 }
 function rebasePatterns(patterns, projectFromOutput) {
 	if (!patterns || !projectFromOutput) return patterns;
@@ -3781,7 +3922,6 @@ function rebasePatterns(patterns, projectFromOutput) {
 		const negated = pattern.startsWith("!");
 		const prefix = negated ? "!" : "";
 		const body = negated ? pattern.slice(1) : pattern;
-		if (isAbsolute(body)) return pattern;
 		return `${prefix}${posix.normalize(`${projectFromOutput}/${body.replace(/^\//u, "")}`)}`;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "biome-to-oxc",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "description": "Migrate from Biome to Oxc ecosystem (oxlint + oxfmt + oxlint-tsgolint)",
   "keywords": [
     "biome",
@@ -58,20 +58,20 @@
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.5",
-    "@biomejs/biome": "^2.5.14",
-    "@types/node": "^26.6.3",
-    "@vitest/coverage-v8": "^5.0.2",
-    "oxfmt": "^0.70.0",
-    "oxlint": "^1.85.0",
+    "@biomejs/biome": "^2.5.15",
+    "@types/node": "^26.6.4",
+    "@vitest/coverage-v8": "^5.0.3",
+    "oxfmt": "^0.72.0",
+    "oxlint": "^1.87.0",
     "oxlint-tsgolint": "^7.0.2003",
-    "publint": "^0.3.24",
+    "publint": "^0.3.25",
     "tsdown": "0.23.0",
     "typescript": "next",
-    "vitest": "^5.0.2"
+    "vitest": "^5.0.3"
   },
   "engines": {
     "node": ">=24.21.0",
-    "pnpm": ">=11.28.0"
+    "pnpm": ">=11.28.5"
   },
-  "packageManager": "pnpm@11.28.0"
+  "packageManager": "pnpm@11.28.5"
 }