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

package/dist/main.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_oxlintOwnership = require("./oxlintOwnership-7hpdB3d1.cjs");
 const require_merge = require("./merge-DJQU2y2U.cjs");
 const require_mergeAllConfig = require("./mergeAllConfig-DjMWjBNg.cjs");
 let eslint_config = require("eslint/config");
 let globals = require("globals");
-globals = require_rolldown_runtime.__toESM(globals, 1);
+globals = require_oxlintOwnership.__toESM(globals, 1);
 let node_fs = require("node:fs");
 let node_module = require("node:module");
 let node_path = require("node:path");
@@ -12,7 +12,7 @@ let node_url = require("node:url");
 let _typescript_eslint_types = require("@typescript-eslint/types");
 let _antfu_install_pkg = require("@antfu/install-pkg");
 let semver = require("semver");
-semver = require_rolldown_runtime.__toESM(semver, 1);
+semver = require_oxlintOwnership.__toESM(semver, 1);
 let node_console = require("node:console");
 //#region src/builders/configFiles.ts
 /**
@@ -33,6 +33,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 = [];
@@ -62,17 +89,148 @@ 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.default.jquery } }
 	}));
 }
 //#endregion
+//#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) => require_oxlintOwnership.isOxlintOwned(name) && !require_oxlintOwnership.isRuleDisabled(rules[name]));
+}
+function translatableRuleNames(rules) {
+	return Object.keys(rules).filter(require_oxlintOwnership.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) => !require_oxlintOwnership.isVueUnsafeRule(name));
+	const vueUnsafe = owned.filter((name) => require_oxlintOwnership.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, ...require_oxlintOwnership.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(require_oxlintOwnership.toOxlintPluginName(name));
+		accumulator[require_oxlintOwnership.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(require_oxlintOwnership.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/ensureConfigStructure.ts
-var CONFIG_FILE_REGEX = /eslint\.config\.[mc]?[jt]s(?:$|\?)/;
-var OPT_OUT_ENV = "INSIDER_SKIP_CONFIG_VALIDATION";
+var ANCHOR_FILE_REGEX = /(?:insider\.lint|eslint\.config)\.[mc]?[jt]s(?:$|\?)/;
+var OPT_OUT_ENV$1 = "INSIDER_SKIP_CONFIG_VALIDATION";
 var FILE_URL_PREFIX = "file://";
 var TARGET_CALLEE_NAME = "useInsider";
+var ESLINT_RENDERER_NAME = "useInsiderESLint";
+var OXC_RENDERER_NAME = "useInsiderOXC";
 var INSIDER_IMPORT_SOURCE = "@useinsider/eslint-config";
+var MODULE_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+var RENDERER_EXPORT = `export const ${`{ ${ESLINT_RENDERER_NAME}, ${OXC_RENDERER_NAME} }`} = ${TARGET_CALLEE_NAME}({ ... })`;
+var LINT_MODULE_FILENAMES = MODULE_EXTENSIONS.map((ext) => `insider.lint.${ext}`);
+var ESLINT_CONFIG_FILENAMES = MODULE_EXTENSIONS.map((ext) => `eslint.config.${ext}`);
 var bypassWarnEmitted = false;
 function computeSelfModulePath() {
 	const raw = (0, node_url.fileURLToPath)({}.url);
@@ -102,24 +260,24 @@ function locOf(node) {
 		column: node.loc.start.column
 	};
 }
-function validateCallExpression(callExpr) {
+function validateCallExpression(callExpr, expectedCallee) {
 	const { callee } = callExpr;
-	if (callee.type !== _typescript_eslint_types.AST_NODE_TYPES.Identifier || callee.name !== TARGET_CALLEE_NAME) return [{
+	if (callee.type !== _typescript_eslint_types.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 === _typescript_eslint_types.AST_NODE_TYPES.AwaitExpression) target = target.argument;
-	if (target.type === _typescript_eslint_types.AST_NODE_TYPES.CallExpression) return validateCallExpression(target);
+	if (target.type === _typescript_eslint_types.AST_NODE_TYPES.CallExpression) return validateCallExpression(target, expectedCallee);
 	if (target.type === _typescript_eslint_types.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 === _typescript_eslint_types.AST_NODE_TYPES.LogicalExpression || target.type === _typescript_eslint_types.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
@@ -127,7 +285,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) {
@@ -148,7 +306,7 @@ function classifyExpressionStatement(node, insiderBindings) {
 		}
 	};
 }
-function classifyStatement(node, exportSeen, insiderBindings) {
+function classifyStatement(node, exportSeen, insiderBindings, expectedCallee) {
 	if (node.type === _typescript_eslint_types.AST_NODE_TYPES.ImportDeclaration || node.type === _typescript_eslint_types.AST_NODE_TYPES.VariableDeclaration) return { type: "ignore" };
 	if (node.type === _typescript_eslint_types.AST_NODE_TYPES.ExpressionStatement) return classifyExpressionStatement(node, insiderBindings);
 	if (node.type === _typescript_eslint_types.AST_NODE_TYPES.ExportDefaultDeclaration) {
@@ -162,13 +320,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",
@@ -183,18 +341,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 ?? ESLINT_RENDERER_NAME;
 	let exportSeen = false;
 	program.body.forEach((node) => {
 		if (node.type === _typescript_eslint_types.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 ?? ESLINT_RENDERER_NAME}()\`.`
+	});
+	return violations;
+}
+function validateRendererPattern(pattern) {
+	const bound = /* @__PURE__ */ new Set();
+	const violations = [];
+	pattern.properties.forEach((property) => {
+		if (property.type !== _typescript_eslint_types.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 !== _typescript_eslint_types.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 !== _typescript_eslint_types.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 === _typescript_eslint_types.AST_NODE_TYPES.ImportDeclaration || node.type === _typescript_eslint_types.AST_NODE_TYPES.VariableDeclaration) return { type: "ignore" };
+	if (node.type === _typescript_eslint_types.AST_NODE_TYPES.ExpressionStatement) return classifyExpressionStatement(node, insiderBindings);
+	if (node.type === _typescript_eslint_types.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 === _typescript_eslint_types.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);
@@ -202,7 +454,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;
 }
@@ -226,7 +478,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);
 }
