@isentinel/eslint-config 6.1.0 → 6.3.0

package/dist/index.mjs

@@ -8,6 +8,7 @@ import process from "node:process";
 import { getStaticJSONValue, parseJSON } from "jsonc-eslint-parser";
 import * as yamlESLintParser from "yaml-eslint-parser";
 import { VisitorKeys, getStaticYAMLValue, parseForESLint, parseYAML, traverseNodes } from "yaml-eslint-parser";
+import { isMainThread } from "node:worker_threads";
 import { minVersion } from "semver";
 import fs$1 from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -485,6 +486,79 @@ function resolvePrettierSettings(prettierOptions = {}, cwd = process.cwd()) {
 		...prettierOptions
 	};
 }
+/**
+* Replace `printWidth` and `tabWidth` in the formatting settings with the
+* values oxfmt really uses.
+*
+* `flawless/arrow-return-style` hands `printWidth` to oxfmt to predict its
+* output (`useOxfmt.printWidth`), so it must match the width oxfmt formats
+* with, or `--fix` ping-pongs. An oxfmt config can set a width that differs
+* from the Prettier-shaped settings, so the oxfmt value wins.
+*
+* @template T - The settings shape.
+* @param settings - The resolved formatting settings.
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns The settings with oxfmt's widths.
+*/
+function withOxfmtWidths(settings, { printWidth, tabWidth }) {
+	return {
+		...settings,
+		...typeof printWidth === "number" ? { printWidth } : {},
+		...typeof tabWidth === "number" ? { tabWidth } : {}
+	};
+}
+/**
+* The indent oxfmt writes.
+*
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns `"tab"`, or the number of spaces.
+*/
+function oxfmtIndent({ tabWidth, useTabs }) {
+	if (useTabs !== false) return "tab";
+	return typeof tabWidth === "number" ? tabWidth : 2;
+}
+/**
+* Default the stylistic `indent` and `quotes` to what oxfmt writes, so the
+* stylistic rules and oxfmt agree. Explicit `stylistic` values win.
+*
+* @param stylistic - The user's stylistic options.
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns The stylistic options with oxfmt's indent and quotes.
+*/
+function withOxfmtStyle(stylistic, oxfmtOptions) {
+	return {
+		indent: oxfmtIndent(oxfmtOptions),
+		quotes: oxfmtOptions["singleQuote"] === true ? "single" : "double",
+		...stylistic
+	};
+}
+/**
+* Turn the nearest `.editorconfig`'s sections into oxfmt overrides, the way
+* the `oxfmt/oxfmt` rule's config loader does: `[*]` is skipped (it feeds the
+* root options), and each other section becomes an override whose globs are
+* relative to `cwd`. A key set in the oxfmt config root wins over the
+* sections.
+*
+* @param cwd - The config directory.
+* @param root - The oxfmt config root options.
+* @returns The overrides, in file order.
+*/
+function editorConfigOverrides(cwd = process.cwd(), root = {}) {
+	for (const directory of ancestorDirectories(cwd)) {
+		const contents = readFileOrUndefined(path.join(directory, ".editorconfig"));
+		if (contents === void 0) continue;
+		const prefix = path.relative(cwd, directory).split(path.sep).join("/");
+		return parseEditorConfig(contents).sections.flatMap(({ pattern, properties }) => {
+			const options = Object.fromEntries(Object.entries(editorConfigToOxfmt(properties)).filter(([key]) => !Object.hasOwn(root, key)));
+			if (pattern === "*" || Object.keys(options).length === 0) return [];
+			return [{
+				files: [prefix === "" ? pattern : `${prefix}/${pattern.replace(LEADING_SLASH, "")}`],
+				options
+			}];
+		});
+	}
+	return [];
+}
 function readFileOrUndefined(filePath) {
 	try {
 		return fs.readFileSync(filePath, "utf-8");
@@ -664,6 +738,31 @@ function resolveEditorConfigOptions(cwd) {
 	}
 	return editorConfigToPrettier(properties);
 }
+/**
+* Map one `.editorconfig` section to oxfmt options, as the rule's config
+* loader does.
+*
+* @param properties - The section's properties.
+* @returns The oxfmt options it sets.
+*/
+function editorConfigToOxfmt(properties) {
+	const options = {};
+	const endOfLine = properties["end_of_line"];
+	if (endOfLine === "cr" || endOfLine === "crlf" || endOfLine === "lf") options["endOfLine"] = endOfLine;
+	const indentStyle = properties["indent_style"];
+	if (indentStyle === "tab" || indentStyle === "space") options["useTabs"] = indentStyle === "tab";
+	const quoteType = properties["quote_type"];
+	if (quoteType === "single" || quoteType === "double") options["singleQuote"] = quoteType === "single";
+	const indentSize = Number(properties["indent_size"]);
+	const tabWidth = Number(properties["tab_width"]);
+	if (options["useTabs"] === false && properties["indent_size"] && Number.isFinite(indentSize)) options["tabWidth"] = indentSize;
+	else if (properties["tab_width"] && Number.isFinite(tabWidth)) options["tabWidth"] = tabWidth;
+	const printWidth = Number(properties["max_line_length"]);
+	if (properties["max_line_length"] && Number.isFinite(printWidth)) options["printWidth"] = printWidth;
+	const finalNewline = properties["insert_final_newline"];
+	if (finalNewline === "true" || finalNewline === "false") options["insertFinalNewline"] = finalNewline === "true";
+	return options;
+}
 //#endregion
 //#region src/guards.ts
 /**
@@ -681,6 +780,141 @@ function resolveEditorConfigOptions(cwd) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+* Whether a value is an array whose every element is a string.
+*
+* @param value - The value to test.
+* @returns Whether the value is a `string` array.
+*/
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
+//#region src/rules/oxfmt.ts
+const UNSUPPORTED_PRETTIER_KEYS = /* @__PURE__ */ new Set([
+	"experimentalOperatorPosition",
+	"experimentalTernaries",
+	"jsdocPreferCodeFences",
+	"jsdocPrintWidth",
+	"parser",
+	"plugins",
+	"tsdoc"
+]);
+const defaultSortImports = {
+	customGroups: [{
+		elementNamePattern: ["react"],
+		groupName: "react"
+	}, {
+		elementNamePattern: ["@*/**"],
+		groupName: "scoped"
+	}],
+	groups: [
+		"react",
+		"scoped",
+		[
+			"type-builtin",
+			"type-external",
+			"builtin",
+			"external"
+		],
+		[
+			"type-internal",
+			"internal",
+			"type-parent",
+			"type-sibling",
+			"type-index",
+			"parent",
+			"sibling",
+			"index"
+		],
+		"unknown"
+	],
+	newlinesBetween: true
+};
+/**
+* Migrate Prettier options to oxfmt options, dropping unsupported keys.
+*
+* @param prettierOptions - The Prettier options to migrate.
+* @returns The migrated oxfmt options.
+*/
+function migratePrettierOptions(prettierOptions) {
+	const oxfmtOptions = {};
+	for (const [key, value] of Object.entries(prettierOptions)) {
+		if (UNSUPPORTED_PRETTIER_KEYS.has(key)) continue;
+		if (key === "endOfLine" && value === "auto") continue;
+		oxfmtOptions[key] = key === "overrides" ? migratePrettierOverrides(value) : value;
+	}
+	return oxfmtOptions;
+}
+/**
+* Migrate Prettier `overrides`: oxfmt wants `files` as an array, and the
+* nested options migrated like the root ones.
+*
+* @param overrides - The `overrides` value, of unknown shape.
+* @returns The overrides in oxfmt's shape; empty when not an array.
+*/
+function migratePrettierOverrides(overrides) {
+	if (!Array.isArray(overrides)) return [];
+	return overrides.flatMap((override) => {
+		if (!isRecord(override)) return [];
+		const { excludeFiles, files, options } = override;
+		return [{
+			...excludeFiles === void 0 ? {} : { excludeFiles: stringsOf(excludeFiles) },
+			files: stringsOf(files),
+			options: isRecord(options) ? migratePrettierOptions(options) : {}
+		}];
+	});
+}
+/**
+* Build the effective oxfmt options shared between the ESLint and oxlint
+* factories.
+*
+* @param options - The option sources, in increasing precedence.
+* @returns The effective oxfmt options.
+*/
+function buildOxfmtOptions({ oxfmtConfigOptions = {}, oxfmtOptions, prettierOptions = {} }) {
+	return {
+		sortImports: defaultSortImports,
+		sortPackageJson: false,
+		...migratePrettierOptions(prettierOptions),
+		...oxfmtConfigOptions,
+		...oxfmtOptions
+	};
+}
+/**
+* Markdown formatting options layered over the base options. Shared by the
+* ESLint config and the standalone oxfmt config so both format Markdown the
+* same way.
+*
+* Oxfmt would format code blocks with these options too, at the prose width.
+* It leaves them alone instead, and ESLint formats each block with the options
+* of its own language (see `isentinel/oxfmt/markdown-code/*`).
+*
+* @param jsdocPrintWidth - Width for Markdown prose; 80 when unset.
+* @returns Options applied on top of the base for Markdown files.
+*/
+function markdownOxfmtOptions(jsdocPrintWidth) {
+	return {
+		embeddedLanguageFormatting: "off",
+		printWidth: Number(jsdocPrintWidth) || 80,
+		proseWrap: "always",
+		tabWidth: 2
+	};
+}
+function stringsOf(value) {
+	return [value].flat().filter((item) => typeof item === "string");
+}
+/**
+* JSON5 formatting options layered over the base options. `jsonc/quote-props`
+* owns the quoting of JSON5 keys; oxfmt's `consistent` would strip the quotes
+* it adds, and `--fix` would loop.
+*/
+const JSON5_OXFMT_OPTIONS = { quoteProps: "preserve" };
+/** YAML formatting options layered over the base options. */
+const YAML_OXFMT_OPTIONS = {
+	tabWidth: 2,
+	useTabs: false
+};
 //#endregion
 //#region src/rules/react.ts
 const DOM_IMPORT_MESSAGE = "Import from react-testing-library-lua instead; it re-exports the DOM utilities, and eslint-plugin-testing-library only detects one module per file.";
@@ -1266,26 +1500,181 @@ function environmentMatcher(name, pattern, { noTty = false } = {}) {
 		return value !== void 0 && pattern.test(value);
 	};
 }
