biome-to-oxc 3.6.0 → 3.7.0

package/README.md

@@ -22,20 +22,31 @@ Current capabilities:
 
 - Converts `biome.json`/`biome.jsonc` to `.oxlintrc.json` and `.oxfmtrc.jsonc`
 - Maps 80+ Biome linter rules to Oxlint equivalents (native `typescript/` rules)
-- Substitutes a non-type-aware Oxlint rule for the three Biome rules that need no types but whose
-  only Oxlint counterpart is type-aware, so a migration without tsgolint keeps their coverage
+- Substitutes a non-type-aware Oxlint rule for the four Biome rules that need no types but whose
+  only Oxlint counterpart is type-aware, so a migration without tsgolint keeps their coverage, and
+  reports every other rule that maps only to a type-aware Oxlint rule as a semantic loss when
+  type-aware linting is off
 - Transforms Biome formatter options to Oxfmt (Prettier-compatible)
 - Normalizes `include`/`includes` field variations automatically
 
 ✅ **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
 - Formatter configuration overrides when they can be represented as Oxfmt file-glob overrides
-- JavaScript globals
+- JavaScript globals, plus `env: { browser: true, node: true }`, which gives Oxlint the browser and
+  Node.js globals Biome resolves without configuration (`no-undef`, `no-global-assign` and
+  `no-implied-eval` depend on it)
 - Rule severities (`error`/`warn`/`off`; `info` and `on` are accepted with explicit lossy-mapping warnings)
 - Explicit `printWidth` handling (no silent changes)
 - The set of formatted files: Oxfmt-only formats (YAML, TOML, Markdown) are excluded, and
@@ -308,7 +319,7 @@ Oxlint's broader `restriction` category.
 
 ### Type-Aware Rule Fallbacks
 
-Three Biome rules need no type information, but their only Oxlint counterpart is a type-aware
+Four Biome rules need no type information, but their only Oxlint counterpart is a type-aware
 (tsgolint) rule. Type-aware linting is off unless the migration enables it, so mapping straight to
 the tsgolint rule would drop diagnostics the Biome config did produce. When type-aware linting is
 off, a non-type-aware Oxlint rule takes its place instead:
@@ -318,15 +329,18 @@ off, a non-type-aware Oxlint rule takes its place instead:
 | `useArrayFind`            | `typescript/prefer-find`                    | `unicorn/prefer-array-find`              |
 | `useIncludes`             | `typescript/prefer-includes`                | `unicorn/prefer-includes`                |
 | `useStringStartsEndsWith` | `typescript/prefer-string-starts-ends-with` | `unicorn/prefer-string-starts-ends-with` |
+| `useThrowOnlyError`       | `typescript/only-throw-error`               | `no-throw-literal`                       |
 
 The fallback replaces the type-aware rule rather than joining it, so turning type-aware linting on
-later can never report the same line twice. The first two pairs report exactly what the Biome rule
-reports; `unicorn/prefer-string-starts-ends-with` covers only the anchored-regex form of the four
+later can never report the same line twice. `useArrayFind`, `useIncludes` and `useThrowOnlyError`
+report exactly what the Biome rule reports; `unicorn/prefer-string-starts-ends-with` covers only the anchored-regex form of the four
 Biome flags, so that substitution is reported as a semantic loss.
 
 Every other Biome rule that maps only to a type-aware Oxlint rule — `noFloatingPromises`,
-`noMisusedPromises`, `useOptionalChain` and the rest — needs types on both sides and has no
-fallback.
+`noMisusedPromises`, `useOptionalChain`, `useLiteralKeys` and the rest — has no non-type-aware
+Oxlint counterpart. Oxlint skips type-aware rules unless type-aware linting is on, so a migration
+without `--type-aware` reports each of them as a semantic loss instead of emitting a rule that
+never runs.
 
 ### Assist Actions
 
@@ -428,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-BN3SXk7r.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;
@@ -397,6 +406,8 @@ export interface PackageUpdateSummary {
   scriptsUpdated: PackageScriptUpdate[];
   dependenciesRemoved: PackageDependencyRemoval[];
   devDependencies: PackageDevDependencyChange[];
+  /** Package scripts that still invoke Biome after the update, which keep Biome in use. */
+  scriptsStillUsingBiome: string[];
   changed: boolean;
   /** Lockfile that dependency changes invalidated, when one was detected. */
   lockfile?: LockfileStatus;

package/dist/src/index.mjs

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

package/dist/{src-BN3SXk7r.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,36 +248,154 @@ 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,
 		exclude: exclude.length > 0 ? exclude : void 0
 	};
 }