@@ -239,13 +491,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;
@@ -255,27 +510,46 @@ function captureConsumerConfigDir(configPath) {
 	consumerConfigDir = configPath === null ? null : (0, node_path.dirname)((0, node_path.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() {
 	return consumerConfigDir ?? process.cwd();
 }
+var EXPECTED_LAYOUT = [
+	"Expected layout (three sibling files):",
+	"",
+	"  // insider.lint.ts",
+	"  import { useInsider } from '@useinsider/eslint-config';",
+	"",
+	`  ${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 formatReport(configPath, violations) {
 	const header = ["@useinsider/eslint-config: protected configuration structure violated in:", `  ${configPath}`].join("\n");
 	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.",
 		"",
-		"Emergency bypass: set INSIDER_SKIP_CONFIG_VALIDATION=true (do not commit)."
+		EXPECTED_LAYOUT,
+		"",
+		`Emergency bypass: set ${OPT_OUT_ENV$1}=true (do not commit).`
 	].join("\n");
 	return `${header}\n${lines.join("\n")}\n${footer}`;
 }
@@ -316,16 +590,50 @@ 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) => (0, node_fs.existsSync)((0, node_path.resolve)(directory, filename)));
+	return found ? (0, node_path.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 runValidation(anchorPath) {
+	if (!anchorPath) fail([
+		"@useinsider/eslint-config: unable to locate the consumer `insider.lint.*` module for structure validation.",
+		"",
+		EXPECTED_LAYOUT,
+		"",
+		`If this is an unexpected environment, set ${OPT_OUT_ENV$1}=true (do not commit).`
+	].join("\n"));
+	const directory = (0, node_path.dirname)((0, node_path.resolve)(anchorPath));
+	const lintModulePath = resolveSibling(directory, LINT_MODULE_FILENAMES);
+	if (!lintModulePath) fail([
+		`@useinsider/eslint-config: no \`insider.lint.*\` module found in ${directory}.`,
+		"",
+		`\`${TARGET_CALLEE_NAME}()\` now returns the two renderers instead of a flat-config array,`,
+		"so the config it is called from must be a module both linters can import.",
+		"",
+		EXPECTED_LAYOUT,
+		"",
+		`Emergency bypass: set ${OPT_OUT_ENV$1}=true (do not commit).`
+	].join("\n"));
+	validateFile(lintModulePath, validateLintModuleStructure, {});
+	const eslintConfigPath = resolveSibling(directory, ESLINT_CONFIG_FILENAMES);
+	if (!eslintConfigPath) fail([
+		`@useinsider/eslint-config: no \`eslint.config.*\` file found in ${directory}.`,
+		"",
+		EXPECTED_LAYOUT,
+		"",
+		`Emergency bypass: set ${OPT_OUT_ENV$1}=true (do not commit).`
+	].join("\n"));
+	validateFile(eslintConfigPath, validateProgramStructure, { expectedCallee: ESLINT_RENDERER_NAME });
 }
 function ensureConfigStructure(overridePath) {
 	const configPath = overridePath === void 0 ? getConsumerConfigPath() : overridePath;
 	captureConsumerConfigDir(configPath);
-	if (process.env[OPT_OUT_ENV] === "true") {
+	if (process.env[OPT_OUT_ENV$1] === "true") {
 		emitBypassWarning();
 		return;
 	}
@@ -366,52 +674,52 @@ function applyVueOverrides(block, input) {
 //#region src/builders/scopeBlocks.ts
 var scopeMap = {
 	async javascript() {
-		return Promise.resolve().then(() => require("./javascript-VBXqjVi8.cjs"));
+		return Promise.resolve().then(() => require("./javascript-DH8-N38w.cjs"));
 	},
 	async javascriptDom() {
-		return Promise.resolve().then(() => require("./javascript-dom-5jRL_yKP.cjs"));
+		return Promise.resolve().then(() => require("./javascript-dom-CvtQ6_9W.cjs"));
 	},
 	async javascriptNode() {
-		return Promise.resolve().then(() => require("./javascript-node-C1AU_4X2.cjs"));
+		return Promise.resolve().then(() => require("./javascript-node-BNsy3loY.cjs"));
 	},
 	async typescript() {
-		return Promise.resolve().then(() => require("./typescript-C1icmOxY.cjs"));
+		return Promise.resolve().then(() => require("./typescript-D3VeLnpn.cjs"));
 	},
 	async typescriptDom() {
-		return Promise.resolve().then(() => require("./typescript-dom-RUJn2WCZ.cjs"));
+		return Promise.resolve().then(() => require("./typescript-dom-iB_xBTAD.cjs"));
 	},
 	async typescriptNode() {
-		return Promise.resolve().then(() => require("./typescript-node-CBEzcc56.cjs"));
+		return Promise.resolve().then(() => require("./typescript-node-Cq6qhj53.cjs"));
 	},
 	async vue2() {
-		return Promise.resolve().then(() => require("./vue2-azKwRgaJ.cjs"));
+		return Promise.resolve().then(() => require("./vue2-Da1i_oVn.cjs"));
 	},
 	async vue3() {
-		return Promise.resolve().then(() => require("./vue3-Df5UQ1Ys.cjs"));
+		return Promise.resolve().then(() => require("./vue3-621EM2Ii.cjs"));
 	},
 	async vue2Typescript() {
-		return Promise.resolve().then(() => require("./vue2-typescript-CZSHzp7I.cjs"));
+		return Promise.resolve().then(() => require("./vue2-typescript-dXLRSGNP.cjs"));
 	},
 	async vue3Typescript() {
-		return Promise.resolve().then(() => require("./vue3-typescript-C0O1JZlk.cjs"));
+		return Promise.resolve().then(() => require("./vue3-typescript-DONe-IKz.cjs"));
 	},
 	async vue2OptionsApi() {
-		return Promise.resolve().then(() => require("./vue2-options-api-ma3J-bvM.cjs"));
+		return Promise.resolve().then(() => require("./vue2-options-api-BSdrUm8H.cjs"));
 	},
 	async vue3OptionsApi() {
-		return Promise.resolve().then(() => require("./vue3-options-api-Bx7yYHza.cjs"));
+		return Promise.resolve().then(() => require("./vue3-options-api-CC9_fAiq.cjs"));
 	},
 	async vue2TypescriptOptionsApi() {
-		return Promise.resolve().then(() => require("./vue2-typescript-options-api-B8OzZlje.cjs"));
+		return Promise.resolve().then(() => require("./vue2-typescript-options-api-LM7U5dWq.cjs"));
 	},
 	async vue3TypescriptOptionsApi() {
-		return Promise.resolve().then(() => require("./vue3-typescript-options-api-cPal4O-K.cjs"));
+		return Promise.resolve().then(() => require("./vue3-typescript-options-api-D4pqpDFs.cjs"));
 	},
 	async jest() {
-		return Promise.resolve().then(() => require("./jest-CHzjzBtf.cjs"));
+		return Promise.resolve().then(() => require("./jest-4Es9Ggaa.cjs"));
 	},
 	async vitest() {
-		return Promise.resolve().then(() => require("./vitest-BomI8gtu.cjs"));
+		return Promise.resolve().then(() => require("./vitest-BlGQswK2.cjs"));
 	},
 	async jsdocBasedTs() {
 		return Promise.resolve().then(() => require("./jsdoc-based-ts-Cfahz0nn.cjs"));
@@ -469,7 +777,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 });
@@ -503,7 +811,7 @@ async function buildStrictBlocks(value) {
 	const { default: strictConfig } = await Promise.resolve().then(() => require("./strict-DnJFBY_B.cjs"));
 	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];
 }
@@ -512,7 +820,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$1 = (0, node_module.createRequire)({}.url);
 function getPackageJSONPath(currentDir) {
 	const fileLocation = (0, node_path.resolve)(currentDir, "package.json");
@@ -568,6 +880,46 @@ function silenceDependencyWarning(input) {
 	input.forEach((dependency) => silencedDependencies.add(String(dependency)));
 }
 //#endregion
+//#region src/utils/ensureOxlintConfig.ts
+var OPT_OUT_ENV = "INSIDER_SKIP_CONFIG_VALIDATION";
+var OXLINT_CONFIG_FILENAMES = ["oxlint.config.ts", "oxlint.config.mts"];
+function lintModuleSpecifier(directory) {
+	return `./${LINT_MODULE_FILENAMES.find((filename) => (0, node_fs.existsSync)((0, node_path.join)(directory, filename))) ?? "insider.lint.ts"}`;
+}
+function formatMessage(directory) {
+	return [
+		"@useinsider/eslint-config: no oxlint config found in",
+		`  ${directory}`,
+		"",
+		"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 .\"",
+		"",
+		`Expected one of: ${OXLINT_CONFIG_FILENAMES.join(", ")}.`,
+		`Emergency bypass: set ${OPT_OUT_ENV}=true (do not commit).`
+	].join("\n");
+}
+/**
+* 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[OPT_OUT_ENV] === "true") return;
+	if (OXLINT_CONFIG_FILENAMES.some((filename) => (0, node_fs.existsSync)((0, node_path.join)(directory, filename)))) return;
+	throw new Error(formatMessage(directory));
+}
+//#endregion
 //#region src/utils/silenceRules.ts
 var globallySilencedRules = /* @__PURE__ */ new Set();
 /**
@@ -587,14 +939,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;
+		(0, node_console.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;
-		(0, node_console.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;
@@ -630,6 +993,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);
@@ -639,29 +1003,44 @@ 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 (0, eslint_config.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);
+	ensureConfigStructure();
+	return {
+		useInsiderESLint: () => renderEslint(config),
+		useInsiderOXC: () => renderOxlint(config)
+	};
+}
 //#endregion
 exports.ensureConfigStructure = ensureConfigStructure;
+exports.ensureOxlintConfig = ensureOxlintConfig;
 exports.merge = require_merge.merge;
 exports.mergeAll = require_mergeAllConfig.mergeAll;
 exports.silenceDependencyWarning = silenceDependencyWarning;