@useinsider/eslint-config 3.0.2 → 4.0.0-beta.2

package/dist/main.js

@@ -1,12 +1,14 @@
+import { a as isVueUnsafeRule, i as isRuleDisabled, n as VUE_LIKE_GLOBS, o as toOxlintPluginName, r as isOxlintOwned, s as toOxlintRuleName, t as OXLINT_CATEGORIES } from "./oxlintOwnership-Cx0hgA_J.js";
 import { t as merge } from "./merge-R5ZHqMsV.js";
 import { t as mergeAll } from "./mergeAllConfig-B2rSXCdn.js";
 import { defineConfig } from "eslint/config";
 import globals from "globals";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { spawnSync } from "node:child_process";
 import { installPackage } from "@antfu/install-pkg";
 import semver from "semver";
 import { warn } from "node:console";
@@ -29,6 +31,33 @@ var configFileRules = {
 	"import-x/no-extraneous-dependencies": "off",
 	"import-x/prefer-default-export": "off"
 };
+var LINT_TOPOLOGY_NAME = "insider/lint-topology";
+/**
+* The three files `useInsider()` requires a consumer to own. They are always linted with
+* {@link buildLintTopologyBlocks}, independently of the `configFiles` option.
+*/
+var LINT_TOPOLOGY_GLOBS = [
+	"**/insider.lint.{ts,mts,cts,js,mjs,cjs}",
+	"**/eslint.config.{ts,mts,cts,js,mjs,cjs}",
+	"**/oxlint.config.{ts,mts,cts,js,mjs,cjs}"
+];
+var lintTopologyRules = {
+	...configFileRules,
+	"import-x/extensions": "off"
+};
+/**
+* Relaxations the mandated three-file layout needs in order to lint clean. Emitted unconditionally
+* because the layout exists whether or not the consumer passes `configFiles`.
+* @example
+* buildLintTopologyBlocks()[0].rules['import-x/extensions']; // 'off'
+*/
+function buildLintTopologyBlocks() {
+	return [{
+		name: LINT_TOPOLOGY_NAME,
+		files: [...LINT_TOPOLOGY_GLOBS],
+		rules: { ...lintTopologyRules }
+	}];
+}
 function mergeGlobs(userGlobs) {
 	const seen = /* @__PURE__ */ new Set();
 	const merged = [];
@@ -58,17 +87,459 @@ function buildConfigFilesBlocks(value) {
 function buildJqueryBlocks(entries) {
 	if (!entries || entries.length === 0) return [];
 	return entries.map((entry) => ({
-		files: entry.files,
+		files: [...entry.files],
 		languageOptions: { globals: { ...globals.jquery } }
 	}));
 }
 //#endregion
-//#region src/utils/ensureConfigStructure.ts
-var CONFIG_FILE_REGEX = /eslint\.config\.[mc]?[jt]s(?:$|\?)/;
+//#region src/builders/oxlint.ts
+var OXLINT_SUPPRESSION_NAME = "insider/oxlint-suppression";
+var OXLINT_SFC_EXCEPTION_NAME = "insider/oxlint-suppression-sfc-exception";
+var UNUSED_DIRECTIVE_BLOCK_NAME = "insider/unused-disable-directives";
+var UNUSED_DIRECTIVE_SEVERITY = "warn";
+var OXLINT_DIRECTIVE_OPTIONS = {
+	respectEslintDisableDirectives: false,
+	reportUnusedDisableDirectives: UNUSED_DIRECTIVE_SEVERITY
+};
+/**
+* The always-on ESLint block that makes a stale `eslint-disable` visible. ESLint 9 defaults this to
+* `warn`, but the split relies on it, so it is pinned rather than inherited.
+* @example
+* buildUnusedDirectiveBlocks()[0].linterOptions; // { reportUnusedDisableDirectives: 'warn' }
+*/
+function buildUnusedDirectiveBlocks() {
+	return [{
+		name: UNUSED_DIRECTIVE_BLOCK_NAME,
+		linterOptions: { reportUnusedDisableDirectives: UNUSED_DIRECTIVE_SEVERITY }
+	}];
+}
+function ownedRuleNames(rules) {
+	return Object.keys(rules).filter((name) => isOxlintOwned(name) && !isRuleDisabled(rules[name]));
+}
+function translatableRuleNames(rules) {
+	return Object.keys(rules).filter(isOxlintOwned);
+}
+function toOffRecord(ruleNames) {
+	return Object.fromEntries(ruleNames.map((name) => [name, "off"]));
+}
+function suppressionFor(block) {
+	if (!block.rules) return [];
+	const owned = ownedRuleNames(block.rules);
+	if (owned.length === 0) return [];
+	const files = block.files ? { files: [...block.files] } : {};
+	const blockIgnores = block.ignores ? [...block.ignores] : [];
+	const vueSafe = owned.filter((name) => !isVueUnsafeRule(name));
+	const vueUnsafe = owned.filter((name) => isVueUnsafeRule(name));
+	const suppressions = [];
+	if (vueSafe.length > 0) suppressions.push({
+		name: OXLINT_SUPPRESSION_NAME,
+		...files,
+		...blockIgnores.length > 0 ? { ignores: blockIgnores } : {},
+		rules: toOffRecord(vueSafe)
+	});
+	if (vueUnsafe.length > 0) suppressions.push({
+		name: OXLINT_SFC_EXCEPTION_NAME,
+		...files,
+		ignores: [...blockIgnores, ...VUE_LIKE_GLOBS],
+		rules: toOffRecord(vueUnsafe)
+	});
+	return suppressions;
+}
+/**
+* ESLint blocks that turn off every rule the emitted oxlint config takes over. Rules oxlint cannot
+* check inside an SFC are suppressed everywhere except `.vue`/`.svelte`/`.astro`, so a Vue consumer
+* keeps them.
+* @example
+* buildOxlintSuppressionBlocks([{ files: ['src/**\/*.ts'], rules: { 'no-var': 'error' } }]);
+* // [{ files: ['src/**\/*.ts'], rules: { 'no-var': 'off' } }]
+*/
+function buildOxlintSuppressionBlocks(blocks) {
+	return blocks.flatMap(suppressionFor);
+}
+function translateRules(rules, plugins) {
+	return translatableRuleNames(rules).reduce((accumulator, name) => {
+		plugins.add(toOxlintPluginName(name));
+		accumulator[toOxlintRuleName(name)] = rules[name];
+		return accumulator;
+	}, {});
+}
+function anchorOxlintGlob(glob) {
+	return glob.startsWith("**") || glob.startsWith("./") || glob.startsWith("/") ? glob : `./${glob}`;
+}
+function anchorGlobs(globs) {
+	return globs.map(anchorOxlintGlob);
+}
+function anchorOxlintIgnorePattern(pattern) {
+	const negated = pattern.startsWith("!");
+	const body = negated ? pattern.slice(1) : pattern;
+	const anchored = body.startsWith("/") || body.startsWith("**") ? body : `/${body}`;
+	return negated ? `!${anchored}` : anchored;
+}
+function overrideFor(block, plugins) {
+	if (!block.files || !block.rules) return [];
+	const translated = translateRules(block.rules, plugins);
+	if (Object.keys(translated).length === 0) return [];
+	return [{
+		files: anchorGlobs(block.files),
+		...block.ignores && block.ignores.length > 0 ? { excludeFiles: anchorGlobs(block.ignores) } : {},
+		rules: translated
+	}];
+}
+/**
+* The oxlint half of the split, derived from the same emitted ESLint blocks the suppression layer
+* reads. Every oxlint category is pinned off so the config enables exactly the preset's own rules
+* and nothing oxlint would otherwise turn on by default.
+* @example
+* buildOxlintConfig([{ files: ['src/**\/*.ts'], rules: { 'no-var': 'error' } }], ['dist']);
+* // { plugins: ['eslint'], categories: { correctness: 'off', ... }, ignorePatterns: ['/dist'], ... }
+*/
+function buildOxlintConfig(blocks, ignores) {
+	const plugins = /* @__PURE__ */ new Set(["eslint"]);
+	const overrides = blocks.flatMap((block) => overrideFor(block, plugins));
+	const globalRules = blocks.filter((block) => !block.files && block.rules).reduce((accumulator, block) => ({
+		...accumulator,
+		...translateRules(block.rules, plugins)
+	}), {});
+	return {
+		plugins: [...plugins].sort((left, right) => left.localeCompare(right)),
+		categories: Object.fromEntries(OXLINT_CATEGORIES.map((name) => [name, "off"])),
+		...ignores && ignores.length > 0 ? { ignorePatterns: ignores.map(anchorOxlintIgnorePattern) } : {},
+		options: { ...OXLINT_DIRECTIVE_OPTIONS },
+		rules: globalRules,
+		overrides
+	};
+}
+//#endregion
+//#region src/utils/layoutDiagnosis.ts
+var MODULE_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+var LINT_MODULE_FILENAMES = MODULE_EXTENSIONS.map((ext) => `insider.lint.${ext}`);
+var ESLINT_CONFIG_FILENAMES = MODULE_EXTENSIONS.map((ext) => `eslint.config.${ext}`);
+var OXLINT_CONFIG_FILENAMES = ["oxlint.config.ts", "oxlint.config.mts"];
 var OPT_OUT_ENV = "INSIDER_SKIP_CONFIG_VALIDATION";
-var FILE_URL_PREFIX = "file://";
-var TARGET_CALLEE_NAME = "useInsider";
+var MIGRATE_COMMAND = "npx @useinsider/eslint-config migrate";
+var SCAFFOLD_COMMAND = "npx @useinsider/eslint-config";
 var INSIDER_IMPORT_SOURCE = "@useinsider/eslint-config";
+var TARGET_CALLEE_NAME = "useInsider";
+var ESLINT_RENDERER_NAME = "useInsiderESLint";
+var OXC_RENDERER_NAME = "useInsiderOXC";
+var RENDERER_EXPORT = `export const ${`{ ${ESLINT_RENDERER_NAME}, ${OXC_RENDERER_NAME} }`} = ${TARGET_CALLEE_NAME}({ ... })`;
+var EXPECTED_LAYOUT = [
+	"Expected layout (three sibling files):",
+	"",
+	"  // insider.lint.ts",
+	`  import { ${TARGET_CALLEE_NAME} } from '${INSIDER_IMPORT_SOURCE}';`,
+	"",
+	`  ${RENDERER_EXPORT};`,
+	"",
+	"  // eslint.config.ts",
+	`  import { ${ESLINT_RENDERER_NAME} } from './insider.lint.ts';`,
+	"",
+	`  export default ${ESLINT_RENDERER_NAME}();`,
+	"",
+	"  // oxlint.config.ts",
+	`  import { ${OXC_RENDERER_NAME} } from './insider.lint.ts';`,
+	"",
+	`  export default await ${OXC_RENDERER_NAME}();`
+].join("\n");
+function findSibling(directory, filenames, fileExists) {
+	return filenames.find((filename) => fileExists(join(directory, filename))) ?? null;
+}
+var lazyRequire$1 = createRequire(import.meta.url);
+function parseProgram(source) {
+	try {
+		const { parse } = lazyRequire$1("@typescript-eslint/parser");
+		return parse(source, {
+			sourceType: "module",
+			range: true,
+			loc: true
+		});
+	} catch {
+		return null;
+	}
+}
+function collectUseInsiderAliases(program) {
+	const aliases = /* @__PURE__ */ new Set();
+	program.body.forEach((node) => {
+		if (node.type !== AST_NODE_TYPES.ImportDeclaration) return;
+		node.specifiers.forEach((specifier) => {
+			if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "useInsider") aliases.add(specifier.local.name);
+		});
+	});
+	return aliases;
+}
+function callsAny(node, aliases) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((child) => callsAny(child, aliases));
+	const candidate = node;
+	if (candidate.type === AST_NODE_TYPES.CallExpression) {
+		const { callee } = candidate;
+		if (callee.type === AST_NODE_TYPES.Identifier && aliases.has(callee.name)) return true;
+	}
+	return Object.entries(node).some(([key, value]) => key !== "parent" && callsAny(value, aliases));
+}
+/**
+* Whether a flat-config source is still the removed v3 shape: it imports `useInsider` and calls it
+* itself, instead of importing a renderer from a sibling `insider.lint.*` module. Both the plain
+* `export default useInsider({...})` form and the spread form are recognized.
+* @example
+* isV3EslintConfigSource("import { useInsider } from '@useinsider/eslint-config';\nexport default useInsider({});");
+* // true
+*/
+function isV3EslintConfigSource(source) {
+	const program = parseProgram(source);
+	if (!program) return false;
+	const aliases = collectUseInsiderAliases(program);
+	if (aliases.size === 0) return false;
+	return program.body.some((node) => callsAny(node, aliases));
+}
+function classify(lintModule, eslintConfig, oxlintConfig, eslintConfigIsV3) {
+	if (lintModule && eslintConfig && oxlintConfig) return "complete";
+	if (!lintModule && !eslintConfig && !oxlintConfig) return "noConfig";
+	if (!lintModule && eslintConfig && eslintConfigIsV3) return "unmigratedV3";
+	return "partial";
+}
+/**
+* What of the three-file layout is on disk in a directory, and which of the four guidance branches
+* applies. `unmigratedV3` is the only branch the in-lint migration offer acts on, because it is the
+* only one {@link import('../cli/migrate').runMigrate} can actually rewrite.
+* @example
+* diagnoseLayout('/repo').kind; // 'unmigratedV3' when eslint.config.js still calls useInsider()
+*/
+function diagnoseLayout(directory, options = {}) {
+	const fileExists = options.fileExists ?? existsSync;
+	const readSource = options.readSource ?? ((path) => readFileSync(path, "utf8"));
+	const lintModule = findSibling(directory, LINT_MODULE_FILENAMES, fileExists);
+	const eslintConfig = findSibling(directory, ESLINT_CONFIG_FILENAMES, fileExists);
+	const oxlintConfig = findSibling(directory, OXLINT_CONFIG_FILENAMES, fileExists);
+	let eslintConfigIsV3 = false;
+	if (eslintConfig && !lintModule) try {
+		eslintConfigIsV3 = isV3EslintConfigSource(readSource(join(directory, eslintConfig)));
+	} catch {
+		eslintConfigIsV3 = false;
+	}
+	const kind = classify(lintModule, eslintConfig, oxlintConfig, eslintConfigIsV3);
+	return {
+		kind,
+		directory,
+		lintModule,
+		eslintConfig,
+		oxlintConfig,
+		missing: [
+			lintModule ? null : "insider.lint.ts",
+			eslintConfig ? null : "eslint.config.ts",
+			oxlintConfig ? null : "oxlint.config.ts"
+		].filter((name) => name !== null),
+		autoMigratable: kind === "unmigratedV3"
+	};
+}
+/**
+* Import specifier for the consumer's lint module, naming the extension that is actually on disk so
+* the suggested snippet resolves as printed.
+* @example
+* lintModuleSpecifier('/repo'); // './insider.lint.mts' when that is the file present
+*/
+function lintModuleSpecifier(directory, fileExists = existsSync) {
+	return `./${findSibling(directory, LINT_MODULE_FILENAMES, fileExists) ?? "insider.lint.ts"}`;
+}
+function inventoryLines(diagnosis) {
+	const v3Note = diagnosis.kind === "unmigratedV3" ? " (still calls `useInsider()` itself)" : "";
+	return [
+		diagnosis.lintModule ? `  present: ${diagnosis.lintModule}` : "  MISSING: insider.lint.{ts,mts}",
+		diagnosis.eslintConfig ? `  present: ${diagnosis.eslintConfig}${v3Note}` : "  MISSING: eslint.config.{ts,mts}",
+		diagnosis.oxlintConfig ? `  present: ${diagnosis.oxlintConfig}` : `  MISSING: ${OXLINT_CONFIG_FILENAMES.join(" or ")}`
+	];
+}
+function guidanceBody(diagnosis) {
+	if (diagnosis.kind === "unmigratedV3") return [
+		"`useInsider()` no longer returns a flat-config array, so the config it is called from has",
+		"to become a module both linters can import. The migration does that rewrite for you:",
+		"",
+		`  ${MIGRATE_COMMAND}`
+	];
+	if (diagnosis.kind === "noConfig") return [
+		"There is no linter configuration here yet. Scaffold the three-file layout:",
+		"",
+		`  ${SCAFFOLD_COMMAND}`
+	];
+	return [
+		`The layout is incomplete — missing ${diagnosis.missing.join(", ")}.`,
+		"Add the missing file, or let the migration regenerate the whole layout:",
+		"",
+		`  ${MIGRATE_COMMAND}`
+	];
+}
+function detailLines(detail) {
+	if (!detail || detail.length === 0) return [];
+	return ["", ...detail];
+}
+/**
+* The consumer-facing failure text: a site-specific headline, then the branch that matches what is
+* on disk, then the layout dump, then the bypass. The command to run always comes before the dump,
+* because a consumer who reads only the first screen still has to be told about `migrate`.
+* @example
+* formatLayoutGuidance({ headline: 'no `insider.lint.*` module found in /repo.', diagnosis });
+*/
+function formatLayoutGuidance(input) {
+	return [
+		`@useinsider/eslint-config: ${input.headline}`,
+		"",
+		...inventoryLines(input.diagnosis),
+		"",
+		...guidanceBody(input.diagnosis),
+		...detailLines(input.detail),
+		"",
+		EXPECTED_LAYOUT,
+		"",
+		`Emergency bypass: set ${OPT_OUT_ENV}=true (do not commit).`
+	].join("\n");
+}
+//#endregion
+//#region src/utils/offerMigration.ts
+var PACKAGE_NAME = "@useinsider/eslint-config";
+var CLI_RELATIVE_PATH = "dist/cli.cjs";
+var NO_PROMPT_ENV = "INSIDER_NO_PROMPT";
+var IN_FLIGHT_ENV = "INSIDER_MIGRATION_IN_PROGRESS";
+var MIGRATE_FROM_LINT_ARGS = ["migrate", "--from-lint"];
+var BINARY_EXTENSIONS = /\.[mc]?js$/u;
+function binaryName(argument) {
+	return basename(argument).replace(BINARY_EXTENSIONS, "");
+}
+/**
+* Which linter is hosting the current process. oxlint evaluates `oxlint.config.ts` inside the Node
+* process that runs its own `bin/oxlint` wrapper, so `useInsider()` genuinely executes under both
+* binaries and the two have to be told apart before anything is written to stdout.
+* @example
+* detectLintHost(['node', '/app/node_modules/oxlint/bin/oxlint', '.']); // 'oxlint'
+*/
+function detectLintHost(argv = process.argv) {
+	const names = argv.slice(1).map(binaryName);
+	if (names.includes("oxlint")) return "oxlint";
+	if (names.includes("eslint")) return "eslint";
+	return "unknown";
+}
+function defaultInteractive() {
+	return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+}
+function skipReasonFor(env, argv, interactive) {
+	if (env[IN_FLIGHT_ENV] === "true") return "already-offered";
+	if (env.VITEST || env.NODE_ENV === "test") return "running-under-test";
+	if (env["INSIDER_SKIP_CONFIG_VALIDATION"] === "true" || env[NO_PROMPT_ENV] === "true") return "suppressed";
+	if (env.CI) return "running-in-ci";
+	if (detectLintHost(argv) === "oxlint") return "host-is-oxlint";
+	if (!interactive) return "no-tty";
+	return null;
+}
+function manifestNameAt(directory) {
+	const manifestPath = join(directory, "package.json");
+	if (!existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(readFileSync(manifestPath, "utf8")).name ?? null;
+	} catch {
+		return null;
+	}
+}
+function packageRootFrom(startDir) {
+	let current = startDir;
+	for (let depth = 0; depth < 10; depth += 1) {
+		if (manifestNameAt(current) === PACKAGE_NAME) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+	return null;
+}
+/**
+* Absolute path to this package's own built CLI, or `null` when it is not on disk. Resolved by
+* walking up from `startDir` — this module's own directory by default — rather than through
+* `require.resolve`, so it works from `dist/` and from `src/` alike.
+* @example
+* resolveCliEntry(); // '/app/node_modules/@useinsider/eslint-config/dist/cli.cjs'
+*/
+function resolveCliEntry(startDir) {
+	const root = packageRootFrom(startDir ?? dirname(fileURLToPath(import.meta.url)));
+	if (!root) return null;
+	const entry = resolve(root, CLI_RELATIVE_PATH);
+	return existsSync(entry) ? entry : null;
+}
+function defaultRunCli(entry, args, cwd, env) {
+	const result = spawnSync(process.execPath, [entry, ...args], {
+		cwd,
+		env,
+		stdio: "inherit"
+	});
+	if (result.error) return 1;
+	return result.status ?? 1;
+}
+function defaultWarn(message) {
+	console.error(message);
+}
+function outdatedNotice(diagnosis) {
+	const config = diagnosis.eslintConfig ?? "eslint.config.*";
+	return [
+		`@useinsider/eslint-config: ${config} still uses the v3 single-file layout.`,
+		`  ${join(diagnosis.directory, config)} calls \`useInsider()\` itself, and`,
+		`  ${diagnosis.missing.join(" and ")} ${diagnosis.missing.length === 1 ? "is" : "are"} missing.`,
+		"",
+		"Starting the guided migration. It shows every change before applying it.",
+		`Skip it with ${NO_PROMPT_ENV}=true.`,
+		""
+	].join("\n");
+}
+var offerAttempted = false;
+function withDefaults(deps) {
+	return {
+		env: deps.env ?? process.env,
+		argv: deps.argv ?? process.argv,
+		interactive: deps.interactive ?? defaultInteractive(),
+		resolveCliEntry: deps.resolveCliEntry ?? resolveCliEntry,
+		runCli: deps.runCli ?? defaultRunCli,
+		warn: deps.warn ?? defaultWarn
+	};
+}
+/**
+* Offers the guided migration for an outdated layout and runs it when the consumer accepts. Declines
+* silently — returning a skip reason instead of prompting — whenever writing to stdout would be
+* wrong: under oxlint, in CI, without a TTY, or when already inside a migration.
+* @example
+* offerMigration(diagnoseLayout('/repo')).accepted; // true after the consumer confirmed
+*/
+function offerMigration(diagnosis, deps = {}) {
+	const resolved = withDefaults(deps);
+	if (offerAttempted) return {
+		offered: false,
+		skipReason: "already-offered"
+	};
+	const skipReason = skipReasonFor(resolved.env, resolved.argv, resolved.interactive);
+	if (skipReason) return {
+		offered: false,
+		skipReason
+	};
+	const entry = resolved.resolveCliEntry();
+	if (!entry) return {
+		offered: false,
+		skipReason: "cli-not-found"
+	};
+	offerAttempted = true;
+	resolved.warn(outdatedNotice(diagnosis));
+	return {
+		offered: true,
+		accepted: resolved.runCli(entry, MIGRATE_FROM_LINT_ARGS, diagnosis.directory, {
+			...resolved.env,
+			[IN_FLIGHT_ENV]: "true"
+		}) === 0
+	};
+}
+//#endregion
+//#region src/utils/ensureConfigStructure.ts
+var ANCHOR_FILE_REGEX = /(?:insider\.lint|eslint\.config)\.[mc]?[jt]s(?:$|\?)/;
+var FILE_URL_PREFIX = "file://";
 var bypassWarnEmitted = false;
 function computeSelfModulePath() {
 	const raw = fileURLToPath(import.meta.url);
@@ -83,7 +554,7 @@ function isPathSpecifier(source) {
 	return source.startsWith(".") || source.startsWith("/");
 }
 function defaultIsInsiderImportSource(source, configPath) {
-	if (source === INSIDER_IMPORT_SOURCE) return true;
+	if (source === "@useinsider/eslint-config") return true;
 	if (!configPath || !isPathSpecifier(source)) return false;
 	try {
 		const absolute = resolve(dirname(configPath), source);
@@ -98,24 +569,24 @@ function locOf(node) {
 		column: node.loc.start.column
 	};
 }
-function validateCallExpression(callExpr) {
+function validateCallExpression(callExpr, expectedCallee) {
 	const { callee } = callExpr;
-	if (callee.type !== AST_NODE_TYPES.Identifier || callee.name !== TARGET_CALLEE_NAME) return [{
+	if (callee.type !== AST_NODE_TYPES.Identifier || callee.name !== expectedCallee) return [{
 		...locOf(callExpr),
-		reason: "Default export must call `useInsider(...)` directly."
+		reason: `Default export must call \`${expectedCallee}(...)\` directly.`
 	}];
 	return [];
 }
-function validateExportedCall(callee, fallbackLoc) {
+function validateExportedCall(callee, fallbackLoc, expectedCallee) {
 	let target = callee;
 	if (target.type === AST_NODE_TYPES.AwaitExpression) target = target.argument;
-	if (target.type === AST_NODE_TYPES.CallExpression) return validateCallExpression(target);
+	if (target.type === AST_NODE_TYPES.CallExpression) return validateCallExpression(target, expectedCallee);
 	if (target.type === AST_NODE_TYPES.ArrayExpression) return [{
 		...locOf(target),
-		reason: "Default export must not wrap `useInsider(...)` in an array. Use the typed options object instead."
+		reason: `Default export must not wrap \`${expectedCallee}(...)\` in an array.`
 	}];
 	if (target.type === AST_NODE_TYPES.LogicalExpression || target.type === AST_NODE_TYPES.ConditionalExpression) {
-		const reason = ["Default export must not gate `useInsider(...)` behind a logical/conditional expression.", "Use the typed options object instead."].join(" ");
+		const reason = [`Default export must not gate \`${expectedCallee}(...)\` behind a logical/conditional expression.`, "Use the typed options object instead."].join(" ");
 		return [{
 			...locOf(target),
 			reason
@@ -123,7 +594,7 @@ function validateExportedCall(callee, fallbackLoc) {
 	}
 	return [{
 		...fallbackLoc,
-		reason: "Default export must be a direct call to `useInsider(...)`."
+		reason: `Default export must be a direct call to \`${expectedCallee}(...)\`.`
 	}];
 }
 function collectInsiderBindings(node, bindings, isInsiderSource) {
@@ -144,7 +615,7 @@ function classifyExpressionStatement(node, insiderBindings) {
 		}
 	};
 }
-function classifyStatement(node, exportSeen, insiderBindings) {
+function classifyStatement(node, exportSeen, insiderBindings, expectedCallee) {
 	if (node.type === AST_NODE_TYPES.ImportDeclaration || node.type === AST_NODE_TYPES.VariableDeclaration) return { type: "ignore" };
 	if (node.type === AST_NODE_TYPES.ExpressionStatement) return classifyExpressionStatement(node, insiderBindings);
 	if (node.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
@@ -158,13 +629,13 @@ function classifyStatement(node, exportSeen, insiderBindings) {
 		const declaration = node.declaration;
 		return {
 			type: "export",
-			violations: validateExportedCall(declaration, locOf(node))
+			violations: validateExportedCall(declaration, locOf(node), expectedCallee)
 		};
 	}
 	const reason = [
 		`Disallowed top-level statement \`${node.type}\`.`,
 		"Only imports, variable declarations, helper calls from `@useinsider/eslint-config`,",
-		"and one `export default useInsider(...)` are allowed."
+		`and one \`export default ${expectedCallee}()\` are allowed.`
 	].join(" ");
 	return {
 		type: "disallowed",
@@ -179,18 +650,112 @@ function validateProgramStructure(program, configPath = "", options = {}) {
 	const insiderBindings = /* @__PURE__ */ new Set();
 	const resolver = options.isInsiderImportSource ?? defaultIsInsiderImportSource;
 	const isInsiderSource = (source) => resolver(source, configPath);
+	const expectedCallee = options.expectedCallee ?? "useInsiderESLint";
 	let exportSeen = false;
 	program.body.forEach((node) => {
 		if (node.type === AST_NODE_TYPES.ImportDeclaration) collectInsiderBindings(node, insiderBindings, isInsiderSource);
-		const result = classifyStatement(node, exportSeen, insiderBindings);
+		const result = classifyStatement(node, exportSeen, insiderBindings, expectedCallee);
 		if (result.type === "ignore") return;
 		if (result.type === "export") {
 			exportSeen = true;
 			violations.push(...result.violations);
 			return;
 		}
-		if (result.type === "duplicateExport") {
-			violations.push(result.violation);
+		violations.push(result.violation);
+	});
+	if (!exportSeen) violations.push({
+		line: 1,
+		column: 0,
+		reason: `Missing \`export default ${options.expectedCallee ?? "useInsiderESLint"}()\`.`
+	});
+	return violations;
+}
+function validateRendererPattern(pattern) {
+	const bound = /* @__PURE__ */ new Set();
+	const violations = [];
+	pattern.properties.forEach((property) => {
+		if (property.type !== AST_NODE_TYPES.Property || property.computed || !property.shorthand) {
+			violations.push({
+				...locOf(property),
+				reason: `Destructure \`${ESLINT_RENDERER_NAME}\` and \`${OXC_RENDERER_NAME}\` by name, without renaming or spreading.`
+			});
+			return;
+		}
+		bound.add(property.key.name);
+	});
+	[ESLINT_RENDERER_NAME, OXC_RENDERER_NAME].forEach((name) => {
+		if (!bound.has(name)) violations.push({
+			...locOf(pattern),
+			reason: `Missing \`${name}\` in the destructured \`${TARGET_CALLEE_NAME}(...)\` result.`
+		});
+	});
+	return violations;
+}
+function validateRendererExport(node) {
+	const { declaration } = node;
+	if (!declaration || declaration.type !== AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") return [{
+		...locOf(node),
+		reason: `Renderer export must be \`${RENDERER_EXPORT};\`.`
+	}];
+	if (declaration.declarations.length !== 1) return [{
+		...locOf(declaration),
+		reason: "Renderer export must declare exactly one binding."
+	}];
+	const [declarator] = declaration.declarations;
+	if (declarator.id.type !== AST_NODE_TYPES.ObjectPattern) return [{
+		...locOf(declarator.id),
+		reason: `Renderer export must destructure \`${ESLINT_RENDERER_NAME}\` and \`${OXC_RENDERER_NAME}\`.`
+	}];
+	const patternViolations = validateRendererPattern(declarator.id);
+	const { init } = declarator;
+	if (!init) return [...patternViolations, {
+		...locOf(declarator),
+		reason: `Renderer export must be initialized by a direct \`${TARGET_CALLEE_NAME}(...)\` call.`
+	}];
+	return [...patternViolations, ...validateExportedCall(init, locOf(declarator), TARGET_CALLEE_NAME)];
+}
+function classifyLintModuleStatement(node, exportSeen, insiderBindings) {
+	if (node.type === AST_NODE_TYPES.ImportDeclaration || node.type === AST_NODE_TYPES.VariableDeclaration) return { type: "ignore" };
+	if (node.type === AST_NODE_TYPES.ExpressionStatement) return classifyExpressionStatement(node, insiderBindings);
+	if (node.type === AST_NODE_TYPES.ExportNamedDeclaration) {
+		if (exportSeen) return {
+			type: "duplicateExport",
+			violation: {
+				...locOf(node),
+				reason: "Only one export is allowed."
+			}
+		};
+		return {
+			type: "export",
+			violations: validateRendererExport(node)
+		};
+	}
+	const reason = [
+		`Disallowed top-level statement \`${node.type}\`.`,
+		"Only imports, variable declarations, helper calls from `@useinsider/eslint-config`,",
+		`and one \`${RENDERER_EXPORT}\` are allowed.`
+	].join(" ");
+	return {
+		type: "disallowed",
+		violation: {
+			...locOf(node),
+			reason
+		}
+	};
+}
+function validateLintModuleStructure(program, configPath = "", options = {}) {
+	const violations = [];
+	const insiderBindings = /* @__PURE__ */ new Set();
+	const resolver = options.isInsiderImportSource ?? defaultIsInsiderImportSource;
+	const isInsiderSource = (source) => resolver(source, configPath);
+	let exportSeen = false;
+	program.body.forEach((node) => {
+		if (node.type === AST_NODE_TYPES.ImportDeclaration) collectInsiderBindings(node, insiderBindings, isInsiderSource);
+		const result = classifyLintModuleStatement(node, exportSeen, insiderBindings);
+		if (result.type === "ignore") return;
+		if (result.type === "export") {
+			exportSeen = true;
+			violations.push(...result.violations);
 			return;
 		}
 		violations.push(result.violation);
@@ -198,7 +763,7 @@ function validateProgramStructure(program, configPath = "", options = {}) {
 	if (!exportSeen) violations.push({
 		line: 1,
 		column: 0,
-		reason: "Missing `export default useInsider(...)`."
+		reason: `Missing \`${RENDERER_EXPORT};\`.`
 	});
 	return violations;
 }
@@ -222,7 +787,7 @@ function extractMatchesFromStack(frames) {
 	const matches = /* @__PURE__ */ new Set();
 	frames.forEach((frame) => {
 		const name = normalizeFrameFilename(frame.getFileName());
-		if (name && CONFIG_FILE_REGEX.test(name)) matches.add(name);
+		if (name && ANCHOR_FILE_REGEX.test(name)) matches.add(name);
 	});
 	return Array.from(matches);
 }
@@ -235,13 +800,16 @@ function argvCandidateAt(argv, index) {
 function extractConfigFromArgv(argv) {
 	for (let i = 0; i < argv.length; i += 1) {
 		const candidate = argvCandidateAt(argv, i);
-		if (candidate && CONFIG_FILE_REGEX.test(candidate)) return candidate;
+		if (candidate && ANCHOR_FILE_REGEX.test(candidate)) return candidate;
 	}
 	return null;
 }
+var LINT_MODULE_REGEX = /insider\.lint\.[mc]?[jt]s(?:$|\?)/;
 function getConsumerConfigPath(frames = readStackFrames(), argv = process.argv) {
 	const stackMatches = extractMatchesFromStack(frames);
 	if (stackMatches.length === 1) return stackMatches[0];
+	const lintModules = stackMatches.filter((match) => LINT_MODULE_REGEX.test(match));
+	if (lintModules.length === 1) return lintModules[0];
 	const fromArgv = extractConfigFromArgv(argv);
 	if (fromArgv) return fromArgv;
 	return null;
@@ -251,11 +819,12 @@ function captureConsumerConfigDir(configPath) {
 	consumerConfigDir = configPath === null ? null : dirname(resolve(configPath));
 }
 /**
-* Directory holding the consumer's `eslint.config.*`, captured by {@link ensureConfigStructure}.
-* This is the anchor `tsconfigPaths` entries are written against; it falls back to `process.cwd()`
-* when the config file could not be located.
+* Directory holding the consumer's `insider.lint.*` module and its sibling linter configs, captured
+* by {@link ensureConfigStructure}. This is the anchor `tsconfigPaths` entries are written against,
+* and where {@link import('./ensureOxlintConfig').ensureOxlintConfig} looks for the oxlint config;
+* it falls back to `process.cwd()` when the module could not be located.
 * @example
-* // consumer config at /repo/eslint.config.mjs, `eslint` launched from /repo/app
+* // consumer module at /repo/insider.lint.ts, `eslint` launched from /repo/app
 * getConsumerConfigDir(); // '/repo'
 */
 function getConsumerConfigDir() {
@@ -266,12 +835,12 @@ function formatReport(configPath, violations) {
 	const lines = violations.map((violation) => `  - [${violation.line}:${violation.column}] ${violation.reason}`);
 	const footer = [
 		"",
-		"Allowed structure:",
-		"  - import statements",
-		"  - const/let/var declarations",
-		"  - exactly one `export default useInsider({ ... })`",
+		"Alongside the export, only import statements, const/let/var declarations and helper calls",
+		"imported from `@useinsider/eslint-config` are allowed.",
+		"",
+		EXPECTED_LAYOUT,
 		"",
-		"Emergency bypass: set INSIDER_SKIP_CONFIG_VALIDATION=true (do not commit)."
+		`Emergency bypass: set ${OPT_OUT_ENV}=true (do not commit).`
 	].join("\n");
 	return `${header}\n${lines.join("\n")}\n${footer}`;
 }
@@ -312,21 +881,57 @@ function parseConsumerSource(configPath, source) {
 		return fail(`@useinsider/eslint-config: failed to parse consumer config at ${configPath}: ${message}`);
 	}
 }
-function runValidation(configPath) {
-	if (!configPath) fail(["@useinsider/eslint-config: unable to locate consumer `eslint.config.*` file for structure validation.", "If this is an unexpected environment, set INSIDER_SKIP_CONFIG_VALIDATION=true (do not commit)."].join("\n"));
-	const violations = validateProgramStructure(parseConsumerSource(configPath, readConsumerSource(configPath)), configPath);
+function resolveSibling(directory, filenames) {
+	const found = filenames.find((filename) => existsSync(resolve(directory, filename)));
+	return found ? resolve(directory, found) : null;
+}
+function validateFile(filePath, validator, options) {
+	const violations = validator(parseConsumerSource(filePath, readConsumerSource(filePath)), filePath, options);
 	if (violations.length === 0) return;
-	fail(formatReport(configPath, violations));
+	fail(formatReport(filePath, violations));
 }
-function ensureConfigStructure(overridePath) {
+var MIGRATED_EXIT_NOTICE = [
+	"@useinsider/eslint-config: migration finished.",
+	"",
+	"Re-run your lint command. This process already loaded the old configuration, so continuing now",
+	"would lint against a config that no longer exists on disk."
+].join("\n");
+var DECLINED_DETAIL = ["The guided migration was not completed, so nothing was written."];
+function failWithGuidance(headline, diagnosis, detail) {
+	return fail(formatLayoutGuidance({
+		headline,
+		diagnosis,
+		detail
+	}));
+}
+function handleOutdatedLayout(headline, diagnosis, offer) {
+	if (!diagnosis.autoMigratable) return failWithGuidance(headline, diagnosis);
+	const outcome = offer(diagnosis);
+	if (!outcome.offered) return failWithGuidance(headline, diagnosis);
+	if (!outcome.accepted) return failWithGuidance(headline, diagnosis, DECLINED_DETAIL);
+	return fail(MIGRATED_EXIT_NOTICE);
+}
+function runValidation(anchorPath, deps = {}) {
+	const diagnose = deps.diagnose ?? ((directory) => diagnoseLayout(directory));
+	const offer = deps.offer ?? offerMigration;
+	if (!anchorPath) handleOutdatedLayout("unable to locate the consumer `insider.lint.*` module for structure validation.", diagnose(process.cwd()), offer);
+	const directory = dirname(resolve(anchorPath));
+	const lintModulePath = resolveSibling(directory, LINT_MODULE_FILENAMES);
+	if (!lintModulePath) handleOutdatedLayout(`no \`insider.lint.*\` module found in ${directory}.`, diagnose(directory), offer);
+	validateFile(lintModulePath, validateLintModuleStructure, {});
+	const eslintConfigPath = resolveSibling(directory, ESLINT_CONFIG_FILENAMES);
+	if (!eslintConfigPath) failWithGuidance(`no \`eslint.config.*\` file found in ${directory}.`, diagnose(directory), [`\`${TARGET_CALLEE_NAME}()\` returns renderers, not a flat-config array, so ESLint still`, `needs a config file whose default export is \`${ESLINT_RENDERER_NAME}()\`.`]);
+	validateFile(eslintConfigPath, validateProgramStructure, { expectedCallee: ESLINT_RENDERER_NAME });
+}
+function ensureConfigStructure(overridePath, deps = {}) {
 	const configPath = overridePath === void 0 ? getConsumerConfigPath() : overridePath;
 	captureConsumerConfigDir(configPath);
-	if (process.env[OPT_OUT_ENV] === "true") {
+	if (process.env["INSIDER_SKIP_CONFIG_VALIDATION"] === "true") {
 		emitBypassWarning();
 		return;
 	}
 	try {
-		runValidation(configPath);
+		runValidation(configPath, deps);
 	} catch (error) {
 		if (error instanceof ConfigStructureExit) return;
 		throw error;
@@ -450,6 +1055,14 @@ function clonePreset(preset) {
 function isScopeName(key) {
 	return Object.keys(scopeMap).includes(key);
 }
+/**
+* Every scope name `useInsider()` accepts, for error messages that have to spell the options out.
+* @example
+* scopeNames().includes('typescriptNode'); // true
+*/
+function scopeNames() {
+	return Object.keys(scopeMap);
+}
 function applyCommonEntryFields(block, entry) {
 	if (entry.ignores && entry.ignores.length > 0) block.ignores = [...entry.ignores];
 	if (entry.globals) {
@@ -465,7 +1078,7 @@ async function buildScopeBlocks(scope, entries) {
 	const preset = (await scopeMap[scope]()).default;
 	return entries.map((entry) => {
 		const block = clonePreset(preset);
-		block.files = entry.files;
+		block.files = [...entry.files];
 		if (tsScopes.has(scope)) {
 			const { tsconfigPaths } = entry;
 			if (tsconfigPaths) applyTypescriptOverrides(block, { tsconfigPaths });
@@ -499,7 +1112,7 @@ async function buildStrictBlocks(value) {
 	const { default: strictConfig } = await import("./strict-BHw_cKrv.js");
 	const clone = { ...strictConfig };
 	if (clone.rules) clone.rules = { ...clone.rules };
-	if (isFileScoped) clone.files = value;
+	if (isFileScoped) clone.files = [...value];
 	else delete clone.files;
 	return [clone];
 }
@@ -508,7 +1121,11 @@ async function buildStrictBlocks(value) {
 var turnOff = false;
 var scanned = false;
 var silencedDependencies = /* @__PURE__ */ new Set();
-var fixedDependencies = ["eslint", "globals"];
+var fixedDependencies = [
+	"eslint",
+	"globals",
+	"oxlint"
+];
 var require = createRequire(import.meta.url);
 function getPackageJSONPath(currentDir) {
 	const fileLocation = resolve(currentDir, "package.json");
@@ -564,6 +1181,42 @@ function silenceDependencyWarning(input) {
 	input.forEach((dependency) => silencedDependencies.add(String(dependency)));
 }
 //#endregion
+//#region src/utils/ensureOxlintConfig.ts
+function formatMessage(directory) {
+	return formatLayoutGuidance({
+		headline: `no oxlint config found in ${directory}.`,
+		diagnosis: diagnoseLayout(directory),
+		detail: [
+			"useInsiderESLint() turns off every rule oxlint owns, so running ESLint alone would silently",
+			"drop those checks. Create the sibling oxlint config:",
+			"",
+			"  // oxlint.config.ts",
+			`  import { useInsiderOXC } from '${lintModuleSpecifier(directory)}';`,
+			"",
+			"  export default await useInsiderOXC();",
+			"",
+			"and run both linters:",
+			"",
+			"  \"lint\": \"oxlint --disable-nested-config && eslint .\"",
+			"",
+			`oxlint discovers only ${OXLINT_CONFIG_FILENAMES.join(" and ")} — any other extension is`,
+			"ignored without a word."
+		]
+	});
+}
+/**
+* Fails when the consumer enabled the ESLint-side oxlint suppression without a sibling oxlint
+* config to run the suppressed rules. Resolved against the directory
+* {@link getConsumerConfigDir} captured during `useInsider()`.
+* @example
+* ensureOxlintConfig(); // throws unless oxlint.config.{ts,mts} sits beside insider.lint.*
+*/
+function ensureOxlintConfig(directory = getConsumerConfigDir()) {
+	if (process.env["INSIDER_SKIP_CONFIG_VALIDATION"] === "true") return;
+	if (OXLINT_CONFIG_FILENAMES.some((filename) => existsSync(join(directory, filename)))) return;
+	throw new Error(formatMessage(directory));
+}
+//#endregion
 //#region src/utils/silenceRules.ts
 var globallySilencedRules = /* @__PURE__ */ new Set();
 /**
@@ -583,14 +1236,25 @@ function silenceRule(config) {
 	const [, ...restConfig] = Array.isArray(config) ? config : [];
 	return ["warn", ...restConfig];
 }
+/**
+* Reports a silenced rule name that no emitted block declares, which is how a typo in
+* `silenceRules` stays visible. The caller passes the union of every block's rule keys: a single
+* block is not evidence, because the emission is many narrow blocks and a correctly spelled rule is
+* absent from nearly all of them.
+* @example
+* warnUnknownSilencedRules(['no-console'], ['no-unknown-rule']); // warns once
+*/
+function warnUnknownSilencedRules(knownRules, silencedRules) {
+	const known = new Set(knownRules);
+	new Set(silencedRules).forEach((rule) => {
+		if (known.has(rule)) return;
+		warn(`Unknown rule "${rule}". Please remove it from the silenced rules list.`);
+	});
+}
 function filterSilencedRules(rules, silencedRules) {
 	let targetSilencedRules = silencedRules || globallySilencedRules;
 	if (Array.isArray(targetSilencedRules)) targetSilencedRules = new Set(targetSilencedRules);
 	if (!rules || !targetSilencedRules.size) return rules;
-	if (silencedRules) targetSilencedRules.forEach((rule) => {
-		if (rules[rule]) return;
-		warn(`Unknown rule "${rule}". Please remove it from the silenced rules list.`);
-	});
 	return Object.entries(rules).reduce((newRules, [key, value]) => {
 		if (value) newRules[key] = targetSilencedRules.has(key) && !isDisabled(value) ? silenceRule(value) : value;
 		return newRules;
@@ -613,6 +1277,11 @@ function assertNoRemovedKeys(config) {
 	const details = used.map((key) => `  - \`${key}\`: ${removedKeys.get(key)}`).join("\n");
 	throw new Error(`@useinsider/eslint-config: removed option(s) passed to useInsider():\n${details}`);
 }
+function assertNoUnknownKeys(config) {
+	const unknown = Object.keys(config).filter((key) => !reservedKeys.has(key) && !removedKeys.has(key) && !isScopeName(key));
+	if (unknown.length === 0) return;
+	throw new Error(`@useinsider/eslint-config: unknown option(s) passed to useInsider(): ${unknown.join(", ")}.\n  Scopes: ${scopeNames().join(", ")}\n  Other options: ${[...reservedKeys].join(", ")}`);
+}
 function isProcessableScopeKey(key) {
 	return !reservedKeys.has(key) && isScopeName(key);
 }
@@ -626,6 +1295,7 @@ async function collectScopeBlocks(config) {
 	}, Promise.resolve([]));
 }
 function applySilenceRules(blocks, perCallSilence) {
+	if (perCallSilence) warnUnknownSilencedRules(blocks.flatMap((block) => Object.keys(block.rules ?? {})), perCallSilence);
 	blocks.forEach((block) => {
 		if (!block.rules) return;
 		block.rules = perCallSilence ? filterSilencedRules(block.rules, perCallSilence) : filterSilencedRules(block.rules);
@@ -635,28 +1305,43 @@ function buildIgnoresBlocks(ignores) {
 	if (!ignores || ignores.length === 0) return [];
 	return [{ ignores: [...ignores] }];
 }
-async function useInsider(config) {
-	assertNoRemovedKeys(config);
-	ensureConfigStructure();
-	await ensureDependencies();
-	const ignoresBlocks = buildIgnoresBlocks(config.ignores);
+async function buildBaseBlocks(config) {
 	const scopeBlocks = await collectScopeBlocks(config);
-	const jqueryBlocks = buildJqueryBlocks(config.jquery);
-	const configFilesBlocks = buildConfigFilesBlocks(config.configFiles);
 	const strictBlocks = await buildStrictBlocks(config.strict);
-	const spellCheckerBlocks = buildSpellCheckerBlocks(config.spellChecker);
-	const blocks = [
-		...ignoresBlocks,
+	return [
+		...buildIgnoresBlocks(config.ignores),
+		...buildUnusedDirectiveBlocks(),
 		...scopeBlocks,
-		...jqueryBlocks,
-		...configFilesBlocks,
+		...buildJqueryBlocks(config.jquery),
+		...buildConfigFilesBlocks(config.configFiles),
 		...strictBlocks,
-		...spellCheckerBlocks
+		...buildLintTopologyBlocks(),
+		...buildSpellCheckerBlocks(config.spellChecker)
 	];
+}
+async function renderEslint(config) {
+	await ensureDependencies();
+	ensureOxlintConfig();
+	const baseBlocks = await buildBaseBlocks(config);
+	const blocks = [...baseBlocks, ...buildOxlintSuppressionBlocks(baseBlocks)];
 	applySilenceRules(blocks, config.silenceRules);
 	return defineConfig(blocks);
 }
+async function renderOxlint(config) {
+	const baseBlocks = await buildBaseBlocks(config);
+	applySilenceRules(baseBlocks, config.silenceRules);
+	return buildOxlintConfig(baseBlocks, config.ignores);
+}
+function useInsider(config) {
+	assertNoRemovedKeys(config);
+	assertNoUnknownKeys(config);
+	ensureConfigStructure();
+	return {
+		useInsiderESLint: () => renderEslint(config),
+		useInsiderOXC: () => renderOxlint(config)
+	};
+}
 //#endregion
-export { ensureConfigStructure, merge, mergeAll, silenceDependencyWarning, silenceRules, useInsider };
+export { ensureConfigStructure, ensureOxlintConfig, merge, mergeAll, silenceDependencyWarning, silenceRules, useInsider };
 
 //# sourceMappingURL=main.js.map