-const OXFMT_CONFIG_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
+/** JSON oxfmt config files oxfmt discovers. */
+const OXFMT_RC_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
+/**
+* Oxfmt config modules oxfmt discovers. It loads other module extensions only
+* through `--config`, never by search.
+*/
+const OXFMT_CONFIG_MODULES = ["oxfmt.config.ts", "oxfmt.config.mts"];
+OXFMT_CONFIG_MODULES[0];
+/** Every file name oxfmt discovers. One directory may hold only one of them. */
+const OXFMT_CONFIG_NAMES = [...OXFMT_RC_FILES, ...OXFMT_CONFIG_MODULES];
+/** The extensions of the JS/TS files ESLint and oxlint format. */
+const SCRIPT_EXTENSIONS = [
+	"cjs",
+	"cts",
+	"js",
+	"jsx",
+	"mjs",
+	"mts",
+	"ts",
+	"tsx"
+];
+const JSON_EXTENSIONS = [
+	"json",
+	"json5",
+	"jsonc"
+];
+const LEADING_DOT_SLASH = /^\.\//;
+/** Set once a process has warned about a JS/TS width override. */
+const WARNED_SCRIPT_OVERRIDE = Symbol.for("@isentinel/eslint-config/oxfmt-override-warned");
+/** Set once a process has warned about options standalone oxfmt ignores. */
+const WARNED_STANDALONE = Symbol.for("@isentinel/eslint-config/standalone-options-warned");
+const GLOB_MAGIC = /[*?[\]{}]/;
 /**
-* Resolve oxfmt configuration from `.oxfmtrc.json` or `.oxfmtrc.jsonc`.
+* List the oxfmt config files in one directory, without walking up.
 *
-* @returns The oxfmt configuration options, or an empty object if none found.
+* @param directory - Directory to check.
+* @returns The file names found, sorted.
 */
