eslint-plugin-oxfmt 0.5.1 → 0.6.1

package/README.md

@@ -13,7 +13,7 @@
 - 🔧 **Auto-fix** - Automatically format code on save or via ESLint's fix command
 - 🎯 **ESLint Integration** - Seamlessly integrates with ESLint v9+ flat config
 - 📦 **Zero Config** - Works out of the box with sensible defaults
-- 🧩 **Config File Discovery** - Supports `.oxfmtrc.json`, `.oxfmtrc.jsonc`, and `oxfmt.config.ts`
+- 🧩 **Config File Discovery** - Auto-discovers `.oxfmtrc.json`, `.oxfmtrc.jsonc`, and `oxfmt.config.ts`
 - 📝 **EditorConfig Integration** - Respects a subset of `.editorconfig` options via [oxfmt's strategy](https://oxc.rs/docs/guide/usage/formatter/config#editorconfig)
 - 🎨 **Highly Configurable** - Supports all oxfmt formatting options
 - 🌐 **Multi-language Support** - JavaScript, TypeScript, JSX, TSX and [more](https://oxc.rs/docs/guide/usage/formatter.html#supported-languages)
@@ -71,6 +71,20 @@ export default [
 ]
 ```
 
+For CLI-like ignore/config behavior, use `cliParity`:
+
+```js
+// eslint.config.mjs
+import pluginOxfmt from 'eslint-plugin-oxfmt'
+
+export default [
+  {
+    ...pluginOxfmt.configs.cliParity,
+    files: ['**/*.{js,ts,mjs,cjs,jsx,tsx,json,jsonc,yaml,yml}'],
+  },
+]
+```
+
 ### Custom Configuration
 
 You can customize the formatting options by configuring the rule:
@@ -157,10 +171,15 @@ All options are optional and default to sensible values.
 
 ### Plugin Options
 
-| Option       | Type      | Default | Description                                                                                                                                                               |
-| ------------ | --------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `useConfig`  | `boolean` | `true`  | Load `.oxfmtrc.json`, `.oxfmtrc.jsonc`, or `oxfmt.config.ts` via `load-oxfmt-config` (with `.editorconfig` merge support). Set to `false` to rely only on inline options. |
-| `configPath` | `string`  | —       | Custom path to an oxfmt config file. Resolved from ESLint `cwd` when set.                                                                                                 |
+| Option                       | Type                                             | Default | Description                                                                                                                                                                                                  |
+| ---------------------------- | ------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `useConfig`                  | `boolean`                                        | `true`  | Load `.oxfmtrc.json`, `.oxfmtrc.jsonc`, or `oxfmt.config.*` via `load-oxfmt-config`. Set to `false` to rely only on inline options.                                                                          |
+| `configPath`                 | `string`                                         | —       | Custom path to an oxfmt config file. Relative paths resolve from ESLint `cwd`; absolute paths are used as-is. Explicit `configPath` accepts `.json`, `.jsonc`, `.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`. |
+| `editorconfig`               | `boolean \| { onlyCwd?: boolean; cwd?: string }` | `true`  | Control `.editorconfig` loading. Use `false` to disable, or object form for advanced resolution strategy.                                                                                                    |
+| `ignorePath`                 | `string \| string[]`                             | —       | Ignore file path(s) for CLI-style ignore resolution (same role as CLI `--ignore-path`).                                                                                                                      |
+| `withNodeModules`            | `boolean`                                        | `false` | Include files under `node_modules` during ignore checks.                                                                                                                                                     |
+| `disableNestedConfig`        | `boolean`                                        | `false` | Disable nested config discovery and resolve config from `cwd` / `configPath` only.                                                                                                                           |
+| `respectOxfmtDefaultIgnores` | `boolean`                                        | `true`  | Respect oxfmt default ignores (`.gitignore`, `.prettierignore`, default ignored directories, default ignored lockfiles).                                                                                     |
 
 > Note: `cwd` is taken from ESLint automatically; you usually do not need to set it manually.
 > `.editorconfig` merge behavior follows oxfmt's documented strategy: https://oxc.rs/docs/guide/usage/formatter/config#editorconfig
@@ -171,10 +190,15 @@ When `useConfig` is `true`, the plugin loads config using `load-oxfmt-config`.
 
 - Config discovery order (from `cwd`, walking upward): `.oxfmtrc.json` → `.oxfmtrc.jsonc` → `oxfmt.config.ts`
 - `.editorconfig` support: nearest `.editorconfig` (including section overrides) is merged into the final options
+- Set `editorconfig: false` to disable `.editorconfig` merging
+- Set `editorconfig: { onlyCwd: true }` to read only the current `cwd`'s `.editorconfig` (no upward traversal)
+- Set `editorconfig: { cwd: '/path/to/base' }` to customize editorconfig resolution base directory
 - `configPath` overrides discovery and directly targets the specified config file
+- `configPath` supports explicit file paths with extensions: `.json`, `.jsonc`, `.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`
 - ESLint rule options generally take highest priority because inline rule options are merged after loaded config.
-- When `useConfig` is `true`, rule-level `overrides` are ignored. Only `overrides` loaded from the resolved oxfmt config file are applied.
-- Rule-level `ignorePatterns` still override config-derived `ignorePatterns` when provided.
+- Rule-level `ignorePatterns` are resolved relative to ESLint `cwd`; config-level `ignorePatterns` are resolved relative to the resolved config file directory.
+- When `useConfig` is `true`, config `overrides` are applied first and rule-level `overrides` are appended after them (later entries win on conflicts).
+- When `useConfig` is `false`, config discovery and config `ignorePatterns` are skipped, while global ignores still apply when `respectOxfmtDefaultIgnores` is enabled.
 
 For detailed behavior, see:
 
@@ -381,12 +405,31 @@ This plugin provides a single rule that formats your code using oxfmt.
 - Fixable: Yes (automatically applies formatting)
 - Type: Layout
 
+## CLI parity mode
+
+`oxfmt/cli-parity` tries to match `oxfmt` CLI behavior for files processed by ESLint.
+
+It respects:
+
+- `.oxfmtrc.json`
+- `.oxfmtrc.jsonc`
+- `oxfmt.config.*`
+- `.editorconfig`
+- `ignorePatterns`
+- `.gitignore`
+- `.prettierignore`
+- default ignored directories
+- default ignored lockfiles
+
+Note: ESLint still controls file discovery. Files excluded by ESLint will never reach this rule.
+
 ## Integration
 
 ### Parser Compatibility
 
 - `recommended`: forces `eslint-parser-plain` for matched files
 - `recommendedWithoutParser`: parser-agnostic (safe to compose with language-specific parsers)
+- `cliParity`: parser-agnostic preset tuned for CLI-like config/ignore behavior
 
 When composing shareable configs, prefer `recommendedWithoutParser` if parser ownership belongs to another preset.
 

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import * as _$eslint from "eslint";
 import { Linter, Rule } from "eslint";
-
 //#region src/types.d.ts
 interface PluginOxfmt {
   configs: {
+    cliParity: Linter.Config<Linter.RulesRecord>;
     recommended: Linter.Config<Linter.RulesRecord>;
     recommendedWithoutParser: Linter.Config<Linter.RulesRecord>;
   };
@@ -33,9 +33,10 @@ declare const parserPlain: Linter.Parser;
 //#region src/configs.d.ts
 declare const recommendedWithoutParser: Linter.Config<Linter.RulesRecord>;
 declare const recommended: Linter.Config<Linter.RulesRecord>;
+declare const cliParity: Linter.Config<Linter.RulesRecord>;
 declare const configs: PluginOxfmt['configs'];
 //#endregion
 //#region src/index.d.ts
 declare const plugin: PluginOxfmt;
 //#endregion
-export { configs, plugin as default, plugin, meta, parserPlain, recommended, recommendedWithoutParser, rules };
+export { cliParity, configs, plugin as default, plugin, meta, parserPlain, recommended, recommendedWithoutParser, rules };

package/dist/index.mjs

@@ -60,7 +60,18 @@ const recommended = {
 	name: "oxfmt/recommended",
 	languageOptions: { parser: parserPlain }
 };
+const cliParity = {
+	...recommendedWithoutParser,
+	name: "oxfmt/cli-parity",
+	rules: { "oxfmt/oxfmt": ["error", {
+		disableNestedConfig: false,
+		respectOxfmtDefaultIgnores: true,
+		useConfig: true,
+		withNodeModules: false
+	}] }
+};
 const configs = {
+	cliParity,
 	recommended,
 	recommendedWithoutParser
 };
@@ -68,7 +79,7 @@ const configs = {
 //#region src/meta.ts
 const meta = {
 	name: "eslint-plugin-oxfmt",
-	version: "0.5.1"
+	version: "0.6.1"
 };
 //#endregion
 //#region src/dir.ts
@@ -184,7 +195,7 @@ const oxfmtOptionsSchema = {
 			type: "string"
 		},
 		ignorePatterns: {
-			description: `Ignore files matching these glob patterns. Current working directory is used as the root.`,
+			description: `Ignore files matching these glob patterns. Rule-level ignorePatterns are resolved relative to ESLint cwd. Config ignorePatterns are resolved relative to the config file directory.`,
 			type: "array",
 			items: { type: "string" }
 		},
@@ -458,8 +469,48 @@ const oxfmtConfigSchema = {
 			description: `Path to Oxfmt configuration file.\nIf you provide an absolute path, Oxfmt will use it directly.\n If not provided, Oxfmt will search for configuration files starting from the current working directory upwards.\n\n- (Default: undefined)`,
 			type: "string"
 		},
+		disableNestedConfig: {
+			default: false,
+			description: `Disable nested config lookup and resolve from cwd/configPath only. (Default: false)`,
+			type: "boolean"
+		},
+		editorconfig: {
+			description: `Control .editorconfig reading.\n- true: enable with default behavior.\n- false: disable .editorconfig reading.\n- object: enable with advanced options (onlyCwd/cwd).\n\n- (Default: true)`,
+			oneOf: [{ type: "boolean" }, {
+				additionalProperties: false,
+				type: "object",
+				properties: {
+					cwd: {
+						description: `Override directory used as the start point for .editorconfig resolution.`,
+						type: "string"
+					},
+					onlyCwd: {
+						description: `When true, only read .editorconfig from cwd (no upward traversal).`,
+						type: "boolean"
+					}
+				}
+			}]
+		},
+		ignorePath: {
+			description: `Path(s) to ignore files used for CLI-style ignore resolution. Accepts a single path or multiple paths. (Default: undefined)`,
+			oneOf: [{ type: "string" }, {
+				type: "array",
+				items: { type: "string" }
+			}]
+		},
+		respectOxfmtDefaultIgnores: {
+			default: true,
+			description: `Whether to respect oxfmt default ignores (.gitignore, .prettierignore, lockfiles, default directories). (Default: true)`,
+			type: "boolean"
+		},
 		useConfig: {
-			description: `Whether to load Oxfmt configuration file.\n\n- (Default: true)`,
+			default: true,
+			description: `Whether to load Oxfmt configuration file. (Default: true)`,
+			type: "boolean"
+		},
+		withNodeModules: {
+			default: false,
+			description: `Whether to include files inside node_modules during ignore resolution. (Default: false)`,
 			type: "boolean"
 		}
 	}
@@ -528,6 +579,7 @@ const rules = { oxfmt: {
 					...context.options?.[0],
 					cwd: context.cwd
 				});
+				if (formatResult.ignored) return;
 				if (formatResult.errors?.length) for (const error of formatResult.errors) {
 					const label = error.labels?.[0];
 					if (label) {
@@ -582,4 +634,4 @@ const plugin = {
 	rules
 };
 //#endregion
-export { configs, plugin as default, plugin, meta, parserPlain, recommended, recommendedWithoutParser, rules };
+export { cliParity, configs, plugin as default, plugin, meta, parserPlain, recommended, recommendedWithoutParser, rules };

package/dts/rule-options.d.ts

@@ -134,8 +134,23 @@ export type OxfmtOxfmt = []|[{
   
   configPath?: string
   
+  disableNestedConfig?: boolean
+  
+  editorconfig?: (boolean | {
+    
+    cwd?: string
+    
+    onlyCwd?: boolean
+  })
+  
+  ignorePath?: (string | string[])
+  
+  respectOxfmtDefaultIgnores?: boolean
+  
   useConfig?: boolean
   
+  withNodeModules?: boolean
+  
   overrides?: {
     
     excludeFiles?: string[]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-oxfmt",
   "type": "module",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "An ESLint plugin for formatting code with oxfmt.",
   "keywords": [
     "eslint",
@@ -48,17 +48,17 @@
   },
   "dependencies": {
     "generate-differences": "^0.1.1",
-    "load-oxfmt-config": "^0.4.1",
+    "load-oxfmt-config": "^0.7.2",
     "picomatch": "^4.0.4",
     "synckit": "^0.11.12"
   },
   "devDependencies": {
-    "@ntnyq/eslint-config": "^6.1.1",
+    "@ntnyq/eslint-config": "^6.1.3",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^25.6.0",
-    "@typescript/native-preview": "^7.0.0-dev.20260429.1",
-    "bumpp": "^11.0.1",
-    "eslint": "^10.2.1",
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260508.1",
+    "bumpp": "^11.1.0",
+    "eslint": "^10.3.0",
     "eslint-parser-plain": "^0.1.1",
     "eslint-typegen": "^2.3.1",
     "eslint-vitest-rule-tester": "^3.1.0",
@@ -66,14 +66,14 @@
     "jsonc-eslint-parser": "^3.1.0",
     "nano-staged": "^1.0.2",
     "npm-run-all2": "^8.0.4",
-    "oxfmt": "^0.47.0",
+    "oxfmt": "^0.48.0",
     "show-invisibles": "^0.0.2",
     "tinyglobby": "^0.2.16",
-    "tsdown": "^0.21.10",
+    "tsdown": "^0.22.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
-    "eslint-plugin-oxfmt": "0.5.1"
+    "eslint-plugin-oxfmt": "0.6.1"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"

package/workers/oxfmt.mjs

@@ -1,508 +1,359 @@
 // @ts-check
 
-import { dirname, isAbsolute, join, relative } from 'node:path'
-import { loadOxfmtConfig, resolveOxfmtrcPath } from 'load-oxfmt-config'
+import { dirname, relative } from 'node:path'
+import { isOxfmtIgnored, loadOxfmtConfigResult } from 'load-oxfmt-config'
 import { format } from 'oxfmt'
 import picomatch from 'picomatch'
 import { runAsWorker } from 'synckit'
 
 /**
- * @typedef {object} PluginOptions
- * @property {boolean} [useConfig] - Whether to use oxfmt configuration file
- * @property {string} cwd - Current working directory for resolving configuration
- * @property {string} [configPath] - Custom path to oxfmt configuration file
+ * @typedef {object} PluginOnlyOptions
+ * @property {string} [cwd] - Base working directory used for path resolution.
+ * @property {string} [configPath] - Explicit path to oxfmt config file.
+ * @property {string | string[]} [ignorePath] - One or more ignore file paths.
+ * @property {boolean} [withNodeModules] - Whether node_modules should be included in ignore checks.
+ * @property {boolean} [disableNestedConfig] - Disable per-file nested config lookup.
+ * @property {boolean} [useCache] - Reuse caches for config/ignore resolution.
+ * @property {boolean} [useConfig] - Whether config discovery/loading is enabled.
+ * @property {boolean} [respectOxfmtDefaultIgnores] - Whether CLI-like default ignores should apply.
+ * @property {import('load-oxfmt-config').LoadOxfmtConfigOptions['editorconfig']} [editorconfig] - EditorConfig loading strategy.
  */
 
 /**
- * @typedef {import('load-oxfmt-config').OxfmtConfigOverride} Override
+ * @typedef {PluginOnlyOptions & import('load-oxfmt-config').LoadOxfmtConfigOptions & import('oxfmt').FormatConfig} PluginOptions
  */
+
 /**
- * @typedef {import('load-oxfmt-config').OxfmtOptions & PluginOptions} Options
+ * @typedef {object} WorkerIgnoredResult
+ * @property {true} ignored - Indicates formatting was skipped due to ignore rules.
+ * @property {import('load-oxfmt-config').IsOxfmtIgnoredResult['reason']} [reason] - Ignore reason from resolution step.
+ * @property {string} code - Unchanged source code.
+ * @property {never} [errors] - Not present for ignored results.
  */
 
 /**
- * @typedef {object} WorkerOptions
- * @property {string} cwd Current working directory for resolving rule-relative inputs.
- * @property {string | undefined} configPath Custom path to an oxfmt configuration file.
- * @property {string[] | undefined} ignorePatterns Rule-level ignore patterns.
- * @property {Override[] | undefined} overrides Rule-level override entries.
- * @property {boolean} useConfig Whether config loading is enabled.
- * @property {import('oxfmt').FormatConfig} formatOptions Pure formatter options passed to oxfmt.
+ * @typedef {object} WorkerFormattedResult
+ * @property {false} [ignored] - False or undefined when formatting was attempted.
+ * @property {string} code - Formatted source code.
+ * @property {unknown[]} [errors] - Optional formatter errors.
  */
 
 /**
- * @typedef {object} ResolvedBaseOptions
- * @property {import('oxfmt').FormatConfig} formatOptions Resolved base formatter options.
- * @property {string[] | undefined} ignorePatterns Resolved ignore patterns from config loading.
- * @property {Override[] | undefined} overrides Resolved overrides from config loading.
- * @property {string} configDir Directory of the resolved config file, used as base for config-derived glob patterns.
+ * @typedef {WorkerIgnoredResult | WorkerFormattedResult} WorkerFormatResult
  */
 
-const MAX_CACHE_SIZE = 1000
-
 /**
- * Evict oldest entries when the cache exceeds MAX_CACHE_SIZE.
- * @param cache - The cache map to evict entries from
+ * @typedef {object} SplitOptionsResult
+ * @property {PluginOnlyOptions} pluginOptions - Plugin orchestration options.
+ * @property {import('oxfmt').FormatConfig} formatOptions - Pure oxfmt options.
  */
-function evictCache(
-  /** @type {Map<string, unknown>} */
-  cache,
-) {
-  if (cache.size <= MAX_CACHE_SIZE) {
-    return
-  }
-  const keysToDelete = [...cache.keys()].slice(0, cache.size - MAX_CACHE_SIZE)
-  for (const key of keysToDelete) {
-    cache.delete(key)
-  }
-}
 
 /**
- * JSON.stringify replacer that sorts object keys for stable serialization.
- * @param key - The key of the property being processed
- * @param value - The value of the property being processed
- * @returns - The value to be serialized, with object keys sorted if it's an object
+ * @typedef {import('load-oxfmt-config').OxfmtConfigOverride} OxfmtConfigOverride
  */
-function stableReplacer(
-  /** @type {string} */
-  key,
-  /** @type {unknown} */
-  value,
-) {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return Object.keys(value)
-      .sort()
-      .reduce((sorted, k) => {
-        sorted[k] = /** @type {Record<string, unknown>} */ (value)[k]
-        return sorted
-      }, /** @type {Record<string, unknown>} */ ({}))
-  }
-  return value
-}
 
-/** @type {Map<string, Promise<ResolvedBaseOptions>>} */
-const resolvedBaseOptionsCache = new Map()
-
-/** @type {Map<string, import('oxfmt').FormatConfig>} */
-const mergedOptionsCache = new Map()
-
-/** @type {Map<string, ReturnType<typeof picomatch>>} */
-const picomatchCache = new Map()
+const MAX_CACHE_SIZE = 200
+const PLUGIN_ONLY_OPTIONS = new Set([
+  'configPath',
+  'cwd',
+  'disableNestedConfig',
+  'editorconfig',
+  'ignorePath',
+  'respectOxfmtDefaultIgnores',
+  'useCache',
+  'useConfig',
+  'withNodeModules',
+])
+/** @type {Map<string, import('picomatch').Matcher>} */
+const matcherCache = new Map()
 
 /**
- * Apply overrides to the base options based on the filename
- * @param relativePath - The file path relative to the glob base directory
- * @param baseOptions - Base format options
- * @param [overrides] - Override configurations
- * @returns - Merged options
+ * Apply override entries to a base options object.
+ * @param {string} relativePath - Relative file path used for matching.
+ * @param {import('oxfmt').FormatConfig} baseOptions - Base format options.
+ * @param {OxfmtConfigOverride[] | undefined} overrides - Override entries.
+ * @returns {import('oxfmt').FormatConfig} Options after override merge.
  */
-function applyOverrides(
-  /** @type {string} */
-  relativePath,
-  /** @type {import('oxfmt').FormatConfig} */
-  baseOptions,
-  /** @type {Override[] | undefined} */
-  overrides,
-) {
-  if (!overrides || overrides.length === 0) {
+function applyOverrides(relativePath, baseOptions, overrides) {
+  if (!overrides?.length) {
     return baseOptions
   }
 
-  let mergedOptions = baseOptions
-  let hasOverrides = false
-
-  // Apply overrides in order (later overrides take precedence)
+  let merged = baseOptions
   for (const override of overrides) {
-    const { excludeFiles, files, options: overrideOptions } = override
+    if (!override?.files?.length) {
+      continue
+    }
 
-    // Check if file matches the files patterns
-    const matches = getCachedMatcher(files)(relativePath)
+    const fileMatcher = getCachedMatcher(override.files)
+    const matches = !!fileMatcher && fileMatcher(relativePath)
 
-    // Check if file is excluded
-    const excluded =
-      excludeFiles && excludeFiles.length > 0
-        ? getCachedMatcher(excludeFiles)(relativePath)
-        : false
+    const excludeMatcher = override.excludeFiles?.length
+      ? getCachedMatcher(override.excludeFiles)
+      : undefined
+    const excluded = excludeMatcher ? excludeMatcher(relativePath) : false
 
-    if (matches && !excluded && overrideOptions) {
-      mergedOptions = { ...mergedOptions, ...overrideOptions }
-      hasOverrides = true
+    if (matches && !excluded && override.options) {
+      merged = {
+        ...merged,
+        ...override.options,
+      }
     }
   }
 
-  return hasOverrides ? mergedOptions : baseOptions
+  return merged
 }
 
 /**
- * Get or create a cached picomatch matcher for the given patterns.
- * @param patterns - Glob patterns to match against file paths
- * @returns - Picomatch matcher function
+ * Format source text via oxfmt with CLI-parity ignore orchestration.
+ * @param {string} filename - File path passed from ESLint.
+ * @param {string} sourceText - Source text to format.
+ * @param {PluginOptions} [options] - Worker options.
+ * @returns {Promise<WorkerFormatResult>} Format result.
  */
-function getCachedMatcher(
-  /** @type {string | string[]} */
-  patterns,
-) {
-  const key = Array.isArray(patterns) ? patterns.join('\0') : patterns
-  const cached = picomatchCache.get(key)
-  if (cached) {
-    return cached
-  }
-  const matcher = picomatch(patterns)
-  picomatchCache.set(key, matcher)
-  evictCache(picomatchCache)
-  return matcher
-}
+async function formatViaOxfmt(filename, sourceText, options = {}) {
+  const { formatOptions: inlineFormatOptions, pluginOptions } =
+    splitOptions(options)
+  validatePluginOptions(pluginOptions)
 
-/**
- * Resolve an effective config path for a file.
- * - Absolute paths are returned as-is.
- * - Relative paths are resolved from cwd.
- *
- * @param cwd - Current working directory from ESLint context.
- * @param [configPath] - Optional user-provided config path.
- * @returns Absolute config path when provided, otherwise undefined.
- */
-function getConfigPathForFile(
-  /** @type {string} */
-  cwd,
-  /** @type {string | undefined} */
-  configPath,
-) {
-  if (!configPath) {
-    return undefined
-  }
+  const cwd = pluginOptions.cwd
+  const useConfig = pluginOptions.useConfig !== false
 
-  return isAbsolute(configPath) ? configPath : join(cwd, configPath)
-}
+  const ruleIgnorePatterns = isStringArray(inlineFormatOptions.ignorePatterns)
+    ? inlineFormatOptions.ignorePatterns
+    : undefined
 
-/**
- * Build cache key for merged options per file invocation.
- * The key only includes data that can affect the final formatter options.
- *
- * @param baseOptions - Resolved base options used for formatting.
- * @param relativePath - File path relative to the override base directory.
- * @param overrides - Rule-level override entries.
- * @returns Serialized cache key.
- */
-function getMergedOptionsCacheKey(
-  /** @type {import('oxfmt').FormatConfig} */
-  baseOptions,
-  /** @type {string | undefined} */
-  relativePath,
-  /** @type {Override[] | undefined} */
-  overrides,
-) {
-  const hasOverrides = !!(overrides && overrides.length > 0)
-
-  return JSON.stringify(
-    {
-      baseOptions,
-      overrides: hasOverrides ? overrides : undefined,
-      relativePath: hasOverrides ? relativePath : undefined,
-    },
-    stableReplacer,
-  )
-}
+  if (ruleIgnorePatterns?.length && cwd) {
+    const ruleRelativePath = getRelativePath(cwd, filename)
+    if (shouldIgnoreFile(ruleRelativePath, ruleIgnorePatterns)) {
+      return {
+        code: sourceText,
+        ignored: true,
+      }
+    }
+  }
 
-/**
- * Normalize a file path relative to the provided base directory.
- * @param baseDir - Base directory used for glob evaluation
- * @param filename - Absolute file path
- * @returns - Normalized relative path using forward slashes
- */
-function getRelativePath(
-  /** @type {string} */
-  baseDir,
-  /** @type {string} */
-  filename,
-) {
-  return relative(baseDir, filename).replace(/\\/g, '/')
-}
+  if (pluginOptions.respectOxfmtDefaultIgnores !== false && cwd) {
+    /** @type {import('load-oxfmt-config').IsOxfmtIgnoredOptions} */
+    const ignoredOptions = {
+      configPath: pluginOptions.configPath,
+      cwd,
+      disableNestedConfig: pluginOptions.disableNestedConfig,
+      filepath: filename,
+      ignorePath: pluginOptions.ignorePath,
+      includeConfigIgnorePatterns: useConfig,
+      loadConfigForIgnorePatterns: useConfig,
+      useCache: pluginOptions.useCache,
+      withNodeModules: pluginOptions.withNodeModules,
+    }
+    const ignored = await isOxfmtIgnored(ignoredOptions)
+
+    if (ignored.ignored) {
+      if (
+        ruleIgnorePatterns?.length &&
+        ignored.reason === 'config-ignore-patterns'
+      ) {
+        // Rule-level ignorePatterns should take precedence over config ignorePatterns.
+      } else {
+        return {
+          code: sourceText,
+          ignored: true,
+          reason: ignored.reason,
+        }
+      }
+    }
+  }
 
-/**
- * Build cache key for resolving base formatter options.
- * The key includes file directory and all resolution inputs.
- *
- * @param filename - Current file path.
- * @param cwd - Current working directory from ESLint context.
- * @param configPath - Optional user-provided config path.
- * @param useConfig - Whether config file loading is enabled.
- * @param formatOptions - Rule-level format options.
- * @returns Serialized cache key.
- */
-function getResolvedBaseOptionsCacheKey(
+  /** @type {OxfmtConfigOverride[] | undefined} */
+  let effectiveOverrides
   /** @type {string} */
-  filename,
-  /** @type {string} */
-  cwd,
-  /** @type {string | undefined} */
-  configPath,
-  /** @type {boolean} */
-  useConfig,
+  let overrideBaseDir = cwd ?? dirname(filename)
   /** @type {import('oxfmt').FormatConfig} */
-  formatOptions,
-) {
-  return JSON.stringify(
-    {
-      configPath: configPath || '',
-      cwd,
-      fileDir: dirname(filename),
-      formatOptions,
-      useConfig,
-    },
-    stableReplacer,
+  let finalOptions
+
+  if (useConfig) {
+    const configResolutionCwd = pluginOptions.configPath
+      ? cwd
+      : pluginOptions.disableNestedConfig
+        ? cwd
+        : dirname(filename)
+
+    const loaded = await loadOxfmtConfigResult({
+      configPath: pluginOptions.configPath,
+      cwd: configResolutionCwd,
+      editorconfig: pluginOptions.editorconfig,
+      useCache: pluginOptions.useCache,
+    })
+    const { overrides: configOverrides, ...loadedConfig } = loaded.config
+    const { overrides: ruleOverrides, ...inlineOptionsWithoutOverrides } =
+      inlineFormatOptions
+    effectiveOverrides = [
+      ...(configOverrides ?? []),
+      ...(Array.isArray(ruleOverrides) ? ruleOverrides : []),
+    ]
+    overrideBaseDir = loaded.dirname ?? overrideBaseDir
+
+    finalOptions = {
+      ...loadedConfig,
+      ...inlineOptionsWithoutOverrides,
+    }
+  } else {
+    const { overrides: ruleOverrides, ...inlineOptionsWithoutOverrides } =
+      inlineFormatOptions
+    effectiveOverrides = Array.isArray(ruleOverrides)
+      ? ruleOverrides
+      : undefined
+    finalOptions = {
+      ...inlineOptionsWithoutOverrides,
+    }
+  }
+
+  const overrideRelativePath = getRelativePath(overrideBaseDir, filename)
+  finalOptions = applyOverrides(
+    overrideRelativePath,
+    finalOptions,
+    effectiveOverrides,
   )
+
+  return format(filename, sourceText, finalOptions)
 }
 
 /**
- * Validate and normalize worker invocation options.
- * @param options - Raw worker options
- * @returns - Validated worker options
+ * Get or create a cached picomatch matcher.
+ * @param {string[]} patterns - Glob patterns.
+ * @returns {import('picomatch').Matcher} Compiled matcher.
  */
-function getWorkerOptions(
-  /** @type {Options | undefined} */
-  options,
-) {
-  if (!options || typeof options !== 'object') {
-    throw new TypeError('oxfmt worker expected an options object.')
+function getCachedMatcher(patterns) {
+  const key = patterns.join('\0')
+  const cached = matcherCache.get(key)
+  if (cached) {
+    return cached
   }
 
-  const {
-    configPath,
-    cwd,
-    ignorePatterns,
-    overrides,
-    useConfig = true,
-    ...formatOptions
-  } = options
-
-  if (typeof cwd !== 'string' || cwd.length === 0) {
-    throw new TypeError('oxfmt worker requires a non-empty "cwd" option.')
-  }
-  if (configPath != null && typeof configPath !== 'string') {
-    throw new TypeError(
-      'oxfmt worker requires "configPath" to be a string when provided.',
-    )
-  }
-  if (ignorePatterns != null && !isStringArray(ignorePatterns)) {
-    throw new TypeError(
-      'oxfmt worker requires "ignorePatterns" to be an array of strings when provided.',
-    )
-  }
-  if (overrides != null && !Array.isArray(overrides)) {
-    throw new TypeError(
-      'oxfmt worker requires "overrides" to be an array when provided.',
-    )
-  }
-  if (typeof useConfig !== 'boolean') {
-    throw new TypeError(
-      'oxfmt worker requires "useConfig" to be a boolean when provided.',
-    )
-  }
+  const matcher = picomatch(patterns)
+  setCacheEntry(matcherCache, key, matcher)
+  return matcher
+}
 
-  return {
-    configPath,
-    cwd,
-    formatOptions,
-    ignorePatterns,
-    overrides,
-    useConfig,
-  }
+/**
+ * Normalize a file path relative to the provided base directory.
+ * @param {string} baseDir - Base directory used for glob evaluation.
+ * @param {string} filename - Absolute file path.
+ * @returns {string} Relative path using forward slashes.
+ */
+function getRelativePath(baseDir, filename) {
+  return relative(baseDir, filename).replace(/\\/g, '/')
 }
 
 /**
  * Check whether a value is an array of strings.
- * @param value - Value to validate
- * @returns - Whether the value is a string array
+ * @param {unknown} value - Value to validate.
+ * @returns {value is string[]} Whether the value is a string array.
  */
-function isStringArray(
-  /** @type {unknown} */
-  value,
-) {
+function isStringArray(value) {
   return Array.isArray(value) && value.every(item => typeof item === 'string')
 }
 
 /**
- * Resolve base formatter options for a file and cache the async result.
- *
- * @param filename - Current file path.
- * @param cwd - Current working directory from ESLint context.
- * @param configPath - Optional user-provided config path.
- * @param useConfig - Whether config file loading is enabled.
- * @param formatOptions - Rule-level format options.
- * @returns Base options after config loading and inline option merge.
+ * Store a value in a FIFO cache map with a bounded size.
+ * @template T Cache value type.
+ * @param {Map<string, T>} cache - Cache map.
+ * @param {string} key - Cache key.
+ * @param {T} value - Value to store.
  */
-async function resolveBaseOptions(
-  /** @type {string} */
-  filename,
-  /** @type {string} */
-  cwd,
-  /** @type {string | undefined} */
-  configPath,
-  /** @type {boolean} */
-  useConfig,
-  /** @type {import('oxfmt').FormatConfig} */
-  formatOptions,
-) {
-  const cacheKey = getResolvedBaseOptionsCacheKey(
-    filename,
-    cwd,
-    configPath,
-    useConfig,
-    formatOptions,
-  )
-
-  const cachedTask = resolvedBaseOptionsCache.get(cacheKey)
-  if (cachedTask) {
-    return cachedTask
-  }
-
-  /** @type {Promise<ResolvedBaseOptions>} */
-  const task = (async () => {
-    const resolveFromDir = dirname(filename)
-
-    if (!useConfig) {
-      return {
-        configDir: cwd,
-        ignorePatterns: undefined,
-        overrides: undefined,
-        formatOptions: {
-          ...formatOptions,
-        },
-      }
-    }
-
-    const resolvedConfigPath = getConfigPathForFile(cwd, configPath)
-    const resolvedPath = await resolveOxfmtrcPath(
-      resolveFromDir,
-      resolvedConfigPath,
-    )
-    const configDir = resolvedPath ? dirname(resolvedPath) : cwd
-    const configOptions = await loadOxfmtConfig({
-      configPath: resolvedConfigPath,
-      cwd: resolveFromDir,
-    })
-    const { ignorePatterns, overrides, ...loadedFormatOptions } =
-      configOptions ?? {}
-
-    return {
-      configDir,
-      ignorePatterns,
-      overrides,
-      formatOptions: {
-        ...loadedFormatOptions,
-        ...formatOptions,
-      },
+function setCacheEntry(cache, key, value) {
+  cache.set(key, value)
+  if (cache.size > MAX_CACHE_SIZE) {
+    const oldestKey = cache.keys().next().value
+    if (oldestKey != null) {
+      cache.delete(oldestKey)
     }
-  })()
-
-  resolvedBaseOptionsCache.set(cacheKey, task)
-  evictCache(resolvedBaseOptionsCache)
-
-  try {
-    return await task
-  } catch (err) {
-    resolvedBaseOptionsCache.delete(cacheKey)
-    throw err
   }
 }
 
 /**
- * Check if a file should be ignored based on ignorePatterns
- * @param relativePath - The file path relative to the glob base directory
- * @param [ignorePatterns] - Ignore patterns
- * @returns - Whether the file should be ignored
+ * Check if a file should be ignored by provided glob patterns.
+ * @param {string} relativePath - Relative path against pattern base.
+ * @param {string[] | undefined} ignorePatterns - Glob patterns.
+ * @returns {boolean} Whether file is ignored.
  */
-function shouldIgnoreFile(
-  /** @type {string} */
-  relativePath,
-  /** @type {string[] | undefined} */ ignorePatterns,
-) {
-  if (!ignorePatterns || ignorePatterns.length === 0) {
+function shouldIgnoreFile(relativePath, ignorePatterns) {
+  if (!ignorePatterns?.length) {
     return false
   }
 
-  // Check if file matches any ignore pattern
-  return getCachedMatcher(ignorePatterns)(relativePath)
+  const matcher = getCachedMatcher(ignorePatterns)
+  return !!matcher && matcher(relativePath)
 }
 
-runAsWorker(
-  async (
-    /**
-     * @type {string} filename
-     */
-    filename,
-    /**
-     * @type {string} source text
-     */
-    sourceText,
-    /**
-     * @type {Options} format options
-     */
-    options,
-  ) => {
-    const {
-      configPath,
-      cwd,
-      formatOptions,
-      ignorePatterns,
-      overrides,
-      useConfig,
-    } = getWorkerOptions(options)
-
-    const {
-      configDir,
-      formatOptions: baseFormatOptions,
-      ignorePatterns: baseIgnorePatterns,
-      overrides: baseOverrides,
-    } = await resolveBaseOptions(
-      filename,
-      cwd,
-      configPath,
-      useConfig,
-      formatOptions,
-    )
-    const effectiveIgnorePatterns = ignorePatterns ?? baseIgnorePatterns
-    const ignoreBase = ignorePatterns == null ? configDir : cwd
-    const ignoreRelativePath = effectiveIgnorePatterns?.length
-      ? getRelativePath(ignoreBase, filename)
-      : undefined
-
-    if (
-      ignoreRelativePath &&
-      shouldIgnoreFile(ignoreRelativePath, effectiveIgnorePatterns)
-    ) {
-      return { code: sourceText }
+/**
+ * Split worker options into plugin orchestration options and pure format options.
+ * @param {PluginOptions} [options] - Raw worker options.
+ * @returns {SplitOptionsResult} Split option buckets.
+ */
+function splitOptions(options = {}) {
+  /** @type {Record<string, unknown>} */
+  const pluginOptions = {}
+  /** @type {Record<string, unknown>} */
+  const formatOptions = {}
+
+  for (const [key, value] of Object.entries(options)) {
+    if (PLUGIN_ONLY_OPTIONS.has(key)) {
+      pluginOptions[key] = value
+    } else {
+      formatOptions[key] = value
     }
+  }
 
-    const effectiveOverrides = useConfig ? baseOverrides : overrides
-    const overrideBase = useConfig ? configDir : cwd
-    const overrideRelativePath = effectiveOverrides?.length
-      ? getRelativePath(overrideBase, filename)
-      : undefined
-    const mergedOptionsCacheKey = getMergedOptionsCacheKey(
-      baseFormatOptions,
-      overrideRelativePath,
-      effectiveOverrides,
-    )
+  return {
+    formatOptions: /** @type {import('oxfmt').FormatConfig} */ (formatOptions),
+    pluginOptions: /** @type {PluginOnlyOptions} */ (pluginOptions),
+  }
+}
 
-    const cachedMergedOptions = mergedOptionsCache.get(mergedOptionsCacheKey)
-    if (cachedMergedOptions) {
-      return format(filename, sourceText, cachedMergedOptions)
+/**
+ * Validate plugin-only options before dispatching to helper libraries.
+ * @param {PluginOnlyOptions} pluginOptions - Plugin-only options.
+ */
+function validatePluginOptions(pluginOptions) {
+  /** @type {('cwd' | 'configPath')[]} */
+  const stringKeys = ['configPath', 'cwd']
+  /** @type {('disableNestedConfig' | 'respectOxfmtDefaultIgnores' | 'useConfig' | 'useCache' | 'withNodeModules')[]} */
+  const booleanKeys = [
+    'disableNestedConfig',
+    'respectOxfmtDefaultIgnores',
+    'useCache',
+    'useConfig',
+    'withNodeModules',
+  ]
+
+  for (const key of stringKeys) {
+    const value = pluginOptions[key]
+    if (value != null && typeof value !== 'string') {
+      throw new TypeError(
+        `oxfmt worker requires "${key}" to be a string when provided.`,
+      )
     }
+  }
 
-    let mergedOptions = baseFormatOptions
-    if (overrideRelativePath && effectiveOverrides?.length) {
-      mergedOptions = applyOverrides(
-        overrideRelativePath,
-        mergedOptions,
-        effectiveOverrides,
+  for (const key of booleanKeys) {
+    const value = pluginOptions[key]
+    if (value != null && typeof value !== 'boolean') {
+      throw new TypeError(
+        `oxfmt worker requires "${key}" to be a boolean when provided.`,
       )
     }
+  }
 
-    mergedOptionsCache.set(mergedOptionsCacheKey, mergedOptions)
-    evictCache(mergedOptionsCache)
+  if (
+    pluginOptions.ignorePath != null &&
+    typeof pluginOptions.ignorePath !== 'string' &&
+    !isStringArray(pluginOptions.ignorePath)
+  ) {
+    throw new TypeError(
+      'oxfmt worker requires "ignorePath" to be a string or string array when provided.',
+    )
+  }
+}
 
-    return format(filename, sourceText, mergedOptions)
-  },
-)
+runAsWorker(formatViaOxfmt)