+/** Patterns that select every file, which Biome 2.x configs list before their `!` exceptions. */
+const MATCH_ALL_PATTERNS = /* @__PURE__ */ new Set(["**", "**/*"]);
+/**
+* Drops a positive selection that already selects every file. `["**", "!dist"]` is Biome's
+* canonical way to exclude a directory, and the positive part narrows nothing, so keeping
+* it would report an unrepresentable include selection for a config that has none.
+*/
+function withoutMatchAllSelection(selection) {
+	return selection.include?.some((pattern) => MATCH_ALL_PATTERNS.has(pattern)) ? {
+		...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) {
-		const { include, exclude } = normalizeIncludeFields(normalized.files, "files", reporter);
+		const { include, exclude } = withoutMatchAllSelection(normalizeIncludeFields(normalized.files, "files", reporter));
 		normalized.files = {
 			...normalized.files,
 			include,
@@ -267,32 +404,36 @@ function normalizeBiomeConfig(config, reporter) {
 		};
 	}
 	if (normalized.linter) {
-		const { include, exclude } = normalizeIncludeFields(normalized.linter, "linter", reporter);
+		const { include, exclude } = withoutMatchAllSelection(normalizeIncludeFields(normalized.linter, "linter", reporter));
 		normalized.linter = {
 			...normalized.linter,
 			include,
-			exclude,
+			exclude: withoutToolReincludes(exclude, "linter", normalized.files?.exclude, reporter),
 			includes: void 0
 		};
 	}
 	if (normalized.formatter) {
-		const { include, exclude } = normalizeIncludeFields(normalized.formatter, "formatter", reporter);
+		const { include, exclude } = withoutMatchAllSelection(normalizeIncludeFields(normalized.formatter, "formatter", 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
@@ -317,7 +458,7 @@ const SUPPORTED_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
 const IncludeFieldsSchema = z.object({
 	include: z.array(z.string()).optional(),
 	includes: z.array(z.string()).optional()
-}).passthrough();
+}).loose();
 const BiomeRuleSeveritySchema = z.union([z.enum([
 	"off",
 	"on",
@@ -333,7 +474,7 @@ const BiomeRuleSeveritySchema = z.union([z.enum([
 		"error"
 	]),
 	options: z.unknown().optional()
-}).passthrough()]);
+}).loose()]);
 const BiomeRuleGroupSchema = z.object({
 	recommended: z.boolean().optional(),
 	all: z.boolean().optional(),
@@ -383,7 +524,7 @@ const BiomeFormatterConfigSchema = IncludeFieldsSchema.extend({
 		"never"
 	]).optional(),
 	trailingNewline: z.boolean().optional()
-}).passthrough();
+}).loose();
 const BiomeJavaScriptFormatterSchema = z.object({
 	enabled: z.boolean().optional(),
 	quoteStyle: z.enum(["single", "double"]).optional(),
@@ -414,21 +555,21 @@ const BiomeJavaScriptFormatterSchema = z.object({
 	lineWidth: z.number().int().optional(),
 	operatorLinebreak: z.enum(["after", "before"]).optional(),
 	trailingNewline: z.boolean().optional()
-}).passthrough();
+}).loose();
 const BiomeJavaScriptConfigSchema = z.object({
 	parser: z.object({
 		unsafeParameterDecoratorsEnabled: z.boolean().optional(),
 		jsxEverywhere: z.boolean().optional()
-	}).passthrough().optional(),
+	}).loose().optional(),
 	formatter: BiomeJavaScriptFormatterSchema.optional(),
-	linter: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
+	linter: z.object({ enabled: z.boolean().optional() }).loose().optional(),
 	globals: z.array(z.string()).optional()
-}).passthrough();
+}).loose();
 const BiomeJsonConfigSchema = z.object({
 	parser: z.object({
 		allowComments: z.boolean().optional(),
 		allowTrailingCommas: z.boolean().optional()
-	}).passthrough().optional(),
+	}).loose().optional(),
 	formatter: z.object({
 		enabled: z.boolean().optional(),
 		expand: z.enum([
@@ -447,11 +588,11 @@ const BiomeJsonConfigSchema = z.object({
 		lineWidth: z.number().int().optional(),
 		trailingCommas: z.enum(["none", "all"]).optional(),
 		trailingNewline: z.boolean().optional()
-	}).passthrough().optional(),
-	linter: z.object({ enabled: z.boolean().optional() }).passthrough().optional()
-}).passthrough();
+	}).loose().optional(),
+	linter: z.object({ enabled: z.boolean().optional() }).loose().optional()
+}).loose();
 const BiomeCssConfigSchema = z.object({
-	parser: z.object({ cssModules: z.boolean().optional() }).passthrough().optional(),
+	parser: z.object({ cssModules: z.boolean().optional() }).loose().optional(),
 	formatter: z.object({
 		enabled: z.boolean().optional(),
 		indentStyle: z.enum(["tab", "space"]).optional(),
@@ -465,9 +606,9 @@ const BiomeCssConfigSchema = z.object({
 		lineWidth: z.number().int().optional(),
 		quoteStyle: z.enum(["single", "double"]).optional(),
 		trailingNewline: z.boolean().optional()
-	}).passthrough().optional(),
-	linter: z.object({ enabled: z.boolean().optional() }).passthrough().optional()
-}).passthrough();
+	}).loose().optional(),
+	linter: z.object({ enabled: z.boolean().optional() }).loose().optional()
+}).loose();
 const BiomeGraphqlConfigSchema = z.object({
 	formatter: z.object({
 		enabled: z.boolean().optional(),
@@ -483,18 +624,18 @@ const BiomeGraphqlConfigSchema = z.object({
 		lineWidth: z.number().int().optional(),
 		quoteStyle: z.enum(["single", "double"]).optional(),
 		trailingNewline: z.boolean().optional()
-	}).passthrough().optional(),
-	linter: z.object({ enabled: z.boolean().optional() }).passthrough().optional()
-}).passthrough();
+	}).loose().optional(),
+	linter: z.object({ enabled: z.boolean().optional() }).loose().optional()
+}).loose();
 const BiomeLinterConfigSchema = IncludeFieldsSchema.extend({
 	enabled: z.boolean().optional(),
 	ignore: z.array(z.string()).optional(),
 	rules: BiomeLinterRulesSchema.optional()
-}).passthrough();
+}).loose();
 const BiomeAssistActionSchema = z.union([z.enum(["off", "on"]), z.object({
 	level: z.enum(["off", "on"]),
 	options: z.unknown().optional()
-}).passthrough()]);
+}).loose()]);
 const BiomeAssistConfigSchema = z.object({
 	enabled: z.boolean().optional(),
 	includes: z.array(z.string()).optional(),
@@ -508,8 +649,8 @@ const BiomeAssistConfigSchema = z.object({
 				"none"
 			]).optional()
 		}).catchall(z.union([BiomeAssistActionSchema, z.boolean()])).optional()
-	}).passthrough().optional()
-}).passthrough();
+	}).loose().optional()
+}).loose();
 const BiomeOverrideSchema = z.object({
 	include: z.array(z.string()).optional(),
 	includes: z.array(z.string()).optional(),
@@ -521,7 +662,7 @@ const BiomeOverrideSchema = z.object({
 	json: BiomeJsonConfigSchema.optional(),
 	css: BiomeCssConfigSchema.optional(),
 	graphql: BiomeGraphqlConfigSchema.optional()
-}).passthrough();
+}).loose();
 const BiomeConfigSchema = z.object({
 	$schema: z.string().optional(),
 	extends: z.union([z.string(), z.array(z.string())]).optional(),
@@ -532,14 +673,14 @@ const BiomeConfigSchema = z.object({
 		ignore: z.array(z.string()).optional(),
 		ignoreUnknown: z.boolean().optional(),
 		maxSize: z.number().int().optional()
-	}).passthrough().optional(),
+	}).loose().optional(),
 	vcs: z.object({
 		enabled: z.boolean().optional(),
 		clientKind: z.literal("git").optional(),
 		useIgnoreFile: z.boolean().optional(),
 		root: z.string().optional(),
 		defaultBranch: z.string().optional()
-	}).passthrough().optional(),
+	}).loose().optional(),
 	linter: BiomeLinterConfigSchema.optional(),
 	formatter: BiomeFormatterConfigSchema.optional(),
 	assist: BiomeAssistConfigSchema.optional(),