-async function resolveOxfmtConfigOptions() {
-	for (const filename of OXFMT_CONFIG_FILES) {
-		const configPath = path.resolve(process.cwd(), filename);
-		try {
-			const content = await fs.promises.readFile(configPath, "utf-8");
-			const parsed = JSON.parse(content);
-			if (!isRecord(parsed)) continue;
-			const { $schema: _, ...config } = parsed;
-			return config;
-		} catch {
-			continue;
-		}
+function oxfmtConfigNamesIn(directory) {
+	return OXFMT_CONFIG_NAMES.filter((name) => fs.existsSync(path.join(directory, name))).sort();
+}
+/**
+* Find the oxfmt config the way oxfmt does: walk up from `cwd` to the
+* filesystem root and take the first directory that holds one. Like oxfmt,
+* refuse a directory that holds more than one.
+*
+* @param cwd - Directory to start from.
+* @returns The config file, if any.
+* @throws When one directory holds more than one oxfmt config file.
+*/
+function findOxfmtConfig(cwd = process.cwd()) {
+	let directory = path.resolve(cwd);
+	for (;;) {
+		const [first, second] = oxfmtConfigNamesIn(directory);
+		if (second !== void 0) throw new Error(`[@isentinel/eslint-config] Both '${first}' and '${second}' found in ${directory}. Keep one oxfmt config file.`);
+		if (first !== void 0) return {
+			isModule: OXFMT_CONFIG_MODULES.some((name) => name === first),
+			path: path.join(directory, first)
+		};
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+}
+/**
+* The string globs of an override's `files` or `excludeFiles`.
+*
+* @param value - One glob or a list of them, of unknown shape.
+* @returns The string globs.
+*/
+function globsOf(value) {
+	return [value].flat().filter((glob) => typeof glob === "string");
+}
+/**
+* Where an override applies: its `files`, minus its `excludeFiles` and any
+* negated glob in `files`.
+*
+* @param override - One override.
+* @returns Its scope.
+*/
+function scopeOf(override) {
+	const globs = globsOf(override["files"]);
+	return {
+		excludeFiles: [...globsOf(override["excludeFiles"]), ...globs.filter((glob) => glob.startsWith("!")).map((glob) => glob.slice(1))],
+		files: globs.filter((glob) => !glob.startsWith("!"))
+	};
+}
+/** Oxfmt options that change the layout the JSON rules check. */
+const JSON_LAYOUT_KEYS = [
+	"bracketSpacing",
+	"singleQuote",
+	"tabWidth",
+	"useTabs"
+];
+/**
+* The overrides that change the layout of JSON files, where the JSON layout
+* rules, set from the root options, would disagree with oxfmt.
+*
+* @param overrides - Overrides, of unknown shape.
+* @returns Each such override's scope, in order.
+*/
+function jsonLayoutOverrides(overrides) {
+	return overrides.flatMap((override) => {
+		if (!isRecord(override) || !isRecord(override["options"]) || !overrideMatches(override, JSON_EXTENSIONS)) return [];
+		const { options } = override;
+		return JSON_LAYOUT_KEYS.some((key) => key in options) ? [scopeOf(override)] : [];
+	});
+}
+/**
+* Warn, at most once per process, about factory options that do not reach
+* standalone oxfmt: it formats with `oxfmt.config.ts` alone. They still choose
+* which Markdown code blocks ESLint formats.
+*
+* @param options - The factory options.
+* @param options.componentExts - Oxfmt formats only the extensions
+*   `isentinelOxfmt` is given.
+* @param options.formatters - Any value but `true` is ignored by oxfmt.
+* @param options.gitignore - Custom ignore files, or `false`, do not reach
+*   oxfmt.
+* @param options.ignores - User ignores do not reach oxfmt.
+*/
+function warnStandaloneOptions({ componentExts, formatters, gitignore, ignores }) {
+	const state = globalThis;
+	if (!isMainThread || state[WARNED_STANDALONE] === true || process.env["ISENTINEL_QUIET_CONFIG_WARNINGS"] === "1") return;
+	const names = [
+		formatters !== void 0 && formatters !== true ? "formatters" : void 0,
+		Array.isArray(componentExts) && componentExts.length > 0 ? "componentExts" : void 0,
+		ignores === void 0 || Array.isArray(ignores) && ignores.length === 0 ? void 0 : "ignores",
+		gitignore === false || isRecord(gitignore) ? "gitignore" : void 0
+	].filter((name) => name !== void 0);
+	if (names.length > 0) {
+		state[WARNED_STANDALONE] = true;
+		console.warn(`[@isentinel/eslint-config] With formatter: "standalone", oxfmt formats with oxfmt.config.ts alone, so these options do not change what oxfmt formats: ${names.join(", ")}. They change only which Markdown code blocks ESLint formats. Set the equivalent in isentinelOxfmt() (formatters, componentExts, ignorePatterns, format options).`);
+	}
+}
+/**
+* Warn, at most once per process, when an oxfmt override changes `printWidth`
+* or `tabWidth` for JS/TS files: ESLint and oxlint use the root values.
+*
+* @param overrides - The config's `overrides`.
+* @param source - The config file name.
+*/
+function warnScriptWidthOverrides(overrides, source) {
+	const state = globalThis;
+	if (state[WARNED_SCRIPT_OVERRIDE] === true || !Array.isArray(overrides)) return;
+	if (overrides.some((override) => {
+		if (!isRecord(override) || !isRecord(override["options"])) return false;
+		const { printWidth, tabWidth } = override["options"];
+		if (printWidth === void 0 && tabWidth === void 0) return false;
+		return overrideMatches(override, SCRIPT_EXTENSIONS);
+	})) {
+		state[WARNED_SCRIPT_OVERRIDE] = true;
+		console.warn(`[@isentinel/eslint-config] ${source} has an override that changes printWidth or tabWidth for JS/TS files. ESLint and oxlint use the root values for those files.`);
 	}
-	return {};
+}
+/**
+* Resolve oxfmt format options from the config oxfmt itself would use (see
+* {@link findOxfmtConfig}): `.oxfmtrc.json`, `.oxfmtrc.jsonc`,
+* `oxfmt.config.ts` or `oxfmt.config.mts`.
+*
+* @returns The format options and overrides; empty options if none found.
+* @rejects When the config is ambiguous or cannot be loaded.
+*/
+async function resolveOxfmtConfig() {
+	const config = findOxfmtConfig();
+	if (config === void 0) return { options: {} };
+	if (!config.isModule) return rcConfig(config.path, await fs.promises.readFile(config.path, "utf-8"));
+	let loaded;
+	try {
+		const { createJiti } = await import("jiti");
+		loaded = await createJiti(import.meta.url, { moduleCache: false }).import(config.path, { default: true });
+	} catch (err) {
+		throw loadError(config.path, err);
+	}
+	return moduleConfig(config.path, loaded);
 }
 /**
 * Override the severity of all rules in a rules object, preserving rule
@@ -1314,6 +1703,91 @@ function shouldEnableFeature(options, key, defaultValue = true) {
 	return options[key] !== false;
 }
 /**
+* Whether a glob can match a file with one of `extensions`, judged by the
+* extension of its last segment (`*.ts`, `*.{ts,tsx}`, `*.?ts`, `*`, ...).
+*
+* @param glob - An override `files` glob.
+* @param extensions - The extensions to look for.
+* @returns Whether it can match such a file.
+*/
+function globMatchesExtension(glob, extensions) {
+	const base = glob.split("/").at(-1) ?? glob;
+	const dot = base.lastIndexOf(".");
+	if (dot === -1) return base.includes("*");
+	const extension = base.slice(dot + 1);
+	if (!GLOB_MAGIC.test(extension)) return extensions.includes(extension);
+	return extensions.some((candidate) => path.matchesGlob(candidate, extension));
+}
+/**
+* Whether an oxfmt override can apply to a file with one of `extensions`.
+*
+* @param override - One entry of the config's `overrides`.
+* @param extensions - The extensions to look for.
+* @returns Whether its `files` can match such a file.
+*/
+function overrideMatches(override, extensions) {
+	return (Array.isArray(override["files"]) ? override["files"] : [override["files"]]).some((glob) => typeof glob === "string" && globMatchesExtension(glob, extensions));
+}
+function loadError(configPath, error) {
+	return new Error(`[@isentinel/eslint-config] Failed to load ${path.basename(configPath)}: ${String(error)}`, { cause: error });
+}
+/**
+* Whether a config override is an `.editorconfig` section that
+* `isentinelOxfmt` copied in: the same globs (anchored or not) and a subset
+* of its options.
+*
+* @param override - One config override.
+* @param sections - The `.editorconfig` sections, as overrides.
+* @returns Whether it mirrors one of them.
+*/
+function mirrorsSection(override, sections) {
+	if (!isRecord(override) || !isRecord(override["options"])) return false;
+	const { options } = override;
+	const files = [override["files"]].flat().map((glob) => typeof glob === "string" ? glob.replace(LEADING_DOT_SLASH, "") : glob);
+	return sections.some((section) => {
+		return section.files.length === files.length && section.files.every((glob, index) => glob === files[index]) && Object.entries(options).every(([key, value]) => section.options[key] === value);
+	});
+}
+/**
+* Turn a loaded oxfmt config into `oxfmt/oxfmt` rule options, its ignore
+* patterns and its overrides. The rule takes format options only, so
+* `$schema`, `ignorePatterns` and `overrides` are dropped from the options.
+*
+* @param config - The loaded config.
+* @param config.$schema - Dropped.
+* @param config.ignorePatterns - Dropped from the options; oxfmt applies them
+*   itself, except in Markdown code blocks.
+* @param config.overrides - Dropped from the options, after the width check.
+* @param configPath - The config file, for the warning.
+* @returns The format options, ignore patterns and overrides.
+*/
+function toResolvedConfig({ $schema: _schema, ignorePatterns, overrides, ...options }, configPath) {
+	const sections = editorConfigOverrides(path.dirname(configPath));
+	const list = Array.isArray(overrides) ? overrides : [];
+	const copied = list.filter((override) => mirrorsSection(override, sections));
+	warnScriptWidthOverrides(copied, ".editorconfig");
+	warnScriptWidthOverrides(list.filter((override) => !copied.includes(override)), path.basename(configPath));
+	return {
+		ignorePatterns: isStringArray(ignorePatterns) ? ignorePatterns : [],
+		options,
+		overrides: Array.isArray(overrides) ? overrides : []
+	};
+}
+function moduleConfig(configPath, loaded) {
+	if (!isRecord(loaded)) throw loadError(configPath, /* @__PURE__ */ new TypeError("the default export is not an object"));
+	return toResolvedConfig(loaded, configPath);
+}
+function rcConfig(configPath, content) {
+	let parsed;
+	try {
+		parsed = getStaticJSONValue(parseJSON(content, { jsonSyntax: "jsonc" }));
+	} catch (err) {
+		throw loadError(configPath, err);
+	}
+	if (!isRecord(parsed)) throw loadError(configPath, /* @__PURE__ */ new TypeError("the config is not an object"));
+	return toResolvedConfig(parsed, configPath);
+}
+/**
 * Resolves the lowest Node major version a semver range can match.
 *
 * @param range - A semver range such as `>=24.12.0` or `^24 || ^26`.
@@ -1798,24 +2272,6 @@ async function eslintPlugin({ files = [GLOB_SRC], overrides = {} } = {}) {
 //#endregion
 //#region src/rules/flawless.ts
 /**
-* Arrow return style rule on its own, for the Markdown code block override
-* where only the line width differs.
-*
-* @param options - Shared rule options.
-* @returns The rule map.
-*/
-function arrowStyleRules({ maxLen, maxLength, printWidth, tabWidth } = {}) {
-	return { "flawless/arrow-return-style": ["error", {
-		jsxAlwaysUseExplicitReturn: true,
-		maxLen: maxLength ?? maxLen ?? printWidth ?? 100,
-		maxObjectProperties: 2,
-		namedExportsAlwaysUseExplicitReturn: true,
-		objectReturnStyle: "complex-explicit",
-		...tabWidth !== void 0 ? { tabWidth } : {},
-		...printWidth !== void 0 ? { useOxfmt: { printWidth } } : {}
-	}] };
-}
-/**
 * Base (non-React) flawless rules shared between the ESLint and oxlint
 * factories. The React flawless rules live in the react rule map; the
 * type-aware rules live in {@link flawlessTypeAwareRules}, plus the type-aware
@@ -1876,6 +2332,23 @@ function antiSlopRules({ roblox = true }) {
 	};
 }
 /**
+* The arrow return style rule.
+*
+* @param options - Shared rule options.
+* @returns The rule map.
+*/
+function arrowStyleRules({ maxLen, printWidth, tabWidth } = {}) {
+	return { "flawless/arrow-return-style": ["error", {
+		jsxAlwaysUseExplicitReturn: true,
+		maxLen: maxLen ?? printWidth ?? 100,
+		maxObjectProperties: 2,
+		namedExportsAlwaysUseExplicitReturn: true,
+		objectReturnStyle: "complex-explicit",
+		...tabWidth !== void 0 ? { tabWidth } : {},
+		...printWidth !== void 0 ? { useOxfmt: { printWidth } } : {}
+	}] };
+}
+/**
 * Type-aware anti-slop rules.
 *
 * `flawless/no-reflect-set` is complement-only, like `flawless/no-reflect-get`.
@@ -1924,15 +2397,6 @@ async function flawless(options = {}, prettierOptions = {}) {
 				roblox
 			})
 		},
-		...stylistic !== false ? [{
-			name: "isentinel/flawless/markdown-code",
-			files: [GLOB_MARKDOWN_CODE],
-			rules: arrowStyleRules({
-				maxLength: Number(prettierOptions["jsdocPrintWidth"]) || 80,
-				printWidth,
-				tabWidth
-			})
-		}] : [],
 		...complementIgnores ? [{
 			name: "isentinel/flawless/complement",
 			files: [GLOB_SRC],
@@ -2596,13 +3060,13 @@ function jsdoc({ full = false, stylistic = true, type = "game" } = {}) {
 //#endregion
 //#region src/eslint/configs/jsonc.ts
 init_globs();
-async function jsonc({ files = [
+async function jsonc({ bracketSpacing = true, files = [
 	GLOB_JSON,
 	GLOB_JSON5,
 	GLOB_JSONC
-], overrides = {}, stylistic = true } = {}) {
+], formatIndent, layoutOverrides = [], overrides = {}, singleQuote = false, stylistic = true } = {}) {
 	const defaults = resolveWithDefaults(stylistic, {});
-	const { indent = "tab" } = defaults === false ? {} : defaults;
+	const { indent = formatIndent ?? "tab" } = defaults === false ? {} : defaults;
 	const indentValue = typeof indent === "number" || indent === "tab" ? indent : "tab";
 	const pluginJsonc = lazyPlugin("eslint-plugin-jsonc");
 	const parserJsonc = await interopDefault(import("jsonc-eslint-parser"));
@@ -2654,7 +3118,7 @@ async function jsonc({ files = [
 						consistent: true,
 						multiline: true
 					}],
-					"jsonc/object-curly-spacing": ["error", "always"],
+					"jsonc/object-curly-spacing": ["error", bracketSpacing ? "always" : "never"],
 					"jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
 					"jsonc/quote-props": "error",
 					"jsonc/quotes": "error"
@@ -2662,6 +3126,23 @@ async function jsonc({ files = [
 				...overrides
 			}
 		},
+		...stylistic !== false && singleQuote ? [{
+			name: "isentinel/jsonc/json5-quotes",
+			files: [GLOB_JSON5],
+			rules: { "jsonc/quotes": ["error", "single"] }
+		}] : [],
+		...stylistic === false ? [] : layoutOverrides.map(({ excludeFiles, files: overrideFiles }, index) => {
+			return {
+				name: `isentinel/jsonc/oxfmt-override-${index}`,
+				files: overrideFiles,
+				ignores: excludeFiles,
+				rules: {
+					"jsonc/indent": "off",
+					"jsonc/object-curly-spacing": "off",
+					"jsonc/quotes": "off"
+				}
+			};
+		}),
 		{
 			name: "isentinel/jsonc/tsconfig",
 			files: [GLOB_TSCONFIG],
@@ -3350,76 +3831,182 @@ async function node({ files = [GLOB_SRC], ignores } = {}) {
 	}];
 }
 //#endregion
-//#region src/rules/oxfmt.ts
-const UNSUPPORTED_PRETTIER_KEYS = /* @__PURE__ */ new Set([
-	"experimentalOperatorPosition",
-	"experimentalTernaries",
-	"jsdocPreferCodeFences",
-	"jsdocPrintWidth",
-	"parser",
-	"plugins",
-	"tsdoc"
-]);
-const defaultSortImports = {
-	customGroups: [{
-		elementNamePattern: ["react"],
-		groupName: "react"
-	}, {
-		elementNamePattern: ["@*/**"],
-		groupName: "scoped"
-	}],
-	groups: [
-		"react",
-		"scoped",
-		[
-			"type-builtin",
-			"type-external",
-			"builtin",
-			"external"
-		],
-		[
-			"type-internal",
-			"internal",
-			"type-parent",
-			"type-sibling",
-			"type-index",
-			"parent",
-			"sibling",
-			"index"
-		],
-		"unknown"
-	],
-	newlinesBetween: true
+//#region src/formatted-files.ts
+init_globs();
+/** Formatted globs, by `oxfmt/oxfmt` config block. */
+const FORMATTED_FILES = {
+	css: [GLOB_CSS, GLOB_POSTCSS],
+	graphql: ["**/*.graphql"],
+	html: ["**/*.html"],
+	javascript: [GLOB_JS, GLOB_JSX],
+	json: [GLOB_ALL_JSON],
+	less: [GLOB_LESS],
+	markdown: [GLOB_MARKDOWN],
+	scss: [GLOB_SCSS],
+	typescript: [GLOB_TS, GLOB_TSX],
+	yaml: [GLOB_YAML]
 };
 /**
-* Migrate Prettier options to oxfmt options, dropping unsupported keys.
+* Resolve `formatters` to one flag per language.
 *
-* @param prettierOptions - The Prettier options to migrate.
-* @returns The migrated oxfmt options.
+* @param formatters - The `formatters` option.
+* @returns Whether each language is formatted.
 */
-function migratePrettierOptions(prettierOptions) {
-	const oxfmtOptions = {};
-	for (const [key, value] of Object.entries(prettierOptions)) {
-		if (UNSUPPORTED_PRETTIER_KEYS.has(key)) continue;
-		if (key === "endOfLine" && value === "auto") continue;
-		oxfmtOptions[key] = value;
+function resolveFormattedLanguages(formatters = true) {
+	const enabled = formatters !== false;
+	const toggles = typeof formatters === "object" ? formatters : {};
+	return {
+		css: enabled && toggles.css !== false,
+		graphql: enabled && toggles.graphql !== false,
+		html: enabled && toggles.html !== false,
+		json: enabled && toggles.json !== false,
+		markdown: enabled && toggles.markdown !== false,
+		yaml: enabled && toggles.yaml !== false
+	};
+}
+//#endregion
+//#region src/eslint/oxfmt-markdown-code.ts
+/** As `GLOB_MARKDOWN`, case-sensitive. */
+const MARKDOWN_FILE = /\.md$/;
+/**
+* Wrap eslint-plugin-oxfmt so `oxfmt/oxfmt` formats Markdown code blocks.
+*
+* The rule skips every virtual file, so a code block is formatted only by
+* the formatter of the file it is in. Oxfmt formats Markdown code blocks at
+* the prose width, so the preset turns that off and lets the rule format each
+* block with the options of its own language. Virtual files of other
+* processors (Vue blocks, say) stay skipped: oxfmt formats those files whole.
+*
+* @param plugin - The loaded plugin.
+* @returns The plugin with the wrapped rule.
+*/
+function oxfmtMarkdownCode(plugin) {
+	const { rules } = plugin;
+	const rule = rules?.["oxfmt"];
+	if (rule === void 0) return plugin;
+	return {
+		...plugin,
+		rules: {
+			...rules,
+			oxfmt: markdownCodeRule(rule)
+		}
+	};
+}
+/**
+* Whether a file is a code block of a Markdown file.
+*
+* @param context - The rule context.
+* @returns Whether the file is a Markdown code block.
+*/
+function isMarkdownCodeBlock({ filename, physicalFilename }) {
+	return filename !== physicalFilename && MARKDOWN_FILE.test(physicalFilename);
+}
+function markdownCodeRule(rule) {
+	return {
+		...rule,
+		create(context) {
+			if (!isMarkdownCodeBlock(context)) return rule.create(context);
+			const proxy = Object.create(context, { physicalFilename: { value: context.filename } });
+			return rule.create(proxy);
+		}
+	};
+}
+//#endregion
+//#region src/eslint/oxfmt-single-fix.ts
+/** Records the edit a fix makes, instead of making it. */
+const recordingFixer = { replaceTextRange(range, text) {
+	return {
+		range,
+		text
+	};
+} };
+/**
+* Wrap eslint-plugin-oxfmt so `oxfmt/oxfmt` reports one fix per file.
+*
+* @param plugin - The loaded plugin.
+* @returns The plugin with the wrapped rule.
+*/
+function oxfmtSingleFix(plugin) {
+	const { rules } = plugin;
+	const rule = rules?.["oxfmt"];
+	if (rule === void 0) return plugin;
+	return {
+		...plugin,
+		rules: {
+			...rules,
+			oxfmt: singleFixRule(rule)
+		}
+	};
+}
+function editOf({ fix }) {
+	if (typeof fix !== "function") return;
+	return fix(recordingFixer) ?? void 0;
+}
+/**
+* Merge non-overlapping edits into one that spans them all.
+*
+* @param source - The file text.
+* @param edits - Edits that do not overlap, in any order.
+* @returns One edit with the same effect.
+*/
+function mergeEdits(source, edits) {
+	const sorted = edits.toSorted((first, second) => first.range[0] - second.range[0]);
+	const start = sorted[0].range[0];
+	let end = start;
+	let text = "";
+	for (const { range, text: insert } of sorted) {
+		text += source.slice(end, range[0]) + insert;
+		[, end] = range;
 	}
-	return oxfmtOptions;
+	return {
+		range: [start, end],
+		text
+	};
 }
 /**
-* Build the effective oxfmt options shared between the ESLint and oxlint
-* factories.
+* Wrap the `oxfmt/oxfmt` rule so one file's formatting is one fix.
 *
-* @param options - The option sources, in increasing precedence.
-* @returns The effective oxfmt options.
+* The rule reports one fix per diff hunk. ESLint skips a fix that overlaps
+* another rule's fix in the same pass but applies the rest, so a delete hunk
+* can be dropped while its insert hunk lands (a moved comment is then kept
+* twice). One fix applies whole or not at all.
+*
+* @param rule - The original rule.
+* @returns The wrapped rule.
 */
-function buildOxfmtOptions({ oxfmtConfigOptions = {}, oxfmtOptions, prettierOptions = {} }) {
+function singleFixRule(rule) {
 	return {
-		sortImports: defaultSortImports,
-		sortPackageJson: false,
-		...migratePrettierOptions(prettierOptions),
-		...oxfmtConfigOptions,
-		...oxfmtOptions
+		...rule,
+		create(context) {
+			const reports = [];
+			const proxy = Object.create(context, { report: { value: (descriptor) => {
+				reports.push(descriptor);
+			} } });
+			function flush() {
+				const edits = reports.map((descriptor) => editOf(descriptor));
+				const fixable = edits.filter((edit) => edit !== void 0);
+				const merged = fixable.length > 0 ? mergeEdits(context.sourceCode.text, fixable) : void 0;
+				let fixAttached = false;
+				for (const [index, descriptor] of reports.entries()) {
+					const { fix: _fix, ...rest } = descriptor;
+					if (merged !== void 0 && !fixAttached && edits[index] !== void 0) {
+						fixAttached = true;
+						context.report({
+							...rest,
+							fix: (fixer) => fixer.replaceTextRange(merged.range, merged.text)
+						});
+					} else context.report(rest);
+				}
+				reports.length = 0;
+			}
+			const listeners = rule.create(proxy);
+			return Object.fromEntries(Object.entries(listeners).map(([selector, listener]) => {
+				return [selector, (...args) => {
+					listener(...args);
+					flush();
+				}];
+			}));
+		}
 	};
 }
 //#endregion
@@ -3438,22 +4025,49 @@ const defaultPluginRenaming = {
 //#region src/eslint/configs/oxfmt.ts
 init_globs();
 async function oxfmt(options) {
-	const { componentExts: componentExtensions = [], files: oxfmtFiles, formatters = {}, oxfmtConfigOptions = {}, oxfmtOptions: userOxfmtOptions, oxlint: enableOxlint = false, prettierOptions = {} } = options ?? {};
-	const formattingOptions = {
-		css: true,
-		graphql: true,
-		html: true,
-		json: true,
-		markdown: true,
-		yaml: true,
-		...resolveWithDefaults(formatters, {})
-	};
+	const { componentExts: componentExtensions = [], files: oxfmtFiles, formatters = {}, oxfmtConfigOptions = {}, oxfmtIgnorePatterns = [], oxfmtOptions: userOxfmtOptions, oxlint: enableOxlint = false, prettierOptions = {}, standalone = false } = options ?? {};
+	const languages = resolveFormattedLanguages(formatters);
 	const oxfmtOptions = buildOxfmtOptions({
 		oxfmtConfigOptions,
 		oxfmtOptions: userOxfmtOptions,
 		prettierOptions
 	});
-	const pluginOxfmt = lazyPlugin("eslint-plugin-oxfmt");
+	/**
+	* The `oxfmt/oxfmt` entry for a block, with an options layer over the
+	* base; none when oxfmt runs on its own.
+	*
+	* @param layer - Options applied over the base options.
+	* @returns The rule entry, or no rules.
+	*/
+	function formatRule(layer = {}) {
+		return standalone ? {} : { "oxfmt/oxfmt": ["error", {
+			...oxfmtOptions,
+			...layer,
+			disableNestedConfig: true
+		}] };
+	}
+	/**
+	* The `oxfmt/oxfmt` entry for Markdown code blocks, in every mode: oxfmt
+	* leaves them alone, and oxlint cannot read Markdown. A code block takes
+	* the root options of its language only: the rule does not load the
+	* config, so its overrides and the `.editorconfig` sections, which match
+	* by path, do not reach the block. The config's ignore patterns still do.
+	*
+	* @param layer - Options applied over the base options.
+	* @returns The rule entry.
+	*/
+	function codeBlockRule(layer = {}) {
+		return { "oxfmt/oxfmt": ["error", {
+			...oxfmtOptions,
+			...layer,
+			ignorePatterns: oxfmtIgnorePatterns,
+			overrides: [],
+			useConfig: false
+		}] };
+	}
+	const pluginOxfmt = lazyPlugin("eslint-plugin-oxfmt", (plugin) => {
+		return oxfmtSingleFix(oxfmtMarkdownCode(plugin));
+	});
 	const configPrettier = await interopDefault(import("eslint-config-prettier/flat"));
 	const rulesToIgnore = ["curly", "style/quotes"];
 	const rules = renameRules(configPrettier.rules, defaultPluginRenaming);
@@ -3462,103 +4076,130 @@ async function oxfmt(options) {
 		name: "isentinel/oxfmt/setup",
 		plugins: { oxfmt: pluginOxfmt }
 	}];
-	const jsFiles = oxfmtFiles ?? [
-		"**/*.{,c,m}js",
-		"**/*.{,c,m}jsx",
-		`**/*.md/**/*.{,c,m}js`,
-		`**/*.md/**/*.{,c,m}jsx`
-	];
-	configs.push({
-		name: "isentinel/oxfmt/javascript",
-		files: jsFiles,
-		rules: {
-			...rules,
-			"arrow-body-style": "off",
-			...enableOxlint ? {} : { "oxfmt/oxfmt": ["error", oxfmtOptions] },
-			"prefer-arrow-callback": "off"
-		}
-	});
-	const tsFiles = oxfmtFiles ?? [
-		"**/*.{,c,m}ts",
-		"**/*.{,c,m}tsx",
-		`**/*.md/**/*.{,c,m}ts`,
-		`**/*.md/**/*.{,c,m}tsx`,
-		...componentExtensions.map((extension) => `**/*.${extension}`)
-	];
-	configs.push({
-		name: "isentinel/oxfmt/typescript",
-		files: tsFiles,
+	const scriptBlocks = [["javascript", oxfmtFiles ?? [...FORMATTED_FILES.javascript]], ["typescript", oxfmtFiles ?? [...FORMATTED_FILES.typescript, ...componentExtensions.map((extension) => `**/*.${extension}`)]]];
+	for (const [name, files] of scriptBlocks) configs.push({
+		name: `isentinel/oxfmt/${name}`,
+		files,
 		rules: {
 			...rules,
 			"arrow-body-style": "off",
-			...enableOxlint ? {} : { "oxfmt/oxfmt": ["error", oxfmtOptions] },
+			...enableOxlint ? {} : formatRule(),
 			"prefer-arrow-callback": "off"
 		}
 	});
-	if (enableOxlint) configs.push({
-		name: "isentinel/oxfmt/markdown-code",
-		files: [
-			`${GLOB_MARKDOWN}/${GLOB_JS}`,
-			`${GLOB_MARKDOWN}/${GLOB_JSX}`,
-			`${GLOB_MARKDOWN}/${GLOB_TS}`,
-			`${GLOB_MARKDOWN}/${GLOB_TSX}`
-		],
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	});
-	if (formattingOptions.css) configs.push({
-		name: "isentinel/oxfmt/css",
-		files: [GLOB_CSS, GLOB_POSTCSS],
-		languageOptions: { parser: parserPlain },
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	}, {
-		name: "isentinel/oxfmt/scss",
-		files: [GLOB_SCSS],
-		languageOptions: { parser: parserPlain },
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	}, {
-		name: "isentinel/oxfmt/less",
-		files: [GLOB_LESS],
-		languageOptions: { parser: parserPlain },
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	});
-	if (formattingOptions.html) configs.push({
-		name: "isentinel/oxfmt/html",
-		files: ["**/*.html"],
-		languageOptions: { parser: parserPlain },
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	});
-	if (formattingOptions.markdown) configs.push({
+	if (languages.css) configs.push(plainBlock("css", [...FORMATTED_FILES.css], formatRule()), plainBlock("scss", [...FORMATTED_FILES.scss], formatRule()), plainBlock("less", [...FORMATTED_FILES.less], formatRule()));
+	if (languages.html) configs.push(plainBlock("html", [...FORMATTED_FILES.html], formatRule()));
+	if (!standalone && languages.markdown) configs.push({
 		name: "isentinel/oxfmt/markdown",
-		files: [GLOB_MARKDOWN],
-		rules: { "oxfmt/oxfmt": ["error", {
-			...oxfmtOptions,
-			printWidth: Number(prettierOptions["jsdocPrintWidth"]) || 80,
-			proseWrap: "always",
-			tabWidth: 2
-		}] }
+		files: [...FORMATTED_FILES.markdown],
+		rules: formatRule(markdownOxfmtOptions(prettierOptions["jsdocPrintWidth"]))
 	});
-	if (formattingOptions.graphql) configs.push({
-		name: "isentinel/oxfmt/graphql",
-		files: ["**/*.graphql"],
-		languageOptions: { parser: parserPlain },
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
-	});
-	if (formattingOptions.json) configs.push({
+	if (languages.graphql) configs.push(plainBlock("graphql", [...FORMATTED_FILES.graphql], formatRule()));
+	if (!standalone && languages.json) configs.push({
 		name: "isentinel/oxfmt/json",
-		files: [GLOB_ALL_JSON],
-		rules: { "oxfmt/oxfmt": ["error", oxfmtOptions] }
+		files: [...FORMATTED_FILES.json],
+		rules: formatRule()
+	}, {
+		name: "isentinel/oxfmt/json5",
+		files: [GLOB_JSON5],
+		rules: formatRule(JSON5_OXFMT_OPTIONS)
 	});
-	if (formattingOptions.yaml) configs.push({
+	if (!standalone && languages.yaml) configs.push({
 		name: "isentinel/oxfmt/yaml",
-		files: [GLOB_YAML],
-		rules: { "oxfmt/oxfmt": ["error", {
-			...oxfmtOptions,
-			tabWidth: 2,
-			useTabs: false
-		}] }
+		files: [...FORMATTED_FILES.yaml],
+		rules: formatRule(YAML_OXFMT_OPTIONS)
+	});
+	const codeBlocks = markdownCodeBlocks(languages, componentExtensions).map(([name, files, layer]) => {
+		return {
+			name: `isentinel/oxfmt/markdown-code/${name}`,
+			files: files.map((glob) => `${GLOB_MARKDOWN}/${glob}`),
+			rules: codeBlockRule(layer)
+		};
+	});
+	if (languages.markdown) configs.push(...codeBlocks);
+	else configs.push({
+		name: "isentinel/oxfmt/markdown-code",
+		files: codeBlocks.flatMap((block) => block.files),
+		rules: { "oxfmt/oxfmt": "off" }
 	});
 	return configs;
 }
+/**
+* The code-block languages to format, with the options each one uses: the
+* same as a file of that language. Markdown blocks are left out: a config
+* that matches their virtual `*.md/*.md` files makes ESLint fail.
+*
+* @param languages - Which languages are formatted.
+* @param componentExtensions - Component extensions formatted as TypeScript.
+* @returns The code-block languages.
+*/
+function markdownCodeBlocks(languages, componentExtensions) {
+	const blocks = [[
+		"javascript",
+		[...FORMATTED_FILES.javascript],
+		{}
+	], [
+		"typescript",
+		[...FORMATTED_FILES.typescript, ...componentExtensions.map((extension) => `**/*.${extension}`)],
+		{}
+	]];
+	if (languages.css) blocks.push([
+		"css",
+		[...FORMATTED_FILES.css],
+		{}
+	], [
+		"scss",
+		[...FORMATTED_FILES.scss],
+		{}
+	], [
+		"less",
+		[...FORMATTED_FILES.less],
+		{}
+	]);
+	if (languages.html) blocks.push([
+		"html",
+		[...FORMATTED_FILES.html],
+		{}
+	]);
+	if (languages.graphql) blocks.push([
+		"graphql",
+		[...FORMATTED_FILES.graphql],
+		{}
+	]);
+	if (languages.json) blocks.push([
+		"json",
+		[...FORMATTED_FILES.json],
+		{}
+	], [
+		"json5",
+		[GLOB_JSON5],
+		JSON5_OXFMT_OPTIONS
+	]);
+	if (languages.yaml) blocks.push([
+		"yaml",
+		[...FORMATTED_FILES.yaml],
+		YAML_OXFMT_OPTIONS
+	]);
+	return blocks;
+}
+/**
+* A block for a language ESLint has no parser for: the plain parser lets
+* `oxfmt/oxfmt` see the file, and keeps ESLint from parsing Markdown code
+* blocks in it as JavaScript.
+*
+* @param name - Appended to `isentinel/oxfmt/` to name the block.
+* @param files - Globs of the files the block applies to.
+* @param rules - Rules to enable for those files.
+* @returns The config block.
+*/
+function plainBlock(name, files, rules) {
+	return {
+		name: `isentinel/oxfmt/${name}`,
+		files,
+		languageOptions: { parser: parserPlain },
+		rules
+	};
+}
 //#endregion
 //#region src/eslint/configs/package-json.ts
 init_globs();
@@ -20251,7 +20892,7 @@ const flatConfigProps = [
 	"settings"
 ];
 async function isentinel(options, ...userConfigs) {
-	const { antiSlop = false, autoRenamePlugins = true, componentExts: componentExtensions = [], e18e: enableE18e = true, eslintPlugin: enableEslintPlugin = false, formatters, gitignore: enableGitignore = true, jsdoc: enableJsdoc = true, jsonc: enableJsonc = true, jsx: enableJsx = true, markdown: enableMarkdown = true, oxlint: enableOxlint = false, pnpm: enableCatalogs = findUpSync("pnpm-workspace.yaml") !== void 0, projectStructure: enableProjectStructure = false, react: enableReact = false, root: customRootGlobs, spellCheck: enableSpellCheck, toml: enableToml = true, yaml: enableYaml = true } = options;
+	const { antiSlop = false, autoRenamePlugins = true, componentExts: componentExtensions = [], e18e: enableE18e = true, eslintPlugin: enableEslintPlugin = false, formatter = "eslint", formatters, gitignore: enableGitignore = true, jsdoc: enableJsdoc = true, jsonc: enableJsonc = true, jsx: enableJsx = true, markdown: enableMarkdown = true, oxlint: enableOxlint = false, pnpm: enableCatalogs = findUpSync("pnpm-workspace.yaml") !== void 0, projectStructure: enableProjectStructure = false, react: enableReact = false, root: customRootGlobs, spellCheck: enableSpellCheck, toml: enableToml = true, yaml: enableYaml = true } = options;
 	const rootGlobs = mergeGlobs(GLOB_ROOT, customRootGlobs);
 	const enableRoblox = options.roblox !== false;
 	const reactOptions = resolveSubOptions(options, "react");
@@ -20281,15 +20922,26 @@ async function isentinel(options, ...userConfigs) {
 		if (options.type !== void 0) return options.type;
 		return enableRoblox ? "game" : "package";
 	})();
+	if (formatter === "standalone") warnStandaloneOptions(options);
+	const formatterOptions = formatter !== "standalone" && typeof formatters === "object" ? formatters : {};
+	const oxfmtFormats = formatter === "standalone" || formatters !== false && options.stylistic !== false;
+	const oxfmtConfig = oxfmtFormats ? await resolveOxfmtConfig() : { options: {} };
+	const oxfmtConfigOptions = oxfmtConfig.options;
+	const prettierSettings = resolvePrettierSettings(formatterOptions.prettierOptions);
+	const effectiveOxfmtOptions = buildOxfmtOptions({
+		oxfmtConfigOptions,
+		oxfmtOptions: formatterOptions.oxfmtOptions,
+		prettierOptions: prettierSettings
+	});
+	const widthSettings = withOxfmtWidths(prettierSettings, effectiveOxfmtOptions);
 	const stylisticOptions = (() => {
 		if (options.stylistic === false) return false;
 		if (typeof options.stylistic === "object") return options.stylistic;
 		return {};
 	})();
 	if (stylisticOptions !== false && !("jsx" in stylisticOptions)) stylisticOptions.jsx = enableJsx;
-	const formatterOptions = typeof formatters === "object" ? formatters : {};
-	const oxfmtConfigOptions = formatters !== false ? await resolveOxfmtConfigOptions() : {};
-	const prettierSettings = resolvePrettierSettings(formatterOptions.prettierOptions);
+	const sectionOverrides = oxfmtFormats ? editorConfigOverrides(void 0, oxfmtConfigOptions) : [];
+	warnScriptWidthOverrides(sectionOverrides, ".editorconfig");
 	const configs = [];
 	if (enableGitignore !== false) configs.push(gitignore({
 		config: enableGitignore,
@@ -20299,7 +20951,7 @@ async function isentinel(options, ...userConfigs) {
 		isInEditor,
 		stylistic: stylisticOptions
 	}), comments({
-		prettierOptions: prettierSettings,
+		prettierOptions: widthSettings,
 		stylistic: stylisticOptions
 	}), flawless({
 		...needsComplementOverlay ? { complementIgnores: robloxScopedFiles } : {},
@@ -20308,7 +20960,7 @@ async function isentinel(options, ...userConfigs) {
 		antiSlop,
 		roblox: enableRoblox,
 		stylistic: stylisticOptions
-	}, prettierSettings), ignores(options.ignores), imports({
+	}, widthSettings), ignores(options.ignores), imports({
 		stylistic: stylisticOptions,
 		type: projectType
 	}), packageJson({
@@ -20368,7 +21020,7 @@ async function isentinel(options, ...userConfigs) {
 			stylistic: stylisticOptions
 		}, shouldFormatLua));
 	}
-	if (stylisticOptions !== false) configs.push(stylistic(stylisticOptions), perfectionist({
+	if (stylisticOptions !== false) configs.push(stylistic(oxfmtFormats ? withOxfmtStyle(stylisticOptions, effectiveOxfmtOptions) : stylisticOptions), perfectionist({
 		...resolveSubOptions(options, "perfectionist"),
 		type: projectType
 	}));
@@ -20391,6 +21043,16 @@ async function isentinel(options, ...userConfigs) {
 	if (enableJsonc !== false && !typeAwareOnly) {
 		configs.push(jsonc({
 			...getOverrides(options, "jsonc"),
+			bracketSpacing: !oxfmtFormats || effectiveOxfmtOptions["bracketSpacing"] !== false,
+			...oxfmtFormats ? {
+				formatIndent: oxfmtIndent(effectiveOxfmtOptions),
+				layoutOverrides: jsonLayoutOverrides([
+					...sectionOverrides,
+					...oxfmtConfig.overrides ?? [],
+					...migratePrettierOverrides(prettierSettings["overrides"])
+				])
+			} : {},
+			singleQuote: oxfmtFormats && effectiveOxfmtOptions["singleQuote"] === true,
 			stylistic: stylisticOptions
 		}));
 		if (stylisticOptions !== false) configs.push(sortTsconfig());
@@ -20450,9 +21112,11 @@ async function isentinel(options, ...userConfigs) {
 			yaml: false
 		} : formatters,
 		oxfmtConfigOptions,
+		oxfmtIgnorePatterns: oxfmtConfig.ignorePatterns,
 		oxfmtOptions: formatterOptions.oxfmtOptions,
 		oxlint: oxlintMode === "full",
-		prettierOptions: prettierSettings
+		prettierOptions: prettierSettings,
+		standalone: formatter === "standalone"
 	}));
 	if ("files" in options) throw new Error("[@isentinel/eslint-config] The first argument should not contain the \"files\" property as the options are supposed to be global. Place it in the second or later config instead.");
 	const fusedConfig = flatConfigProps.reduce((accumulator, key) => {