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

package/dist/cli.cjs

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_oxlintOwnership = require("./oxlintOwnership-7hpdB3d1.cjs");
 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_path = require("node:path");
 let node_url = require("node:url");
+let _typescript_eslint_types = require("@typescript-eslint/types");
 let node_crypto = require("node:crypto");
 let node_os = require("node:os");
 let typescript = require("typescript");
-typescript = require_rolldown_runtime.__toESM(typescript, 1);
+typescript = require_oxlintOwnership.__toESM(typescript, 1);
+let _typescript_eslint_parser = require("@typescript-eslint/parser");
 //#region src/cli/detect.ts
 var FLAT_CONFIG_FILENAMES = [
 	"eslint.config.mjs",
@@ -307,20 +309,26 @@ function detectVueApiPattern(input) {
 //#region src/cli/dispatch.ts
 var yesFlags = /* @__PURE__ */ new Set(["--yes", "-y"]);
 var noInstallFlags = /* @__PURE__ */ new Set(["--no-install"]);
+var fromLintFlags = /* @__PURE__ */ new Set(["--from-lint"]);
 function isYesFlag(arg) {
 	return yesFlags.has(arg);
 }
 function isNoInstallFlag(arg) {
 	return noInstallFlags.has(arg);
 }
+function isFromLintFlag(arg) {
+	return fromLintFlags.has(arg);
+}
 function parseMigrateArgs(rest) {
 	const yes = rest.some(isYesFlag);
 	const noInstall = rest.some(isNoInstallFlag);
-	const positional = rest.filter((arg) => !isYesFlag(arg) && !isNoInstallFlag(arg));
+	const fromLint = rest.some(isFromLintFlag);
+	const positional = rest.filter((arg) => !isYesFlag(arg) && !isNoInstallFlag(arg) && !isFromLintFlag(arg));
 	return {
 		target: positional.length > 0 ? positional[positional.length - 1] : void 0,
 		yes,
-		noInstall
+		noInstall,
+		fromLint
 	};
 }
 function parseScaffoldArgs(argv) {
@@ -329,12 +337,14 @@ function parseScaffoldArgs(argv) {
 function printUsage(stderr, unknown) {
 	stderr(`[useinsider/eslint-config] Unknown subcommand: ${unknown}`);
 	stderr("Usage:");
-	stderr("  npx @useinsider/eslint-config [--yes|-y]   Scaffold a new eslint.config.mjs");
-	stderr("  npx @useinsider/eslint-config migrate [path] [--yes|-y] [--no-install]");
-	stderr("                                              Migrate an existing v1 useInsider() config to v2");
+	stderr("  npx @useinsider/eslint-config [--yes|-y]");
+	stderr("      Scaffold insider.lint.*, eslint.config.* and oxlint.config.*");
+	stderr("  npx @useinsider/eslint-config migrate [path] [--yes|-y] [--no-install] [--from-lint]");
+	stderr("      Split an existing useInsider() or .eslintrc* config into the three-file layout");
+	stderr("      --from-lint: started by a failing lint run — confirm first, exit non-zero if declined");
 }
 function isScaffoldArgv(argv) {
-	return argv.length === 0 || argv.every((arg) => isYesFlag(arg));
+	return argv.every((arg) => isYesFlag(arg));
 }
 async function dispatch(argv, cwd, deps) {
 	if (isScaffoldArgv(argv)) {
@@ -346,18 +356,22 @@ async function dispatch(argv, cwd, deps) {
 	}
 	const [subcommand, ...rest] = argv;
 	if (subcommand === "migrate") {
-		const { target, yes, noInstall } = parseMigrateArgs(rest);
+		const { target, yes, noInstall, fromLint } = parseMigrateArgs(rest);
 		return deps.migrate({
 			cwd,
 			target,
 			yes,
-			noInstall
+			noInstall,
+			fromLint
 		});
 	}
 	printUsage(deps.stderr, subcommand);
 	return 1;
 }
 //#endregion
+//#region src/configs/dependencies.ts
+var dependencies$14 = { oxlint: true };
+//#endregion
 //#region src/configs/jest/dependencies.ts
 var dependencies$13 = { "eslint-plugin-jest": true };
 //#endregion
@@ -471,6 +485,7 @@ function buildDependencyList(answers, rawManifest = readOwnEslintConfigManifest$
 	deps.add(`@useinsider/eslint-config@${manifest.version}`);
 	deps.add(pinned(manifest, "eslint"));
 	deps.add(pinned(manifest, "globals"));
+	applyRecord(deps, manifest, dependencies$14);
 	const wantsTypescript = answers.languages.includes("typescript");
 	if (answers.framework === "vue") applyRecord(deps, manifest, vueDepsFor(answers.vueMajor ?? 3, wantsTypescript));
 	else if (wantsTypescript) applyRecord(deps, manifest, dependencies$12);
@@ -654,39 +669,66 @@ function noteGenericError(clack, summary, context, specs) {
 async function tryRetryInstall(clack, installer, deps, context) {
 	try {
 		await installer(deps);
+		return { installed: true };
 	} catch (retryError) {
-		noteError(clack, "Retry install failed after wipe: ", retryError instanceof Error ? retryError.message : String(retryError), context, deps);
+		const retryReason = retryError instanceof Error ? retryError.message : String(retryError);
+		noteError(clack, "Retry install failed after wipe: ", retryReason, context, deps);
+		return {
+			installed: false,
+			reason: retryReason
+		};
 	}
 }
 async function tryGenericRetryInstall(clack, installer, deps, context) {
 	try {
 		await installer(deps);
+		return { installed: true };
 	} catch (retryError) {
-		noteGenericError(clack, buildGenericSummary(`Clean reinstall failed: ${retryError instanceof Error ? retryError.message : String(retryError)}`), context, deps);
+		const summary = buildGenericSummary(`Clean reinstall failed: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+		noteGenericError(clack, summary, context, deps);
+		return {
+			installed: false,
+			reason: summary
+		};
 	}
 }
 async function handlePeerDepFailure(clack, deps, autoConfirm, installer, reason, context) {
 	if (!await confirmPeerDepWipe(clack, autoConfirm)) {
 		noteError(clack, "Install failed: ", reason, context, deps);
-		return;
+		return {
+			installed: false,
+			reason
+		};
 	}
 	performFullWipe(clack, context);
-	await tryRetryInstall(clack, installer, deps, context);
+	return tryRetryInstall(clack, installer, deps, context);
 }
 async function handleGenericFailure(clack, deps, autoConfirm, installer, reason, context) {
 	const summary = buildGenericSummary(reason);
 	if (!await confirmCleanReinstall(clack, autoConfirm, summary)) {
 		if (clack.note) clack.note(`${summary}\nSkipping clean reinstall. Please resolve the issue manually and re-run.`, "Error");
-		return;
+		return {
+			installed: false,
+			reason: summary
+		};
 	}
 	performFullWipe(clack, context);
-	await tryGenericRetryInstall(clack, installer, deps, context);
-}
+	return tryGenericRetryInstall(clack, installer, deps, context);
+}
+/**
+* Installs the dependencies, offering one wipe-and-retry when the first attempt fails, and reports
+* whether they ended up installed. Every failure path is already explained to the consumer through
+* `clack`, so the outcome exists for the caller's exit code rather than for a second message.
+* @example
+* const outcome = await installWithRetry(options);
+* if (!outcome.installed) { return 1; }
+*/
 async function installWithRetry(opts) {
 	const installer = opts.installer ?? defaultInstaller;
 	const fs = opts.fsOps ?? defaultWipeFs();
 	try {
 		await installer(opts.deps);
+		return { installed: true };
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
 		const context = {
@@ -694,12 +736,303 @@ async function installWithRetry(opts) {
 			fs,
 			detected: detectLockfile(opts.cwd, fs.exists)
 		};
-		if (isPeerDepFailure(reason)) {
-			await handlePeerDepFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+		if (isPeerDepFailure(reason)) return handlePeerDepFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+		return handleGenericFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+	}
+}
+//#endregion
+//#region src/cli/lintLayout.ts
+var OXLINT_COMMAND = "oxlint --disable-nested-config";
+var OXLINT_LINT_SCRIPT = `${OXLINT_COMMAND} && eslint .`;
+/**
+* Extension for the lint module and the oxlint config. oxlint only discovers `oxlint.config.ts` and
+* `oxlint.config.mts`, and Node warns on a bare `.ts` file inside a package that declares no
+* `"type"`, so such a consumer gets the unambiguous `.mts` form.
+* @example
+* resolveLayoutExtension('/repo'); // 'ts' when /repo/package.json declares "type": "module"
+*/
+function resolveLayoutExtension(cwd) {
+	try {
+		const raw = (0, node_fs.readFileSync)((0, node_path.join)(cwd, "package.json"), "utf8");
+		return JSON.parse(raw).type === "module" ? "ts" : "mts";
+	} catch {
+		return "mts";
+	}
+}
+var ESLINT_CONFIG_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+var TYPESCRIPT_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
+	"cts",
+	"mts",
+	"ts"
+]);
+function extensionOf(filename) {
+	return filename.slice(filename.lastIndexOf(".") + 1);
+}
+function existingEslintConfigs(cwd) {
+	return ESLINT_CONFIG_EXTENSIONS.map((extension) => `eslint.config.${extension}`).filter((filename) => (0, node_fs.existsSync)((0, node_path.join)(cwd, filename)));
+}
+/**
+* The three filenames `useInsider()` requires, resolved against a consumer directory. A JavaScript
+* flat config is renamed to the TypeScript extension — it cannot import the lint module on every
+* supported Node version — and every other `eslint.config.*` in the directory is reported through
+* `replacedEslintConfigs` so the caller deletes it. ESLint resolves `.js`/`.mjs`/`.cjs` before the
+* TypeScript extensions, so a leftover JavaScript config keeps winning over the one just written.
+* @example
+* resolveLintLayout('/repo');
+* // { eslintConfig: 'eslint.config.ts', replacedEslintConfigs: ['eslint.config.js'], ... }
+*/
+function resolveLintLayout(cwd) {
+	const extension = resolveLayoutExtension(cwd);
+	const existing = existingEslintConfigs(cwd);
+	const eslintConfig = existing.find((filename) => TYPESCRIPT_CONFIG_EXTENSIONS.has(extensionOf(filename))) ?? `eslint.config.${extension}`;
+	return {
+		extension,
+		lintModule: `insider.lint.${extension}`,
+		oxlintConfig: `oxlint.config.${extension}`,
+		eslintConfig,
+		replacedEslintConfigs: existing.filter((filename) => filename !== eslintConfig)
+	};
+}
+/**
+* Body of the generated `eslint.config.*`. The import names the lint module's real extension
+* because neither linter's loader applies TypeScript's `.js` → `.ts` specifier rewriting.
+* @example
+* renderEslintConfigFile('insider.lint.ts'); // "import { useInsiderESLint } from './insider.lint.ts';\n…"
+*/
+function renderEslintConfigFile(lintModule) {
+	return [
+		`import { useInsiderESLint } from './${lintModule}';`,
+		"",
+		"export default useInsiderESLint();",
+		""
+	].join("\n");
+}
+/**
+* Body of the generated `oxlint.config.*`.
+* @example
+* renderOxlintConfigFile('insider.lint.mts'); // "…export default await useInsiderOXC();\n"
+*/
+function renderOxlintConfigFile(lintModule) {
+	return [
+		`import { useInsiderOXC } from './${lintModule}';`,
+		"",
+		"export default await useInsiderOXC();",
+		""
+	].join("\n");
+}
+/**
+* The two thin files that sit beside a lint module, ready to write.
+* @example
+* renderLintLayoutFiles(resolveLintLayout('/repo')).map(file => file.filename);
+* // ['eslint.config.mts', 'oxlint.config.mts']
+*/
+function renderLintLayoutFiles(layout) {
+	return [{
+		filename: layout.eslintConfig,
+		source: renderEslintConfigFile(layout.lintModule)
+	}, {
+		filename: layout.oxlintConfig,
+		source: renderOxlintConfigFile(layout.lintModule)
+	}];
+}
+var DEFAULT_INDENT = 2;
+function detectIndent$1(raw) {
+	const firstBreak = raw.indexOf("\n");
+	if (firstBreak === -1) return DEFAULT_INDENT;
+	const rest = raw.slice(firstBreak + 1);
+	const width = rest.length - rest.trimStart().length;
+	return width > 0 ? width : DEFAULT_INDENT;
+}
+var SEGMENT_SEPARATOR = /&&|\|\||[;|]/u;
+var ASSIGNMENT = /^[A-Za-z_]\w*=/u;
+var WRAPPER_COMMANDS = /* @__PURE__ */ new Set([
+	"bunx",
+	"cross-env",
+	"dotenv",
+	"exec",
+	"npx",
+	"pnpm",
+	"run",
+	"yarn"
+]);
+function baseName(token) {
+	return token.slice(token.lastIndexOf("/") + 1).replace(/\.[mc]?js$/u, "");
+}
+function segmentsOf(command) {
+	return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function tokensOf(segment) {
+	return segment.split(/\s+/u).filter((token) => token.length > 0 && !ASSIGNMENT.test(token));
+}
+function commandWordOf(segment) {
+	return tokensOf(segment).map(baseName).find((word) => !word.startsWith("-") && !WRAPPER_COMMANDS.has(word)) ?? null;
+}
+/**
+* Whether a package script really invokes the `eslint` binary, as opposed to delegating to another
+* script that does. `npm run lint:es` is not an ESLint invocation; `NODE_OPTIONS=… eslint .` is.
+* @example
+* invokesBinary('npm run lint:es-ci -- --cache', 'eslint'); // false
+*/
+function invokesBinary(command, binary) {
+	return segmentsOf(command).some((segment) => commandWordOf(segment) === binary);
+}
+function oxlintPrefixFor(command) {
+	return tokensOf(command).includes("--fix") ? `${OXLINT_COMMAND} --fix` : OXLINT_COMMAND;
+}
+var CANONICAL_LINT_SCRIPT = "lint";
+function referencedScripts(command, names) {
+	return tokensOf(command).map((token) => token.replace(/^["']|["']$/gu, "").replace(/^npm:/u, "")).filter((token) => names.has(token));
+}
+function collectReachable(scripts, names, script, seen) {
+	if (seen.has(script)) return;
+	seen.add(script);
+	referencedScripts(scripts[script] ?? "", names).forEach((next) => {
+		collectReachable(scripts, names, next, seen);
+	});
+}
+function reachableFromLint(scripts) {
+	const names = new Set(Object.keys(scripts));
+	const seen = /* @__PURE__ */ new Set();
+	if (names.has(CANONICAL_LINT_SCRIPT)) collectReachable(scripts, names, CANONICAL_LINT_SCRIPT, seen);
+	return seen;
+}
+function fixingRank(candidate) {
+	return tokensOf(candidate.previous).includes("--fix") ? 1 : 0;
+}
+function compareCandidates(left, right) {
+	return fixingRank(left) - fixingRank(right) || left.script.length - right.script.length || left.script.localeCompare(right.script);
+}
+function selectTarget(scripts, candidates) {
+	if (candidates.length === 0) return null;
+	const reachable = reachableFromLint(scripts);
+	const preferred = candidates.filter((candidate) => reachable.has(candidate.script));
+	return [...preferred.length > 0 ? preferred : candidates].sort(compareCandidates)[0];
+}
+function planChanges(scripts) {
+	const alreadyRunsOxlint = [];
+	const candidates = [];
+	Object.entries(scripts).forEach(([script, previous]) => {
+		if (!invokesBinary(previous, "eslint")) return;
+		if (invokesBinary(previous, "oxlint")) {
+			alreadyRunsOxlint.push(script);
 			return;
 		}
-		await handleGenericFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+		candidates.push({
+			script,
+			previous
+		});
+	});
+	const target = selectTarget(scripts, candidates);
+	if (!target) return {
+		changes: [],
+		alreadyRunsOxlint,
+		skipped: []
+	};
+	return {
+		changes: [{
+			script: target.script,
+			previous: target.previous,
+			next: `${oxlintPrefixFor(target.previous)} && ${target.previous}`
+		}],
+		alreadyRunsOxlint,
+		skipped: candidates.filter((candidate) => candidate.script !== target.script)
+	};
+}
+/**
+* Adds oxlint beside the one script that actually runs ESLint, by prepending to it rather than
+* replacing it — so a composed `lint` such as `run-p lint:type lint:es lint:style` keeps its
+* type-check and stylelint passes and only its `lint:es-ci` leaf is rewritten. Sibling entry points
+* that also run ESLint (`lint:fix`, `lint:ci`) are reported through `skipped` rather than rewritten,
+* so oxlint runs once per lint pass. Never rewrites a script it did not author: when nothing invokes
+* `eslint` and a `lint` script already exists, the manifest is left alone and the conflict reported.
+* @example
+* setLintScript('{"scripts":{"lint":"eslint ."}}').changes;
+* // [{ script: 'lint', previous: 'eslint .', next: 'oxlint --disable-nested-config && eslint .' }]
+*/
+function setLintScript(rawManifest) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawManifest);
+	} catch {
+		return {
+			manifest: rawManifest,
+			changed: false,
+			changes: [],
+			alreadyRunsOxlint: [],
+			skipped: []
+		};
+	}
+	const scripts = parsed.scripts ?? {};
+	const { changes, alreadyRunsOxlint, skipped } = planChanges(scripts);
+	const existingLint = scripts.lint;
+	if (changes.length === 0 && alreadyRunsOxlint.length === 0) {
+		if (existingLint !== void 0) return {
+			manifest: rawManifest,
+			changed: false,
+			changes: [],
+			alreadyRunsOxlint: [],
+			skipped: [],
+			unresolved: {
+				reason: "lint-script-runs-neither",
+				script: "lint",
+				previous: existingLint
+			}
+		};
+		changes.push({
+			script: "lint",
+			previous: "",
+			next: OXLINT_LINT_SCRIPT
+		});
 	}
+	if (changes.length === 0) return {
+		manifest: rawManifest,
+		changed: false,
+		changes: [],
+		alreadyRunsOxlint,
+		skipped
+	};
+	parsed.scripts = { ...scripts };
+	changes.forEach((change) => {
+		parsed.scripts[change.script] = change.next;
+	});
+	return {
+		manifest: `${JSON.stringify(parsed, null, detectIndent$1(rawManifest))}\n`,
+		changed: true,
+		changes,
+		alreadyRunsOxlint,
+		skipped
+	};
+}
+/**
+* The scripts that still run ESLint alone, for the CLI to print. Each line carries the oxlint prefix
+* that script would need, so a consumer who wants oxlint on a second entry point can paste it.
+* @example
+* formatSkippedLintScripts([{ script: 'lint:fix', previous: 'eslint . --fix' }]);
+* // 'lint:fix\n  prefix with: oxlint --disable-nested-config --fix && '
+*/
+function formatSkippedLintScripts(skipped) {
+	return skipped.map((candidate) => `${candidate.script}\n  prefix with: ${oxlintPrefixFor(candidate.previous)} && `).join("\n\n");
+}
+/**
+* One line per rewritten script, for the CLI to print. The previous command survives verbatim inside
+* the new one, so the report doubles as the recovery instructions.
+* @example
+* formatLintScriptChanges([{ script: 'lint:es-ci', previous: 'eslint .', next: 'oxlint && eslint .' }]);
+* // 'lint:es-ci\n  before: eslint .\n  after:  oxlint && eslint .'
+*/
+function formatLintScriptChanges(changes) {
+	return changes.map((change) => [
+		change.script,
+		`  before: ${change.previous === "" ? "(no such script)" : change.previous}`,
+		`  after:  ${change.next}`
+	].join("\n")).join("\n\n");
 }
 //#endregion
 //#region src/cli/quote.ts
@@ -995,11 +1328,17 @@ function formatScope$1(scope, entries, baseIndent) {
 function renderUseInsiderBody(merged) {
 	return [...merged.entries()].map(([scope, entries]) => formatScope$1(scope, entries, indent$1)).join("\n");
 }
-function renderConfigFile(answers) {
+/**
+* Body of the generated `insider.lint.*` module — the one file that calls `useInsider()` and the
+* only one both linter configs import.
+* @example
+* renderLintModuleFile(answers); // "…export const { useInsiderESLint, useInsiderOXC } = useInsider({…"
+*/
+function renderLintModuleFile(answers) {
 	return [
 		"import { useInsider } from '@useinsider/eslint-config';",
 		"",
-		"export default useInsider({",
+		"export const { useInsiderESLint, useInsiderOXC } = useInsider({",
 		renderUseInsiderBody(mergeByScope(buildScopedConfigs(answers))),
 		"});",
 		""
@@ -1440,7 +1779,11 @@ var SCOPE_TO_DEPS = {
 	vitest: dependencies$11,
 	jsdocBasedTs: dependencies$3
 };
-var ALL_PRESET_DEPS = [dependencies$2, ...Object.values(SCOPE_TO_DEPS)];
+var ALL_PRESET_DEPS = [
+	dependencies$14,
+	dependencies$2,
+	...Object.values(SCOPE_TO_DEPS)
+];
 var PRESET_DEPENDENCY_KEYS = new Set(ALL_PRESET_DEPS.flatMap((record) => Object.keys(record)));
 function isEslintRelatedDependency(name) {
 	if (SAFELIST.has(name)) return false;
@@ -1538,6 +1881,9 @@ function buildInstallList(scopes, manifest) {
 	const fallbacks = [];
 	appendSpec(specs, "@useinsider/eslint-config@latest");
 	appendSpec(specs, resolveSpec("eslint", manifest, fallbacks));
+	Object.entries(dependencies$14).forEach(([packageName, shouldInstall]) => {
+		if (shouldInstall) appendSpec(specs, resolveSpec(packageName, manifest, fallbacks));
+	});
 	[...scopes].forEach((scope) => {
 		const record = SCOPE_TO_DEPS[scope];
 		if (!record) return;
@@ -1597,6 +1943,448 @@ function pruneConsumerPackageJson(cwd) {
 	};
 }
 //#endregion
+//#region src/cli/tsconfigFlag.ts
+var TS_EXTENSIONS_FLAG = "allowImportingTsExtensions";
+var TS_EXTENSIONS_SNIPPET = [
+	"{",
+	"    \"compilerOptions\": {",
+	`        "${TS_EXTENSIONS_FLAG}": true`,
+	"    }",
+	"}"
+].join("\n");
+var DEFAULT_INDENT_UNIT = "    ";
+function acceptsTsExtensionsFlag(options) {
+	return options.noEmit === true || options.emitDeclarationOnly === true || options.rewriteRelativeImportExtensions === true;
+}
+function parseTsconfig(path, raw) {
+	const { config } = typescript.parseConfigFileTextToJson(path, raw);
+	if (!config) return null;
+	const parsed = typescript.parseJsonConfigFileContent(config, typescript.sys, (0, node_path.dirname)(path), void 0, path);
+	return {
+		enabled: parsed.options.allowImportingTsExtensions === true,
+		acceptsFlag: acceptsTsExtensionsFlag(parsed.options),
+		fileNames: parsed.fileNames,
+		references: (parsed.projectReferences ?? []).map((reference) => reference.path)
+	};
+}
+function readTsconfigAt(path, governedFiles) {
+	if (!(0, node_fs.existsSync)(path)) return null;
+	try {
+		const raw = (0, node_fs.readFileSync)(path, "utf8");
+		const parsed = parseTsconfig(path, raw);
+		if (!parsed) return {
+			state: {
+				path,
+				raw,
+				enabled: false,
+				governs: false,
+				acceptsFlag: false
+			},
+			references: []
+		};
+		const owned = new Set(parsed.fileNames.map((name) => typescript.sys.resolvePath(name)));
+		const governs = governedFiles.some((file) => owned.has(typescript.sys.resolvePath(file)));
+		return {
+			state: {
+				path,
+				raw,
+				enabled: parsed.enabled,
+				governs,
+				acceptsFlag: parsed.acceptsFlag
+			},
+			references: parsed.references
+		};
+	} catch {
+		return null;
+	}
+}
+function resolveReferencePath(reference) {
+	if (!(0, node_fs.existsSync)(reference)) return reference;
+	return typescript.sys.directoryExists(reference) ? (0, node_path.join)(reference, "tsconfig.json") : reference;
+}
+/**
+* Every tsconfig in the consumer's solution — the root plus each project reference — annotated with
+* whether it actually type-checks the generated lint files. A solution-style root has an empty file
+* set, so the project that governs `insider.lint.ts` is usually a referenced `tsconfig.node.json`,
+* and that is the one `tsc` reports TS5097 from.
+* @example
+* collectTsconfigStates('/repo', ['/repo/insider.lint.ts']).filter(state => state.governs);
+* // [{ path: '/repo/tsconfig.node.json', enabled: true, governs: true, ... }]
+*/
+function collectTsconfigStates(cwd, governedFiles = []) {
+	const root = readTsconfigAt((0, node_path.join)(cwd, "tsconfig.json"), governedFiles);
+	if (!root) return [];
+	const seen = /* @__PURE__ */ new Set([root.state.path]);
+	const states = [root.state];
+	root.references.forEach((reference) => {
+		const path = resolveReferencePath(reference);
+		if (seen.has(path)) return;
+		seen.add(path);
+		const referenced = readTsconfigAt(path, governedFiles);
+		if (referenced) states.push(referenced.state);
+	});
+	return states;
+}
+/**
+* The tsconfigs that must gain `allowImportingTsExtensions`: the ones that type-check the generated
+* files and do not already resolve the flag to `true`. Empty when an applicable config already sets
+* it, and empty when no config type-checks the generated files at all — a tsconfig that never sees
+* them cannot raise TS5097, so editing it would only add a flag it has no use for.
+* @example
+* tsconfigsNeedingFlag('/repo', ['/repo/insider.lint.ts']).map(state => state.path); // []
+*/
+function tsconfigsNeedingFlag(cwd, governedFiles) {
+	return collectTsconfigStates(cwd, governedFiles).filter((state) => state.governs && !state.enabled);
+}
+function rootObject(source) {
+	const [statement] = source.statements;
+	const expression = statement?.expression;
+	return expression && typescript.isObjectLiteralExpression(expression) ? expression : null;
+}
+function findProperty$2(object, name) {
+	return object.properties.find((property) => typescript.isPropertyAssignment(property) && typescript.isStringLiteral(property.name) && property.name.text === name);
+}
+function indentAt(raw, position) {
+	const lineStart = raw.lastIndexOf("\n", position - 1) + 1;
+	const prefix = raw.slice(lineStart, position);
+	return prefix.trim().length === 0 ? prefix : "";
+}
+function detectIndentUnit(raw) {
+	const match = /\n([\t ]+)\S/u.exec(raw);
+	return match ? match[1] : DEFAULT_INDENT_UNIT;
+}
+function splice(raw, start, end, text) {
+	return raw.slice(0, start) + text + raw.slice(end);
+}
+function setExistingFlag(raw, source, property) {
+	return splice(raw, property.initializer.getStart(source), property.initializer.getEnd(), "true");
+}
+function insertIntoCompilerOptions(raw, source, compilerOptions, object) {
+	const openBrace = object.getStart(source) + 1;
+	const [first] = object.properties;
+	if (first) return splice(raw, openBrace, openBrace, `\n${indentAt(raw, first.getStart(source)) || detectIndentUnit(raw).repeat(2)}"${TS_EXTENSIONS_FLAG}": true,`);
+	const outer = indentAt(raw, compilerOptions.getStart(source));
+	const unit = detectIndentUnit(raw);
+	return splice(raw, openBrace, object.getEnd() - 1, `\n${outer}${unit}"${TS_EXTENSIONS_FLAG}": true\n${outer}`);
+}
+function insertCompilerOptions(raw, source, root) {
+	const openBrace = root.getStart(source) + 1;
+	const unit = detectIndentUnit(raw);
+	const [first] = root.properties;
+	const indent = first ? indentAt(raw, first.getStart(source)) || unit : unit;
+	const block = `\n${indent}"compilerOptions": {\n${indent}${unit}"${TS_EXTENSIONS_FLAG}": true\n${indent}}`;
+	if (first) return splice(raw, openBrace, openBrace, `${block},`);
+	return splice(raw, openBrace, root.getEnd() - 1, `${block}\n`);
+}
+/**
+* Turns `allowImportingTsExtensions` on in a `tsconfig.json` source without reformatting it. The
+* file is edited through its JSON syntax tree rather than re-serialized, so comments, key order and
+* indentation survive.
+* @example
+* enableTsExtensionsFlag('{\n  "compilerOptions": {\n    "strict": true\n  }\n}').changed; // true
+*/
+function enableTsExtensionsFlag(raw) {
+	const source = typescript.parseJsonText("tsconfig.json", raw);
+	const root = rootObject(source);
+	if (!root) return {
+		source: raw,
+		changed: false
+	};
+	const compilerOptions = findProperty$2(root, "compilerOptions");
+	if (!compilerOptions) return {
+		source: insertCompilerOptions(raw, source, root),
+		changed: true
+	};
+	if (!typescript.isObjectLiteralExpression(compilerOptions.initializer)) return {
+		source: raw,
+		changed: false
+	};
+	const existing = findProperty$2(compilerOptions.initializer, TS_EXTENSIONS_FLAG);
+	if (existing) {
+		if (existing.initializer.kind === typescript.SyntaxKind.TrueKeyword) return {
+			source: raw,
+			changed: false
+		};
+		return {
+			source: setExistingFlag(raw, source, existing),
+			changed: true
+		};
+	}
+	return {
+		source: insertIntoCompilerOptions(raw, source, compilerOptions, compilerOptions.initializer),
+		changed: true
+	};
+}
+function noteManualStep(clack, lintModule) {
+	if (!clack.note) return;
+	clack.note(`\`eslint.config.*\` imports \`./${lintModule}\` by its real extension, which \`tsc\` rejects with TS5097 unless \`${TS_EXTENSIONS_FLAG}\` is on. Add this to your tsconfig.json:\n\n${TS_EXTENSIONS_SNIPPET}`, "tsconfig.json not updated");
+}
+function noteEmitConflict(clack, path, lintModule) {
+	if (!clack.note) return;
+	clack.note(`${path} type-checks \`./${lintModule}\`, so \`tsc\` needs \`${TS_EXTENSIONS_FLAG}\` there — but that project emits, and TypeScript rejects the pair with TS5096. Set \`noEmit\`, \`emitDeclarationOnly\` or \`rewriteRelativeImportExtensions\` on it first, then add:\n\n${TS_EXTENSIONS_SNIPPET}`, "tsconfig.json not updated");
+}
+async function confirmFlag(clack, path) {
+	const result = await clack.confirm({
+		message: `Set \`${TS_EXTENSIONS_FLAG}: true\` in ${path}? Without it \`tsc\` fails with TS5097 on the generated config files.`,
+		initialValue: true
+	});
+	return !clack.isCancel(result) && result === true;
+}
+function governedFilesOf(input) {
+	return [input.lintModule, input.eslintConfig].filter((name) => Boolean(name)).map((name) => (0, node_path.join)(input.cwd, name));
+}
+async function applyToOne(clack, state, input) {
+	if (!state.acceptsFlag) {
+		noteEmitConflict(clack, state.path, input.lintModule);
+		return;
+	}
+	if (!(input.autoConfirm || await confirmFlag(clack, state.path))) {
+		noteManualStep(clack, input.lintModule);
+		return;
+	}
+	const result = enableTsExtensionsFlag(state.raw);
+	if (!result.changed) {
+		noteManualStep(clack, input.lintModule);
+		return;
+	}
+	(0, node_fs.writeFileSync)(state.path, result.source, "utf8");
+	if (clack.note) clack.note(`Set \`${TS_EXTENSIONS_FLAG}: true\` in ${state.path}.`, "Updated tsconfig.json");
+}
+/**
+* Offers to set `allowImportingTsExtensions` on every tsconfig that actually type-checks the
+* generated lint files, and prints the exact snippet when an offer is declined or when the project
+* emits — in which case writing the flag would trade TS5097 for TS5096. A no-op when there is no
+* `tsconfig.json`, when no config governs the generated files, or when an applicable config already
+* resolves the flag to `true` — through its own `compilerOptions`, through `extends`, or by being a
+* project reference that already sets it.
+* @example
+* await applyTsExtensionsFlag(clack, { cwd: '/repo', lintModule: 'insider.lint.ts' });
+*/
+async function applyTsExtensionsFlag(clack, input) {
+	await tsconfigsNeedingFlag(input.cwd, governedFilesOf(input)).reduce(async (previous, state) => {
+		await previous;
+		return applyToOne(clack, state, input);
+	}, Promise.resolve());
+}
+//#endregion
+//#region src/cli/migrate/disableDirectives.ts
+var DIRECTIVE_HEAD = /^\s*eslint-disable(-next-line|-line)?(?![\w-])/u;
+var SCRIPT_BLOCK = /<script\b[^>]*>([\s\S]*?)<\/script>/giu;
+var SFC_EXTENSIONS = [
+	".astro",
+	".svelte",
+	".vue"
+];
+var JSX_EXTENSIONS = [
+	".cjs",
+	".js",
+	".jsx",
+	".mjs",
+	".tsx"
+];
+var LINTED_EXTENSIONS = [
+	".astro",
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".svelte",
+	".ts",
+	".tsx",
+	".vue"
+];
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	"coverage",
+	"dist",
+	"build",
+	"node_modules",
+	"out",
+	"vendor"
+]);
+function parseDirectiveBody(body) {
+	const [ruleList, ...reasonParts] = body.split("--");
+	return {
+		rules: ruleList.split(",").map((rule) => rule.trim()).filter((rule) => rule.length > 0),
+		reason: reasonParts.join("--").trim()
+	};
+}
+function formatDirective(owner, block, kind, rules, reason) {
+	const text = `${owner}-disable${kind} ${reason ? `${rules.join(", ")} -- ${reason}` : rules.join(", ")}`;
+	return block ? `/* ${text} */` : `// ${text}`;
+}
+/**
+* Whether the split hands this rule to oxlint for the given file, so an `eslint-disable` comment
+* naming it would read as an unused directive to ESLint.
+* @example
+* movesToOxlint('no-console', '.ts'); // true
+* movesToOxlint('@typescript-eslint/no-unused-vars', '.vue'); // false — ESLint still runs it in SFCs
+*/
+function movesToOxlint(rule, fileExtension) {
+	if (!require_oxlintOwnership.isOxlintOwned(rule)) return false;
+	return !(SFC_EXTENSIONS.includes(fileExtension) && require_oxlintOwnership.isVueUnsafeRule(rule));
+}
+function toSpans(comments, offset) {
+	return comments.map((comment) => ({
+		start: comment.range[0] + offset,
+		end: comment.range[1] + offset,
+		block: comment.type === _typescript_eslint_types.AST_TOKEN_TYPES.Block,
+		value: comment.value
+	}));
+}
+function parseComments(source, jsx) {
+	try {
+		return (0, _typescript_eslint_parser.parse)(source, {
+			comment: true,
+			jsx,
+			range: true
+		}).comments ?? [];
+	} catch {
+		return null;
+	}
+}
+function collectFromScript(source, jsx, offset) {
+	const comments = parseComments(source, jsx) ?? parseComments(source, !jsx);
+	return comments ? toSpans(comments, offset) : [];
+}
+var CLOSING_SCRIPT_TAG_LENGTH = 9;
+function collectSfcComments(source, jsx) {
+	return [...source.matchAll(SCRIPT_BLOCK)].flatMap((match) => {
+		const [whole, body] = match;
+		return collectFromScript(body, jsx, (match.index ?? 0) + whole.length - body.length - CLOSING_SCRIPT_TAG_LENGTH);
+	});
+}
+/**
+* Every real comment node in the file, with ranges relative to the whole source. Only comments are
+* returned, so a string or template literal that happens to spell out a directive is invisible here.
+* @example
+* collectComments("const label = '// eslint-disable-next-line';\n", '.ts'); // []
+*/
+function collectComments(source, fileExtension) {
+	const jsx = JSX_EXTENSIONS.includes(fileExtension);
+	if (SFC_EXTENSIONS.includes(fileExtension)) return collectSfcComments(source, jsx);
+	return collectFromScript(source, jsx, 0);
+}
+function startsItsOwnLine(source, start) {
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	return source.slice(lineStart, start).trim().length === 0;
+}
+function splitLayout(source, span, kind) {
+	if (kind !== "" || !startsItsOwnLine(source, span.start)) return {
+		block: true,
+		separator: " "
+	};
+	const indent = " ".repeat(span.start - (source.lastIndexOf("\n", span.start - 1) + 1));
+	return {
+		block: span.block,
+		separator: `\n${indent}`
+	};
+}
+function replacementFor(source, span, fileExtension) {
+	const head = DIRECTIVE_HEAD.exec(span.value);
+	if (!head) return null;
+	const kind = head[1] ?? "";
+	const { rules, reason } = parseDirectiveBody(span.value.slice(head[0].length));
+	if (rules.length === 0) return null;
+	const moved = rules.filter((rule) => movesToOxlint(rule, fileExtension));
+	if (moved.length === 0) return null;
+	const kept = rules.filter((rule) => !moved.includes(rule));
+	if (kept.length === 0) return {
+		start: span.start,
+		end: span.end,
+		text: formatDirective("oxlint", span.block, kind, moved, reason)
+	};
+	const { block, separator } = splitLayout(source, span, kind);
+	const text = formatDirective("oxlint", block, kind, moved, reason) + separator + formatDirective("eslint", block, kind, kept, reason);
+	return {
+		start: span.start,
+		end: span.end,
+		text
+	};
+}
+/**
+* Re-points the rules oxlint now owns onto an `oxlint-disable` comment, leaving the ESLint-owned
+* ones behind. Only real comment nodes are rewritten, so a string or template literal spelling out
+* a directive is left alone.
+* @example
+* rewriteDirectives('// <eslint>-disable-next-line no-console\nlog();', '.ts').source;
+* // '// oxlint-disable-next-line no-console\nlog();'
+*/
+function rewriteDirectives(source, fileExtension) {
+	const replacements = collectComments(source, fileExtension).map((span) => replacementFor(source, span, fileExtension)).filter((replacement) => replacement !== null).sort((left, right) => right.start - left.start);
+	if (replacements.length === 0) return {
+		source,
+		changed: false
+	};
+	return {
+		source: replacements.reduce((accumulator, replacement) => accumulator.slice(0, replacement.start) + replacement.text + accumulator.slice(replacement.end), source),
+		changed: true
+	};
+}
+function isLintedFile(filePath) {
+	return LINTED_EXTENSIONS.includes((0, node_path.extname)(filePath));
+}
+function readEntries(directory) {
+	try {
+		return (0, node_fs.readdirSync)(directory, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+function realPathOf(path) {
+	try {
+		return (0, node_fs.realpathSync)(path);
+	} catch {
+		return null;
+	}
+}
+function collectFiles(directory, accumulator, visited) {
+	const real = realPathOf(directory);
+	if (real === null || visited.has(real)) return;
+	visited.add(real);
+	readEntries(directory).forEach((entry) => {
+		if (SKIPPED_DIRECTORIES.has(entry.name)) return;
+		const full = (0, node_path.join)(directory, entry.name);
+		if (entry.isDirectory()) {
+			collectFiles(full, accumulator, visited);
+			return;
+		}
+		if (entry.isFile() && isLintedFile(full)) accumulator.push(full);
+	});
+}
+/**
+* Every file whose `eslint-disable` comments would be re-pointed, and the rewritten source, without
+* touching disk. The directive rewrite is the largest diff a migration produces, so the count is
+* reported — and confirmed — before anything is written.
+* @example
+* previewDisableDirectives('/repo').length; // 131
+*/
+function previewDisableDirectives(cwd) {
+	const files = [];
+	collectFiles(cwd, files, /* @__PURE__ */ new Set());
+	return files.reduce((candidates, filePath) => {
+		const result = rewriteDirectives((0, node_fs.readFileSync)(filePath, "utf8"), (0, node_path.extname)(filePath));
+		if (!result.changed) return candidates;
+		return [...candidates, {
+			path: filePath,
+			source: result.source
+		}];
+	}, []);
+}
+/**
+* Applies {@link rewriteDirectives} across a consumer tree, skipping build output and dependencies.
+* @example
+* rewriteDisableDirectives('/repo').rewritten; // ['/repo/src/logger.ts']
+*/
+function rewriteDisableDirectives(cwd, candidates = previewDisableDirectives(cwd)) {
+	candidates.forEach((candidate) => {
+		(0, node_fs.writeFileSync)(candidate.path, candidate.source, "utf8");
+	});
+	return { rewritten: candidates.map((candidate) => candidate.path) };
+}
+//#endregion
 //#region src/cli/migrate/stringEntry.ts
 function toEntries(values) {
 	return values.map((value) => ({ value }));
@@ -2214,7 +3002,7 @@ function appendScope$1(config, scope, entry) {
 }
 function mergeGlobals(base, extra) {
 	if (!base && !extra) return;
-	const merged = { ...base ?? {} };
+	const merged = { ...base };
 	if (extra) Object.entries(extra).forEach(([key, value]) => {
 		if (!(key in merged)) merged[key] = value;
 	});
@@ -3539,11 +4327,11 @@ function renderV2(plan) {
 	parts.push("");
 	if (plan.useInsiderLeadingComment !== void 0) parts.push(plan.useInsiderLeadingComment);
 	if (!hasAnyContent(plan)) {
-		parts.push("export default useInsider({});");
+		parts.push("export const { useInsiderESLint, useInsiderOXC } = useInsider({});");
 		parts.push("");
 		return pruneUnusedImports(parts.join("\n"));
 	}
-	parts.push("export default useInsider({");
+	parts.push("export const { useInsiderESLint, useInsiderOXC } = useInsider({");
 	parts.push(renderConfigBody(plan));
 	parts.push("});");
 	parts.push("");
@@ -3903,15 +4691,56 @@ function formatWarnings(warnings) {
 }
 //#endregion
 //#region src/cli/migrate/writer.ts
+function writeLayout(directory, lintModuleSource) {
+	const layout = resolveLintLayout(directory);
+	const lintModulePath = (0, node_path.join)(directory, layout.lintModule);
+	(0, node_fs.writeFileSync)(lintModulePath, lintModuleSource, "utf8");
+	const writtenPaths = [lintModulePath];
+	renderLintLayoutFiles(layout).forEach((file) => {
+		const path = (0, node_path.join)(directory, file.filename);
+		(0, node_fs.writeFileSync)(path, file.source, "utf8");
+		writtenPaths.push(path);
+	});
+	return {
+		eslintConfigPath: (0, node_path.join)(directory, layout.eslintConfig),
+		lintModulePath,
+		writtenPaths,
+		replacedEslintConfigPaths: layout.replacedEslintConfigs.map((name) => (0, node_path.join)(directory, name))
+	};
+}
+function withoutDuplicates(paths, keep) {
+	return [...new Set(paths.filter((path) => path !== keep))];
+}
+/**
+* Writes the three-file layout beside an existing flat config: the rendered `useInsider()` call
+* becomes `insider.lint.*`, and `eslint.config.*` / `oxlint.config.*` become thin re-exports. A
+* JavaScript-extension source config is superseded by the TypeScript one and nominated for deletion.
+* @example
+* writeMigration('/repo/eslint.config.js', source).deletedSourceCandidates; // ['/repo/eslint.config.js']
+*/
 function writeMigration(targetPath, newSource) {
-	(0, node_fs.writeFileSync)(targetPath, newSource, "utf8");
-	return { targetPath };
+	const result = writeLayout((0, node_path.dirname)(targetPath), newSource);
+	return {
+		targetPath: result.eslintConfigPath,
+		lintModulePath: result.lintModulePath,
+		writtenPaths: result.writtenPaths,
+		deletedSourceCandidates: withoutDuplicates([...result.replacedEslintConfigPaths, targetPath], result.eslintConfigPath)
+	};
 }
+/**
+* Same as {@link writeMigration}, but for a legacy `.eslintrc*` source that has to be replaced by a
+* differently-named flat config.
+* @example
+* writeMigrationLegacy('/repo/.eslintrc.cjs', '/repo/eslint.config.mts', src).deletedSourceCandidates;
+* // ['/repo/.eslintrc.cjs']
+*/
 function writeMigrationLegacy(sourcePath, writePath, newSource) {
-	(0, node_fs.writeFileSync)(writePath, newSource, "utf8");
+	const result = writeLayout((0, node_path.dirname)(writePath), newSource);
 	return {
-		targetPath: writePath,
-		deletedSourceCandidate: (0, node_path.basename)(sourcePath) === (0, node_path.basename)(writePath) ? void 0 : sourcePath
+		targetPath: result.eslintConfigPath,
+		lintModulePath: result.lintModulePath,
+		writtenPaths: result.writtenPaths,
+		deletedSourceCandidates: withoutDuplicates([...result.replacedEslintConfigPaths, sourcePath], result.eslintConfigPath)
 	};
 }
 //#endregion
@@ -3986,26 +4815,14 @@ function summary(plan, format) {
 function planFromSource(source, filePath, format) {
 	if (format === "flat") {
 		const parseResult = parseV1Config(source, filePath);
-		if (!isV1Shape(parseResult)) return null;
-		const plan = transformToV2(parseResult);
-		return {
-			plan,
-			rendered: renderV2(plan)
-		};
+		return isV1Shape(parseResult) ? transformToV2(parseResult) : null;
 	}
 	const parseResult = parseEslintrc(source, filePath);
-	if (!parseResult.found) return null;
-	const plan = transformEslintrcToV2(parseResult);
-	return {
-		plan,
-		rendered: renderV2(plan)
-	};
+	return parseResult.found ? transformEslintrcToV2(parseResult) : null;
 }
-function targetWritePath(cwd, sourcePath, format) {
-	if (format !== "eslintrc") return sourcePath;
-	const base = (0, node_path.basename)(sourcePath);
-	const dir = sourcePath.slice(0, sourcePath.length - base.length);
-	return (0, node_path.join)(dir.length > 0 ? dir : cwd, "eslint.config.mjs");
+function targetWritePath(cwd, sourcePath) {
+	const directory = (0, node_path.dirname)(sourcePath) || cwd;
+	return (0, node_path.join)(directory, resolveLintLayout(directory).eslintConfig);
 }
 function parseEslintIgnoreContents(raw) {
 	return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
@@ -4039,6 +4856,17 @@ function describeDepChanges(depChanges) {
 	lines.push(`- Install (${depChanges.install.specs.length}): ${depChanges.install.specs.join(", ")}`);
 	return lines.join("\n");
 }
+async function confirmGuidedStart(clack, sourcePath) {
+	const result = await clack.confirm({
+		message: `${(0, node_path.basename)(sourcePath)} still uses the v3 single-file layout. Migrate it now?`,
+		initialValue: true
+	});
+	return !clack.isCancel(result) && result === true;
+}
+function noteConfigRename(clack, sourcePath, writePath) {
+	if (!clack.note || (0, node_path.basename)(sourcePath) === (0, node_path.basename)(writePath)) return;
+	clack.note(`${(0, node_path.basename)(sourcePath)} -> ${(0, node_path.basename)(writePath)}\n\nESLint loads a JavaScript config through Node, so importing the TypeScript lint module from one needs unflagged type stripping (Node >= 22.18) and fails on Node 20. A TypeScript config goes through jiti and loads on every supported version.`, "Renaming the flat config");
+}
 async function confirmWrite(clack, writePath, initial = true) {
 	const message = `Write migrated config to ${writePath}?`;
 	const result = await clack.confirm({
@@ -4080,17 +4908,19 @@ function emitSummary(clack, plan, format) {
 	if (plan.warnings.length > 0 && clack.note) clack.note(formatWarnings(plan.warnings), "Warnings");
 }
 function writeAndAnnounce(clack, targetPath, writePath, rendered, format) {
-	if (format === "eslintrc") {
-		const result = writeMigrationLegacy(targetPath, writePath, rendered);
-		clack.outro(`Wrote ${writePath}`);
-		return { deletedSourceCandidate: result.deletedSourceCandidate };
-	}
-	writeMigration(targetPath, rendered);
-	clack.outro(`Wrote ${targetPath}`);
-	return {};
-}
-async function confirmOverwriteExistingOutput(clack, writePath, sourcePath, initial = false) {
-	const message = `An \`${(0, node_path.basename)(writePath)}\` already exists. Overwrite + delete \`${(0, node_path.basename)(sourcePath)}\`?`;
+	const result = format === "eslintrc" ? writeMigrationLegacy(targetPath, writePath, rendered) : writeMigration(targetPath, rendered);
+	clack.outro(`Wrote ${result.writtenPaths.join(", ")}`);
+	return { deletedSourceCandidates: result.deletedSourceCandidates };
+}
+function supersededFlatConfigs(sourcePath, writePath) {
+	const directory = (0, node_path.dirname)(writePath);
+	const { replacedEslintConfigs } = resolveLintLayout(directory);
+	const candidates = [...replacedEslintConfigs.map((filename) => (0, node_path.join)(directory, filename)), writePath];
+	return [...new Set(candidates.filter((path) => path !== sourcePath && (0, node_fs.existsSync)(path)))];
+}
+async function confirmOverwriteExistingOutput(clack, superseded, sourcePath, initial = false) {
+	const names = superseded.map((path) => (0, node_path.basename)(path));
+	const message = `${names.length === 1 ? `An \`${names[0]}\` already exists` : `\`${names.join("`, `")}\` already exist`}. Overwrite + delete \`${(0, node_path.basename)(sourcePath)}\`?`;
 	const result = await clack.confirm({
 		message,
 		initialValue: initial
@@ -4126,10 +4956,9 @@ function resolveSource(input, clack) {
 	};
 }
 function prepareMigration(resolved, input) {
-	const planResult = planFromSource(resolved.source, resolved.targetPath, resolved.format);
-	if (!planResult) return null;
-	const { plan } = planResult;
-	const writePath = targetWritePath(input.cwd, resolved.targetPath, resolved.format);
+	const plan = planFromSource(resolved.source, resolved.targetPath, resolved.format);
+	if (!plan) return null;
+	const writePath = targetWritePath(input.cwd, resolved.targetPath);
 	const eslintIgnore = findEslintIgnore(resolved.targetPath);
 	if (eslintIgnore && eslintIgnore.patterns.length > 0) mergeIgnorePatterns(plan, eslintIgnore.patterns);
 	return {
@@ -4140,8 +4969,9 @@ function prepareMigration(resolved, input) {
 	};
 }
 async function runConfirmations(clack, input, targetPath, writePath, previous) {
-	if (writePath !== targetPath && (0, node_fs.existsSync)(writePath)) {
-		if (!await confirmOverwriteExistingOutput(clack, writePath, targetPath, previous?.overwriteExisting ?? false)) {
+	const superseded = supersededFlatConfigs(targetPath, writePath);
+	if (superseded.length > 0) {
+		if (!await confirmOverwriteExistingOutput(clack, superseded, targetPath, previous?.overwriteExisting ?? false)) {
 			clack.outro("Aborted: existing output kept.");
 			return false;
 		}
@@ -4199,7 +5029,7 @@ function resolveInstallCwd(depSummary, input) {
 	return input.cwd;
 }
 async function runInstaller(clack, depSummary, input) {
-	await installWithRetry({
+	return installWithRetry({
 		deps: depSummary.install.specs,
 		cwd: resolveInstallCwd(depSummary, input),
 		autoConfirm: Boolean(input.yes),
@@ -4211,26 +5041,73 @@ async function runInstaller(clack, depSummary, input) {
 async function applyDepChanges(clack, depSummary, input) {
 	if (!depSummary.packageJsonPath) {
 		if (clack.note) clack.note("No package.json found alongside the migrated config — skipping dependency updates.", "Notice");
-		return;
+		return true;
 	}
 	persistPrunedManifest(depSummary);
 	if (input.noInstall) {
 		emitInstallNextSteps(clack, depSummary, input.cwd);
-		return;
+		return true;
 	}
 	if (!input.yes) {
 		if (!await confirmInstall(clack, depSummary)) {
 			emitInstallNextSteps(clack, depSummary, input.cwd);
-			return;
+			return true;
 		}
 	}
 	noteFallbacks(clack, depSummary);
-	await runInstaller(clack, depSummary, input);
+	if (!(await runInstaller(clack, depSummary, input)).installed) {
+		emitInstallNextSteps(clack, depSummary, input.cwd);
+		return false;
+	}
+	return true;
 }
 function performWriteAndCleanup(clack, resolved, prepared) {
 	const outcome = writeAndAnnounce(clack, resolved.targetPath, prepared.writePath, prepared.rendered, resolved.format);
 	if (prepared.eslintIgnore) safeUnlink(prepared.eslintIgnore.path, clack, ".eslintignore");
-	if (outcome.deletedSourceCandidate) safeUnlink(outcome.deletedSourceCandidate, clack, "source config");
+	outcome.deletedSourceCandidates.forEach((path) => {
+		safeUnlink(path, clack, "superseded config");
+	});
+}
+function noteLintScriptOutcome$1(clack, result) {
+	if (!clack.note) return;
+	if (result.unresolved) {
+		clack.note(`Left \`${result.unresolved.script}\` untouched — it runs neither eslint nor oxlint:\n\n  ${result.unresolved.previous}\n\nAdd \`${OXLINT_LINT_SCRIPT}\` yourself, next to whatever invokes ESLint.`, "package.json script not changed");
+		return;
+	}
+	if (result.alreadyRunsOxlint.length > 0 && result.changes.length === 0) {
+		clack.note(`\`${result.alreadyRunsOxlint.join("`, `")}\` already run oxlint — left alone.`, "package.json scripts unchanged");
+		return;
+	}
+	if (result.skipped.length > 0) clack.note(`${formatSkippedLintScripts(result.skipped)}\n\noxlint was added to one entry point only, so it does not run twice over the same tree.`, "package.json scripts left alone");
+	if (result.changes.length === 0) return;
+	clack.note(`${formatLintScriptChanges(result.changes)}\n\noxlint was prepended, never substituted, so every command that was there still runs.`, "Updated package.json scripts");
+}
+function applyLintScript$1(clack, directory) {
+	const manifestPath = (0, node_path.join)(directory, "package.json");
+	if (!(0, node_fs.existsSync)(manifestPath)) return;
+	const result = setLintScript((0, node_fs.readFileSync)(manifestPath, "utf8"));
+	if (result.changed) (0, node_fs.writeFileSync)(manifestPath, result.manifest, "utf8");
+	noteLintScriptOutcome$1(clack, result);
+}
+async function rewriteDirectivesWithNote(clack, directory, autoConfirm) {
+	const candidates = previewDisableDirectives(directory);
+	if (candidates.length === 0) return;
+	const count = candidates.length;
+	if (clack.note) clack.note(`${count} file(s) carry an \`eslint-disable\` naming a rule oxlint now owns. Left as they are, ESLint reports each one as an unused directive.
+
+This is a separate, source-wide diff — review it on its own commit.`, "Disable directives");
+	if (!autoConfirm) {
+		const proceed = await clack.confirm({
+			message: `Re-point \`eslint-disable\` onto \`oxlint-disable\` in ${count} file(s) now?`,
+			initialValue: true
+		});
+		if (clack.isCancel(proceed) || proceed !== true) {
+			if (clack.note) clack.note("Skipped. Re-run `npx @useinsider/eslint-config migrate` to apply it later.", "Disable directives not rewritten");
+			return;
+		}
+	}
+	const { rewritten } = rewriteDisableDirectives(directory, candidates);
+	if (clack.note) clack.note(`Re-pointed directives in ${rewritten.length} file(s).`, "Disable directives");
 }
 function loadPreviousMigrate(clack, cwd) {
 	const restored = loadSession({ cwd });
@@ -4242,7 +5119,7 @@ function emitNothingToMigrate(clack, format) {
 	clack.outro(format === "eslintrc" ? "No legacy `.eslintrc` shape found — nothing to migrate." : "No v1 useInsider patterns found — nothing to migrate.");
 }
 function persistMigrateSession(input, prepared, resolved) {
-	const overwriteExisting = prepared.writePath !== resolved.targetPath && (0, node_fs.existsSync)(prepared.writePath);
+	const overwriteExisting = supersededFlatConfigs(resolved.targetPath, prepared.writePath).length > 0;
 	saveSession({
 		command: "migrate",
 		migrate: {
@@ -4254,26 +5131,48 @@ function persistMigrateSession(input, prepared, resolved) {
 		}
 	}, { cwd: input.cwd });
 }
+async function finishMigrate(clack, depSummary, input) {
+	if (depSummary && !await applyDepChanges(clack, depSummary, input)) {
+		clack.cancel("Config migrated, but the dependencies did not install. Install them and re-run lint.");
+		return 1;
+	}
+	clearSession({ cwd: input.cwd });
+	return 0;
+}
 async function runMigrate(input, clackOverride) {
 	const clack = clackOverride ?? await loadClack();
 	const sourceResult = resolveSource(input, clack);
 	if (!sourceResult.ok) return sourceResult.exitCode;
 	const { resolved } = sourceResult;
 	clack.intro(`Migrating ${resolved.targetPath}`);
+	const declinedExitCode = input.fromLint ? 1 : 0;
+	if (input.fromLint && !input.yes && !await confirmGuidedStart(clack, resolved.targetPath)) {
+		clack.outro("Left the config as it is — nothing was written.");
+		return declinedExitCode;
+	}
 	const previousMigrate = loadPreviousMigrate(clack, input.cwd);
 	const prepared = prepareMigration(resolved, input);
 	if (!prepared) {
 		emitNothingToMigrate(clack, resolved.format);
-		return 0;
+		return declinedExitCode;
 	}
 	emitSummary(clack, prepared.plan, resolved.format);
+	noteConfigRename(clack, resolved.targetPath, prepared.writePath);
 	const depSummary = computeDepSummary(prepared.plan, prepared.writePath, input.overrides);
-	if (!await runConfirmations(clack, input, resolved.targetPath, prepared.writePath, previousMigrate)) return 0;
+	if (!await runConfirmations(clack, input, resolved.targetPath, prepared.writePath, previousMigrate)) return declinedExitCode;
 	persistMigrateSession(input, prepared, resolved);
 	performWriteAndCleanup(clack, resolved, prepared);
-	if (depSummary) await applyDepChanges(clack, depSummary, input);
-	clearSession({ cwd: input.cwd });
-	return 0;
+	applyLintScript$1(clack, (0, node_path.dirname)(prepared.writePath));
+	await rewriteDirectivesWithNote(clack, (0, node_path.dirname)(prepared.writePath), Boolean(input.yes));
+	const consumerDir = (0, node_path.dirname)(prepared.writePath);
+	const consumerLayout = resolveLintLayout(consumerDir);
+	await applyTsExtensionsFlag(clack, {
+		cwd: consumerDir,
+		lintModule: consumerLayout.lintModule,
+		eslintConfig: consumerLayout.eslintConfig,
+		autoConfirm: input.yes
+	});
+	return finishMigrate(clack, depSummary, input);
 }
 //#endregion
 //#region src/cli/index.ts
@@ -4438,21 +5337,50 @@ async function resolveHybridAnswers(clack, input, answers) {
 	};
 	return answers;
 }
+function applyLintScript(cwd) {
+	const manifestPath = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(manifestPath)) return null;
+	const result = setLintScript((0, node_fs.readFileSync)(manifestPath, "utf8"));
+	if (result.changed) (0, node_fs.writeFileSync)(manifestPath, result.manifest, "utf8");
+	return result;
+}
+function noteLintScriptOutcome(clack, result) {
+	if (!clack.note || !result) return;
+	if (result.unresolved) {
+		clack.note(`Left \`${result.unresolved.script}\` untouched — it runs neither eslint nor oxlint:\n\n  ${result.unresolved.previous}\n\nAdd \`${OXLINT_LINT_SCRIPT}\` yourself, next to whatever invokes ESLint.`, "package.json script not changed");
+		return;
+	}
+	if (result.skipped.length > 0) clack.note(`${formatSkippedLintScripts(result.skipped)}\n\noxlint was added to one entry point only, so it does not run twice over the same tree.`, "package.json scripts left alone");
+	if (result.changes.length > 0) clack.note(formatLintScriptChanges(result.changes), "Updated package.json scripts");
+}
+function writeLintLayout(cwd, lintModuleSource) {
+	const layout = resolveLintLayout(cwd);
+	const lintModulePath = (0, node_path.join)(cwd, layout.lintModule);
+	(0, node_fs.writeFileSync)(lintModulePath, lintModuleSource, "utf8");
+	renderLintLayoutFiles(layout).forEach((file) => {
+		(0, node_fs.writeFileSync)((0, node_path.join)(cwd, file.filename), file.source, "utf8");
+	});
+	layout.replacedEslintConfigs.forEach((filename) => {
+		(0, node_fs.rmSync)((0, node_path.join)(cwd, filename), { force: true });
+	});
+	return {
+		lintModulePath,
+		lintScript: applyLintScript(cwd)
+	};
+}
 async function installAndWrite(clack, input, answers, options) {
 	if (options.pruneBeforeInstall) noteOverridePrune(clack, pruneConsumerPackageJson(input.cwd).removed);
 	const deps = buildDependencyList(answers);
 	if (clack.note) clack.note(deps.map((dep) => `  - ${dep}`).join("\n"), "Installing dev dependencies");
-	await installWithRetry({
+	if (!(await installWithRetry({
 		deps,
 		cwd: input.cwd,
 		autoConfirm: Boolean(input.yes),
 		clack,
 		installer: input.overrides?.installer ?? installDependencies,
 		fsOps: input.overrides?.wipeFs
-	});
-	const targetPath = (0, node_path.join)(input.cwd, "eslint.config.mjs");
-	(0, node_fs.writeFileSync)(targetPath, renderConfigFile(answers), "utf8");
-	return targetPath;
+	})).installed) return null;
+	return writeLintLayout(input.cwd, renderLintModuleFile(answers));
 }
 async function runScaffold(input, clackOverride) {
 	const clack = clackOverride ?? await loadClack();
@@ -4473,9 +5401,21 @@ async function runScaffold(input, clackOverride) {
 			existingConfigChoice: "override"
 		}
 	}, { cwd: input.cwd });
-	const targetPath = await installAndWrite(clack, input, resolvedAnswers, { pruneBeforeInstall: viaOverride });
+	const written = await installAndWrite(clack, input, resolvedAnswers, { pruneBeforeInstall: viaOverride });
+	if (!written) {
+		clack.cancel("Dependencies were not installed — nothing was written. Fix the install and re-run.");
+		return 1;
+	}
+	noteLintScriptOutcome(clack, written.lintScript);
+	const layout = resolveLintLayout(input.cwd);
+	await applyTsExtensionsFlag(clack, {
+		cwd: input.cwd,
+		lintModule: layout.lintModule,
+		eslintConfig: layout.eslintConfig,
+		autoConfirm: input.yes
+	});
 	clearSession({ cwd: input.cwd });
-	clack.outro(`Wrote ${targetPath}`);
+	clack.outro(`Wrote ${written.lintModulePath} and its sibling linter configs`);
 	return 0;
 }
 async function runScaffoldSubcommand(scaffoldInput) {
@@ -4486,7 +5426,8 @@ async function runMigrateSubcommand(input) {
 		cwd: input.cwd,
 		target: input.target,
 		yes: input.yes,
-		noInstall: input.noInstall
+		noInstall: input.noInstall,
+		fromLint: input.fromLint
 	});
 }
 function writeStderr(line) {
@@ -4514,5 +5455,6 @@ if (!isUnderTest()) main().then(exitCleanly).catch((error) => {
 });
 //#endregion
 exports.runScaffold = runScaffold;
+exports.writeLintLayout = writeLintLayout;
 
 //# sourceMappingURL=cli.cjs.map