@@ -549,8 +690,8 @@ const BiomeConfigSchema = z.object({
 	graphql: BiomeGraphqlConfigSchema.optional(),
 	html: z.record(z.string(), z.unknown()).optional(),
 	overrides: z.array(BiomeOverrideSchema).optional()
-}).passthrough();
-const WorkspacePackageJsonSchema$1 = z.object({ workspaces: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).optional() }).passthrough();
+}).loose();
+const WorkspacePackageJsonSchema$1 = z.object({ workspaces: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).optional() }).loose();
 async function findBiomeConfig(startDir) {
 	for (const name of BIOME_CONFIG_NAMES) {
 		const configPath = resolve(startDir, name);
@@ -1024,6 +1165,7 @@ const GLOBAL_FORMATTER_KEYS = /* @__PURE__ */ new Set([
 	"enabled",
 	"include",
 	"includes",
+	"exclude",
 	"ignore",
 	"formatWithErrors",
 	"indentStyle",
@@ -1227,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)];
 }
@@ -1306,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
@@ -1328,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"],
@@ -1540,12 +1689,21 @@ const REACT_COMPILER_RULES = [
 * is reported once per migration so the narrowing is visible rather than silent.
 */
 const PARTIAL_RULE_MAPPING_NOTES = {
+	noAssignInExpressions: "Biome rule noAssignInExpressions was mapped to no-cond-assign in `always` mode, which reports assignments inside conditions but not assignments nested in other expressions, such as `const a = (b = 1)` or a call argument.",
 	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.",
+	useConsistentCurlyBraces: "Biome rule useConsistentCurlyBraces was mapped to react/jsx-curly-brace-presence, which reports unnecessary braces around string literals in JSX props and children but not a JSX element passed as a prop value without braces (`foo=<Bar />`).",
+	useArrowFunction: "Biome rule useArrowFunction was mapped to prefer-arrow-callback, which reports function expressions passed as callbacks but not ones assigned to variables or properties, such as `const f = function () {}`.",
 	useExplicitType: "Biome rule useExplicitType was mapped to typescript/explicit-function-return-type, which requires return types on functions and methods but not types on variables or parameters.",
+	noUselessSwitchCase: "Biome rule noUselessSwitchCase was mapped to unicorn/no-useless-switch-case, which reports a case that falls through into a trailing `default` but not one next to a `default` placed earlier in the switch.",
 	useStaticResponseMethods: "Biome rule useStaticResponseMethods was mapped to unicorn/prefer-response-static-json, which reports `new Response(JSON.stringify(...))` but not the `new Response(null, { status, headers: { Location } })` form Biome rewrites to Response.redirect()."
 };
 /**
@@ -1562,8 +1720,77 @@ const TYPE_AWARE_RULE_FALLBACKS = {
 	useArrayFind: "unicorn/prefer-array-find",
 	useFind: "unicorn/prefer-array-find",
 	useIncludes: "unicorn/prefer-includes",
-	useStringStartsEndsWith: "unicorn/prefer-string-starts-ends-with"
+	useStringStartsEndsWith: "unicorn/prefer-string-starts-ends-with",
+	useThrowOnlyError: "no-throw-literal"
 };
+/**
+* Oxlint rules implemented by tsgolint, which only run when type-aware linting is on. A Biome
+* rule that maps onto one of them with no fallback above loses its diagnostics in a migration
+* that leaves type-aware linting off, so that is reported rather than emitted silently.
+* `rule-inventory.test.ts` keeps this list equal to `docs/tsgolint-rules.tsv`.
+*/
+const TYPE_AWARE_OXLINT_RULES = /* @__PURE__ */ new Set([
+	"typescript/await-thenable",
+	"typescript/consistent-return",
+	"typescript/consistent-type-exports",
+	"typescript/dot-notation",
+	"typescript/no-array-delete",
+	"typescript/no-base-to-string",
+	"typescript/no-confusing-void-expression",
+	"typescript/no-deprecated",
+	"typescript/no-duplicate-type-constituents",
+	"typescript/no-floating-promises",
+	"typescript/no-for-in-array",
+	"typescript/no-generated-empty-object-type",
+	"typescript/no-implied-eval",
+	"typescript/no-meaningless-void-operator",
+	"typescript/no-misused-promises",
+	"typescript/no-misused-spread",
+	"typescript/no-mixed-enums",
+	"typescript/no-redundant-type-constituents",
+	"typescript/no-unnecessary-boolean-literal-compare",
+	"typescript/no-unnecessary-condition",
+	"typescript/no-unnecessary-qualifier",
+	"typescript/no-unnecessary-template-expression",
+	"typescript/no-unnecessary-type-arguments",
+	"typescript/no-unnecessary-type-assertion",
+	"typescript/no-unnecessary-type-conversion",
+	"typescript/no-unnecessary-type-parameters",
+	"typescript/no-unsafe-argument",
+	"typescript/no-unsafe-assignment",
+	"typescript/no-unsafe-call",
+	"typescript/no-unsafe-enum-comparison",
+	"typescript/no-unsafe-member-access",
+	"typescript/no-unsafe-return",
+	"typescript/no-unsafe-type-assertion",
+	"typescript/no-unsafe-unary-minus",
+	"typescript/no-useless-default-assignment",
+	"typescript/non-nullable-type-assertion-style",
+	"typescript/only-throw-error",
+	"typescript/prefer-find",
+	"typescript/prefer-includes",
+	"typescript/prefer-nullish-coalescing",
+	"typescript/prefer-optional-chain",
+	"typescript/prefer-promise-reject-errors",
+	"typescript/prefer-readonly",
+	"typescript/prefer-readonly-parameter-types",
+	"typescript/prefer-reduce-type-parameter",
+	"typescript/prefer-regexp-exec",
+	"typescript/prefer-return-this-type",
+	"typescript/prefer-string-starts-ends-with",
+	"typescript/promise-function-async",
+	"typescript/related-getter-setter-pairs",
+	"typescript/require-array-sort-compare",
+	"typescript/require-await",
+	"typescript/restrict-plus-operands",
+	"typescript/restrict-template-expressions",
+	"typescript/return-await",
+	"typescript/strict-boolean-expressions",
+	"typescript/strict-void-return",
+	"typescript/switch-exhaustiveness-check",
+	"typescript/unbound-method",
+	"typescript/use-unknown-in-catch-callback-variable"
+]);
 /** Fallbacks that cover less than the type-aware rule they stand in for. */
 const TYPE_AWARE_FALLBACK_NOTES = { useStringStartsEndsWith: "Biome rule useStringStartsEndsWith was mapped to unicorn/prefer-string-starts-ends-with because type-aware linting is off; it reports anchored RegExp#test() prefix checks but not the indexOf(), slice() and charAt() comparisons Biome also reports. Enabling type-aware linting maps it to typescript/prefer-string-starts-ends-with instead, which covers all four." };
 const BIOME_TO_OXLINT_RULE_MAP = {
@@ -1628,7 +1855,11 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noDocumentImportInPage: "nextjs/no-document-import-in-page",
 	noDoneCallback: "jest/no-done-callback",
 	noDivRegex: "no-div-regex",
-	noEmptyBlockStatements: "no-empty",
+	noEmptyBlockStatements: [
+		"no-empty",
+		"no-empty-function",
+		"no-empty-static-block"
+	],
 	noEmptyCharacterClassInRegex: "no-empty-character-class",
 	noEmptyInterface: "typescript/no-empty-interface",
 	noEmptyPattern: "no-empty-pattern",
@@ -1664,7 +1895,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noImplicitCoercions: "no-implicit-coercion",
 	noInnerDeclarations: "no-inner-declarations",
 	noInlineStyles: "react/forbid-dom-props",
-	noImplicitBoolean: "no-implicit-coercion",
+	noImplicitBoolean: "react/jsx-boolean-value",
 	noImpliedEval: "no-implied-eval",
 	noIncrementDecrement: "no-plusplus",
 	noInferrableTypes: "typescript/no-inferrable-types",
@@ -1682,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",
@@ -1714,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",
@@ -1734,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",
@@ -1754,7 +1988,6 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noUnusedExpressions: "no-unused-expressions",
 	noUnusedFunctionParameters: "no-unused-vars",
 	noUnusedImports: "no-unused-vars",
-	noUnnecessaryContinue: "no-continue",
 	noUnmodifiedLoopCondition: "no-unmodified-loop-condition",
 	noUnnecessaryConditions: "typescript/no-unnecessary-condition",
 	noUnnecessaryTemplateExpression: "typescript/no-unnecessary-template-expression",
@@ -1774,7 +2007,6 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	noUnusedVariables: "no-unused-vars",
 	noUnwantedPolyfillio: "nextjs/no-unwanted-polyfillio",
 	noUselessCatch: "no-useless-catch",
-	noUselessContinue: "no-continue",
 	noUselessCatchBinding: "unicorn/prefer-optional-catch-binding",
 	noUselessConstructor: "no-useless-constructor",
 	noUselessElse: "no-else-return",
@@ -1830,7 +2062,7 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	useConsistentArrayType: "typescript/array-type",
 	useConsistentArrowReturn: "arrow-body-style",
 	useConsistentBuiltinInstantiation: "no-new-wrappers",
-	useConsistentCurlyBraces: "curly",
+	useConsistentCurlyBraces: "react/jsx-curly-brace-presence",
 	useConsistentEnumValueType: "typescript/no-mixed-enums",
 	useConsistentFunctionStyle: "func-style",
 	useConsistentMethodSignatures: "typescript/method-signature-style",
@@ -1905,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,
@@ -1918,10 +2151,10 @@ const BIOME_TO_OXLINT_RULE_MAP = {
 	useShorthandAssign: "operator-assignment",
 	useShorthandFunctionType: "typescript/prefer-function-type",
 	useSingleVarDeclarator: "one-var",
-	useSimplifiedLogicExpression: "unicorn/prefer-logical-operator-over-ternary",
 	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",
@@ -1968,12 +2201,13 @@ function normalizeOxlintRuleName(ruleName) {
 	return ruleName;
 }
 function mapBiomeRuleOptionsToOxlintSeverity(biomeName, severity, biomeSeverity, reporter) {
-	if (typeof severity !== "string") return severity;
+	if (typeof severity !== "string" || severity === "off") return severity;
 	if (biomeName === "useVueNextTickPromise") return [severity, "promise"];
 	const options = getBiomeRuleOptions(biomeSeverity);
 	if (biomeName === "noExcessiveNestedCallbacks") return [severity, { max: options && isNonNegativeInteger(options.max) ? options.max : 5 }];
 	if (biomeName === "useErrorCause") return [severity, { requireCatchParameter: options && typeof options.requireCatchParameter === "boolean" ? options.requireCatchParameter : true }];
 	if (biomeName === "useMaxParams") return [severity, { max: options && isNonNegativeInteger(options.max) ? options.max : 4 }];
+	if (biomeName === "noExcessiveCognitiveComplexity") return [severity, { max: options && isNonNegativeInteger(options.maxAllowedComplexity) ? options.maxAllowedComplexity : 15 }];
 	if (biomeName === "noExcessiveLinesPerFile") return [severity, {
 		max: options && isNonNegativeInteger(options.maxLines) ? options.maxLines : 300,
 		skipBlankLines: options?.skipBlankLines === true
@@ -1984,6 +2218,34 @@ function mapBiomeRuleOptionsToOxlintSeverity(biomeName, severity, biomeSeverity,
 		IIFEs: options?.skipIifes !== true
 	}];
 	if (biomeName === "useSingleVarDeclarator") return [severity, "never"];
+	if (biomeName === "noAssignInExpressions") return [severity, "always"];
+	if (biomeName === "noConfusingLabels") {
+		if (options?.allowedLabels !== void 0) reporter.loss("Biome rule noConfusingLabels option \"allowedLabels\" is not supported by Oxlint no-labels; those labels are reported again unless they label a loop.");
+		return [severity, { allowLoop: true }];
+	}
+	if (biomeName === "noDoubleEquals") return options?.ignoreNull === false ? [severity, "always"] : [
+		severity,
+		"always",
+		{ null: "ignore" }
+	];
+	if (biomeName === "noRestrictedGlobals") {
+		const denied = options?.deniedGlobals;
+		return [
+			severity,
+			"event",
+			"error",
+			...Array.isArray(denied) ? denied.filter((name) => typeof name === "string") : isRecord(denied) ? Object.entries(denied).map(([name, message]) => typeof message === "string" ? {
+				name,
+				message
+			} : name) : []
+		];
+	}
+	if (biomeName === "useConsistentMemberAccessibility") {
+		if (options?.accessibility === "explicit") return [severity, { accessibility: "explicit" }];
+		if (options?.accessibility === "none") reporter.loss("Biome rule useConsistentMemberAccessibility option \"accessibility\": \"none\" is not supported by Oxlint explicit-member-accessibility, which can forbid `public` but not `protected` or `private`; it was migrated as `no-public`.");
+		return [severity, { accessibility: "no-public" }];
+	}
+	if (biomeName === "noImplicitBoolean") return [severity, "always"];
 	if (biomeName === "noInlineStyles") return [severity, { forbid: ["style"] }];
 	if (biomeName === "useImportExtensions") {
 		if (options?.extensionMappings !== void 0 || options?.forceJsExtensions !== void 0) reporter.loss("Biome rule useImportExtensions options \"extensionMappings\" and \"forceJsExtensions\" are not supported by Oxlint import/extensions; the rule requires an extension without rewriting it.");
@@ -2146,30 +2408,37 @@ function mapBiomeRuleSeverity(severity, reporter, biomeRuleName) {
 	warnUnsupportedSeverityOnce(rawSeverity, reporter, biomeRuleName);
 	return "warn";
 }
-function mapBiomeRuleToOxlintRules(biomeName, reporter, typeAware) {
+/**
+* Maps a Biome rule to its Oxlint rules. Coverage gaps are only reported for an `enabled`
+* rule: a rule the Biome config turns off produced no diagnostics, so nothing is lost when
+* the Oxlint side covers less of it, or none of it.
+*/
+function mapBiomeRuleToOxlintRules(biomeName, reporter, typeAware, enabled = true) {
 	const fallback = typeAware ? void 0 : TYPE_AWARE_RULE_FALLBACKS[biomeName];
 	if (fallback) {
 		const fallbackNote = TYPE_AWARE_FALLBACK_NOTES[biomeName];
-		if (fallbackNote) warnPartialMappingOnce(biomeName, fallbackNote, reporter);
+		if (fallbackNote && enabled) warnPartialMappingOnce(biomeName, fallbackNote, reporter);
 		return [normalizeOxlintRuleName(fallback)];
 	}
 	const mapped = BIOME_TO_OXLINT_RULE_MAP[biomeName];
 	if (mapped) {
 		const partialMappingNote = PARTIAL_RULE_MAPPING_NOTES[biomeName];
-		if (partialMappingNote) warnPartialMappingOnce(biomeName, partialMappingNote, reporter);
-		return [...new Set((Array.isArray(mapped) ? mapped : [mapped]).map((ruleName) => normalizeOxlintRuleName(ruleName)))];
+		if (partialMappingNote && enabled) warnPartialMappingOnce(biomeName, partialMappingNote, reporter);
+		const ruleNames = [...new Set((Array.isArray(mapped) ? mapped : [mapped]).map(normalizeOxlintRuleName))];
+		if (!typeAware && enabled) for (const ruleName of ruleNames.filter((name) => TYPE_AWARE_OXLINT_RULES.has(name))) warnPartialMappingOnce(`${biomeName}::${ruleName}`, `Biome rule ${biomeName} was mapped to ${ruleName}, a type-aware Oxlint rule that only runs with type-aware linting, so its diagnostics are not reported. Re-run the migration with --type-aware to keep them.`, reporter);
+		return ruleNames;
 	}
-	warnUnmappedRuleOnce(biomeName, reporter);
+	if (enabled) warnUnmappedRuleOnce(biomeName, reporter);
 	return [];
 }
-function warnPartialMappingOnce(biomeName, note, reporter) {
+function warnPartialMappingOnce(key, note, reporter) {
 	let warnedRules = WARNED_PARTIAL_MAPPINGS_BY_REPORTER.get(reporter);
 	if (!warnedRules) {
 		warnedRules = /* @__PURE__ */ new Set();
 		WARNED_PARTIAL_MAPPINGS_BY_REPORTER.set(reporter, warnedRules);
 	}
-	if (warnedRules.has(biomeName)) return;
-	warnedRules.add(biomeName);
+	if (warnedRules.has(key)) return;
+	warnedRules.add(key);
 	reporter.loss(note);
 }
 function warnUnmappedRuleOnce(biomeName, reporter) {
@@ -2215,6 +2484,7 @@ function extractRulesFromBiomeConfig(linterRules, reporter, options = {}) {
 		sourceRulesSkipped
 	};
 	applyTopLevelPreset(linterRules, categories, reporter, applyImplicitRecommended);
+	const sourcesByOxlintRule = /* @__PURE__ */ new Map();
 	for (const [key, value] of Object.entries(linterRules)) {
 		if (key === "recommended" || key === "all" || key === "preset") continue;
 		if (typeof value === "boolean") continue;
@@ -2233,11 +2503,18 @@ function extractRulesFromBiomeConfig(linterRules, reporter, options = {}) {
 				if (ruleName === "recommended" || ruleName === "all" || ruleName === "preset") continue;
 				if (typeof ruleSeverity === "boolean" || ruleSeverity === void 0) continue;
 				if (!isBiomeRuleSeverity(ruleSeverity)) continue;
-				const oxlintRuleNames = mapBiomeRuleToOxlintRules(ruleName, reporter, typeAware);
+				const oxlintRuleNames = mapBiomeRuleToOxlintRules(ruleName, reporter, typeAware, (typeof ruleSeverity === "string" ? ruleSeverity : ruleSeverity.level) !== "off");
 				if (oxlintRuleNames.length > 0) {
 					sourceRulesConverted.add(ruleName);
 					const oxlintSeverity = mapBiomeRuleOptionsToOxlintSeverity(ruleName, mapBiomeRuleSeverity(ruleSeverity, reporter, ruleName), ruleSeverity, reporter);
-					for (const oxlintRuleName of oxlintRuleNames) rules[oxlintRuleName] = oxlintSeverity;
+					for (const oxlintRuleName of oxlintRuleNames) {
+						const sources = sourcesByOxlintRule.get(oxlintRuleName) ?? [];
+						sources.push({
+							biomeRule: ruleName,
+							severity: oxlintSeverity
+						});
+						sourcesByOxlintRule.set(oxlintRuleName, sources);
+					}
 				} else sourceRulesSkipped.add(ruleName);
 			}
 			const groupPreset = value.preset;
@@ -2245,6 +2522,7 @@ function extractRulesFromBiomeConfig(linterRules, reporter, options = {}) {
 			if (oxlintCategory && groupEnabled !== void 0) categories[oxlintCategory] = groupEnabled ? "warn" : "off";
 		}
 	}
+	for (const [oxlintRuleName, sources] of sourcesByOxlintRule) rules[oxlintRuleName] = resolveSharedRuleSeverity(oxlintRuleName, sources, reporter);
 	return {
 		rules,
 		categories,
@@ -2252,6 +2530,48 @@ function extractRulesFromBiomeConfig(linterRules, reporter, options = {}) {
 		sourceRulesSkipped
 	};
 }
+const SEVERITY_RANK = {
+	off: 0,
+	warn: 1,
+	error: 2
+};
+function severityLevel(severity) {
+	return typeof severity === "string" ? severity : severity[0];
+}
+/**
+* Resolves one Oxlint rule that several configured Biome rules map onto.
+*
+* Writing each source in turn would let whichever Biome rule the config lists last decide,
+* so `noUnusedFunctionParameters: "off"` listed after `noUnusedVariables: "error"` would turn
+* off `no-unused-vars` and drop every unused-variable diagnostic. Instead the strongest
+* severity wins, because an enabled Biome rule's diagnostics are behaviour to keep, while a
+* disabled one only means that Biome rule stayed quiet. What the shared rule then reports
+* beyond the enabled sources is surfaced rather than hidden.
+*/
+function resolveSharedRuleSeverity(oxlintRuleName, sources, reporter) {
+	const [first] = sources;
+	const enabled = sources.filter(({ severity }) => severityLevel(severity) !== "off");
+	if (!first || sources.length === 1 || enabled.length === 0) return first?.severity ?? "off";
+	const strongest = enabled.reduce((current, candidate) => SEVERITY_RANK[severityLevel(candidate.severity)] > SEVERITY_RANK[severityLevel(current.severity)] ? candidate : current);
+	const optionSets = /* @__PURE__ */ new Map();
+	for (const { severity } of enabled) if (typeof severity !== "string") optionSets.set(JSON.stringify(severity.slice(1)), severity.slice(1));
+	if (optionSets.size > 1) reporter.loss(`Biome rules ${formatRuleList(enabled)} all map to Oxlint ${oxlintRuleName} with different options; Oxlint accepts one set, so the options of ${strongest.biomeRule} were kept and the others were not migrated.`);
+	const level = severityLevel(strongest.severity);
+	const options = typeof strongest.severity === "string" ? [...optionSets.values()][0] ?? [] : strongest.severity.slice(1);
+	const disabled = sources.filter(({ severity }) => severityLevel(severity) === "off");
+	if (oxlintRuleName === "no-unused-vars" && disabled.length === 1 && disabled[0]?.biomeRule === "noUnusedFunctionParameters") {
+		const [currentOptions] = options;
+		return [level, {
+			...isRecord(currentOptions) ? currentOptions : {},
+			args: "none"
+		}];
+	}
+	if (disabled.length > 0) reporter.warn(`Biome ${formatRuleList(disabled)} ${disabled.length === 1 ? "is" : "are"} off, but Oxlint ${oxlintRuleName} also implements ${formatRuleList(enabled)}, which ${enabled.length === 1 ? "is" : "are"} on; Oxlint will also report what ${disabled.length === 1 ? "that rule" : "those rules"} would have reported.`);
+	return options.length > 0 ? [level, ...options] : level;
+}
+function formatRuleList(sources) {
+	return sources.map(({ biomeRule }) => biomeRule).join(", ");
+}
 function applyTopLevelPreset(linterRules, categories, reporter, applyImplicitRecommended) {
 	const preset = linterRules.preset ?? (linterRules.all === true ? "all" : linterRules.all === false || linterRules.recommended === false ? "none" : linterRules.recommended === true ? "recommended" : applyImplicitRecommended ? "recommended" : void 0);
 	if (!preset) return;
@@ -2377,7 +2697,7 @@ function generateOxlintConfig(biomeConfig, reporter, options = {}) {
 	if (options.enableImportGraph && !linterDisabled) addImportGraphRecipe(oxlintConfig, options.importCycleMaxDepth ?? 3);
 	determinePlugins(oxlintConfig);
 	mapIgnorePatterns(biomeConfig, oxlintConfig, options.biomeIgnorePatterns ?? []);
-	mapEnvironment(biomeConfig, oxlintConfig);
+	mapEnvironment(biomeConfig, oxlintConfig, linterDisabled);
 	mapTypeAwareOptions(oxlintConfig, options.typeAware ?? false, options.typeCheck ?? false);
 	mapSettings(biomeConfig, oxlintConfig, options.typeAwareProfile ?? "standard");
 	return {
@@ -2396,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 ??= {};
@@ -2441,15 +2763,25 @@ 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)];
 }
-function mapEnvironment(biomeConfig, oxlintConfig) {
+/**
+* Biome resolves browser and Node.js globals without any configuration, while Oxlint only
+* knows ECMAScript builtins until an `env` names more. Without these two environments
+* `no-undef` reports `window`, `console` and `process`, and `no-global-assign` and
+* `no-implied-eval` stop recognising the globals they guard, so each would diverge from the
+* Biome rule it replaces. Both environments together match Biome's set of known globals.
+*/
+function mapEnvironment(biomeConfig, oxlintConfig, linterDisabled) {
+	if (!linterDisabled) oxlintConfig.env = {
+		browser: true,
+		node: true
+	};
 	if (biomeConfig.javascript?.globals) {
 		const globals = {};
 		for (const globalVar of biomeConfig.javascript.globals) globals[globalVar] = "readonly";
@@ -2494,7 +2826,7 @@ const PackageJsonSchema = z.object({
 const ToolVersionManifestSchema = z.object({
 	dependencies: z.record(z.string(), z.string()).optional(),
 	devDependencies: z.record(z.string(), z.string()).optional()
-}).passthrough();
+}).loose();
 let recommendedToolVersionsPromise;
 async function updatePackageJson(projectDir, reporter, dryRun, options = {}) {
 	const packageJsonPath = await findClosestPackageJson(projectDir) ?? resolve(projectDir, "package.json");
@@ -2505,6 +2837,7 @@ async function updatePackageJson(projectDir, reporter, dryRun, options = {}) {
 		scriptsUpdated: [],
 		dependenciesRemoved: [],
 		devDependencies: [],
+		scriptsStillUsingBiome: [],
 		changed: false
 	};
 	try {
@@ -2533,16 +2866,16 @@ async function updatePackageJson(projectDir, reporter, dryRun, options = {}) {
 			oxfmtCommand
 		}) || modified;
 		const scriptsStillUsingBiome = Object.entries(packageJson.scripts ?? {}).filter(([, script]) => containsBiomeExecutable(script)).map(([name]) => name);
+		summary.scriptsStillUsingBiome = scriptsStillUsingBiome;
 		if (!removeBiomeAllowed) reporter.info("Keeping @biomejs/biome: removing it requires --delete and a migration with no semantic losses.");
-		else if (scriptsStillUsingBiome.length > 0) reporter.warn(`Keeping @biomejs/biome because these package scripts still invoke Biome: ${scriptsStillUsingBiome.join(", ")}`);
+		else if (scriptsStillUsingBiome.length > 0) reporter.warn(`Keeping @biomejs/biome and the Biome config because these package scripts still invoke Biome: ${scriptsStillUsingBiome.join(", ")}`);
 		else {
 			if (packageJson.devDependencies) modified = removeBiomeDependency(packageJson.devDependencies, "devDependencies", summary.dependenciesRemoved, reporter) || modified;
 			if (packageJson.dependencies) modified = removeBiomeDependency(packageJson.dependencies, "dependencies", summary.dependenciesRemoved, reporter) || modified;
 		}
-		packageJson.devDependencies ??= {};
-		modified = ensureDevDependency(packageJson.devDependencies, "oxlint", recommendedVersions.oxlint, summary.devDependencies) || modified;
-		modified = ensureDevDependency(packageJson.devDependencies, "oxfmt", recommendedVersions.oxfmt, summary.devDependencies) || modified;
-		if (needsTypeAwareDependency) modified = ensureDevDependency(packageJson.devDependencies, "oxlint-tsgolint", recommendedVersions["oxlint-tsgolint"], summary.devDependencies) || modified;
+		modified = ensureDevDependency(packageJson, "oxlint", recommendedVersions.oxlint, summary.devDependencies) || modified;
+		modified = ensureDevDependency(packageJson, "oxfmt", recommendedVersions.oxfmt, summary.devDependencies) || modified;
+		if (needsTypeAwareDependency) modified = ensureDevDependency(packageJson, "oxlint-tsgolint", recommendedVersions["oxlint-tsgolint"], summary.devDependencies) || modified;
 		summary.changed = modified;
 		const dependenciesChanged = summary.dependenciesRemoved.length > 0 || summary.devDependencies.some((change) => change.action !== "already-present");
 		summary.lockfile = await detectLockfile(dirname(packageJsonPath), dependenciesChanged);
@@ -2769,7 +3102,7 @@ function replaceBiomeCommand(script, command, checkReplacement, fixByStrategy, d
 			const cleanedArgs = args.replace(/\s--(write|fix|unsafe)\b/gu, "").trim();
 			const suffix = cleanedArgs.length > 0 ? ` ${cleanedArgs}` : "";
 			const effectiveFixStrategy = hasUnsafe ? escalateFixStrategy(defaultFixStrategy, "dangerous") : defaultFixStrategy;
-			return `${leading}${applySuffixToCommands(hasFix || hasUnsafe ? fixByStrategy[effectiveFixStrategy] : checkReplacement, suffix)}`;
+			return `${leading}${applySuffixToCommands(hasFix ? fixByStrategy[effectiveFixStrategy] : checkReplacement, suffix)}`;
 		}),
 		didReplace
 	};
@@ -2815,9 +3148,18 @@ function removeBiomeDependency(dependencies, dependencyType, removals, reporter)
 	}
 	return modified;
 }
-function ensureDevDependency(dependencies, name, version, changes) {
+/**
+* Makes sure an Oxc tool is installed at least at the version this migration targets.
+*
+* An existing entry is only raised when it is a plain semver range whose minimum is older
+* than the target. A newer range, a `catalog:`/`workspace:` protocol or a dist-tag is the
+* project's own choice, and an entry under `dependencies` already installs the tool, so
+* those are left alone rather than downgraded, broken, or duplicated.
+*/
+function ensureDevDependency(packageJson, name, version, changes) {
+	const dependencies = [packageJson.devDependencies, packageJson.dependencies].find((candidate) => candidate?.[name] !== void 0) ?? (packageJson.devDependencies ??= {});
 	const existing = dependencies[name];
-	if (!existing) {
+	if (existing === void 0) {
 		dependencies[name] = version;
 		changes.push({
 			name,
@@ -2826,21 +3168,32 @@ function ensureDevDependency(dependencies, name, version, changes) {
 		});
 		return true;
 	}
-	if (existing !== version) {
-		dependencies[name] = version;
+	if (!isOlderSemverRange(existing, version)) {
 		changes.push({
 			name,
-			action: "updated",
-			from: existing,
-			to: version
+			action: "already-present",
+			to: existing
 		});
-		return true;
+		return false;
 	}
+	dependencies[name] = version;
 	changes.push({
 		name,
-		action: "already-present",
-		to: existing
+		action: "updated",
+		from: existing,
+		to: version
 	});
+	return true;
+}
+const SEMVER_RANGE_PATTERN = /^(?:\^|~|>=)?(\d+)\.(\d+)\.(\d+)/u;
+function isOlderSemverRange(existing, target) {
+	const existingVersion = SEMVER_RANGE_PATTERN.exec(existing.trim());
+	const targetVersion = SEMVER_RANGE_PATTERN.exec(target.trim());
+	if (!existingVersion || !targetVersion) return false;
+	for (let index = 1; index <= 3; index++) {
+		const difference = Number(existingVersion[index]) - Number(targetVersion[index]);
+		if (difference !== 0) return difference < 0;
+	}
 	return false;
 }
 async function getRecommendedToolVersions() {
@@ -3075,7 +3428,7 @@ const LEGACY_BIOME_CONFIG_NAMES = [
 	".biome.jsonc"
 ];
 var MigrationStepFailedError = class extends Error {};
-const WorkspacePackageJsonSchema = z.object({ workspaces: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).optional() }).passthrough();
+const WorkspacePackageJsonSchema = z.object({ workspaces: z.union([z.array(z.string()), z.record(z.string(), z.unknown())]).optional() }).loose();
 async function migrate(options = {}, reporter = new CollectingReporter()) {
 	const cwd = process.cwd();
 	const biomeConfigPath = options.configPath ? resolve(cwd, options.configPath) : await findBiomeConfig(cwd);
@@ -3248,7 +3601,7 @@ async function runMigration(options, reporter, biomeConfigPath) {
 				await updateTurboConfig(projectDir, reporter, false, options.signal);
 				throwIfMigrationErrorsIncreased(turboErrorCount, reporter);
 			}
-			if (cleanupAllowed) {
+			if (cleanupAllowed && !biomeStillInvoked(packageJsonSummary)) {
 				deleteWasAttempted = true;
 				deletedLegacyFiles = await cleanupLegacyBiomeFiles(projectDir, biomeConfigPath, false, reporter, options.signal);
 			}
@@ -3277,7 +3630,7 @@ async function runMigration(options, reporter, biomeConfigPath) {
 				await updateTurboConfig(projectDir, reporter, true, options.signal);
 				throwIfMigrationErrorsIncreased(turboErrorCount, reporter);
 			}
-			if (cleanupAllowed) {
+			if (cleanupAllowed && !biomeStillInvoked(packageJsonSummary)) {
 				deleteWasAttempted = true;
 				deletedLegacyFiles = await cleanupLegacyBiomeFiles(projectDir, biomeConfigPath, true, reporter, options.signal);
 			}
@@ -3300,6 +3653,7 @@ async function runMigration(options, reporter, biomeConfigPath) {
 		deletedLegacyFiles,
 		dryRun: options.dryRun ?? false,
 		semanticLosses: reporter.getLosses(),
+		scriptsStillUsingBiome: packageJsonSummary?.scriptsStillUsingBiome ?? [],
 		suggestions
 	});
 	if (packageJsonSummary?.lockfile?.stale) suggestions.push(`Dependencies changed: run \`${packageJsonSummary.lockfile.installCommand}\` to refresh ${packageJsonSummary.lockfile.path} before any frozen-lockfile install.`);
@@ -3369,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}`);
 	}
@@ -3415,7 +3769,7 @@ function reconcileVcsIgnoreSettings(biomeConfig, reporter) {
 	reporter.warn("Biome vcs is enabled without useIgnoreFile, so Biome ignored .gitignore. Oxfmt reads .gitignore by default and will therefore skip files Biome formatted; pass --ignore-path to override.");
 	if (vcs.root !== void 0 || vcs.defaultBranch !== void 0) reporter.loss("Biome vcs.root/vcs.defaultBranch scoping (used by Biome’s changed-files filtering) has no Oxlint or Oxfmt equivalent and was not migrated.");
 }
-function buildCleanupOutcome({ requested, cleanupAllowed, deleteWasAttempted, deletedLegacyFiles, dryRun, semanticLosses, suggestions }) {
+function buildCleanupOutcome({ requested, cleanupAllowed, deleteWasAttempted, deletedLegacyFiles, dryRun, semanticLosses, scriptsStillUsingBiome, suggestions }) {
 	if (!requested) return {
 		requested: false,
 		performed: false,
@@ -3433,6 +3787,16 @@ function buildCleanupOutcome({ requested, cleanupAllowed, deleteWasAttempted, de
 			files: []
 		};
 	}
+	if (scriptsStillUsingBiome.length > 0) {
+		const blockedReason = `package scripts still invoke Biome: ${scriptsStillUsingBiome.join(", ")}`;
+		suggestions.push(`--delete was skipped because ${blockedReason}. Deleting the Biome config would leave them running with Biome's defaults; update them (or re-run with --update-scripts), then re-run with --delete.`);
+		return {
+			requested: true,
+			performed: false,
+			blockedReason,
+			files: []
+		};
+	}
 	if (!deleteWasAttempted) {
 		const blockedReason = "the migration did not complete successfully";
 		suggestions.push(`--delete skipped because ${blockedReason}.`);
@@ -3460,6 +3824,10 @@ function buildCleanupOutcome({ requested, cleanupAllowed, deleteWasAttempted, de
 		files: deletedLegacyFiles
 	};
 }
+/** Scripts that still run Biome need its config, so it cannot be deleted from under them. */
+function biomeStillInvoked(summary) {
+	return (summary?.scriptsStillUsingBiome.length ?? 0) > 0;
+}
 async function detectWorkspaceMonorepo(projectDir) {
 	const packageJsonPath = resolve(projectDir, "package.json");
 	if (!await pathExists(packageJsonPath)) return false;
@@ -3546,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;
@@ -3557,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.0",
+  "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",
-    "tsdown": "rc",
+    "publint": "^0.3.25",
+    "tsdown": "0.23.0",
     "typescript": "next",
-    "vitest": "^5.0.2"
+    "vitest": "^5.0.3"
   },
   "engines": {
-    "node": ">=24.19.0",
-    "pnpm": ">=11.25.0"
+    "node": ">=24.21.0",
+    "pnpm": ">=11.28.5"
   },
-  "packageManager": "pnpm@11.25.0"
+  "packageManager": "pnpm@11.28.5"
 }